2 files changed, 106 insertions, 0 deletions
diff --git a/test/syscalls/linux/cgroup.cc b/test/syscalls/linux/cgroup.cc
index a009ade7e..f29891571 100644
--- a/test/syscalls/linux/cgroup.cc
+++ b/test/syscalls/linux/cgroup.cc
@@ -227,6 +227,41 @@ TEST(Cgroup, MountRace) {
   EXPECT_NO_ERRNO(c.ContainsCallingProcess());
 }
 
+TEST(Cgroup, MountUnmountRace) {
+  SKIP_IF(!CgroupsAvailable());
+
+  TempPath mountpoint = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
+
+  const DisableSave ds;  // Too many syscalls.
+
+  auto mount_thread = [&mountpoint]() {
+    for (int i = 0; i < 100; ++i) {
+      mount("none", mountpoint.path().c_str(), "cgroup", 0, 0);
+    }
+  };
+  auto unmount_thread = [&mountpoint]() {
+    for (int i = 0; i < 100; ++i) {
+      umount(mountpoint.path().c_str());
+    }
+  };
+  std::list<ScopedThread> threads;
+  for (int i = 0; i < 10; ++i) {
+    threads.emplace_back(mount_thread);
+  }
+  for (int i = 0; i < 10; ++i) {
+    threads.emplace_back(unmount_thread);
+  }
+  for (auto& t : threads) {
+    t.Join();
+  }
+
+  // We don't know how many mount refs are remaining, since the count depends on
+  // the ordering of mount and umount calls. Keep calling unmount until it
+  // returns an error.
+  while (umount(mountpoint.path().c_str()) == 0) {
+  }
+}
+
 TEST(Cgroup, UnmountRepeated) {
   SKIP_IF(!CgroupsAvailable());
 
diff --git a/test/syscalls/linux/socket_inet_loopback.cc b/test/syscalls/linux/socket_inet_loopback.cc
index 9a6b089f6..f99d6f1c7 100644
--- a/test/syscalls/linux/socket_inet_loopback.cc
+++ b/test/syscalls/linux/socket_inet_loopback.cc
@@ -472,6 +472,77 @@ TEST_P(SocketInetLoopbackTest, TCPListenClose) {
   }
 }
 
+// Test the protocol state information returned by TCPINFO.
+TEST_P(SocketInetLoopbackTest, TCPInfoState) {
+  auto const& param = GetParam();
+  TestAddress const& listener = param.listener;
+  TestAddress const& connector = param.connector;
+
+  // Create the listening socket.
+  FileDescriptor const listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
+      Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
+
+  auto state = [](int fd) -> int {
+    struct tcp_info opt = {};
+    socklen_t optLen = sizeof(opt);
+    EXPECT_THAT(getsockopt(fd, SOL_TCP, TCP_INFO, &opt, &optLen),
+                SyscallSucceeds());
+    return opt.tcpi_state;
+  };
+  ASSERT_EQ(state(listen_fd.get()), TCP_CLOSE);
+
+  sockaddr_storage listen_addr = listener.addr;
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
+  ASSERT_EQ(state(listen_fd.get()), TCP_CLOSE);
+
+  ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
+  ASSERT_EQ(state(listen_fd.get()), TCP_LISTEN);
+
+  // Get the port bound by the listening socket.
+  socklen_t addrlen = listener.addr_len;
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
+              SyscallSucceeds());
+  uint16_t const port =
+      ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
+
+  // Connect to the listening socket.
+  FileDescriptor conn_fd = ASSERT_NO_ERRNO_AND_VALUE(
+      Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
+  sockaddr_storage conn_addr = connector.addr;
+  ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
+  ASSERT_EQ(state(conn_fd.get()), TCP_CLOSE);
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
+                                  connector.addr_len),
+              SyscallSucceeds());
+  ASSERT_EQ(state(conn_fd.get()), TCP_ESTABLISHED);
+
+  auto accepted =
+      ASSERT_NO_ERRNO_AND_VALUE(Accept(listen_fd.get(), nullptr, nullptr));
+  ASSERT_EQ(state(accepted.get()), TCP_ESTABLISHED);
+
+  ASSERT_THAT(close(accepted.release()), SyscallSucceeds());
+
+  struct pollfd pfd = {
+      .fd = conn_fd.get(),
+      .events = POLLIN | POLLRDHUP,
+  };
+  constexpr int kTimeout = 10000;
+  int n = poll(&pfd, 1, kTimeout);
+  ASSERT_GE(n, 0) << strerror(errno);
+  ASSERT_EQ(n, 1);
+  if (IsRunningOnGvisor()) {
+    // TODO(gvisor.dev/issue/6015): Notify POLLRDHUP on incoming FIN.
+    ASSERT_EQ(pfd.revents, POLLIN);
+  } else {
+    ASSERT_EQ(pfd.revents, POLLIN | POLLRDHUP);
+  }
+
+  ASSERT_THAT(state(conn_fd.get()), TCP_CLOSE_WAIT);
+  ASSERT_THAT(close(conn_fd.release()), SyscallSucceeds());
+}
+
 void TestHangupDuringConnect(const TestParam& param,
                              void (*hangup)(FileDescriptor&)) {
   TestAddress const& listener = param.listener;