netbird/gvisor
0
0
Fork 0
mirror of https://github.com/netbirdio/gvisor.git synced 2026-05-22 17:12:49 -07:00
Code Issues Packages Projects Releases Wiki Activity

Move udp port exhaustion tests to a 'nogotsan' one.

Browse Source 
It frequently times out under GoTSAN.

PiperOrigin-RevId: 327894343
This commit is contained in:
Ting-Yu Wang
2020-08-21 16:34:50 -07:00
committed by gVisor bot
parent 23070b2e5f
commit bd3383a7e2
4 changed files with 118 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/syscalls/BUILD
+7
View File
@@ -667,6 +667,13 @@ syscall_test(
test = "//test/syscalls/linux:socket_ipv4_udp_unbound_loopback_test",
)
syscall_test(
size = "medium",
# Takes too long under gotsan to run.
tags = ["nogotsan"],
test = "//test/syscalls/linux:socket_ipv4_udp_unbound_loopback_nogotsan_test",
)
syscall_test(
test = "//test/syscalls/linux:socket_ip_unbound_test",
)
test/syscalls/linux/BUILD
+17
View File
@@ -2738,6 +2738,23 @@ cc_binary(
],
)
cc_binary(
name = "socket_ipv4_udp_unbound_loopback_nogotsan_test",
testonly = 1,
srcs = [
"socket_ipv4_udp_unbound_loopback_nogotsan.cc",
],
linkstatic = 1,
deps = [
":ip_socket_test_util",
":socket_test_util",
gtest,
"//test/util:test_main",
"//test/util:test_util",
"@com_google_absl//absl/memory",
],
)
cc_binary(
name = "socket_ip_unbound_test",
testonly = 1,
test/syscalls/linux/socket_ipv4_udp_unbound.cc
-56
View File
@@ -2121,62 +2121,6 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrReusePortDistribution) {
SyscallSucceedsWithValue(kMessageSize));
}
// Check that connect returns EAGAIN when out of local ephemeral ports.
// We disable S/R because this test creates a large number of sockets.
TEST_P(IPv4UDPUnboundSocketTest, UDPConnectPortExhaustion_NoRandomSave) {
auto receiver1 = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
constexpr int kClients = 65536;
// Bind the first socket to the loopback and take note of the selected port.
auto addr = V4Loopback();
ASSERT_THAT(bind(receiver1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len),
SyscallSucceeds());
socklen_t addr_len = addr.addr_len;
ASSERT_THAT(getsockname(receiver1->get(),
reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
SyscallSucceeds());
EXPECT_EQ(addr_len, addr.addr_len);
// Disable cooperative S/R as we are making too many syscalls.
DisableSave ds;
std::vector<std::unique_ptr<FileDescriptor>> sockets;
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret = connect(s->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
}
ASSERT_THAT(ret, SyscallFailsWithErrno(EAGAIN));
break;
}
}
// Check that bind returns EADDRINUSE when out of local ephemeral ports.
// We disable S/R because this test creates a large number of sockets.
TEST_P(IPv4UDPUnboundSocketTest, UDPBindPortExhaustion_NoRandomSave) {
auto receiver1 = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
constexpr int kClients = 65536;
auto addr = V4Loopback();
// Disable cooperative S/R as we are making too many syscalls.
DisableSave ds;
std::vector<std::unique_ptr<FileDescriptor>> sockets;
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret =
bind(s->get(), reinterpret_cast<sockaddr*>(&addr.addr), addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
}
ASSERT_THAT(ret, SyscallFailsWithErrno(EADDRINUSE));
break;
}
}
// Test that socket will receive packet info control message.
TEST_P(IPv4UDPUnboundSocketTest, SetAndReceiveIPPKTINFO) {
// TODO(gvisor.dev/issue/1202): ioctl() is not supported by hostinet.
test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc
+94
View File
@@ -0,0 +1,94 @@
// Copyright 2020 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <sys/socket.h>
#include <sys/types.h>
#include "gtest/gtest.h"
#include "absl/memory/memory.h"
#include "test/syscalls/linux/ip_socket_test_util.h"
#include "test/syscalls/linux/socket_test_util.h"
#include "test/util/test_util.h"
namespace gvisor {
namespace testing {
// Test fixture for tests that apply to IPv4 UDP sockets.
using IPv4UDPUnboundSocketNogotsanTest = SimpleSocketTest;
// Check that connect returns EAGAIN when out of local ephemeral ports.
// We disable S/R because this test creates a large number of sockets.
TEST_P(IPv4UDPUnboundSocketNogotsanTest,
UDPConnectPortExhaustion_NoRandomSave) {
auto receiver1 = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
constexpr int kClients = 65536;
// Bind the first socket to the loopback and take note of the selected port.
auto addr = V4Loopback();
ASSERT_THAT(bind(receiver1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len),
SyscallSucceeds());
socklen_t addr_len = addr.addr_len;
ASSERT_THAT(getsockname(receiver1->get(),
reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
SyscallSucceeds());
EXPECT_EQ(addr_len, addr.addr_len);
// Disable cooperative S/R as we are making too many syscalls.
DisableSave ds;
std::vector<std::unique_ptr<FileDescriptor>> sockets;
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret = connect(s->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
}
ASSERT_THAT(ret, SyscallFailsWithErrno(EAGAIN));
break;
}
}
// Check that bind returns EADDRINUSE when out of local ephemeral ports.
// We disable S/R because this test creates a large number of sockets.
TEST_P(IPv4UDPUnboundSocketNogotsanTest, UDPBindPortExhaustion_NoRandomSave) {
auto receiver1 = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
constexpr int kClients = 65536;
auto addr = V4Loopback();
// Disable cooperative S/R as we are making too many syscalls.
DisableSave ds;
std::vector<std::unique_ptr<FileDescriptor>> sockets;
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret =
bind(s->get(), reinterpret_cast<sockaddr*>(&addr.addr), addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
}
ASSERT_THAT(ret, SyscallFailsWithErrno(EADDRINUSE));
break;
}
}
INSTANTIATE_TEST_SUITE_P(
IPv4UDPSockets, IPv4UDPUnboundSocketNogotsanTest,
::testing::ValuesIn(ApplyVec<SocketKind>(IPv4UDPUnboundSocket,
AllBitwiseCombinations(List<int>{
0, SOCK_NONBLOCK}))));
} // namespace testing
} // namespace gvisor