Date: Mon, 3 Jun 2019 17:34:01 +0000 (UTC) From: Alan Somers <asomers@FreeBSD.org> To: src-committers@freebsd.org, svn-src-projects@freebsd.org Subject: svn commit: r348560 - in projects/fuse2: sys/fs/fuse tests/sys/fs/fusefs Message-ID: <201906031734.x53HY12U041009@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: asomers Date: Mon Jun 3 17:34:01 2019 New Revision: 348560 URL: https://svnweb.freebsd.org/changeset/base/348560 Log: fusefs: support asynchronous cache invalidation Protocol 7.12 adds a way for the server to notify the client that it should invalidate an inode's data cache and/or attributes. This commit implements that mechanism. Unlike Linux's implementation, ours requires that the file system also supports FUSE_EXPORT_SUPPORT (NFS-style lookups). Otherwise the invalidation operation will return EINVAL. Sponsored by: The FreeBSD Foundation Modified: projects/fuse2/sys/fs/fuse/fuse_device.c projects/fuse2/sys/fs/fuse/fuse_internal.c projects/fuse2/sys/fs/fuse/fuse_internal.h projects/fuse2/sys/fs/fuse/fuse_vfsops.c projects/fuse2/tests/sys/fs/fusefs/mockfs.cc projects/fuse2/tests/sys/fs/fusefs/mockfs.hh projects/fuse2/tests/sys/fs/fusefs/notify.cc Modified: projects/fuse2/sys/fs/fuse/fuse_device.c ============================================================================== --- projects/fuse2/sys/fs/fuse/fuse_device.c Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/sys/fs/fuse/fuse_device.c Mon Jun 3 17:34:01 2019 (r348560) @@ -515,8 +515,10 @@ fuse_device_write(struct cdev *dev, struct uio *uio, i case FUSE_NOTIFY_INVAL_ENTRY: err = fuse_internal_invalidate_entry(mp, uio); break; - case FUSE_NOTIFY_POLL: case FUSE_NOTIFY_INVAL_INODE: + err = fuse_internal_invalidate_inode(mp, uio); + break; + case FUSE_NOTIFY_POLL: default: /* Not implemented */ err = ENOSYS; Modified: projects/fuse2/sys/fs/fuse/fuse_internal.c ============================================================================== --- projects/fuse2/sys/fs/fuse/fuse_internal.c Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/sys/fs/fuse/fuse_internal.c Mon Jun 3 17:34:01 2019 (r348560) @@ -89,6 +89,7 @@ __FBSDID("$FreeBSD$"); #include "fuse.h" #include "fuse_file.h" #include "fuse_internal.h" +#include "fuse_io.h" #include "fuse_ipc.h" #include "fuse_node.h" #include "fuse_file.h" @@ -106,6 +107,42 @@ static int isbzero(void *buf, size_t len); #endif +int +fuse_internal_get_cached_vnode(struct mount* mp, ino_t ino, int flags, + struct vnode **vpp) +{ + struct bintime now; + struct thread *td = curthread; + uint64_t nodeid = ino; + int error; + + *vpp = NULL; + + error = vfs_hash_get(mp, fuse_vnode_hash(nodeid), flags, td, vpp, + fuse_vnode_cmp, &nodeid); + if (error) + return error; + /* + * Check the entry cache timeout. We have to do this within fusefs + * instead of by using cache_enter_time/cache_lookup because those + * routines are only intended to work with pathnames, not inodes + */ + if (*vpp != NULL) { + getbinuptime(&now); + if (bintime_cmp(&(VTOFUD(*vpp)->entry_cache_timeout), &now, >)){ + atomic_add_acq_long(&fuse_lookup_cache_hits, 1); + return 0; + } else { + /* Entry cache timeout */ + atomic_add_acq_long(&fuse_lookup_cache_misses, 1); + cache_purge(*vpp); + vput(*vpp); + *vpp = NULL; + } + } + return 0; +} + /* Synchronously send a FUSE_ACCESS operation */ int fuse_internal_access(struct vnode *vp, @@ -337,7 +374,6 @@ fuse_internal_invalidate_entry(struct mount *mp, struc struct fuse_notify_inval_entry_out fnieo; struct fuse_data *data = fuse_get_mpdata(mp); struct componentname cn; - /*struct vnode *dvp;*/ struct vnode *dvp, *vp; char name[PATH_MAX]; int err; @@ -367,8 +403,9 @@ fuse_internal_invalidate_entry(struct mount *mp, struc if (fnieo.parent == FUSE_ROOT_ID) err = VFS_ROOT(mp, LK_SHARED, &dvp); else - err = VFS_VGET(mp, fnieo.parent, LK_SHARED, &dvp); - if (err != 0) + err = fuse_internal_get_cached_vnode( mp, fnieo.parent, + LK_SHARED, &dvp); + if (err != 0 || dvp == NULL) return (err); /* * XXX we can't check dvp's generation because the FUSE invalidate @@ -388,6 +425,53 @@ fuse_internal_invalidate_entry(struct mount *mp, struc MPASS(err == 0); fuse_vnode_clear_attr_cache(dvp); vput(dvp); + return (0); +} + +int +fuse_internal_invalidate_inode(struct mount *mp, struct uio *uio) +{ + struct fuse_notify_inval_inode_out fniio; + struct fuse_data *data = fuse_get_mpdata(mp); + struct vnode *vp; + int err; + + if (!(data->dataflags & FSESS_EXPORT_SUPPORT)) { + /* + * Linux allows file systems without export support to use + * asynchronous notification because its inode cache is indexed + * purely by the inode number. But FreeBSD's vnode is cache + * requires access to the entire vnode structure. + */ + SDT_PROBE1(fusefs, , internal, invalidate_without_export, mp); + return (EINVAL); + } + + if ((err = uiomove(&fniio, sizeof(fniio), uio)) != 0) + return (err); + + if (fniio.ino == FUSE_ROOT_ID) + err = VFS_ROOT(mp, LK_EXCLUSIVE, &vp); + else + err = fuse_internal_get_cached_vnode(mp, fniio.ino, LK_SHARED, + &vp); + if (err != 0 || vp == NULL) + return (err); + /* + * XXX we can't check vp's generation because the FUSE invalidate + * entry message doesn't include it. Worse case is that we invalidate + * an inode that didn't need to be invalidated. + */ + + /* + * Flush and invalidate buffers if off >= 0. Technically we only need + * to flush and invalidate the range of offsets [off, off + len), but + * for simplicity's sake we do everything. + */ + if (fniio.off >= 0) + fuse_io_invalbuf(vp, curthread); + fuse_vnode_clear_attr_cache(vp); + vput(vp); return (0); } Modified: projects/fuse2/sys/fs/fuse/fuse_internal.h ============================================================================== --- projects/fuse2/sys/fs/fuse/fuse_internal.h Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/sys/fs/fuse/fuse_internal.h Mon Jun 3 17:34:01 2019 (r348560) @@ -193,6 +193,10 @@ fuse_validity_2_timespec(const struct fuse_entry_out * } +/* VFS ops */ +int +fuse_internal_get_cached_vnode(struct mount*, ino_t, int, struct vnode**); + /* access */ static inline int fuse_match_cred(struct ucred *basecred, struct ucred *usercred) @@ -230,6 +234,7 @@ int fuse_internal_getattr(struct vnode *vp, struct vat /* asynchronous invalidation */ int fuse_internal_invalidate_entry(struct mount *mp, struct uio *uio); +int fuse_internal_invalidate_inode(struct mount *mp, struct uio *uio); /* mknod */ int fuse_internal_mknod(struct vnode *dvp, struct vnode **vpp, Modified: projects/fuse2/sys/fs/fuse/fuse_vfsops.c ============================================================================== --- projects/fuse2/sys/fs/fuse/fuse_vfsops.c Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/sys/fs/fuse/fuse_vfsops.c Mon Jun 3 17:34:01 2019 (r348560) @@ -527,34 +527,14 @@ fuse_vfsop_vget(struct mount *mp, ino_t ino, int flags struct fuse_dispatcher fdi; struct fuse_entry_out *feo; struct fuse_vnode_data *fvdat; - struct bintime now; const char dot[] = "."; off_t filesize; enum vtype vtyp; int error; - error = vfs_hash_get(mp, fuse_vnode_hash(nodeid), flags, td, vpp, - fuse_vnode_cmp, &nodeid); - if (error) + error = fuse_internal_get_cached_vnode(mp, ino, flags, vpp); + if (error || *vpp != NULL) return error; - /* - * Check the entry cache timeout. We have to do this within fusefs - * instead of by using cache_enter_time/cache_lookup because those - * routines are only intended to work with pathnames, not inodes - */ - if (*vpp != NULL) { - getbinuptime(&now); - if (bintime_cmp(&(VTOFUD(*vpp)->entry_cache_timeout), &now, >)){ - atomic_add_acq_long(&fuse_lookup_cache_hits, 1); - return 0; - } else { - /* Entry cache timeout */ - atomic_add_acq_long(&fuse_lookup_cache_misses, 1); - cache_purge(*vpp); - vput(*vpp); - *vpp = NULL; - } - } /* Do a LOOKUP, using nodeid as the parent and "." as filename */ fdisp_init(&fdi, sizeof(dot)); Modified: projects/fuse2/tests/sys/fs/fusefs/mockfs.cc ============================================================================== --- projects/fuse2/tests/sys/fs/fusefs/mockfs.cc Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/tests/sys/fs/fusefs/mockfs.cc Mon Jun 3 17:34:01 2019 (r348560) @@ -322,6 +322,13 @@ void MockFS::debug_response(const mockfs_buf_out &out) printf("<- INVAL_ENTRY parent=%" PRIu64 " %s\n", out.body.inval_entry.parent, name); break; + case FUSE_NOTIFY_INVAL_INODE: + printf("<- INVAL_INODE ino=%" PRIu64 " off=%" PRIi64 + " len=%" PRIi64 "\n", + out.body.inval_inode.ino, + out.body.inval_inode.off, + out.body.inval_inode.len); + break; default: break; } @@ -511,6 +518,21 @@ int MockFS::notify_inval_entry(ino_t parent, const cha name, sizeof(out->body.bytes) - sizeof(out->body.inval_entry)); out->header.len = sizeof(out->header) + sizeof(out->body.inval_entry) + namelen; + debug_response(*out); + write_response(*out); + return 0; +} + +int MockFS::notify_inval_inode(ino_t ino, off_t off, ssize_t len) +{ + std::unique_ptr<mockfs_buf_out> out(new mockfs_buf_out); + + out->header.unique = 0; /* 0 means asynchronous notification */ + out->header.error = FUSE_NOTIFY_INVAL_INODE; + out->body.inval_inode.ino = ino; + out->body.inval_inode.off = off; + out->body.inval_inode.len = len; + out->header.len = sizeof(out->header) + sizeof(out->body.inval_inode); debug_response(*out); write_response(*out); return 0; Modified: projects/fuse2/tests/sys/fs/fusefs/mockfs.hh ============================================================================== --- projects/fuse2/tests/sys/fs/fusefs/mockfs.hh Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/tests/sys/fs/fusefs/mockfs.hh Mon Jun 3 17:34:01 2019 (r348560) @@ -178,6 +178,7 @@ union fuse_payloads_out { fuse_init_out init; /* The inval_entry structure should be followed by the entry's name */ fuse_notify_inval_entry_out inval_entry; + fuse_notify_inval_inode_out inval_inode; fuse_listxattr_out listxattr; fuse_open_out open; fuse_statfs_out statfs; @@ -324,6 +325,23 @@ class MockFS { * @param namelen size of name, including the NUL */ int notify_inval_entry(ino_t parent, const char *name, size_t namelen); + + /* + * Send an asynchronous notification to invalidate an inode's cached + * data and/or attributes. Similar to libfuse's + * fuse_lowlevel_notify_inval_inode. + * + * This method will block until the client has responded, so it should + * generally be run in a separate thread from request processing. + * + * @param ino File's inode number + * @param off offset at which to begin invalidation. A + * negative offset means to invalidate attributes + * only. + * @param len Size of region of data to invalidate. 0 means + * to invalidate all cached data. + */ + int notify_inval_inode(ino_t ino, off_t off, ssize_t len); /* * Request handler Modified: projects/fuse2/tests/sys/fs/fusefs/notify.cc ============================================================================== --- projects/fuse2/tests/sys/fs/fusefs/notify.cc Mon Jun 3 17:29:57 2019 (r348559) +++ projects/fuse2/tests/sys/fs/fusefs/notify.cc Mon Jun 3 17:34:01 2019 (r348560) @@ -29,6 +29,10 @@ */ extern "C" { +#include <sys/types.h> +#include <sys/sysctl.h> + +#include <fcntl.h> #include <pthread.h> } @@ -46,14 +50,13 @@ using namespace testing; class Notify: public FuseTest { public: -public: virtual void SetUp() { m_init_flags = FUSE_EXPORT_SUPPORT; FuseTest::SetUp(); } void expect_lookup(uint64_t parent, const char *relpath, uint64_t ino, - Sequence &seq) + off_t size, Sequence &seq) { EXPECT_LOOKUP(parent, relpath) .InSequence(seq) @@ -64,12 +67,39 @@ void expect_lookup(uint64_t parent, const char *relpat out.body.entry.nodeid = ino; out.body.entry.attr.ino = ino; out.body.entry.attr.nlink = 1; + out.body.entry.attr.size = size; out.body.entry.attr_valid = UINT64_MAX; out.body.entry.entry_valid = UINT64_MAX; }))); } }; +class NotifyWriteback: public Notify { +public: +virtual void SetUp() { + const char *node = "vfs.fusefs.data_cache_mode"; + int val = 0; + size_t size = sizeof(val); + + Notify::SetUp(); + if (IsSkipped()) + return; + + ASSERT_EQ(0, sysctlbyname(node, &val, &size, NULL, 0)) + << strerror(errno); + if (val != 2) + GTEST_SKIP() << "vfs.fusefs.data_cache_mode must be set to 2 " + "(writeback) for this test"; +} + +void expect_write(uint64_t ino, uint64_t offset, uint64_t size, + const void *contents) +{ + FuseTest::expect_write(ino, offset, size, size, 0, 0, contents); +} + +}; + struct inval_entry_args { MockFS *mock; ino_t parent; @@ -88,6 +118,24 @@ static void* inval_entry(void* arg) { return (void*)(intptr_t)errno; } +struct inval_inode_args { + MockFS *mock; + ino_t ino; + off_t off; + ssize_t len; +}; + +static void* inval_inode(void* arg) { + const struct inval_inode_args *iia = (struct inval_inode_args*)arg; + ssize_t r; + + r = iia->mock->notify_inval_inode(iia->ino, iia->off, iia->len); + if (r >= 0) + return 0; + else + return (void*)(intptr_t)errno; +} + /* Invalidate a nonexistent entry */ TEST_F(Notify, inval_entry_nonexistent) { @@ -120,8 +168,8 @@ TEST_F(Notify, inval_entry) Sequence seq; pthread_t th0; - expect_lookup(FUSE_ROOT_ID, RELPATH, ino0, seq); - expect_lookup(FUSE_ROOT_ID, RELPATH, ino1, seq); + expect_lookup(FUSE_ROOT_ID, RELPATH, ino0, 0, seq); + expect_lookup(FUSE_ROOT_ID, RELPATH, ino1, 0, seq); /* Fill the entry cache */ ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); @@ -135,7 +183,6 @@ TEST_F(Notify, inval_entry) ASSERT_EQ(0, pthread_create(&th0, NULL, inval_entry, &iea)) << strerror(errno); pthread_join(th0, &thr0_value); - /* It's not an error for an entry to not be cached */ EXPECT_EQ(0, (intptr_t)thr0_value); /* The second lookup should return the alternate ino */ @@ -171,8 +218,8 @@ TEST_F(Notify, inval_entry_below_root) out.body.entry.attr_valid = UINT64_MAX; out.body.entry.entry_valid = UINT64_MAX; }))); - expect_lookup(dir_ino, FNAME, ino0, seq); - expect_lookup(dir_ino, FNAME, ino1, seq); + expect_lookup(dir_ino, FNAME, ino0, 0, seq); + expect_lookup(dir_ino, FNAME, ino1, 0, seq); /* Fill the entry cache */ ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); @@ -186,7 +233,6 @@ TEST_F(Notify, inval_entry_below_root) ASSERT_EQ(0, pthread_create(&th0, NULL, inval_entry, &iea)) << strerror(errno); pthread_join(th0, &thr0_value); - /* It's not an error for an entry to not be cached */ EXPECT_EQ(0, (intptr_t)thr0_value); /* The second lookup should return the alternate ino */ @@ -206,7 +252,7 @@ TEST_F(Notify, inval_entry_invalidates_parent_attrs) Sequence seq; pthread_t th0; - expect_lookup(FUSE_ROOT_ID, RELPATH, ino, seq); + expect_lookup(FUSE_ROOT_ID, RELPATH, ino, 0, seq); EXPECT_CALL(*m_mock, process( ResultOf([=](auto in) { return (in.header.opcode == FUSE_GETATTR && @@ -232,9 +278,187 @@ TEST_F(Notify, inval_entry_invalidates_parent_attrs) ASSERT_EQ(0, pthread_create(&th0, NULL, inval_entry, &iea)) << strerror(errno); pthread_join(th0, &thr0_value); - /* It's not an error for an entry to not be cached */ EXPECT_EQ(0, (intptr_t)thr0_value); /* /'s attribute cache should be cleared */ ASSERT_EQ(0, stat("mountpoint", &sb)) << strerror(errno); +} + + +TEST_F(Notify, inval_inode_nonexistent) +{ + struct inval_inode_args iia; + ino_t ino = 42; + void *thr0_value; + pthread_t th0; + + iia.mock = m_mock; + iia.ino = ino; + iia.off = 0; + iia.len = 0; + ASSERT_EQ(0, pthread_create(&th0, NULL, inval_inode, &iia)) + << strerror(errno); + pthread_join(th0, &thr0_value); + /* It's not an error for an inode to not be cached */ + EXPECT_EQ(0, (intptr_t)thr0_value); +} + +TEST_F(Notify, inval_inode_with_clean_cache) +{ + const static char FULLPATH[] = "mountpoint/foo"; + const static char RELPATH[] = "foo"; + const char CONTENTS0[] = "abcdefgh"; + const char CONTENTS1[] = "ijklmnopqrstuvwxyz"; + struct inval_inode_args iia; + struct stat sb; + ino_t ino = 42; + void *thr0_value; + Sequence seq; + uid_t uid = 12345; + pthread_t th0; + ssize_t size0 = sizeof(CONTENTS0); + ssize_t size1 = sizeof(CONTENTS1); + char buf[80]; + int fd; + + expect_lookup(FUSE_ROOT_ID, RELPATH, ino, size0, seq); + expect_open(ino, 0, 1); + EXPECT_CALL(*m_mock, process( + ResultOf([=](auto in) { + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == ino); + }, Eq(true)), + _) + ).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_valid = UINT64_MAX; + out.body.attr.attr.size = size1; + out.body.attr.attr.uid = uid; + }))); + expect_read(ino, 0, size0, size0, CONTENTS0); + expect_read(ino, 0, size1, size1, CONTENTS1); + + /* Fill the data cache */ + fd = open(FULLPATH, O_RDWR); + ASSERT_LE(0, fd) << strerror(errno); + ASSERT_EQ(size0, read(fd, buf, size0)) << strerror(errno); + EXPECT_EQ(0, memcmp(buf, CONTENTS0, size0)); + + /* Evict the data cache */ + iia.mock = m_mock; + iia.ino = ino; + iia.off = 0; + iia.len = 0; + ASSERT_EQ(0, pthread_create(&th0, NULL, inval_inode, &iia)) + << strerror(errno); + pthread_join(th0, &thr0_value); + EXPECT_EQ(0, (intptr_t)thr0_value); + + /* cache attributes were been purged; this will trigger a new GETATTR */ + ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); + EXPECT_EQ(uid, sb.st_uid); + EXPECT_EQ(size1, sb.st_size); + + /* This read should not be serviced by cache */ + ASSERT_EQ(0, lseek(fd, 0, SEEK_SET)) << strerror(errno); + ASSERT_EQ(size1, read(fd, buf, size1)) << strerror(errno); + EXPECT_EQ(0, memcmp(buf, CONTENTS1, size1)); + + /* Deliberately leak fd. close(2) will be tested in release.cc */ +} + +/* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=238312 */ +TEST_F(NotifyWriteback, DISABLED_inval_inode_with_dirty_cache) +{ + const static char FULLPATH[] = "mountpoint/foo"; + const static char RELPATH[] = "foo"; + const char CONTENTS[] = "abcdefgh"; + struct inval_inode_args iia; + ino_t ino = 42; + void *thr0_value; + Sequence seq; + pthread_t th0; + ssize_t bufsize = sizeof(CONTENTS); + int fd; + + expect_lookup(FUSE_ROOT_ID, RELPATH, ino, 0, seq); + expect_open(ino, 0, 1); + + /* Fill the data cache */ + fd = open(FULLPATH, O_RDWR); + ASSERT_EQ(bufsize, write(fd, CONTENTS, bufsize)) << strerror(errno); + + /* Evict the data cache */ + expect_write(ino, 0, bufsize, CONTENTS); + iia.mock = m_mock; + iia.ino = ino; + iia.off = 0; + iia.len = 0; + ASSERT_EQ(0, pthread_create(&th0, NULL, inval_inode, &iia)) + << strerror(errno); + pthread_join(th0, &thr0_value); + EXPECT_EQ(0, (intptr_t)thr0_value); + + /* Deliberately leak fd. close(2) will be tested in release.cc */ +} + +/* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=238312 */ +TEST_F(NotifyWriteback, DISABLED_inval_inode_attrs_only) +{ + const static char FULLPATH[] = "mountpoint/foo"; + const static char RELPATH[] = "foo"; + const char CONTENTS[] = "abcdefgh"; + struct inval_inode_args iia; + struct stat sb; + uid_t uid = 12345; + ino_t ino = 42; + void *thr0_value; + Sequence seq; + pthread_t th0; + ssize_t bufsize = sizeof(CONTENTS); + int fd; + + expect_lookup(FUSE_ROOT_ID, RELPATH, ino, 0, seq); + expect_open(ino, 0, 1); + EXPECT_CALL(*m_mock, process( + ResultOf([=](auto in) { + return (in.header.opcode == FUSE_WRITE); + }, Eq(true)), + _) + ).Times(0); + EXPECT_CALL(*m_mock, process( + ResultOf([=](auto in) { + return (in.header.opcode == FUSE_GETATTR && + in.header.nodeid == FUSE_ROOT_ID); + }, Eq(true)), + _) + ).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_valid = UINT64_MAX; + out.body.attr.attr.size = bufsize; + out.body.attr.attr.uid = uid; + }))); + + /* Fill the data cache */ + fd = open(FULLPATH, O_RDWR); + ASSERT_EQ(bufsize, write(fd, CONTENTS, bufsize)) << strerror(errno); + + /* Evict the attributes, but not data cache */ + iia.mock = m_mock; + iia.ino = ino; + iia.off = -1; + iia.len = 0; + ASSERT_EQ(0, pthread_create(&th0, NULL, inval_inode, &iia)) + << strerror(errno); + pthread_join(th0, &thr0_value); + EXPECT_EQ(0, (intptr_t)thr0_value); + + /* cache attributes were been purged; this will trigger a new GETATTR */ + ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno); + EXPECT_EQ(uid, sb.st_uid); + EXPECT_EQ(bufsize, sb.st_size); + + /* Deliberately leak fd. close(2) will be tested in release.cc */ }
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201906031734.x53HY12U041009>