From 4ac6b1cf1490dadd34e54e015bf226bb03f56d10 Mon Sep 17 00:00:00 2001 From: asomers Date: Mon, 27 May 2019 17:08:16 +0000 Subject: [PATCH] fusefs: make the tests more cplusplusy * Prefer std::unique_ptr to raw pointers * Prefer pass-by-reference to pass-by-pointer * Prefer static_cast to C-style cast, unless it's too much typing Reported by: ngie Sponsored by: The FreeBSD Foundation --- tests/sys/fs/fusefs/allow_other.cc | 48 +- tests/sys/fs/fusefs/create.cc | 116 ++--- tests/sys/fs/fusefs/default_permissions.cc | 190 ++++---- .../fusefs/default_permissions_privileged.cc | 26 +- tests/sys/fs/fusefs/dev_fuse_poll.cc | 64 +-- tests/sys/fs/fusefs/fifo.cc | 24 +- tests/sys/fs/fusefs/flush.cc | 16 +- tests/sys/fs/fusefs/fsync.cc | 18 +- tests/sys/fs/fusefs/fsyncdir.cc | 10 +- tests/sys/fs/fusefs/getattr.cc | 146 +++--- tests/sys/fs/fusefs/interrupt.cc | 148 +++--- tests/sys/fs/fusefs/link.cc | 90 ++-- tests/sys/fs/fusefs/locks.cc | 112 ++--- tests/sys/fs/fusefs/lookup.cc | 114 ++--- tests/sys/fs/fusefs/mkdir.cc | 68 +-- tests/sys/fs/fusefs/mknod.cc | 26 +- tests/sys/fs/fusefs/mockfs.cc | 200 ++++---- tests/sys/fs/fusefs/mockfs.hh | 37 +- tests/sys/fs/fusefs/mount.cc | 8 +- tests/sys/fs/fusefs/nfs.cc | 136 +++--- tests/sys/fs/fusefs/open.cc | 54 +-- tests/sys/fs/fusefs/opendir.cc | 16 +- tests/sys/fs/fusefs/read.cc | 70 +-- tests/sys/fs/fusefs/readdir.cc | 50 +- tests/sys/fs/fusefs/readlink.cc | 21 +- tests/sys/fs/fusefs/release.cc | 18 +- tests/sys/fs/fusefs/releasedir.cc | 12 +- tests/sys/fs/fusefs/rename.cc | 64 +-- tests/sys/fs/fusefs/rmdir.cc | 38 +- tests/sys/fs/fusefs/setattr.cc | 432 +++++++++--------- tests/sys/fs/fusefs/statfs.cc | 22 +- tests/sys/fs/fusefs/symlink.cc | 44 +- tests/sys/fs/fusefs/unlink.cc | 24 +- tests/sys/fs/fusefs/utils.cc | 202 ++++---- tests/sys/fs/fusefs/write.cc | 10 +- tests/sys/fs/fusefs/xattr.cc | 90 ++-- 36 files changed, 1382 insertions(+), 1382 deletions(-) diff --git a/tests/sys/fs/fusefs/allow_other.cc b/tests/sys/fs/fusefs/allow_other.cc index cf6bda02071..fef672d0796 100644 --- a/tests/sys/fs/fusefs/allow_other.cc +++ b/tests/sys/fs/fusefs/allow_other.cc @@ -108,9 +108,9 @@ TEST_F(AllowOther, creds) get_unprivileged_id(&uid, &gid); fork(true, &status, [=] { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_LOOKUP && - in->header.uid == uid && - in->header.gid == gid); + return (in.header.opcode == FUSE_LOOKUP && + in.header.uid == uid && + in.header.gid == gid); }, Eq(true)), _) ).Times(1) @@ -143,25 +143,25 @@ TEST_F(AllowOther, privilege_escalation) expect_lookup(RELPATH, ino, S_IFREG | 0600, 0, 2); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.pid == (uint32_t)getpid() && - in->header.uid == (uint32_t)geteuid() && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.pid == (uint32_t)getpid() && + in.header.uid == (uint32_t)geteuid() && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke( - ReturnImmediate([](auto in __unused, auto out) { - out->body.open.fh = fh; - out->header.len = sizeof(out->header); + ReturnImmediate([](auto in __unused, auto& out) { + out.body.open.fh = fh; + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.pid != (uint32_t)getpid() && - in->header.uid != (uint32_t)geteuid() && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.pid != (uint32_t)getpid() && + in.header.uid != (uint32_t)geteuid() && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(AnyNumber()) @@ -228,12 +228,12 @@ TEST_F(NoAllowOther, disallowed_beneath_root) expect_lookup(RELPATH, ino, S_IFDIR | 0755, 0, 1); EXPECT_LOOKUP(ino, RELPATH2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino2; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino2; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; }))); expect_opendir(ino); dfd = open(FULLPATH, O_DIRECTORY); @@ -269,12 +269,12 @@ TEST_F(NoAllowOther, setextattr) fork(true, &status, [&] { EXPECT_LOOKUP(1, RELPATH) .WillOnce(Invoke( - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; }))); /* diff --git a/tests/sys/fs/fusefs/create.cc b/tests/sys/fs/fusefs/create.cc index e922cc03798..2dd13371b12 100644 --- a/tests/sys/fs/fusefs/create.cc +++ b/tests/sys/fs/fusefs/create.cc @@ -44,10 +44,10 @@ void expect_create(const char *relpath, mode_t mode, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_open_in); - return (in->header.opcode == FUSE_CREATE && - in->body.open.mode == mode && + return (in.header.opcode == FUSE_CREATE && + in.body.open.mode == mode && (0 == strcmp(relpath, name))); }, Eq(true)), _) @@ -80,18 +80,18 @@ TEST_F(Create, attr_cache) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(0); @@ -114,25 +114,25 @@ TEST_F(Create, clear_attr_cache) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == 1); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == 1); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = 1; - out->body.attr.attr.mode = S_IFDIR | 0755; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = 1; + out.body.attr.attr.mode = S_IFDIR | 0755; + out.body.attr.attr_valid = UINT64_MAX; }))); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); EXPECT_EQ(0, stat("mountpoint", &sb)) << strerror(errno); @@ -177,30 +177,30 @@ TEST_F(Create, Enosys) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mknod_in); - return (in->header.opcode == FUSE_MKNOD && - in->body.mknod.mode == (S_IFREG | mode) && - in->body.mknod.rdev == 0 && + return (in.header.opcode == FUSE_MKNOD && + in.body.mknod.mode == (S_IFREG | mode) && + in.body.mknod.rdev == 0 && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); @@ -229,12 +229,12 @@ TEST_F(Create, entry_cache_negative) /* create will first do a LOOKUP, adding a negative cache entry */ EXPECT_LOOKUP(1, RELPATH).WillOnce(ReturnNegativeCache(&entry_valid)); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); fd = open(FULLPATH, O_CREAT | O_EXCL, mode); @@ -261,11 +261,11 @@ TEST_F(Create, entry_cache_negative_purge) /* Then the CREATE should purge the negative cache entry */ expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.attr_valid = UINT64_MAX; })); fd = open(FULLPATH, O_CREAT | O_EXCL, mode); @@ -305,12 +305,12 @@ TEST_F(Create, ok) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); fd = open(FULLPATH, O_CREAT | O_EXCL, mode); @@ -336,12 +336,12 @@ TEST_F(Create, wronly_0444) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); fd = open(FULLPATH, O_CREAT | O_WRONLY, mode); @@ -359,12 +359,12 @@ TEST_F(Create_7_8, ok) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); expect_create(RELPATH, mode, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create_7_8); - out->body.create.entry.attr.mode = mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; })); fd = open(FULLPATH, O_CREAT | O_EXCL, mode); diff --git a/tests/sys/fs/fusefs/default_permissions.cc b/tests/sys/fs/fusefs/default_permissions.cc index 88f6d76c6b4..cf190226433 100644 --- a/tests/sys/fs/fusefs/default_permissions.cc +++ b/tests/sys/fs/fusefs/default_permissions.cc @@ -61,7 +61,7 @@ virtual void SetUp() { /* With -o default_permissions, FUSE_ACCESS should never be called */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_ACCESS); + return (in.header.opcode == FUSE_ACCESS); }, Eq(true)), _) ).Times(0); @@ -72,18 +72,18 @@ void expect_chmod(uint64_t ino, mode_t mode, uint64_t size = 0) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == FATTR_MODE && - in->body.setattr.mode == mode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == FATTR_MODE && + in.body.setattr.mode == mode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | mode; - out->body.attr.attr.size = size; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | mode; + out.body.attr.attr.size = size; + out.body.attr.attr_valid = UINT64_MAX; }))); } @@ -91,18 +91,18 @@ void expect_create(const char *relpath, uint64_t ino) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_open_in); - return (in->header.opcode == FUSE_CREATE && + return (in.header.opcode == FUSE_CREATE && (0 == strcmp(relpath, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, create); - out->body.create.entry.attr.mode = S_IFREG | 0644; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = S_IFREG | 0644; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; }))); } @@ -111,19 +111,19 @@ void expect_getattr(uint64_t ino, mode_t mode, uint64_t attr_valid, int times, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = mode; - out->body.attr.attr.size = 0; - out->body.attr.attr.uid = uid; - out->body.attr.attr.uid = gid; - out->body.attr.attr_valid = attr_valid; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = mode; + out.body.attr.attr.size = 0; + out.body.attr.attr.uid = uid; + out.body.attr.attr.uid = gid; + out.body.attr.attr_valid = attr_valid; }))); } @@ -158,7 +158,7 @@ void expect_removexattr() { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_REMOVEXATTR); + return (in.header.opcode == FUSE_REMOVEXATTR); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); @@ -171,7 +171,7 @@ void expect_getxattr(ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETXATTR); + return (in.header.opcode == FUSE_GETXATTR); }, Eq(true)), _) ).WillOnce(Invoke(r)); @@ -184,11 +184,11 @@ void expect_listxattr() { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_LISTXATTR); + return (in.header.opcode == FUSE_LISTXATTR); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto out) { - out->body.listxattr.size = 0; + ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) { + out.body.listxattr.size = 0; SET_OUT_HEADER_LEN(out, listxattr); }))); } @@ -204,7 +204,7 @@ public: { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RENAME); + return (in.header.opcode == FUSE_RENAME); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -217,7 +217,7 @@ void expect_setxattr(int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETXATTR); + return (in.header.opcode == FUSE_SETXATTR); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -312,13 +312,13 @@ TEST_F(Chown, chown_to_self) /* The OS may optimize chown by omitting the redundant setattr */ EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out){ + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out){ SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | mode; - out->body.attr.attr.uid = uid; + out.body.attr.attr.mode = S_IFREG | mode; + out.body.attr.attr.uid = uid; }))); EXPECT_EQ(0, chown(FULLPATH, uid, -1)) << strerror(errno); @@ -342,17 +342,17 @@ TEST_F(Chown, clear_suid) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, uid); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr_valid = UINT64_MAX; }))); EXPECT_EQ(0, chown(FULLPATH, uid, -1)) << strerror(errno); @@ -371,7 +371,7 @@ TEST_F(Chown, eperm) expect_lookup(RELPATH, ino, S_IFREG | mode, UINT64_MAX, geteuid()); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) ).Times(0); @@ -399,17 +399,17 @@ TEST_F(Chgrp, clear_suid) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, uid, gid); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr_valid = UINT64_MAX; }))); EXPECT_EQ(0, chown(FULLPATH, -1, gid)) << strerror(errno); @@ -433,7 +433,7 @@ TEST_F(Chgrp, eperm) expect_lookup(RELPATH, ino, S_IFREG | mode, UINT64_MAX, uid, gid); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) ).Times(0); @@ -460,15 +460,15 @@ TEST_F(Chgrp, ok) /* The OS may optimize chgrp by omitting the redundant setattr */ EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out){ + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out){ SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | mode; - out->body.attr.attr.uid = uid; - out->body.attr.attr.gid = newgid; + out.body.attr.attr.mode = S_IFREG | mode; + out.body.attr.attr.uid = uid; + out.body.attr.attr.gid = newgid; }))); EXPECT_EQ(0, chown(FULLPATH, -1, newgid)) << strerror(errno); @@ -564,15 +564,15 @@ TEST_F(Utimensat, utime_now) expect_lookup(RELPATH, ino, S_IFREG | mode, UINT64_MAX, owner); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid & FATTR_ATIME && - in->body.setattr.valid & FATTR_MTIME); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid & FATTR_ATIME && + in.body.setattr.valid & FATTR_MTIME); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | mode; + out.body.attr.attr.mode = S_IFREG | mode; }))); ASSERT_EQ(0, utimensat(AT_FDCWD, FULLPATH, ×[0], 0)) @@ -647,9 +647,9 @@ TEST_F(Getextattr, ok) /* Getting user attributes only requires read access */ expect_lookup(RELPATH, ino, S_IFREG | 0444, UINT64_MAX, 0); expect_getxattr( - ReturnImmediate([&](auto in __unused, auto out) { - memcpy((void*)out->body.bytes, value, value_len); - out->header.len = sizeof(out->header) + value_len; + ReturnImmediate([&](auto in __unused, auto& out) { + memcpy((void*)out.body.bytes, value, value_len); + out.header.len = sizeof(out.header) + value_len; }) ); @@ -892,13 +892,13 @@ TEST_F(Rename, eperm_on_sticky_dstdir) expect_lookup(RELSRC, src_ino, S_IFREG | 0644, UINT64_MAX); expect_lookup(RELDSTDIR, dstdir_ino, S_IFDIR | 01777, UINT64_MAX); EXPECT_LOOKUP(dstdir_ino, RELDST) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = dst_ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.uid = 0; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = dst_ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.uid = 0; }))); ASSERT_EQ(-1, rename(FULLSRC, FULLDST)); @@ -952,14 +952,14 @@ TEST_F(Setattr, ok) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, geteuid()); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.mode = S_IFREG | newmode; }))); EXPECT_EQ(0, chmod(FULLPATH, newmode)) << strerror(errno); @@ -977,7 +977,7 @@ TEST_F(Setattr, eacces) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, 0); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) ).Times(0); @@ -1004,16 +1004,16 @@ TEST_F(Setattr, ftruncate_of_newly_created_file) expect_create(RELPATH, ino); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - (in->body.setattr.valid & FATTR_SIZE)); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + (in.body.setattr.valid & FATTR_SIZE)); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; - out->body.attr.attr.mode = S_IFREG | mode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; + out.body.attr.attr.mode = S_IFREG | mode; + out.body.attr.attr_valid = UINT64_MAX; }))); fd = open(FULLPATH, O_CREAT | O_RDWR, 0); @@ -1040,7 +1040,7 @@ TEST_F(Setattr, sgid_by_non_group_member) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, uid, gid); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) ).Times(0); @@ -1062,7 +1062,7 @@ TEST_F(Setattr, sticky_regular_file) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, geteuid()); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) ).Times(0); @@ -1173,11 +1173,11 @@ TEST_F(Unlink, cached_unwritable_directory) EXPECT_LOOKUP(1, RELPATH) .Times(AnyNumber()) .WillRepeatedly(Invoke( - ReturnImmediate([=](auto i __unused, auto out) { + ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; })) ); diff --git a/tests/sys/fs/fusefs/default_permissions_privileged.cc b/tests/sys/fs/fusefs/default_permissions_privileged.cc index 186bc79a8d6..621411b0958 100644 --- a/tests/sys/fs/fusefs/default_permissions_privileged.cc +++ b/tests/sys/fs/fusefs/default_permissions_privileged.cc @@ -60,7 +60,7 @@ virtual void SetUp() { /* With -o default_permissions, FUSE_ACCESS should never be called */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_ACCESS); + return (in.header.opcode == FUSE_ACCESS); }, Eq(true)), _) ).Times(0); @@ -72,19 +72,19 @@ void expect_getattr(uint64_t ino, mode_t mode, uint64_t attr_valid, int times, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = mode; - out->body.attr.attr.size = 0; - out->body.attr.attr.uid = uid; - out->body.attr.attr.uid = gid; - out->body.attr.attr_valid = attr_valid; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = mode; + out.body.attr.attr.size = 0; + out.body.attr.attr.uid = uid; + out.body.attr.attr.uid = gid; + out.body.attr.attr_valid = attr_valid; }))); } @@ -110,12 +110,12 @@ TEST_F(Setattr, sticky_regular_file) expect_lookup(RELPATH, ino, S_IFREG | oldmode, UINT64_MAX, geteuid()); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.mode = S_IFREG | newmode; }))); EXPECT_EQ(0, chmod(FULLPATH, newmode)) << strerror(errno); diff --git a/tests/sys/fs/fusefs/dev_fuse_poll.cc b/tests/sys/fs/fusefs/dev_fuse_poll.cc index f915ccab681..3504ec0a341 100644 --- a/tests/sys/fs/fusefs/dev_fuse_poll.cc +++ b/tests/sys/fs/fusefs/dev_fuse_poll.cc @@ -127,73 +127,73 @@ TEST_F(Kqueue, data) ASSERT_EQ(0, sem_init(&sem1, 0, 0)) << strerror(errno); EXPECT_LOOKUP(1, "foo") - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = foo_ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = foo_ino; }))); EXPECT_LOOKUP(1, "bar") - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = bar_ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = bar_ino; }))); EXPECT_LOOKUP(1, "baz") - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = baz_ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = baz_ino; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == foo_ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == foo_ino); }, Eq(true)), _) ) - .WillOnce(Invoke(ReturnImmediate([&](auto in, auto out) { + .WillOnce(Invoke(ReturnImmediate([&](auto in, auto& out) { nready0 = m_mock->m_nready; sem_post(&sem0); // Block the daemon so we can accumulate a few more ops sem_wait(&sem1); - out->header.unique = in->header.unique; - out->header.error = -EIO; - out->header.len = sizeof(out->header); + out.header.unique = in.header.unique; + out.header.error = -EIO; + out.header.len = sizeof(out.header); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - (in->header.nodeid == bar_ino || - in->header.nodeid == baz_ino)); + return (in.header.opcode == FUSE_GETATTR && + (in.header.nodeid == bar_ino || + in.header.nodeid == baz_ino)); }, Eq(true)), _) ).InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([&](auto in, auto out) { + .WillOnce(Invoke(ReturnImmediate([&](auto in, auto& out) { nready1 = m_mock->m_nready; - out->header.unique = in->header.unique; - out->header.error = -EIO; - out->header.len = sizeof(out->header); + out.header.unique = in.header.unique; + out.header.error = -EIO; + out.header.len = sizeof(out.header); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - (in->header.nodeid == bar_ino || - in->header.nodeid == baz_ino)); + return (in.header.opcode == FUSE_GETATTR && + (in.header.nodeid == bar_ino || + in.header.nodeid == baz_ino)); }, Eq(true)), _) ).InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([&](auto in, auto out) { + .WillOnce(Invoke(ReturnImmediate([&](auto in, auto& out) { nready2 = m_mock->m_nready; - out->header.unique = in->header.unique; - out->header.error = -EIO; - out->header.len = sizeof(out->header); + out.header.unique = in.header.unique; + out.header.error = -EIO; + out.header.len = sizeof(out.header); }))); /* diff --git a/tests/sys/fs/fusefs/fifo.cc b/tests/sys/fs/fusefs/fifo.cc index bf9314bd9ba..62fe68bc885 100644 --- a/tests/sys/fs/fusefs/fifo.cc +++ b/tests/sys/fs/fusefs/fifo.cc @@ -159,27 +159,27 @@ TEST_F(Socket, read_write) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_MKNOD); + return (in.header.opcode == FUSE_MKNOD); }, Eq(true)), _) ).InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; }))); EXPECT_LOOKUP(1, RELPATH) .InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); fd = socket(AF_UNIX, SOCK_STREAM, 0); diff --git a/tests/sys/fs/fusefs/flush.cc b/tests/sys/fs/fusefs/flush.cc index 38169023da8..c501984ebaa 100644 --- a/tests/sys/fs/fusefs/flush.cc +++ b/tests/sys/fs/fusefs/flush.cc @@ -46,10 +46,10 @@ expect_flush(uint64_t ino, int times, pid_t lo, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FLUSH && - in->header.nodeid == ino && - in->body.flush.lock_owner == (uint64_t)lo && - in->body.flush.fh == FH); + return (in.header.opcode == FUSE_FLUSH && + in.header.nodeid == ino && + in.body.flush.lock_owner == (uint64_t)lo && + in.body.flush.fh == FH); }, Eq(true)), _) ).Times(times) @@ -69,7 +69,7 @@ void expect_release() { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RELEASE); + return (in.header.opcode == FUSE_RELEASE); }, Eq(true)), _) ).WillRepeatedly(Invoke(ReturnErrno(0))); @@ -206,9 +206,9 @@ TEST_F(FlushWithLocks, unlock_on_close) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlk.fh == FH); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlk.fh == FH); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); diff --git a/tests/sys/fs/fusefs/fsync.cc b/tests/sys/fs/fusefs/fsync.cc index 23bb58713e8..e5bb9046430 100644 --- a/tests/sys/fs/fusefs/fsync.cc +++ b/tests/sys/fs/fusefs/fsync.cc @@ -54,15 +54,15 @@ void expect_fsync(uint64_t ino, uint32_t flags, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FSYNC && - in->header.nodeid == ino && + return (in.header.opcode == FUSE_FSYNC && + in.header.nodeid == ino && /* * TODO: reenable pid check after fixing * bug 236379 */ - //(pid_t)in->header.pid == getpid() && - in->body.fsync.fh == FH && - in->body.fsync.fsync_flags == flags); + //(pid_t)in.header.pid == getpid() && + in.body.fsync.fh == FH && + in.body.fsync.fsync_flags == flags); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -129,16 +129,16 @@ TEST_F(Fsync, close) expect_write(ino, bufsize, CONTENTS); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.ino = ino; // Must match nodeid }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FSYNC); + return (in.header.opcode == FUSE_FSYNC); }, Eq(true)), _) ).Times(0); diff --git a/tests/sys/fs/fusefs/fsyncdir.cc b/tests/sys/fs/fusefs/fsyncdir.cc index c8c861eb6e4..c7cc4c72131 100644 --- a/tests/sys/fs/fusefs/fsyncdir.cc +++ b/tests/sys/fs/fusefs/fsyncdir.cc @@ -54,15 +54,15 @@ void expect_fsyncdir(uint64_t ino, uint32_t flags, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FSYNCDIR && - in->header.nodeid == ino && + return (in.header.opcode == FUSE_FSYNCDIR && + in.header.nodeid == ino && /* * TODO: reenable pid check after fixing * bug 236379 */ - //(pid_t)in->header.pid == getpid() && - in->body.fsyncdir.fh == FH && - in->body.fsyncdir.fsync_flags == flags); + //(pid_t)in.header.pid == getpid() && + in.body.fsyncdir.fh == FH && + in.body.fsyncdir.fsync_flags == flags); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); diff --git a/tests/sys/fs/fusefs/getattr.cc b/tests/sys/fs/fusefs/getattr.cc index d0b4dcd076d..9a32852111f 100644 --- a/tests/sys/fs/fusefs/getattr.cc +++ b/tests/sys/fs/fusefs/getattr.cc @@ -44,15 +44,15 @@ void expect_lookup(const char *relpath, uint64_t ino, mode_t mode, { EXPECT_LOOKUP(1, relpath) .Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = attr_valid; - out->body.entry.attr_valid_nsec = attr_valid_nsec; - out->body.entry.attr.size = size; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = attr_valid; + out.body.entry.attr_valid_nsec = attr_valid_nsec; + out.body.entry.attr.size = size; + out.body.entry.entry_valid = UINT64_MAX; }))); } }; @@ -77,23 +77,23 @@ TEST_F(Getattr, attr_cache) struct stat sb; EXPECT_LOOKUP(1, RELPATH) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr_valid = UINT64_MAX; - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; }))); EXPECT_EQ(0, stat(FULLPATH, &sb)); /* The second stat(2) should use cached attributes */ @@ -115,17 +115,17 @@ TEST_F(Getattr, attr_cache_timeout) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1, 0, 0); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr_valid_nsec = NAP_NS / 2; - out->body.attr.attr_valid = 0; - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr_valid_nsec = NAP_NS / 2; + out.body.attr.attr_valid = 0; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; }))); EXPECT_EQ(0, stat(FULLPATH, &sb)); @@ -148,15 +148,15 @@ TEST_F(Getattr, blksize_zero) expect_lookup(RELPATH, ino, S_IFREG | 0644, 1, 1, 0, 0); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.blksize = 0; + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.blksize = 0; }))); ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); @@ -173,8 +173,8 @@ TEST_F(Getattr, enoent) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1, 0, 0); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(ENOENT))); @@ -192,27 +192,27 @@ TEST_F(Getattr, ok) expect_lookup(RELPATH, ino, S_IFREG | 0644, 1, 1, 0, 0); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.size = 1; - out->body.attr.attr.blocks = 2; - out->body.attr.attr.atime = 3; - out->body.attr.attr.mtime = 4; - out->body.attr.attr.ctime = 5; - out->body.attr.attr.atimensec = 6; - out->body.attr.attr.mtimensec = 7; - out->body.attr.attr.ctimensec = 8; - out->body.attr.attr.nlink = 9; - out->body.attr.attr.uid = 10; - out->body.attr.attr.gid = 11; - out->body.attr.attr.rdev = 12; - out->body.attr.attr.blksize = 12345; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.size = 1; + out.body.attr.attr.blocks = 2; + out.body.attr.attr.atime = 3; + out.body.attr.attr.mtime = 4; + out.body.attr.attr.ctime = 5; + out.body.attr.attr.atimensec = 6; + out.body.attr.attr.mtimensec = 7; + out.body.attr.attr.ctimensec = 8; + out.body.attr.attr.nlink = 9; + out.body.attr.attr.uid = 10; + out.body.attr.attr.gid = 11; + out.body.attr.attr.rdev = 12; + out.body.attr.attr.blksize = 12345; }))); ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); @@ -248,35 +248,35 @@ TEST_F(Getattr_7_8, ok) struct stat sb; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr.size = 1; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr.size = 1; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr_7_8); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.size = 1; - out->body.attr.attr.blocks = 2; - out->body.attr.attr.atime = 3; - out->body.attr.attr.mtime = 4; - out->body.attr.attr.ctime = 5; - out->body.attr.attr.atimensec = 6; - out->body.attr.attr.mtimensec = 7; - out->body.attr.attr.ctimensec = 8; - out->body.attr.attr.nlink = 9; - out->body.attr.attr.uid = 10; - out->body.attr.attr.gid = 11; - out->body.attr.attr.rdev = 12; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.size = 1; + out.body.attr.attr.blocks = 2; + out.body.attr.attr.atime = 3; + out.body.attr.attr.mtime = 4; + out.body.attr.attr.ctime = 5; + out.body.attr.attr.atimensec = 6; + out.body.attr.attr.mtimensec = 7; + out.body.attr.attr.ctimensec = 8; + out.body.attr.attr.nlink = 9; + out.body.attr.attr.uid = 10; + out.body.attr.attr.gid = 11; + out.body.attr.attr.rdev = 12; }))); ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); diff --git a/tests/sys/fs/fusefs/interrupt.cc b/tests/sys/fs/fusefs/interrupt.cc index 63124afce96..c142b2c8297 100644 --- a/tests/sys/fs/fusefs/interrupt.cc +++ b/tests/sys/fs/fusefs/interrupt.cc @@ -100,11 +100,11 @@ void expect_mkdir(uint64_t *mkdir_unique) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) ).WillOnce(Invoke([=](auto in, auto &out __unused) { - *mkdir_unique = in->header.unique; + *mkdir_unique = in.header.unique; sem_post(blocked_semaphore); })); } @@ -117,12 +117,12 @@ void expect_read(uint64_t ino, uint64_t *read_unique) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke([=](auto in, auto &out __unused) { - *read_unique = in->header.unique; + *read_unique = in.header.unique; sem_post(blocked_semaphore); })); } @@ -135,12 +135,12 @@ void expect_write(uint64_t ino, uint64_t *write_unique) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_WRITE && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_WRITE && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke([=](auto in, auto &out __unused) { - *write_unique = in->header.unique; + *write_unique = in.header.unique; sem_post(blocked_semaphore); })); } @@ -228,33 +228,33 @@ TEST_F(Interrupt, already_complete) expect_mkdir(&mkdir_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in, auto &out) { // First complete the mkdir request - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->header.unique = mkdir_unique; - SET_OUT_HEADER_LEN(out0, entry); + SET_OUT_HEADER_LEN(*out0, entry); out0->body.create.entry.attr.mode = S_IFDIR | MODE; out0->body.create.entry.nodeid = ino; - out.push_back(out0); + out.push_back(std::move(out0)); // Then, respond EAGAIN to the interrupt request - auto out1 = new mockfs_buf_out; - out1->header.unique = in->header.unique; + std::unique_ptr out1(new mockfs_buf_out); + out1->header.unique = in.header.unique; out1->header.error = -EAGAIN; out1->header.len = sizeof(out1->header); - out.push_back(out1); + out.push_back(std::move(out1)); })); EXPECT_LOOKUP(1, RELDIRPATH0) .InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | MODE; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 2; + out.body.entry.attr.mode = S_IFDIR | MODE; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 2; }))); setup_interruptor(self); @@ -289,44 +289,44 @@ TEST_F(Interrupt, enosys) expect_mkdir(&mkdir_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).InSequence(seq) .WillOnce(Invoke([&](auto in, auto &out) { // reject FUSE_INTERRUPT and respond to the FUSE_MKDIR - auto out0 = new mockfs_buf_out; - auto out1 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); + std::unique_ptr out1(new mockfs_buf_out); - out0->header.unique = in->header.unique; + out0->header.unique = in.header.unique; out0->header.error = -ENOSYS; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); - SET_OUT_HEADER_LEN(out1, entry); + SET_OUT_HEADER_LEN(*out1, entry); out1->body.create.entry.attr.mode = S_IFDIR | MODE; out1->body.create.entry.nodeid = ino1; out1->header.unique = mkdir_unique; - out.push_back(out1); + out.push_back(std::move(out1)); })); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) ).InSequence(seq) .WillOnce(Invoke([&](auto in, auto &out) { - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); sem_post(&sem0); sem_wait(&sem1); - SET_OUT_HEADER_LEN(out0, entry); + SET_OUT_HEADER_LEN(*out0, entry); out0->body.create.entry.attr.mode = S_IFDIR | MODE; out0->body.create.entry.nodeid = ino0; - out0->header.unique = in->header.unique; - out.push_back(out0); + out0->header.unique = in.header.unique; + out.push_back(std::move(out0)); })); setup_interruptor(self); @@ -367,8 +367,8 @@ TEST_F(Interrupt, fatal_signal) expect_mkdir(&mkdir_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out __unused) { @@ -424,18 +424,18 @@ TEST_F(Interrupt, ignore) expect_mkdir(&mkdir_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out) { // Ignore FUSE_INTERRUPT; respond to the FUSE_MKDIR - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->header.unique = mkdir_unique; - SET_OUT_HEADER_LEN(out0, entry); + SET_OUT_HEADER_LEN(*out0, entry); out0->body.create.entry.attr.mode = S_IFDIR | MODE; out0->body.create.entry.nodeid = ino; - out.push_back(out0); + out.push_back(std::move(out0)); })); setup_interruptor(self); @@ -466,18 +466,18 @@ TEST_F(Interrupt, in_kernel_restartable) expect_open(ino1, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto& out) { /* Let the next write proceed */ sem_post(&sem1); /* Pause the daemon thread so it won't read the next op */ sem_wait(&sem0); SET_OUT_HEADER_LEN(out, entry); - out->body.create.entry.attr.mode = S_IFDIR | MODE; - out->body.create.entry.nodeid = ino0; + out.body.create.entry.attr.mode = S_IFDIR | MODE; + out.body.create.entry.nodeid = ino0; }))); FuseTest::expect_read(ino1, 0, FILESIZE, 0, NULL); @@ -539,18 +539,18 @@ TEST_F(Interrupt, in_kernel_nonrestartable) expect_open(ino1, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto& out) { /* Let the next write proceed */ sem_post(&sem1); /* Pause the daemon thread so it won't read the next op */ sem_wait(&sem0); SET_OUT_HEADER_LEN(out, entry); - out->body.create.entry.attr.mode = S_IFDIR | MODE; - out->body.create.entry.nodeid = ino0; + out.body.create.entry.attr.mode = S_IFDIR | MODE; + out.body.create.entry.nodeid = ino0; }))); fd1 = open(FULLPATH1, O_WRONLY); @@ -597,16 +597,16 @@ TEST_F(Interrupt, in_progress) expect_mkdir(&mkdir_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out) { - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->header.error = -EINTR; out0->header.unique = mkdir_unique; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); })); setup_interruptor(self); @@ -633,16 +633,16 @@ TEST_F(Interrupt, in_progress_read) expect_read(ino, &read_unique); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == read_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == read_unique); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out) { - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->header.error = -EINTR; out0->header.unique = read_unique; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); })); fd = open(FULLPATH, O_RDONLY); @@ -670,12 +670,12 @@ TEST_F(Interrupt, priority) EXPECT_LOOKUP(1, RELDIRPATH1).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) ).InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([&](auto in, auto out) { - mkdir_unique = in->header.unique; + .WillOnce(Invoke(ReturnImmediate([&](auto in, auto& out) { + mkdir_unique = in.header.unique; /* Let the next mkdir proceed */ sem_post(&sem1); @@ -684,9 +684,9 @@ TEST_F(Interrupt, priority) sem_wait(&sem0); /* Finally, interrupt the original op */ - out->header.error = -EINTR; - out->header.unique = mkdir_unique; - out->header.len = sizeof(out->header); + out.header.error = -EINTR; + out.header.unique = mkdir_unique; + out.header.len = sizeof(out.header); }))); /* * FUSE_INTERRUPT should be received before the second FUSE_MKDIR, @@ -694,22 +694,22 @@ TEST_F(Interrupt, priority) */ EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).InSequence(seq) .WillOnce(Invoke(ReturnErrno(EAGAIN))); EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_MKDIR); + return (in.header.opcode == FUSE_MKDIR); }, Eq(true)), _) ).InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.create.entry.attr.mode = S_IFDIR | MODE; - out->body.create.entry.nodeid = ino1; + out.body.create.entry.attr.mode = S_IFDIR | MODE; + out.body.create.entry.nodeid = ino1; }))); /* Use a separate thread for the first mkdir */ @@ -751,8 +751,8 @@ TEST_F(Interrupt, too_soon) EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).InSequence(seq) @@ -760,17 +760,17 @@ TEST_F(Interrupt, too_soon) EXPECT_CALL(*m_mock, process( ResultOf([&](auto in) { - return (in->header.opcode == FUSE_INTERRUPT && - in->body.interrupt.unique == mkdir_unique); + return (in.header.opcode == FUSE_INTERRUPT && + in.body.interrupt.unique == mkdir_unique); }, Eq(true)), _) ).InSequence(seq) .WillOnce(Invoke([&](auto in __unused, auto &out __unused) { - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->header.error = -EINTR; out0->header.unique = mkdir_unique; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); })); setup_interruptor(self); diff --git a/tests/sys/fs/fusefs/link.cc b/tests/sys/fs/fusefs/link.cc index 3236b471e1f..d79b711afab 100644 --- a/tests/sys/fs/fusefs/link.cc +++ b/tests/sys/fs/fusefs/link.cc @@ -43,20 +43,20 @@ void expect_link(uint64_t ino, const char *relpath, mode_t mode, uint32_t nlink) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + const char *name = (const char*)in.body.bytes + sizeof(struct fuse_link_in); - return (in->header.opcode == FUSE_LINK && - in->body.link.oldnodeid == ino && + return (in.header.opcode == FUSE_LINK && + in.body.link.oldnodeid == ino && (0 == strcmp(name, relpath))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.nodeid = ino; - out->body.entry.attr.mode = mode; - out->body.entry.attr.nlink = nlink; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.nodeid = ino; + out.body.entry.attr.mode = mode; + out.body.entry.attr.nlink = nlink; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); } @@ -77,20 +77,20 @@ void expect_link(uint64_t ino, const char *relpath, mode_t mode, uint32_t nlink) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + const char *name = (const char*)in.body.bytes + sizeof(struct fuse_link_in); - return (in->header.opcode == FUSE_LINK && - in->body.link.oldnodeid == ino && + return (in.header.opcode == FUSE_LINK && + in.body.link.oldnodeid == ino && (0 == strcmp(name, relpath))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.nodeid = ino; - out->body.entry.attr.mode = mode; - out->body.entry.attr.nlink = nlink; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.nodeid = ino; + out.body.entry.attr.mode = mode; + out.body.entry.attr.nlink = nlink; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); } @@ -117,26 +117,26 @@ TEST_F(Link, clear_attr_cache) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == 1); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == 1); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = 1; - out->body.attr.attr.mode = S_IFDIR | 0755; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = 1; + out.body.attr.attr.mode = S_IFDIR | 0755; + out.body.attr.attr_valid = UINT64_MAX; }))); EXPECT_LOOKUP(1, RELDST) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); expect_link(ino, RELPATH, mode, 2); @@ -158,10 +158,10 @@ TEST_F(Link, emlink) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + const char *name = (const char*)in.body.bytes + sizeof(struct fuse_link_in); - return (in->header.opcode == FUSE_LINK && - in->body.link.oldnodeid == dst_ino && + return (in.header.opcode == FUSE_LINK && + in.body.link.oldnodeid == dst_ino && (0 == strcmp(name, RELPATH))); }, Eq(true)), _) @@ -183,13 +183,13 @@ TEST_F(Link, ok) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_LOOKUP(1, RELDST) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); expect_link(ino, RELPATH, mode, 2); @@ -211,13 +211,13 @@ TEST_F(Link_7_8, ok) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_LOOKUP(1, RELDST) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); expect_link(ino, RELPATH, mode, 2); diff --git a/tests/sys/fs/fusefs/locks.cc b/tests/sys/fs/fusefs/locks.cc index d5745e3d0ab..6d4c3c5d8bc 100644 --- a/tests/sys/fs/fusefs/locks.cc +++ b/tests/sys/fs/fusefs/locks.cc @@ -110,20 +110,20 @@ TEST_F(Getlk, no_locks) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETLK && - in->header.nodeid == ino && - in->body.getlk.fh == FH && - in->body.getlk.owner == (uint32_t)pid && - in->body.getlk.lk.start == 10 && - in->body.getlk.lk.end == 1009 && - in->body.getlk.lk.type == F_RDLCK && - in->body.getlk.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_GETLK && + in.header.nodeid == ino && + in.body.getlk.fh == FH && + in.body.getlk.owner == (uint32_t)pid && + in.body.getlk.lk.start == 10 && + in.body.getlk.lk.end == 1009 && + in.body.getlk.lk.type == F_RDLCK && + in.body.getlk.lk.pid == (uint64_t)pid); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in, auto& out) { SET_OUT_HEADER_LEN(out, getlk); - out->body.getlk.lk = in->body.getlk.lk; - out->body.getlk.lk.type = F_UNLCK; + out.body.getlk.lk = in.body.getlk.lk; + out.body.getlk.lk.type = F_UNLCK; }))); fd = open(FULLPATH, O_RDWR); @@ -154,22 +154,22 @@ TEST_F(Getlk, lock_exists) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETLK && - in->header.nodeid == ino && - in->body.getlk.fh == FH && - in->body.getlk.owner == (uint32_t)pid && - in->body.getlk.lk.start == 10 && - in->body.getlk.lk.end == 1009 && - in->body.getlk.lk.type == F_RDLCK && - in->body.getlk.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_GETLK && + in.header.nodeid == ino && + in.body.getlk.fh == FH && + in.body.getlk.owner == (uint32_t)pid && + in.body.getlk.lk.start == 10 && + in.body.getlk.lk.end == 1009 && + in.body.getlk.lk.type == F_RDLCK && + in.body.getlk.lk.pid == (uint64_t)pid); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, getlk); - out->body.getlk.lk.start = 100; - out->body.getlk.lk.end = 199; - out->body.getlk.lk.type = F_WRLCK; - out->body.getlk.lk.pid = (uint32_t)pid2;; + out.body.getlk.lk.start = 100; + out.body.getlk.lk.end = 199; + out.body.getlk.lk.type = F_WRLCK; + out.body.getlk.lk.pid = (uint32_t)pid2;; }))); fd = open(FULLPATH, O_RDWR); @@ -231,14 +231,14 @@ TEST_F(Setlk, set) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlk.fh == FH && - in->body.setlk.owner == (uint32_t)pid && - in->body.setlk.lk.start == 10 && - in->body.setlk.lk.end == 1009 && - in->body.setlk.lk.type == F_RDLCK && - in->body.setlk.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlk.fh == FH && + in.body.setlk.owner == (uint32_t)pid && + in.body.setlk.lk.start == 10 && + in.body.setlk.lk.end == 1009 && + in.body.setlk.lk.type == F_RDLCK && + in.body.setlk.lk.pid == (uint64_t)pid); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); @@ -269,14 +269,14 @@ TEST_F(Setlk, set_eof) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlk.fh == FH && - in->body.setlk.owner == (uint32_t)pid && - in->body.setlk.lk.start == 10 && - in->body.setlk.lk.end == OFFSET_MAX && - in->body.setlk.lk.type == F_RDLCK && - in->body.setlk.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlk.fh == FH && + in.body.setlk.owner == (uint32_t)pid && + in.body.setlk.lk.start == 10 && + in.body.setlk.lk.end == OFFSET_MAX && + in.body.setlk.lk.type == F_RDLCK && + in.body.setlk.lk.pid == (uint64_t)pid); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); @@ -307,14 +307,14 @@ TEST_F(Setlk, eagain) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlk.fh == FH && - in->body.setlk.owner == (uint32_t)pid && - in->body.setlk.lk.start == 10 && - in->body.setlk.lk.end == 1009 && - in->body.setlk.lk.type == F_RDLCK && - in->body.setlk.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlk.fh == FH && + in.body.setlk.owner == (uint32_t)pid && + in.body.setlk.lk.start == 10 && + in.body.setlk.lk.end == 1009 && + in.body.setlk.lk.type == F_RDLCK && + in.body.setlk.lk.pid == (uint64_t)pid); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EAGAIN))); @@ -377,14 +377,14 @@ TEST_F(Setlkw, set) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlkw.fh == FH && - in->body.setlkw.owner == (uint32_t)pid && - in->body.setlkw.lk.start == 10 && - in->body.setlkw.lk.end == 1009 && - in->body.setlkw.lk.type == F_RDLCK && - in->body.setlkw.lk.pid == (uint64_t)pid); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlkw.fh == FH && + in.body.setlkw.owner == (uint32_t)pid && + in.body.setlkw.lk.start == 10 && + in.body.setlkw.lk.end == 1009 && + in.body.setlkw.lk.type == F_RDLCK && + in.body.setlkw.lk.pid == (uint64_t)pid); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); diff --git a/tests/sys/fs/fusefs/lookup.cc b/tests/sys/fs/fusefs/lookup.cc index 03c51e766ad..1e2761ee2a3 100644 --- a/tests/sys/fs/fusefs/lookup.cc +++ b/tests/sys/fs/fusefs/lookup.cc @@ -59,25 +59,25 @@ TEST_F(Lookup, attr_cache) struct stat sb; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.ino = ino; // Must match nodeid - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.attr.size = 1; - out->body.entry.attr.blocks = 2; - out->body.entry.attr.atime = 3; - out->body.entry.attr.mtime = 4; - out->body.entry.attr.ctime = 5; - out->body.entry.attr.atimensec = 6; - out->body.entry.attr.mtimensec = 7; - out->body.entry.attr.ctimensec = 8; - out->body.entry.attr.nlink = 9; - out->body.entry.attr.uid = 10; - out->body.entry.attr.gid = 11; - out->body.entry.attr.rdev = 12; - out->body.entry.generation = generation; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.ino = ino; // Must match nodeid + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.attr.size = 1; + out.body.entry.attr.blocks = 2; + out.body.entry.attr.atime = 3; + out.body.entry.attr.mtime = 4; + out.body.entry.attr.ctime = 5; + out.body.entry.attr.atimensec = 6; + out.body.entry.attr.mtimensec = 7; + out.body.entry.attr.ctimensec = 8; + out.body.entry.attr.nlink = 9; + out.body.entry.attr.uid = 10; + out.body.entry.attr.gid = 11; + out.body.entry.attr.rdev = 12; + out.body.entry.generation = generation; }))); /* stat(2) issues a VOP_LOOKUP followed by a VOP_GETATTR */ ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); @@ -120,12 +120,12 @@ TEST_F(Lookup, attr_cache_timeout) EXPECT_LOOKUP(1, RELPATH) .Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.nodeid = ino; - out->body.entry.attr_valid_nsec = NAP_NS / 2; - out->body.entry.attr.ino = ino; // Must match nodeid - out->body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid_nsec = NAP_NS / 2; + out.body.entry.attr.ino = ino; // Must match nodeid + out.body.entry.attr.mode = S_IFREG | 0644; }))); /* access(2) will issue a VOP_LOOKUP and fill the attr cache */ @@ -143,12 +143,12 @@ TEST_F(Lookup, dot) uint64_t ino = 42; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); /* @@ -164,12 +164,12 @@ TEST_F(Lookup, dotdot) const char RELDIRPATH[] = "some_dir"; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = 14; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = 14; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); /* @@ -195,11 +195,11 @@ TEST_F(Lookup, enotdir) const char RELPATH[] = "not_a_dir"; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = 42; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = 42; }))); ASSERT_EQ(-1, access(FULLPATH, F_OK)); @@ -216,11 +216,11 @@ TEST_F(Lookup, entry_cache) const char RELPATH[] = "some_file.txt"; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = 14; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = 14; }))); ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno); /* The second access(2) should use the cache */ @@ -275,11 +275,11 @@ TEST_F(Lookup, entry_cache_timeout) EXPECT_LOOKUP(1, RELPATH) .Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.entry_valid_nsec = NAP_NS / 2; - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = 14; + out.body.entry.entry_valid_nsec = NAP_NS / 2; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = 14; }))); /* access(2) will issue a VOP_LOOKUP and fill the entry cache */ @@ -303,10 +303,10 @@ TEST_F(Lookup, ok) const char RELPATH[] = "some_file.txt"; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = 14; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = 14; }))); /* * access(2) is one of the few syscalls that will not (always) follow @@ -325,16 +325,16 @@ TEST_F(Lookup, subdir) uint64_t file_ino = 3; EXPECT_LOOKUP(1, DIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = dir_ino; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = dir_ino; }))); EXPECT_LOOKUP(dir_ino, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = file_ino; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = file_ino; }))); /* * access(2) is one of the few syscalls that will not (always) follow @@ -369,10 +369,10 @@ TEST_F(Lookup_7_8, ok) const char RELPATH[] = "some_file.txt"; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = 14; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = 14; }))); /* * access(2) is one of the few syscalls that will not (always) follow diff --git a/tests/sys/fs/fusefs/mkdir.cc b/tests/sys/fs/fusefs/mkdir.cc index 0ac070a3e50..85b098cf1fb 100644 --- a/tests/sys/fs/fusefs/mkdir.cc +++ b/tests/sys/fs/fusefs/mkdir.cc @@ -60,10 +60,10 @@ TEST_F(Mkdir, emlink) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mkdir_in); - return (in->header.opcode == FUSE_MKDIR && - in->body.mkdir.mode == (S_IFDIR | mode) && + return (in.header.opcode == FUSE_MKDIR && + in.body.mkdir.mode == (S_IFDIR | mode) && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) @@ -94,19 +94,19 @@ TEST_F(Mkdir, entry_cache_negative) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_open_in); - return (in->header.opcode == FUSE_MKDIR && - in->body.mkdir.mode == (S_IFDIR | mode) && + return (in.header.opcode == FUSE_MKDIR && + in.body.mkdir.mode == (S_IFDIR | mode) && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.create.entry.attr.mode = S_IFDIR | mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = S_IFDIR | mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno); @@ -131,18 +131,18 @@ TEST_F(Mkdir, entry_cache_negative_purge) /* Then the MKDIR should purge the negative cache entry */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_open_in); - return (in->header.opcode == FUSE_MKDIR && - in->body.mkdir.mode == (S_IFDIR | mode) && + return (in.header.opcode == FUSE_MKDIR && + in.body.mkdir.mode == (S_IFDIR | mode) && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | mode; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | mode; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno); @@ -164,19 +164,19 @@ TEST_F(Mkdir, ok) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mkdir_in); - return (in->header.opcode == FUSE_MKDIR && - in->body.mkdir.mode == (S_IFDIR | mode) && + return (in.header.opcode == FUSE_MKDIR && + in.body.mkdir.mode == (S_IFDIR | mode) && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.create.entry.attr.mode = S_IFDIR | mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = S_IFDIR | mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno); @@ -193,19 +193,19 @@ TEST_F(Mkdir_7_8, ok) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mkdir_in); - return (in->header.opcode == FUSE_MKDIR && - in->body.mkdir.mode == (S_IFDIR | mode) && + return (in.header.opcode == FUSE_MKDIR && + in.body.mkdir.mode == (S_IFDIR | mode) && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.create.entry.attr.mode = S_IFDIR | mode; - out->body.create.entry.nodeid = ino; - out->body.create.entry.entry_valid = UINT64_MAX; - out->body.create.entry.attr_valid = UINT64_MAX; + out.body.create.entry.attr.mode = S_IFDIR | mode; + out.body.create.entry.nodeid = ino; + out.body.create.entry.entry_valid = UINT64_MAX; + out.body.create.entry.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno); diff --git a/tests/sys/fs/fusefs/mknod.cc b/tests/sys/fs/fusefs/mknod.cc index 44a9c8b5ba4..fddfe0c74f7 100644 --- a/tests/sys/fs/fusefs/mknod.cc +++ b/tests/sys/fs/fusefs/mknod.cc @@ -66,21 +66,21 @@ void expect_mknod(mode_t mode, dev_t dev) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mknod_in); - return (in->header.opcode == FUSE_MKNOD && - in->body.mknod.mode == mode && - in->body.mknod.rdev == (uint32_t)dev && + return (in.header.opcode == FUSE_MKNOD && + in.body.mknod.mode == mode && + in.body.mknod.rdev == (uint32_t)dev && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.rdev = dev; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.rdev = dev; }))); } @@ -119,10 +119,10 @@ TEST_F(Mknod, eperm) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes + + const char *name = (const char*)in.body.bytes + sizeof(fuse_mknod_in); - return (in->header.opcode == FUSE_MKNOD && - in->body.mknod.mode == mode && + return (in.header.opcode == FUSE_MKNOD && + in.body.mknod.mode == mode && (0 == strcmp(RELPATH, name))); }, Eq(true)), _) diff --git a/tests/sys/fs/fusefs/mockfs.cc b/tests/sys/fs/fusefs/mockfs.cc index 1a3855aa10b..b8dfd99e992 100644 --- a/tests/sys/fs/fusefs/mockfs.cc +++ b/tests/sys/fs/fusefs/mockfs.cc @@ -112,11 +112,11 @@ ProcessMockerT ReturnErrno(int error) { return([=](auto in, auto &out) { - auto out0 = new mockfs_buf_out; - out0->header.unique = in->header.unique; + std::unique_ptr out0(new mockfs_buf_out); + out0->header.unique = in.header.unique; out0->header.error = -error; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); }); } @@ -126,26 +126,26 @@ ReturnNegativeCache(const struct timespec *entry_valid) { return([=](auto in, auto &out) { /* nodeid means ENOENT and cache it */ - auto out0 = new mockfs_buf_out; + std::unique_ptr out0(new mockfs_buf_out); out0->body.entry.nodeid = 0; - out0->header.unique = in->header.unique; + out0->header.unique = in.header.unique; out0->header.error = 0; out0->body.entry.entry_valid = entry_valid->tv_sec; out0->body.entry.entry_valid_nsec = entry_valid->tv_nsec; - SET_OUT_HEADER_LEN(out0, entry); - out.push_back(out0); + SET_OUT_HEADER_LEN(*out0, entry); + out.push_back(std::move(out0)); }); } ProcessMockerT -ReturnImmediate(std::function f) +ReturnImmediate(std::function f) { - return([=](auto in, auto &out) { - auto out0 = new mockfs_buf_out; - out0->header.unique = in->header.unique; - f(in, out0); - out.push_back(out0); + return([=](auto& in, auto &out) { + std::unique_ptr out0(new mockfs_buf_out); + out0->header.unique = in.header.unique; + f(in, *out0); + out.push_back(std::move(out0)); }); } @@ -153,117 +153,117 @@ void sigint_handler(int __unused sig) { // Don't do anything except interrupt the daemon's read(2) call } -void debug_fuseop(const mockfs_buf_in *in) +void debug_fuseop(const mockfs_buf_in &in) { - printf("%-11s ino=%2" PRIu64, opcode2opname(in->header.opcode), - in->header.nodeid); + printf("%-11s ino=%2" PRIu64, opcode2opname(in.header.opcode), + in.header.nodeid); if (verbosity > 1) { printf(" uid=%5u gid=%5u pid=%5u unique=%" PRIu64 " len=%u", - in->header.uid, in->header.gid, in->header.pid, - in->header.unique, in->header.len); + in.header.uid, in.header.gid, in.header.pid, + in.header.unique, in.header.len); } - switch (in->header.opcode) { + switch (in.header.opcode) { const char *name, *value; case FUSE_ACCESS: - printf(" mask=%#x", in->body.access.mask); + printf(" mask=%#x", in.body.access.mask); break; case FUSE_CREATE: - name = (const char*)in->body.bytes + + name = (const char*)in.body.bytes + sizeof(fuse_open_in); printf(" flags=%#x name=%s", - in->body.open.flags, name); + in.body.open.flags, name); break; case FUSE_FLUSH: printf(" fh=%#" PRIx64 " lock_owner=%" PRIu64, - in->body.flush.fh, - in->body.flush.lock_owner); + in.body.flush.fh, + in.body.flush.lock_owner); break; case FUSE_FORGET: - printf(" nlookup=%" PRIu64, in->body.forget.nlookup); + printf(" nlookup=%" PRIu64, in.body.forget.nlookup); break; case FUSE_FSYNC: - printf(" flags=%#x", in->body.fsync.fsync_flags); + printf(" flags=%#x", in.body.fsync.fsync_flags); break; case FUSE_FSYNCDIR: - printf(" flags=%#x", in->body.fsyncdir.fsync_flags); + printf(" flags=%#x", in.body.fsyncdir.fsync_flags); break; case FUSE_INTERRUPT: - printf(" unique=%" PRIu64, in->body.interrupt.unique); + printf(" unique=%" PRIu64, in.body.interrupt.unique); break; case FUSE_LINK: - printf(" oldnodeid=%" PRIu64, in->body.link.oldnodeid); + printf(" oldnodeid=%" PRIu64, in.body.link.oldnodeid); break; case FUSE_LOOKUP: - printf(" %s", in->body.lookup); + printf(" %s", in.body.lookup); break; case FUSE_MKDIR: - name = (const char*)in->body.bytes + + name = (const char*)in.body.bytes + sizeof(fuse_mkdir_in); - printf(" name=%s mode=%#o", name, in->body.mkdir.mode); + printf(" name=%s mode=%#o", name, in.body.mkdir.mode); break; case FUSE_MKNOD: - printf(" mode=%#o rdev=%x", in->body.mknod.mode, - in->body.mknod.rdev); + printf(" mode=%#o rdev=%x", in.body.mknod.mode, + in.body.mknod.rdev); break; case FUSE_OPEN: printf(" flags=%#x mode=%#o", - in->body.open.flags, in->body.open.mode); + in.body.open.flags, in.body.open.mode); break; case FUSE_OPENDIR: printf(" flags=%#x mode=%#o", - in->body.opendir.flags, in->body.opendir.mode); + in.body.opendir.flags, in.body.opendir.mode); break; case FUSE_READ: printf(" offset=%" PRIu64 " size=%u", - in->body.read.offset, - in->body.read.size); + in.body.read.offset, + in.body.read.size); break; case FUSE_READDIR: printf(" fh=%#" PRIx64 " offset=%" PRIu64 " size=%u", - in->body.readdir.fh, in->body.readdir.offset, - in->body.readdir.size); + in.body.readdir.fh, in.body.readdir.offset, + in.body.readdir.size); break; case FUSE_RELEASE: printf(" fh=%#" PRIx64 " flags=%#x lock_owner=%" PRIu64, - in->body.release.fh, - in->body.release.flags, - in->body.release.lock_owner); + in.body.release.fh, + in.body.release.flags, + in.body.release.lock_owner); break; case FUSE_SETATTR: if (verbosity <= 1) { - printf(" valid=%#x", in->body.setattr.valid); + printf(" valid=%#x", in.body.setattr.valid); break; } - if (in->body.setattr.valid & FATTR_MODE) - printf(" mode=%#o", in->body.setattr.mode); - if (in->body.setattr.valid & FATTR_UID) - printf(" uid=%u", in->body.setattr.uid); - if (in->body.setattr.valid & FATTR_GID) - printf(" gid=%u", in->body.setattr.gid); - if (in->body.setattr.valid & FATTR_SIZE) - printf(" size=%" PRIu64, in->body.setattr.size); - if (in->body.setattr.valid & FATTR_ATIME) + if (in.body.setattr.valid & FATTR_MODE) + printf(" mode=%#o", in.body.setattr.mode); + if (in.body.setattr.valid & FATTR_UID) + printf(" uid=%u", in.body.setattr.uid); + if (in.body.setattr.valid & FATTR_GID) + printf(" gid=%u", in.body.setattr.gid); + if (in.body.setattr.valid & FATTR_SIZE) + printf(" size=%" PRIu64, in.body.setattr.size); + if (in.body.setattr.valid & FATTR_ATIME) printf(" atime=%" PRIu64 ".%u", - in->body.setattr.atime, - in->body.setattr.atimensec); - if (in->body.setattr.valid & FATTR_MTIME) + in.body.setattr.atime, + in.body.setattr.atimensec); + if (in.body.setattr.valid & FATTR_MTIME) printf(" mtime=%" PRIu64 ".%u", - in->body.setattr.mtime, - in->body.setattr.mtimensec); - if (in->body.setattr.valid & FATTR_FH) - printf(" fh=%" PRIu64 "", in->body.setattr.fh); + in.body.setattr.mtime, + in.body.setattr.mtimensec); + if (in.body.setattr.valid & FATTR_FH) + printf(" fh=%" PRIu64 "", in.body.setattr.fh); break; case FUSE_SETLK: printf(" fh=%#" PRIx64 " owner=%" PRIu64 " type=%u pid=%u", - in->body.setlk.fh, in->body.setlk.owner, - in->body.setlk.lk.type, - in->body.setlk.lk.pid); + in.body.setlk.fh, in.body.setlk.owner, + in.body.setlk.lk.type, + in.body.setlk.lk.pid); if (verbosity >= 2) { printf(" range=[%" PRIu64 "-%" PRIu64 "]", - in->body.setlk.lk.start, - in->body.setlk.lk.end); + in.body.setlk.lk.start, + in.body.setlk.lk.end); } break; case FUSE_SETXATTR: @@ -271,7 +271,7 @@ void debug_fuseop(const mockfs_buf_in *in) * In theory neither the xattr name and value need be * ASCII, but in this test suite they always are. */ - name = (const char*)in->body.bytes + + name = (const char*)in.body.bytes + sizeof(fuse_setxattr_in); value = name + strlen(name) + 1; printf(" %s=%s", name, value); @@ -279,9 +279,9 @@ void debug_fuseop(const mockfs_buf_in *in) case FUSE_WRITE: printf(" fh=%#" PRIx64 " offset=%" PRIu64 " size=%u flags=%u", - in->body.write.fh, - in->body.write.offset, in->body.write.size, - in->body.write.write_flags); + in.body.write.fh, + in.body.write.offset, in.body.write.size, + in.body.write.write_flags); break; default: break; @@ -392,15 +392,10 @@ MockFS::~MockFS() { } void MockFS::init(uint32_t flags) { - mockfs_buf_in *in; - mockfs_buf_out *out; - - in = new mockfs_buf_in; - ASSERT_TRUE(in != NULL); - out = new mockfs_buf_out; - ASSERT_TRUE(out != NULL); + std::unique_ptr in(new mockfs_buf_in); + std::unique_ptr out(new mockfs_buf_out); - read_request(in); + read_request(*in); ASSERT_EQ(FUSE_INIT, in->header.opcode); out->header.unique = in->header.unique; @@ -420,11 +415,8 @@ void MockFS::init(uint32_t flags) { out->body.init.max_write = m_max_write; out->body.init.max_readahead = m_maxreadahead; - SET_OUT_HEADER_LEN(out, init); - write(m_fuse_fd, out, out->header.len); - - delete out; - delete in; + SET_OUT_HEADER_LEN(*out, init); + write(m_fuse_fd, out.get(), out->header.len); } void MockFS::kill_daemon() { @@ -439,20 +431,19 @@ void MockFS::kill_daemon() { } void MockFS::loop() { - mockfs_buf_in *in; - std::vector out; + std::vector> out; - in = (mockfs_buf_in*) malloc(sizeof(*in)); + std::unique_ptr in(new mockfs_buf_in); ASSERT_TRUE(in != NULL); while (!m_quit) { - bzero(in, sizeof(*in)); - read_request(in); + bzero(in.get(), sizeof(*in)); + read_request(*in); if (m_quit) break; if (verbosity > 0) - debug_fuseop(in); + debug_fuseop(*in); if (pid_ok((pid_t)in->header.pid)) { - process(in, out); + process(*in, out); } else { /* * Reject any requests from unknown processes. Because @@ -462,15 +453,12 @@ void MockFS::loop() { if (verbosity > 1) printf("\tREJECTED (wrong pid %d)\n", in->header.pid); - process_default(in, out); - } - for (auto &it: out) { - write_response(it); - delete it; + process_default(*in, out); } + for (auto &it: out) + write_response(*it); out.clear(); } - free(in); } bool MockFS::pid_ok(pid_t pid) { @@ -496,17 +484,17 @@ bool MockFS::pid_ok(pid_t pid) { } } -void MockFS::process_default(const mockfs_buf_in *in, - std::vector &out) +void MockFS::process_default(const mockfs_buf_in& in, + std::vector> &out) { - auto out0 = new mockfs_buf_out; - out0->header.unique = in->header.unique; + std::unique_ptr out0(new mockfs_buf_out); + out0->header.unique = in.header.unique; out0->header.error = -EOPNOTSUPP; out0->header.len = sizeof(out0->header); - out.push_back(out0); + out.push_back(std::move(out0)); } -void MockFS::read_request(mockfs_buf_in *in) { +void MockFS::read_request(mockfs_buf_in &in) { ssize_t res; int nready = 0; fd_set readfds; @@ -570,14 +558,14 @@ void MockFS::read_request(mockfs_buf_in *in) { default: FAIL() << "not yet implemented"; } - res = read(m_fuse_fd, in, sizeof(*in)); + res = read(m_fuse_fd, &in, sizeof(in)); if (res < 0 && !m_quit) perror("read"); - ASSERT_TRUE(res >= (ssize_t)sizeof(in->header) || m_quit); + ASSERT_TRUE(res >= static_cast(sizeof(in.header)) || m_quit); } -void MockFS::write_response(mockfs_buf_out *out) { +void MockFS::write_response(const mockfs_buf_out &out) { fd_set writefds; pollfd fds[1]; int nready, nfds; @@ -607,7 +595,7 @@ void MockFS::write_response(mockfs_buf_out *out) { default: FAIL() << "not yet implemented"; } - r = write(m_fuse_fd, out, out->header.len); + r = write(m_fuse_fd, &out, out.header.len); ASSERT_TRUE(r > 0 || errno == EAGAIN) << strerror(errno); } diff --git a/tests/sys/fs/fusefs/mockfs.hh b/tests/sys/fs/fusefs/mockfs.hh index 226af2c3d1f..186d54064cb 100644 --- a/tests/sys/fs/fusefs/mockfs.hh +++ b/tests/sys/fs/fusefs/mockfs.hh @@ -47,8 +47,8 @@ extern "C" { #define FUSE_NORESPONSE 9999 #define SET_OUT_HEADER_LEN(out, variant) { \ - (out)->header.len = (sizeof((out)->header) + \ - sizeof((out)->body.variant)); \ + (out).header.len = (sizeof((out).header) + \ + sizeof((out).body.variant)); \ } /* @@ -61,9 +61,9 @@ extern "C" { #define EXPECT_LOOKUP(parent, path) \ EXPECT_CALL(*m_mock, process( \ ResultOf([=](auto in) { \ - return (in->header.opcode == FUSE_LOOKUP && \ - in->header.nodeid == (parent) && \ - strcmp(in->body.lookup, (path)) == 0); \ + return (in.header.opcode == FUSE_LOOKUP && \ + in.header.nodeid == (parent) && \ + strcmp(in.body.lookup, (path)) == 0); \ }, Eq(true)), \ _) \ ) @@ -165,8 +165,11 @@ union fuse_payloads_out { fuse_attr_out_7_8 attr_7_8; fuse_create_out create; fuse_create_out_7_8 create_7_8; - /* The protocol places no limits on the size of bytes */ - uint8_t bytes[0x20000]; + /* + * The protocol places no limits on the size of bytes. Choose + * a size big enough for anything we'll test. + */ + uint8_t bytes[0x20000]; fuse_entry_out entry; fuse_entry_out_7_8 entry_7_8; fuse_lk_out getlk; @@ -194,8 +197,8 @@ struct mockfs_buf_out { }; /* A function that can be invoked in place of MockFS::process */ -typedef std::function &out)> +typedef std::function> &out)> ProcessMockerT; /* @@ -209,8 +212,8 @@ ProcessMockerT ReturnNegativeCache(const struct timespec *entry_valid); /* Helper function used for returning a single immediate response */ ProcessMockerT ReturnImmediate( - std::function f); + std::function f); /* How the daemon should check /dev/fuse for readiness */ enum poll_method { @@ -261,17 +264,17 @@ class MockFS { bool pid_ok(pid_t pid); /* Default request handler */ - void process_default(const mockfs_buf_in*, - std::vector&); + void process_default(const mockfs_buf_in&, + std::vector>&); /* Entry point for the daemon thread */ static void* service(void*); /* Read, but do not process, a single request from the kernel */ - void read_request(mockfs_buf_in*); + void read_request(mockfs_buf_in& in); /* Write a single response back to the kernel */ - void write_response(mockfs_buf_out *out); + void write_response(const mockfs_buf_out &out); public: /* pid of child process, for two-process test cases */ @@ -312,8 +315,8 @@ class MockFS { * plus a delayed response to an earlier operation, push two bufs. * Test cases must define each response using Googlemock expectations */ - MOCK_METHOD2(process, void(const mockfs_buf_in*, - std::vector&)); + MOCK_METHOD2(process, void(const mockfs_buf_in&, + std::vector>&)); /* Gracefully unmount */ void unmount(); diff --git a/tests/sys/fs/fusefs/mount.cc b/tests/sys/fs/fusefs/mount.cc index d2e8c6213f0..8c0e2971994 100644 --- a/tests/sys/fs/fusefs/mount.cc +++ b/tests/sys/fs/fusefs/mount.cc @@ -79,10 +79,10 @@ TEST_P(UpdateOk, update) EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { /* * All of the fields except f_flags are don't care, and f_flags is set by * the VFS @@ -114,10 +114,10 @@ TEST_P(UpdateErr, update) flag = mntflag_from_string(GetParam()); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { /* * All of the fields except f_flags are don't care, and f_flags is set by * the VFS diff --git a/tests/sys/fs/fusefs/nfs.cc b/tests/sys/fs/fusefs/nfs.cc index d1edb33c455..ec0efc667e9 100644 --- a/tests/sys/fs/fusefs/nfs.cc +++ b/tests/sys/fs/fusefs/nfs.cc @@ -80,24 +80,24 @@ TEST_F(Fhstat, estale) EXPECT_LOOKUP(1, RELDIRPATH) .InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); EXPECT_LOOKUP(ino, ".") .InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 2; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 2; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno); @@ -117,25 +117,25 @@ TEST_F(Fhstat, lookup_dot) const uid_t uid = 12345; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr.uid = uid; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr.uid = uid; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); EXPECT_LOOKUP(ino, ".") - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr.uid = uid; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr.uid = uid; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno); @@ -160,14 +160,14 @@ TEST_F(Fhstat, DISABLED_cached) const uid_t uid = 12345; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr.uid = uid; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr.uid = uid; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno); @@ -189,13 +189,13 @@ TEST_F(FhstatNotExportable, lookup_dot) const mode_t mode = S_IFDIR | 0755; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); ASSERT_EQ(-1, getfh(FULLPATH, &fhp)); @@ -211,13 +211,13 @@ TEST_F(Getfh, eoverflow) uint64_t ino = 42; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = ino; - out->body.entry.generation = (uint64_t)UINT32_MAX + 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = ino; + out.body.entry.generation = (uint64_t)UINT32_MAX + 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); ASSERT_NE(0, getfh(FULLPATH, &fhp)); @@ -233,12 +233,12 @@ TEST_F(Getfh, ok) uint64_t ino = 42; EXPECT_LOOKUP(1, RELDIRPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno); @@ -264,37 +264,37 @@ TEST_F(Readdir, getdirentries) ssize_t r; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); EXPECT_LOOKUP(ino, ".") - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.generation = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = 0; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.generation = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = 0; }))); expect_opendir(ino); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.size == sizeof(buf)); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.size == sizeof(buf)); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno); diff --git a/tests/sys/fs/fusefs/open.cc b/tests/sys/fs/fusefs/open.cc index 800aff6e20e..cb241b1b154 100644 --- a/tests/sys/fs/fusefs/open.cc +++ b/tests/sys/fs/fusefs/open.cc @@ -52,13 +52,13 @@ void test_ok(int os_flags, int fuse_flags) { FuseTest::expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->body.open.flags == (uint32_t)fuse_flags && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.body.open.flags == (uint32_t)fuse_flags && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); @@ -80,13 +80,13 @@ TEST_F(Open, chr) uint64_t ino = 42; EXPECT_LOOKUP(1, RELPATH) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFCHR | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.rdev = 44; /* /dev/zero's rdev */ + out.body.entry.attr.mode = S_IFCHR | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.rdev = 44; /* /dev/zero's rdev */ }))); ASSERT_EQ(-1, open(FULLPATH, O_RDONLY)); @@ -107,8 +107,8 @@ TEST_F(Open, enoent) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(ENOENT))); @@ -129,8 +129,8 @@ TEST_F(Open, eperm) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EPERM))); @@ -157,29 +157,29 @@ TEST_F(Open, multiple_creds) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 2); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.pid == (uint32_t)getpid() && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.pid == (uint32_t)getpid() && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke( - ReturnImmediate([](auto in __unused, auto out) { - out->body.open.fh = fh0; - out->header.len = sizeof(out->header); + ReturnImmediate([](auto in __unused, auto& out) { + out.body.open.fh = fh0; + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.pid != (uint32_t)getpid() && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.pid != (uint32_t)getpid() && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke( - ReturnImmediate([](auto in __unused, auto out) { - out->body.open.fh = fh1; - out->header.len = sizeof(out->header); + ReturnImmediate([](auto in __unused, auto& out) { + out.body.open.fh = fh1; + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); expect_flush(ino, 2, ReturnErrno(0)); diff --git a/tests/sys/fs/fusefs/opendir.cc b/tests/sys/fs/fusefs/opendir.cc index bc47bd6bd36..3cae8105040 100644 --- a/tests/sys/fs/fusefs/opendir.cc +++ b/tests/sys/fs/fusefs/opendir.cc @@ -50,18 +50,18 @@ void expect_opendir(uint64_t ino, uint32_t flags, ProcessMockerT r) /* opendir(3) calls fstatfs */ EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, statfs); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPENDIR && - in->header.nodeid == ino && - in->body.opendir.flags == flags); + return (in.header.opcode == FUSE_OPENDIR && + in.header.nodeid == ino && + in.body.opendir.flags == flags); }, Eq(true)), _) ).WillOnce(Invoke(r)); @@ -113,7 +113,7 @@ TEST_F(Opendir, open) expect_lookup(RELPATH, ino); expect_opendir(ino, O_RDONLY, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, open); })); @@ -130,7 +130,7 @@ TEST_F(Opendir, open_exec) expect_lookup(RELPATH, ino); expect_opendir(ino, O_EXEC, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, open); })); @@ -146,7 +146,7 @@ TEST_F(Opendir, opendir) expect_lookup(RELPATH, ino); expect_opendir(ino, O_RDONLY, - ReturnImmediate([=](auto in __unused, auto out) { + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, open); })); diff --git a/tests/sys/fs/fusefs/read.cc b/tests/sys/fs/fusefs/read.cc index f86de3cdc0a..81730ed719d 100644 --- a/tests/sys/fs/fusefs/read.cc +++ b/tests/sys/fs/fusefs/read.cc @@ -168,10 +168,10 @@ TEST_F(AioRead, async_read_disabled) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == FH && - in->body.read.offset == (uint64_t)off0); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == FH && + in.body.read.offset == (uint64_t)off0); }, Eq(true)), _) ).WillRepeatedly(Invoke([&](auto in __unused, auto &out __unused) { @@ -180,10 +180,10 @@ TEST_F(AioRead, async_read_disabled) })); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == FH && - in->body.read.offset == (uint64_t)off1); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == FH && + in.body.read.offset == (uint64_t)off1); }, Eq(true)), _) ).WillRepeatedly(Invoke([&](auto in __unused, auto &out __unused) { @@ -250,10 +250,10 @@ TEST_F(AsyncRead, async_read) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == FH && - in->body.read.offset == (uint64_t)off0); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == FH && + in.body.read.offset == (uint64_t)off0); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out __unused) { @@ -262,10 +262,10 @@ TEST_F(AsyncRead, async_read) })); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == FH && - in->body.read.offset == (uint64_t)off1); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == FH && + in.body.read.offset == (uint64_t)off1); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out __unused) { @@ -395,7 +395,7 @@ TEST_F(Read, eio) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ); + return (in.header.opcode == FUSE_READ); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EIO))); @@ -496,16 +496,16 @@ TEST_F(ReadCacheable, mmap) /* mmap may legitimately try to read more data than is available */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == Read::FH && - in->body.read.offset == 0 && - in->body.read.size >= bufsize); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == Read::FH && + in.body.read.offset == 0 && + in.body.read.size >= bufsize); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(struct fuse_out_header) + bufsize; - memmove(out->body.bytes, CONTENTS, bufsize); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(struct fuse_out_header) + bufsize; + memmove(out.body.bytes, CONTENTS, bufsize); }))); fd = open(FULLPATH, O_RDONLY); @@ -683,16 +683,16 @@ TEST_F(ReadCacheable, sendfile) /* Like mmap, sendfile may request more data than is available */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == Read::FH && - in->body.read.offset == 0 && - in->body.read.size >= bufsize); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == Read::FH && + in.body.read.offset == 0 && + in.body.read.size >= bufsize); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(struct fuse_out_header) + bufsize; - memmove(out->body.bytes, CONTENTS, bufsize); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(struct fuse_out_header) + bufsize; + memmove(out.body.bytes, CONTENTS, bufsize); }))); ASSERT_EQ(0, socketpair(PF_LOCAL, SOCK_STREAM, 0, sp)) @@ -702,7 +702,7 @@ TEST_F(ReadCacheable, sendfile) ASSERT_EQ(0, sendfile(fd, sp[1], 0, bufsize, NULL, &sbytes, 0)) << strerror(errno); - ASSERT_EQ((ssize_t)bufsize, read(sp[0], buf, bufsize)) + ASSERT_EQ(static_cast(bufsize), read(sp[0], buf, bufsize)) << strerror(errno); ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize)); @@ -728,7 +728,7 @@ TEST_F(ReadCacheable, DISABLED_sendfile_eio) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ); + return (in.header.opcode == FUSE_READ); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EIO))); diff --git a/tests/sys/fs/fusefs/readdir.cc b/tests/sys/fs/fusefs/readdir.cc index 6be4ce774c5..24117a52fee 100644 --- a/tests/sys/fs/fusefs/readdir.cc +++ b/tests/sys/fs/fusefs/readdir.cc @@ -132,9 +132,9 @@ TEST_F(Readdir, eio) expect_opendir(ino); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.offset == 0); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.offset == 0); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EIO))); @@ -166,14 +166,14 @@ TEST_F(Readdir, getdirentries) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.size == 8192); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.size == 8192); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); fd = open(FULLPATH, O_DIRECTORY); @@ -203,15 +203,15 @@ TEST_F(Readdir, getdirentries_concurrent) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.size == 8192); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.size == 8192); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); fd0 = open(FULLPATH, O_DIRECTORY); @@ -247,13 +247,13 @@ TEST_F(Readdir, nodots) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); errno = 0; @@ -354,13 +354,13 @@ TEST_F(Readdir_7_8, nodots) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); errno = 0; diff --git a/tests/sys/fs/fusefs/readlink.cc b/tests/sys/fs/fusefs/readlink.cc index de2828dd877..5fca720cc5f 100644 --- a/tests/sys/fs/fusefs/readlink.cc +++ b/tests/sys/fs/fusefs/readlink.cc @@ -49,8 +49,8 @@ void expect_readlink(uint64_t ino, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READLINK && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_READLINK && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke(r)); @@ -88,12 +88,12 @@ TEST_F(Readlink, ok) char buf[80]; expect_lookup(RELPATH, ino); - expect_readlink(ino, ReturnImmediate([=](auto in __unused, auto out) { - strlcpy(out->body.str, dst, sizeof(out->body.str)); - out->header.len = sizeof(out->header) + strlen(dst) + 1; + expect_readlink(ino, ReturnImmediate([=](auto in __unused, auto& out) { + strlcpy(out.body.str, dst, sizeof(out.body.str)); + out.header.len = sizeof(out.header) + strlen(dst) + 1; })); - EXPECT_EQ((ssize_t)strlen(dst) + 1, + EXPECT_EQ(static_cast(strlen(dst)) + 1, readlink(FULLPATH, buf, sizeof(buf))); EXPECT_STREQ(dst, buf); } @@ -108,15 +108,16 @@ TEST_F(PushSymlinksIn, readlink) int len; expect_lookup(RELPATH, ino); - expect_readlink(ino, ReturnImmediate([=](auto in __unused, auto out) { - strlcpy(out->body.str, dst, sizeof(out->body.str)); - out->header.len = sizeof(out->header) + strlen(dst) + 1; + expect_readlink(ino, ReturnImmediate([=](auto in __unused, auto& out) { + strlcpy(out.body.str, dst, sizeof(out.body.str)); + out.header.len = sizeof(out.header) + strlen(dst) + 1; })); ASSERT_NE(NULL, getcwd(wd, sizeof(wd))) << strerror(errno); len = snprintf(want, sizeof(want), "%s/mountpoint%s", wd, dst); ASSERT_LE(0, len) << strerror(errno); - EXPECT_EQ((ssize_t)len + 1, readlink(FULLPATH, buf, sizeof(buf))); + EXPECT_EQ(static_cast(len) + 1, + readlink(FULLPATH, buf, sizeof(buf))); EXPECT_STREQ(want, buf); } diff --git a/tests/sys/fs/fusefs/release.cc b/tests/sys/fs/fusefs/release.cc index bb27910a4f6..d22aaf9b046 100644 --- a/tests/sys/fs/fusefs/release.cc +++ b/tests/sys/fs/fusefs/release.cc @@ -51,11 +51,11 @@ void expect_release(uint64_t ino, uint64_t lock_owner, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RELEASE && - in->header.nodeid == ino && - in->body.release.lock_owner == lock_owner && - in->body.release.fh == FH && - in->body.release.flags == flags); + return (in.header.opcode == FUSE_RELEASE && + in.header.nodeid == ino && + in.body.release.lock_owner == lock_owner && + in.body.release.fh == FH && + in.body.release.flags == flags); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))) @@ -201,14 +201,14 @@ TEST_F(ReleaseWithLocks, unlock_on_close) expect_open(ino, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETLK && - in->header.nodeid == ino && - in->body.setlk.fh == FH); + return (in.header.opcode == FUSE_SETLK && + in.header.nodeid == ino && + in.body.setlk.fh == FH); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); expect_flush(ino, 1, ReturnErrno(0)); - expect_release(ino, (uint64_t)pid, O_RDWR, 0); + expect_release(ino, static_cast(pid), O_RDWR, 0); fd = open(FULLPATH, O_RDWR); ASSERT_LE(0, fd) << strerror(errno); diff --git a/tests/sys/fs/fusefs/releasedir.cc b/tests/sys/fs/fusefs/releasedir.cc index 588ea092eb7..e2b7fd3f114 100644 --- a/tests/sys/fs/fusefs/releasedir.cc +++ b/tests/sys/fs/fusefs/releasedir.cc @@ -59,14 +59,14 @@ TEST_F(ReleaseDir, dup) expect_opendir(ino); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.offset == 0); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.offset == 0); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.error = 0; - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.error = 0; + out.header.len = sizeof(out.header); }))); expect_releasedir(ino, ReturnErrno(0)); diff --git a/tests/sys/fs/fusefs/rename.cc b/tests/sys/fs/fusefs/rename.cc index b24c88ef374..68854b52534 100644 --- a/tests/sys/fs/fusefs/rename.cc +++ b/tests/sys/fs/fusefs/rename.cc @@ -56,16 +56,16 @@ class Rename: public FuseTest { { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke( - ReturnImmediate([=](auto i __unused, auto out) { + ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = mode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = mode; + out.body.attr.attr_valid = UINT64_MAX; }))); } @@ -128,11 +128,11 @@ TEST_F(Rename, entry_cache_negative) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *src = (const char*)in->body.bytes + + const char *src = (const char*)in.body.bytes + sizeof(fuse_rename_in); const char *dst = src + strlen(src) + 1; - return (in->header.opcode == FUSE_RENAME && - in->body.rename.newdir == dst_dir_ino && + return (in.header.opcode == FUSE_RENAME && + in.body.rename.newdir == dst_dir_ino && (0 == strcmp(RELDST, dst)) && (0 == strcmp(RELSRC, src))); }, Eq(true)), @@ -164,11 +164,11 @@ TEST_F(Rename, entry_cache_negative_purge) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *src = (const char*)in->body.bytes + + const char *src = (const char*)in.body.bytes + sizeof(fuse_rename_in); const char *dst = src + strlen(src) + 1; - return (in->header.opcode == FUSE_RENAME && - in->body.rename.newdir == dst_dir_ino && + return (in.header.opcode == FUSE_RENAME && + in.body.rename.newdir == dst_dir_ino && (0 == strcmp(RELDST, dst)) && (0 == strcmp(RELSRC, src))); }, Eq(true)), @@ -219,11 +219,11 @@ TEST_F(Rename, ok) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *src = (const char*)in->body.bytes + + const char *src = (const char*)in.body.bytes + sizeof(fuse_rename_in); const char *dst = src + strlen(src) + 1; - return (in->header.opcode == FUSE_RENAME && - in->body.rename.newdir == dst_dir_ino && + return (in.header.opcode == FUSE_RENAME && + in.body.rename.newdir == dst_dir_ino && (0 == strcmp(RELDST, dst)) && (0 == strcmp(RELSRC, src))); }, Eq(true)), @@ -250,24 +250,24 @@ TEST_F(Rename, parent) expect_lookup(RELSRC, ino, S_IFDIR | 0755, 0, 1); expect_getattr(1, S_IFDIR | 0755); EXPECT_LOOKUP(1, RELDSTDIR) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.nodeid = dst_dir_ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.attr.ino = dst_dir_ino; + out.body.entry.nodeid = dst_dir_ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.attr.ino = dst_dir_ino; }))); EXPECT_LOOKUP(dst_dir_ino, RELDST) .InSequence(seq) .WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *src = (const char*)in->body.bytes + + const char *src = (const char*)in.body.bytes + sizeof(fuse_rename_in); const char *dst = src + strlen(src) + 1; - return (in->header.opcode == FUSE_RENAME && - in->body.rename.newdir == dst_dir_ino && + return (in.header.opcode == FUSE_RENAME && + in.body.rename.newdir == dst_dir_ino && (0 == strcmp(RELDST, dst)) && (0 == strcmp(RELSRC, src))); }, Eq(true)), @@ -275,12 +275,12 @@ TEST_F(Rename, parent) ).WillOnce(Invoke(ReturnErrno(0))); EXPECT_LOOKUP(dst_dir_ino, RELDST) .InSequence(seq) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, rename(FULLSRC, FULLDST)) << strerror(errno); @@ -306,11 +306,11 @@ TEST_F(Rename, overwrite) expect_lookup(RELDST, dst_ino, S_IFREG | 0644, 0, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *src = (const char*)in->body.bytes + + const char *src = (const char*)in.body.bytes + sizeof(fuse_rename_in); const char *dst = src + strlen(src) + 1; - return (in->header.opcode == FUSE_RENAME && - in->body.rename.newdir == dst_dir_ino && + return (in.header.opcode == FUSE_RENAME && + in.body.rename.newdir == dst_dir_ino && (0 == strcmp(RELDST, dst)) && (0 == strcmp(RELSRC, src))); }, Eq(true)), diff --git a/tests/sys/fs/fusefs/rmdir.cc b/tests/sys/fs/fusefs/rmdir.cc index 434ea658f3c..97e1f3dadd3 100644 --- a/tests/sys/fs/fusefs/rmdir.cc +++ b/tests/sys/fs/fusefs/rmdir.cc @@ -43,26 +43,26 @@ void expect_getattr(uint64_t ino, mode_t mode) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = mode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = mode; + out.body.attr.attr_valid = UINT64_MAX; }))); } void expect_lookup(const char *relpath, uint64_t ino) { EXPECT_LOOKUP(1, relpath) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFDIR | 0755; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 2; + out.body.entry.attr.mode = S_IFDIR | 0755; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 2; }))); } @@ -70,9 +70,9 @@ void expect_rmdir(uint64_t parent, const char *relpath, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RMDIR && - 0 == strcmp(relpath, in->body.rmdir) && - in->header.nodeid == parent); + return (in.header.opcode == FUSE_RMDIR && + 0 == strcmp(relpath, in.body.rmdir) && + in.header.nodeid == parent); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -92,16 +92,16 @@ TEST_F(Rmdir, clear_attr_cache) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == 1); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == 1); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFDIR | 0755; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFDIR | 0755; + out.body.attr.attr_valid = UINT64_MAX; }))); expect_lookup(RELPATH, ino); expect_rmdir(1, RELPATH, 0); diff --git a/tests/sys/fs/fusefs/setattr.cc b/tests/sys/fs/fusefs/setattr.cc index f36bcc43fce..3a7e8e3325c 100644 --- a/tests/sys/fs/fusefs/setattr.cc +++ b/tests/sys/fs/fusefs/setattr.cc @@ -71,28 +71,28 @@ TEST_F(Setattr, attr_cache) const mode_t newmode = 0644; EXPECT_LOOKUP(1, RELPATH) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_GETATTR); + return (in.header.opcode == FUSE_GETATTR); }, Eq(true)), _) ).Times(0); @@ -115,26 +115,26 @@ TEST_F(Setattr, chmod) const mode_t newmode = 0644; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_MODE; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; }))); EXPECT_EQ(0, chmod(FULLPATH, newmode)) << strerror(errno); } @@ -155,40 +155,40 @@ TEST_F(Setattr, chmod_multiply_linked) const mode_t newmode = 0666; EXPECT_LOOKUP(1, RELPATH0) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 2; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 2; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); EXPECT_LOOKUP(1, RELPATH1) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 2; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 2; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { uint32_t valid = FATTR_MODE; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; - out->body.attr.attr.mode = S_IFREG | newmode; - out->body.attr.attr.nlink = 2; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; + out.body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.nlink = 2; + out.body.attr.attr_valid = UINT64_MAX; }))); /* For a lookup of the 2nd file to get it into the cache*/ @@ -215,31 +215,31 @@ TEST_F(Setattr, chown) const uid_t newuser = 44; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr.gid = oldgroup; - out->body.entry.attr.uid = olduser; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr.gid = oldgroup; + out.body.entry.attr.uid = olduser; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_GID | FATTR_UID; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.uid == newuser && - in->body.setattr.gid == newgroup); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.uid == newuser && + in.body.setattr.gid == newgroup); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.uid = newuser; - out->body.attr.attr.gid = newgroup; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.uid = newuser; + out.body.attr.attr.gid = newgroup; }))); EXPECT_EQ(0, chown(FULLPATH, newuser, newgroup)) << strerror(errno); } @@ -258,18 +258,18 @@ TEST_F(Setattr, eperm) const uint64_t ino = 42; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0777; - out->body.entry.nodeid = ino; - out->body.entry.attr.uid = in->header.uid; - out->body.entry.attr.gid = in->header.gid; + out.body.entry.attr.mode = S_IFREG | 0777; + out.body.entry.nodeid = ino; + out.body.entry.attr.uid = in.header.uid; + out.body.entry.attr.gid = in.header.gid; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EPERM))); @@ -288,21 +288,21 @@ TEST_F(Setattr, fchmod) const mode_t newmode = 0644; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); }))); @@ -310,16 +310,16 @@ TEST_F(Setattr, fchmod) ResultOf([=](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_MODE; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; }))); fd = open(FULLPATH, O_RDONLY); @@ -340,41 +340,41 @@ TEST_F(Setattr, ftruncate) const off_t newsize = 12345; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0755; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.size = oldsize; + out.body.entry.attr.mode = S_IFREG | 0755; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.size = oldsize; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); - out->body.open.fh = fh; + out.body.open.fh = fh; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_SIZE | FATTR_FH; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.fh == fh); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.fh == fh); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0755; - out->body.attr.attr.size = newsize; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0755; + out.body.attr.attr.size = newsize; }))); fd = open(FULLPATH, O_RDWR); @@ -392,28 +392,28 @@ TEST_F(Setattr, truncate) { const uint64_t newsize = 20'000'000; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr.size = oldsize; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr.size = oldsize; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_SIZE; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.size == newsize); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.size == newsize); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.size = newsize; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.size = newsize; }))); EXPECT_EQ(0, truncate(FULLPATH, newsize)) << strerror(errno); } @@ -471,15 +471,15 @@ TEST_F(Setattr, truncate_discards_cached_data) { expect_open(ino, O_RDWR, 1); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([&](auto i __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([&](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; - out->body.attr.attr.mode = mode; - out->body.attr.attr.size = cur_size; + out.body.attr.attr.ino = ino; + out.body.attr.attr.mode = mode; + out.body.attr.attr.size = cur_size; }))); /* * The exact pattern of FUSE_WRITE operations depends on the setting of @@ -488,64 +488,68 @@ TEST_F(Setattr, truncate_discards_cached_data) { */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_WRITE); + return (in.header.opcode == FUSE_WRITE); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto& out) { SET_OUT_HEADER_LEN(out, write); - out->body.attr.attr.ino = ino; - out->body.write.size = in->body.write.size; - cur_size = std::max((uint64_t)cur_size, - in->body.write.size + in->body.write.offset); + out.body.attr.attr.ino = ino; + out.body.write.size = in.body.write.size; + cur_size = std::max(static_cast(cur_size), + in.body.write.size + in.body.write.offset); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - (in->body.setattr.valid & FATTR_SIZE)); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + (in.body.setattr.valid & FATTR_SIZE)); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto out) { - auto trunc_size = in->body.setattr.size; + ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto& out) { + auto trunc_size = in.body.setattr.size; SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; - out->body.attr.attr.mode = mode; - out->body.attr.attr.size = trunc_size; + out.body.attr.attr.ino = ino; + out.body.attr.attr.mode = mode; + out.body.attr.attr.size = trunc_size; cur_size = trunc_size; }))); /* exact pattern of FUSE_READ depends on vfs.fusefs.data_cache_mode */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ); + return (in.header.opcode == FUSE_READ); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto out) { - auto osize = std::min((uint64_t)cur_size - in->body.read.offset, - (uint64_t)in->body.read.size); - out->header.len = sizeof(struct fuse_out_header) + osize; + ).WillRepeatedly(Invoke(ReturnImmediate([&](auto in, auto& out) { + auto osize = std::min( + static_cast(cur_size) - in.body.read.offset, + static_cast(in.body.read.size)); + out.header.len = sizeof(struct fuse_out_header) + osize; if (should_have_data) - memset(out->body.bytes, 'X', osize); + memset(out.body.bytes, 'X', osize); else - bzero(out->body.bytes, osize); + bzero(out.body.bytes, osize); }))); fd = open(FULLPATH, O_RDWR, 0644); ASSERT_LE(0, fd) << strerror(errno); /* Fill the file with Xs */ - ASSERT_EQ((ssize_t)w0_size, pwrite(fd, w0buf, w0_size, w0_offset)); + ASSERT_EQ(static_cast(w0_size), + pwrite(fd, w0buf, w0_size, w0_offset)); should_have_data = true; /* Fill the cache, if data_cache_mode == 1 */ - ASSERT_EQ((ssize_t)r0_size, pread(fd, r0buf, r0_size, r0_offset)); + ASSERT_EQ(static_cast(r0_size), + pread(fd, r0buf, r0_size, r0_offset)); /* 1st truncate should discard cached data */ EXPECT_EQ(0, ftruncate(fd, trunc0_size)) << strerror(errno); should_have_data = false; /* 2nd truncate extends file into previously cached data */ EXPECT_EQ(0, ftruncate(fd, trunc1_size)) << strerror(errno); /* Read should return all zeros */ - ASSERT_EQ((ssize_t)r1_size, pread(fd, r1buf, r1_size, r1_offset)); + ASSERT_EQ(static_cast(r1_size), + pread(fd, r1buf, r1_size, r1_offset)); r = memcmp(expected, r1buf, r1_size); ASSERT_EQ(0, r); @@ -571,40 +575,40 @@ TEST_F(Setattr, utimensat) { }; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.atime = oldtimes[0].tv_sec; - out->body.entry.attr.atimensec = oldtimes[0].tv_nsec; - out->body.entry.attr.mtime = oldtimes[1].tv_sec; - out->body.entry.attr.mtimensec = oldtimes[1].tv_nsec; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.atime = oldtimes[0].tv_sec; + out.body.entry.attr.atimensec = oldtimes[0].tv_nsec; + out.body.entry.attr.mtime = oldtimes[1].tv_sec; + out.body.entry.attr.mtimensec = oldtimes[1].tv_nsec; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_ATIME | FATTR_MTIME; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.atime == newtimes[0].tv_sec && - in->body.setattr.atimensec == + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.atime == newtimes[0].tv_sec && + in.body.setattr.atimensec == newtimes[0].tv_nsec && - in->body.setattr.mtime == newtimes[1].tv_sec && - in->body.setattr.mtimensec == + in.body.setattr.mtime == newtimes[1].tv_sec && + in.body.setattr.mtimensec == newtimes[1].tv_nsec); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.atime = newtimes[0].tv_sec; - out->body.attr.attr.atimensec = newtimes[0].tv_nsec; - out->body.attr.attr.mtime = newtimes[1].tv_sec; - out->body.attr.attr.mtimensec = newtimes[1].tv_nsec; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.atime = newtimes[0].tv_sec; + out.body.attr.attr.atimensec = newtimes[0].tv_nsec; + out.body.attr.attr.mtime = newtimes[1].tv_sec; + out.body.attr.attr.mtimensec = newtimes[1].tv_nsec; }))); EXPECT_EQ(0, utimensat(AT_FDCWD, FULLPATH, &newtimes[0], 0)) << strerror(errno); @@ -625,37 +629,37 @@ TEST_F(Setattr, utimensat_mtime_only) { }; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.attr.atime = oldtimes[0].tv_sec; - out->body.entry.attr.atimensec = oldtimes[0].tv_nsec; - out->body.entry.attr.mtime = oldtimes[1].tv_sec; - out->body.entry.attr.mtimensec = oldtimes[1].tv_nsec; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.atime = oldtimes[0].tv_sec; + out.body.entry.attr.atimensec = oldtimes[0].tv_nsec; + out.body.entry.attr.mtime = oldtimes[1].tv_sec; + out.body.entry.attr.mtimensec = oldtimes[1].tv_nsec; }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_MTIME; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mtime == newtimes[1].tv_sec && - in->body.setattr.mtimensec == + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mtime == newtimes[1].tv_sec && + in.body.setattr.mtimensec == newtimes[1].tv_nsec); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.atime = oldtimes[0].tv_sec; - out->body.attr.attr.atimensec = oldtimes[0].tv_nsec; - out->body.attr.attr.mtime = newtimes[1].tv_sec; - out->body.attr.attr.mtimensec = newtimes[1].tv_nsec; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.atime = oldtimes[0].tv_sec; + out.body.attr.attr.atimensec = oldtimes[0].tv_nsec; + out.body.attr.attr.mtime = newtimes[1].tv_sec; + out.body.attr.attr.mtimensec = newtimes[1].tv_nsec; }))); EXPECT_EQ(0, utimensat(AT_FDCWD, FULLPATH, &newtimes[0], 0)) << strerror(errno); @@ -687,16 +691,16 @@ TEST_F(Setattr, utimensat_utime_now) { struct stat sb; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | 0644; - out->body.entry.nodeid = ino; - out->body.entry.attr_valid = UINT64_MAX; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr.atime = oldtimes[0].tv_sec; - out->body.entry.attr.atimensec = oldtimes[0].tv_nsec; - out->body.entry.attr.mtime = oldtimes[1].tv_sec; - out->body.entry.attr.mtimensec = oldtimes[1].tv_nsec; + out.body.entry.attr.mode = S_IFREG | 0644; + out.body.entry.nodeid = ino; + out.body.entry.attr_valid = UINT64_MAX; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr.atime = oldtimes[0].tv_sec; + out.body.entry.attr.atimensec = oldtimes[0].tv_nsec; + out.body.entry.attr.mtime = oldtimes[1].tv_sec; + out.body.entry.attr.mtimensec = oldtimes[1].tv_nsec; }))); EXPECT_CALL(*m_mock, process( @@ -704,20 +708,20 @@ TEST_F(Setattr, utimensat_utime_now) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_ATIME | FATTR_ATIME_NOW | FATTR_MTIME | FATTR_MTIME_NOW; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.atime = now[0].tv_sec; - out->body.attr.attr.atimensec = now[0].tv_nsec; - out->body.attr.attr.mtime = now[1].tv_sec; - out->body.attr.attr.mtimensec = now[1].tv_nsec; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.atime = now[0].tv_sec; + out.body.attr.attr.atimensec = now[0].tv_nsec; + out.body.attr.attr.mtime = now[1].tv_sec; + out.body.attr.attr.mtimensec = now[1].tv_nsec; + out.body.attr.attr_valid = UINT64_MAX; }))); ASSERT_EQ(0, utimensat(AT_FDCWD, FULLPATH, &newtimes[0], 0)) << strerror(errno); @@ -738,10 +742,10 @@ TEST_F(RofsSetattr, erofs) const mode_t newmode = 0644; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; }))); ASSERT_EQ(-1, chmod(FULLPATH, newmode)); @@ -758,26 +762,26 @@ TEST_F(Setattr_7_8, chmod) const mode_t newmode = 0644; EXPECT_LOOKUP(1, RELPATH) - .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = S_IFREG | oldmode; - out->body.entry.nodeid = ino; + out.body.entry.attr.mode = S_IFREG | oldmode; + out.body.entry.nodeid = ino; }))); EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { /* In protocol 7.23, ctime will be changed too */ uint32_t valid = FATTR_MODE; - return (in->header.opcode == FUSE_SETATTR && - in->header.nodeid == ino && - in->body.setattr.valid == valid && - in->body.setattr.mode == newmode); + return (in.header.opcode == FUSE_SETATTR && + in.header.nodeid == ino && + in.body.setattr.valid == valid && + in.body.setattr.mode == newmode); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr_7_8); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | newmode; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | newmode; }))); EXPECT_EQ(0, chmod(FULLPATH, newmode)) << strerror(errno); } diff --git a/tests/sys/fs/fusefs/statfs.cc b/tests/sys/fs/fusefs/statfs.cc index d09d0de427a..a97d131b085 100644 --- a/tests/sys/fs/fusefs/statfs.cc +++ b/tests/sys/fs/fusefs/statfs.cc @@ -47,7 +47,7 @@ TEST_F(Statfs, eio) EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(EIO))); @@ -104,7 +104,7 @@ TEST_F(Statfs, enotconn_while_blocked) EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) ).WillOnce(Invoke([&](auto in __unused, auto &out __unused) { @@ -136,18 +136,18 @@ TEST_F(Statfs, ok) EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, statfs); - out->body.statfs.st.blocks = 1000; - out->body.statfs.st.bfree = 100; - out->body.statfs.st.bavail = 200; - out->body.statfs.st.files = 5; - out->body.statfs.st.ffree = 6; - out->body.statfs.st.namelen = 128; - out->body.statfs.st.frsize = 1024; + out.body.statfs.st.blocks = 1000; + out.body.statfs.st.bfree = 100; + out.body.statfs.st.bavail = 200; + out.body.statfs.st.files = 5; + out.body.statfs.st.ffree = 6; + out.body.statfs.st.namelen = 128; + out.body.statfs.st.frsize = 1024; }))); ASSERT_NE(NULL, getcwd(mp, PATH_MAX)) << strerror(errno); diff --git a/tests/sys/fs/fusefs/symlink.cc b/tests/sys/fs/fusefs/symlink.cc index db032d74dcf..430ce9c195a 100644 --- a/tests/sys/fs/fusefs/symlink.cc +++ b/tests/sys/fs/fusefs/symlink.cc @@ -44,19 +44,19 @@ void expect_symlink(uint64_t ino, const char *target, const char *relpath) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes; + const char *name = (const char*)in.body.bytes; const char *linkname = name + strlen(name) + 1; - return (in->header.opcode == FUSE_SYMLINK && + return (in.header.opcode == FUSE_SYMLINK && (0 == strcmp(linkname, target)) && (0 == strcmp(name, relpath))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = S_IFLNK | 0777; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFLNK | 0777; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; }))); } @@ -73,19 +73,19 @@ void expect_symlink(uint64_t ino, const char *target, const char *relpath) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes; + const char *name = (const char*)in.body.bytes; const char *linkname = name + strlen(name) + 1; - return (in->header.opcode == FUSE_SYMLINK && + return (in.header.opcode == FUSE_SYMLINK && (0 == strcmp(linkname, target)) && (0 == strcmp(name, relpath))); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = S_IFLNK | 0777; - out->body.entry.nodeid = ino; - out->body.entry.entry_valid = UINT64_MAX; - out->body.entry.attr_valid = UINT64_MAX; + out.body.entry.attr.mode = S_IFLNK | 0777; + out.body.entry.nodeid = ino; + out.body.entry.entry_valid = UINT64_MAX; + out.body.entry.attr_valid = UINT64_MAX; }))); } @@ -106,16 +106,16 @@ TEST_F(Symlink, clear_attr_cache) EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == 1); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == 1); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = 1; - out->body.attr.attr.mode = S_IFDIR | 0755; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = 1; + out.body.attr.attr.mode = S_IFDIR | 0755; + out.body.attr.attr_valid = UINT64_MAX; }))); expect_symlink(ino, dst, RELPATH); @@ -134,9 +134,9 @@ TEST_F(Symlink, enospc) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *name = (const char*)in->body.bytes; + const char *name = (const char*)in.body.bytes; const char *linkname = name + strlen(name) + 1; - return (in->header.opcode == FUSE_SYMLINK && + return (in.header.opcode == FUSE_SYMLINK && (0 == strcmp(linkname, dst)) && (0 == strcmp(name, RELPATH))); }, Eq(true)), diff --git a/tests/sys/fs/fusefs/unlink.cc b/tests/sys/fs/fusefs/unlink.cc index e98d944e63f..dc51ecc83d7 100644 --- a/tests/sys/fs/fusefs/unlink.cc +++ b/tests/sys/fs/fusefs/unlink.cc @@ -42,15 +42,15 @@ void expect_getattr(uint64_t ino, mode_t mode) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = mode; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = mode; + out.body.attr.attr_valid = UINT64_MAX; }))); } @@ -74,16 +74,16 @@ TEST_F(Unlink, clear_attr_cache) EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == 1); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == 1); }, Eq(true)), _) ).Times(2) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFDIR | 0755; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFDIR | 0755; + out.body.attr.attr_valid = UINT64_MAX; }))); expect_lookup(RELPATH, ino, 1); expect_unlink(1, RELPATH, 0); diff --git a/tests/sys/fs/fusefs/utils.cc b/tests/sys/fs/fusefs/utils.cc index 1a8af3cf349..9b601c47abe 100644 --- a/tests/sys/fs/fusefs/utils.cc +++ b/tests/sys/fs/fusefs/utils.cc @@ -108,7 +108,7 @@ void FuseTest::SetUp() { */ EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_ACCESS); + return (in.header.opcode == FUSE_ACCESS); }, Eq(true)), _) ).Times(AnyNumber()) @@ -123,9 +123,9 @@ FuseTest::expect_access(uint64_t ino, mode_t access_mode, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_ACCESS && - in->header.nodeid == ino && - in->body.access.mask == access_mode); + return (in.header.opcode == FUSE_ACCESS && + in.header.nodeid == ino && + in.body.access.mask == access_mode); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -136,14 +136,14 @@ FuseTest::expect_destroy(int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_DESTROY); + return (in.header.opcode == FUSE_DESTROY); }, Eq(true)), _) - ).WillOnce(Invoke( ReturnImmediate([&](auto in, auto out) { + ).WillOnce(Invoke( ReturnImmediate([&](auto in, auto& out) { m_mock->m_quit = true; - out->header.len = sizeof(out->header); - out->header.unique = in->header.unique; - out->header.error = -error; + out.header.len = sizeof(out.header); + out.header.unique = in.header.unique; + out.header.error = -error; }))); } @@ -152,8 +152,8 @@ FuseTest::expect_flush(uint64_t ino, int times, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FLUSH && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_FLUSH && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(times) @@ -165,9 +165,9 @@ FuseTest::expect_forget(uint64_t ino, uint64_t nlookup) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_FORGET && - in->header.nodeid == ino && - in->body.forget.nlookup == nlookup); + return (in.header.opcode == FUSE_FORGET && + in.header.nodeid == ino && + in.body.forget.nlookup == nlookup); }, Eq(true)), _) ).WillOnce(Invoke([](auto in __unused, auto &out __unused) { @@ -179,16 +179,16 @@ void FuseTest::expect_getattr(uint64_t ino, uint64_t size) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_GETATTR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid - out->body.attr.attr.mode = S_IFREG | 0644; - out->body.attr.attr.size = size; - out->body.attr.attr_valid = UINT64_MAX; + out.body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.mode = S_IFREG | 0644; + out.body.attr.attr.size = size; + out.body.attr.attr_valid = UINT64_MAX; }))); } @@ -197,15 +197,16 @@ void FuseTest::expect_lookup(const char *relpath, uint64_t ino, mode_t mode, { EXPECT_LOOKUP(1, relpath) .Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke( + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = attr_valid; - out->body.entry.attr.size = size; - out->body.entry.attr.uid = uid; - out->body.entry.attr.gid = gid; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = attr_valid; + out.body.entry.attr.size = size; + out.body.entry.attr.uid = uid; + out.body.entry.attr.gid = gid; }))); } @@ -214,15 +215,16 @@ void FuseTest::expect_lookup_7_8(const char *relpath, uint64_t ino, mode_t mode, { EXPECT_LOOKUP(1, relpath) .Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + .WillRepeatedly(Invoke( + ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, entry_7_8); - out->body.entry.attr.mode = mode; - out->body.entry.nodeid = ino; - out->body.entry.attr.nlink = 1; - out->body.entry.attr_valid = attr_valid; - out->body.entry.attr.size = size; - out->body.entry.attr.uid = uid; - out->body.entry.attr.gid = gid; + out.body.entry.attr.mode = mode; + out.body.entry.nodeid = ino; + out.body.entry.attr.nlink = 1; + out.body.entry.attr_valid = attr_valid; + out.body.entry.attr.size = size; + out.body.entry.attr.uid = uid; + out.body.entry.attr.gid = gid; }))); } @@ -230,16 +232,17 @@ void FuseTest::expect_open(uint64_t ino, uint32_t flags, int times) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPEN && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPEN && + in.header.nodeid == ino); }, Eq(true)), _) ).Times(times) - .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + .WillRepeatedly(Invoke( + ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); - out->body.open.fh = FH; - out->body.open.open_flags = flags; + out.body.open.fh = FH; + out.body.open.open_flags = flags; }))); } @@ -248,23 +251,24 @@ void FuseTest::expect_opendir(uint64_t ino) /* opendir(3) calls fstatfs */ EXPECT_CALL(*m_mock, process( ResultOf([](auto in) { - return (in->header.opcode == FUSE_STATFS); + return (in.header.opcode == FUSE_STATFS); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillRepeatedly(Invoke( + ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, statfs); }))); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_OPENDIR && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_OPENDIR && + in.header.nodeid == ino); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(out->header); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(out.header); SET_OUT_HEADER_LEN(out, open); - out->body.open.fh = FH; + out.body.open.fh = FH; }))); } @@ -273,16 +277,16 @@ void FuseTest::expect_read(uint64_t ino, uint64_t offset, uint64_t isize, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READ && - in->header.nodeid == ino && - in->body.read.fh == FH && - in->body.read.offset == offset && - in->body.read.size == isize); + return (in.header.opcode == FUSE_READ && + in.header.nodeid == ino && + in.body.read.fh == FH && + in.body.read.offset == offset && + in.body.read.size == isize); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { - out->header.len = sizeof(struct fuse_out_header) + osize; - memmove(out->body.bytes, contents, osize); + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { + out.header.len = sizeof(struct fuse_out_header) + osize; + memmove(out.body.bytes, contents, osize); }))).RetiresOnSaturation(); } @@ -291,18 +295,18 @@ void FuseTest::expect_readdir(uint64_t ino, uint64_t off, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_READDIR && - in->header.nodeid == ino && - in->body.readdir.fh == FH && - in->body.readdir.offset == off); + return (in.header.opcode == FUSE_READDIR && + in.header.nodeid == ino && + in.body.readdir.fh == FH && + in.body.readdir.offset == off); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto out) { - struct fuse_dirent *fde = (struct fuse_dirent*)&(out->body); + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto& out) { + struct fuse_dirent *fde = (struct fuse_dirent*)&(out.body); int i = 0; - out->header.error = 0; - out->header.len = 0; + out.header.error = 0; + out.header.len = 0; for (const auto& it: ents) { size_t entlen, entsize; @@ -322,17 +326,17 @@ void FuseTest::expect_readdir(uint64_t ino, uint64_t off, * kernel */ memset(fde->name + fde->namelen, 0, entsize - entlen); - if (out->header.len + entsize > in->body.read.size) { + if (out.header.len + entsize > in.body.read.size) { printf("Overflow in readdir expectation: i=%d\n" , i); break; } - out->header.len += entsize; + out.header.len += entsize; fde = (struct fuse_dirent*) ((long*)fde + entsize / sizeof(long)); i++; } - out->header.len += sizeof(out->header); + out.header.len += sizeof(out.header); }))); } @@ -340,9 +344,9 @@ void FuseTest::expect_release(uint64_t ino, uint64_t fh) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RELEASE && - in->header.nodeid == ino && - in->body.release.fh == fh); + return (in.header.opcode == FUSE_RELEASE && + in.header.nodeid == ino && + in.body.release.fh == fh); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(0))); @@ -352,9 +356,9 @@ void FuseTest::expect_releasedir(uint64_t ino, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RELEASEDIR && - in->header.nodeid == ino && - in->body.release.fh == FH); + return (in.header.opcode == FUSE_RELEASEDIR && + in.header.nodeid == ino && + in.body.release.fh == FH); }, Eq(true)), _) ).WillOnce(Invoke(r)); @@ -364,9 +368,9 @@ void FuseTest::expect_unlink(uint64_t parent, const char *path, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_UNLINK && - 0 == strcmp(path, in->body.unlink) && - in->header.nodeid == parent); + return (in.header.opcode == FUSE_UNLINK && + 0 == strcmp(path, in.body.unlink) && + in.header.nodeid == parent); }, Eq(true)), _) ).WillOnce(Invoke(ReturnErrno(error))); @@ -377,28 +381,28 @@ void FuseTest::expect_write(uint64_t ino, uint64_t offset, uint64_t isize, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *buf = (const char*)in->body.bytes + + const char *buf = (const char*)in.body.bytes + sizeof(struct fuse_write_in); bool pid_ok; - if (in->body.write.write_flags & FUSE_WRITE_CACHE) + if (in.body.write.write_flags & FUSE_WRITE_CACHE) pid_ok = true; else - pid_ok = (pid_t)in->header.pid == getpid(); + pid_ok = (pid_t)in.header.pid == getpid(); - return (in->header.opcode == FUSE_WRITE && - in->header.nodeid == ino && - in->body.write.fh == FH && - in->body.write.offset == offset && - in->body.write.size == isize && + return (in.header.opcode == FUSE_WRITE && + in.header.nodeid == ino && + in.body.write.fh == FH && + in.body.write.offset == offset && + in.body.write.size == isize && pid_ok && - in->body.write.write_flags == flags && + in.body.write.write_flags == flags && 0 == bcmp(buf, contents, isize)); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, write); - out->body.write.size = osize; + out.body.write.size = osize; }))); } @@ -407,22 +411,22 @@ void FuseTest::expect_write_7_8(uint64_t ino, uint64_t offset, uint64_t isize, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *buf = (const char*)in->body.bytes + + const char *buf = (const char*)in.body.bytes + FUSE_COMPAT_WRITE_IN_SIZE; - bool pid_ok = (pid_t)in->header.pid == getpid(); - return (in->header.opcode == FUSE_WRITE && - in->header.nodeid == ino && - in->body.write.fh == FH && - in->body.write.offset == offset && - in->body.write.size == isize && + bool pid_ok = (pid_t)in.header.pid == getpid(); + return (in.header.opcode == FUSE_WRITE && + in.header.nodeid == ino && + in.body.write.fh == FH && + in.body.write.offset == offset && + in.body.write.size == isize && pid_ok && - in->body.write.write_flags == flags && + in.body.write.write_flags == flags && 0 == bcmp(buf, contents, isize)); }, Eq(true)), _) - ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { + ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, write); - out->body.write.size = osize; + out.body.write.size = osize; }))); } diff --git a/tests/sys/fs/fusefs/write.cc b/tests/sys/fs/fusefs/write.cc index 9380467eedb..e8576bc941d 100644 --- a/tests/sys/fs/fusefs/write.cc +++ b/tests/sys/fs/fusefs/write.cc @@ -58,8 +58,8 @@ void expect_release(uint64_t ino, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_RELEASE && - in->header.nodeid == ino); + return (in.header.opcode == FUSE_RELEASE && + in.header.nodeid == ino); }, Eq(true)), _) ).WillRepeatedly(Invoke(r)); @@ -585,12 +585,12 @@ TEST_F(WriteBack, close) expect_write(ino, 0, bufsize, bufsize, 0, CONTENTS); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_SETATTR); + return (in.header.opcode == FUSE_SETATTR); }, Eq(true)), _) - ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { + ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { SET_OUT_HEADER_LEN(out, attr); - out->body.attr.attr.ino = ino; // Must match nodeid + out.body.attr.attr.ino = ino; // Must match nodeid }))); expect_flush(ino, 1, ReturnErrno(0)); expect_release(ino, ReturnErrno(0)); diff --git a/tests/sys/fs/fusefs/xattr.cc b/tests/sys/fs/fusefs/xattr.cc index f6312d3fcb8..c6a5e168c8a 100644 --- a/tests/sys/fs/fusefs/xattr.cc +++ b/tests/sys/fs/fusefs/xattr.cc @@ -49,10 +49,10 @@ void expect_getxattr(uint64_t ino, const char *attr, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *a = (const char*)in->body.bytes + + const char *a = (const char*)in.body.bytes + sizeof(fuse_getxattr_in); - return (in->header.opcode == FUSE_GETXATTR && - in->header.nodeid == ino && + return (in.header.opcode == FUSE_GETXATTR && + in.header.nodeid == ino && 0 == strcmp(attr, a)); }, Eq(true)), _) @@ -63,9 +63,9 @@ void expect_listxattr(uint64_t ino, uint32_t size, ProcessMockerT r) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - return (in->header.opcode == FUSE_LISTXATTR && - in->header.nodeid == ino && - in->body.listxattr.size == size); + return (in.header.opcode == FUSE_LISTXATTR && + in.header.nodeid == ino && + in.body.listxattr.size == size); }, Eq(true)), _) ).WillOnce(Invoke(r)) @@ -76,9 +76,9 @@ void expect_removexattr(uint64_t ino, const char *attr, int error) { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *a = (const char*)in->body.bytes; - return (in->header.opcode == FUSE_REMOVEXATTR && - in->header.nodeid == ino && + const char *a = (const char*)in.body.bytes; + return (in.header.opcode == FUSE_REMOVEXATTR && + in.header.nodeid == ino && 0 == strcmp(attr, a)); }, Eq(true)), _) @@ -90,11 +90,11 @@ void expect_setxattr(uint64_t ino, const char *attr, const char *value, { EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { - const char *a = (const char*)in->body.bytes + + const char *a = (const char*)in.body.bytes + sizeof(fuse_setxattr_in); const char *v = a + strlen(a) + 1; - return (in->header.opcode == FUSE_SETXATTR && - in->header.nodeid == ino && + return (in.header.opcode == FUSE_SETXATTR && + in.header.nodeid == ino && 0 == strcmp(attr, a) && 0 == strcmp(value, v)); }, Eq(true)), @@ -199,9 +199,9 @@ TEST_F(Getxattr, size_only) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); expect_getxattr(ino, "user.foo", - ReturnImmediate([](auto in __unused, auto out) { + ReturnImmediate([](auto in __unused, auto& out) { SET_OUT_HEADER_LEN(out, getxattr); - out->body.getxattr.size = 99; + out.body.getxattr.size = 99; }) ); @@ -223,9 +223,9 @@ TEST_F(Getxattr, system) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); expect_getxattr(ino, "system.foo", - ReturnImmediate([&](auto in __unused, auto out) { - memcpy((void*)out->body.bytes, value, value_len); - out->header.len = sizeof(out->header) + value_len; + ReturnImmediate([&](auto in __unused, auto& out) { + memcpy((void*)out.body.bytes, value, value_len); + out.header.len = sizeof(out.header) + value_len; }) ); @@ -248,9 +248,9 @@ TEST_F(Getxattr, user) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); expect_getxattr(ino, "user.foo", - ReturnImmediate([&](auto in __unused, auto out) { - memcpy((void*)out->body.bytes, value, value_len); - out->header.len = sizeof(out->header) + value_len; + ReturnImmediate([&](auto in __unused, auto& out) { + memcpy((void*)out.body.bytes, value, value_len); + out.header.len = sizeof(out.header) + value_len; }) ); @@ -329,8 +329,8 @@ TEST_F(Listxattr, size_only_empty) int ns = EXTATTR_NAMESPACE_USER; expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); - expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto out) { - out->body.listxattr.size = 0; + expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto& out) { + out.body.listxattr.size = 0; SET_OUT_HEADER_LEN(out, listxattr); })); @@ -350,19 +350,19 @@ TEST_F(Listxattr, size_only_nonempty) int ns = EXTATTR_NAMESPACE_USER; expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); - expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto out) { - out->body.listxattr.size = 45; + expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto& out) { + out.body.listxattr.size = 45; SET_OUT_HEADER_LEN(out, listxattr); })); // TODO: fix the expected size after fixing the size calculation bug in // fuse_vnop_listextattr. It should be exactly 45. expect_listxattr(ino, 53, - ReturnImmediate([](auto in __unused, auto out) { + ReturnImmediate([](auto in __unused, auto& out) { const char l[] = "user.foo"; - strlcpy((char*)out->body.bytes, l, - sizeof(out->body.bytes)); - out->header.len = sizeof(fuse_out_header) + sizeof(l); + strlcpy((char*)out.body.bytes, l, + sizeof(out.body.bytes)); + out.header.len = sizeof(fuse_out_header) + sizeof(l); }) ); @@ -376,20 +376,20 @@ TEST_F(Listxattr, size_only_really_big) int ns = EXTATTR_NAMESPACE_USER; expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); - expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto out) { - out->body.listxattr.size = 16000; + expect_listxattr(ino, 0, ReturnImmediate([](auto i __unused, auto& out) { + out.body.listxattr.size = 16000; SET_OUT_HEADER_LEN(out, listxattr); })); // TODO: fix the expected size after fixing the size calculation bug in // fuse_vnop_listextattr. It should be exactly 16000. expect_listxattr(ino, 16008, - ReturnImmediate([](auto in __unused, auto out) { + ReturnImmediate([](auto in __unused, auto& out) { const char l[16] = "user.foobarbang"; for (int i=0; i < 1000; i++) { - memcpy(&out->body.bytes[16 * i], l, 16); + memcpy(&out.body.bytes[16 * i], l, 16); } - out->header.len = sizeof(fuse_out_header) + 16000; + out.header.len = sizeof(fuse_out_header) + 16000; }) ); @@ -411,8 +411,8 @@ TEST_F(Listxattr, user) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); expect_listxattr(ino, 0, - ReturnImmediate([&](auto in __unused, auto out) { - out->body.listxattr.size = sizeof(attrs); + ReturnImmediate([&](auto in __unused, auto& out) { + out.body.listxattr.size = sizeof(attrs); SET_OUT_HEADER_LEN(out, listxattr); }) ); @@ -420,12 +420,12 @@ TEST_F(Listxattr, user) // TODO: fix the expected size after fixing the size calculation bug in // fuse_vnop_listextattr. expect_listxattr(ino, sizeof(attrs) + 8, - ReturnImmediate([&](auto in __unused, auto out) { - memcpy((void*)out->body.bytes, attrs, sizeof(attrs)); - out->header.len = sizeof(fuse_out_header) + sizeof(attrs); + ReturnImmediate([&](auto in __unused, auto& out) { + memcpy((void*)out.body.bytes, attrs, sizeof(attrs)); + out.header.len = sizeof(fuse_out_header) + sizeof(attrs); })); - ASSERT_EQ((ssize_t)sizeof(expected), + ASSERT_EQ(static_cast(sizeof(expected)), extattr_list_file(FULLPATH, ns, data, sizeof(data))) << strerror(errno); ASSERT_EQ(0, memcmp(expected, data, sizeof(expected))); @@ -445,8 +445,8 @@ TEST_F(Listxattr, system) expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1); expect_listxattr(ino, 0, - ReturnImmediate([&](auto in __unused, auto out) { - out->body.listxattr.size = sizeof(attrs); + ReturnImmediate([&](auto in __unused, auto& out) { + out.body.listxattr.size = sizeof(attrs); SET_OUT_HEADER_LEN(out, listxattr); }) ); @@ -454,12 +454,12 @@ TEST_F(Listxattr, system) // TODO: fix the expected size after fixing the size calculation bug in // fuse_vnop_listextattr. expect_listxattr(ino, sizeof(attrs) + 8, - ReturnImmediate([&](auto in __unused, auto out) { - memcpy((void*)out->body.bytes, attrs, sizeof(attrs)); - out->header.len = sizeof(fuse_out_header) + sizeof(attrs); + ReturnImmediate([&](auto in __unused, auto& out) { + memcpy((void*)out.body.bytes, attrs, sizeof(attrs)); + out.header.len = sizeof(fuse_out_header) + sizeof(attrs); })); - ASSERT_EQ((ssize_t)sizeof(expected), + ASSERT_EQ(static_cast(sizeof(expected)), extattr_list_file(FULLPATH, ns, data, sizeof(data))) << strerror(errno); ASSERT_EQ(0, memcmp(expected, data, sizeof(expected))); -- 2.45.0