| // Copyright 2019 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/fpromise/bridge.h> | |
| #include <lib/fpromise/promise.h> | |
| #include <lib/fpromise/single_threaded_executor.h> | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <sys/socket.h> | |
| #include <future> | |
| #include <optional> | |
| #include <fbl/unique_fd.h> | |
| #include <gmock/gmock.h> | |
| #include <gtest/gtest.h> | |
| #include "src/lib/fxl/strings/string_printf.h" | |
| #include "src/lib/fxl/strings/trim.h" | |
| #include "src/virtualization/tests/lib/enclosed_guest.h" | |
| #include "src/virtualization/tests/lib/guest_test.h" | |
| using ::testing::HasSubstr; | |
| static constexpr char kVirtioNetUtil[] = "virtio_net_test_util"; | |
| static constexpr size_t kTestPacketSize = 1000; | |
| // Includes ethernet + IPv4 + UDP headers. | |
| static constexpr size_t kHeadersSize = 42; | |
| static constexpr fuchsia::net::MacAddress kDefaultMacAddress = { | |
| .octets = {0x02, 0x1a, 0x11, 0x00, 0x01, 0x00}, | |
| }; | |
| static constexpr fuchsia::net::MacAddress kSecondNicMacAddress = { | |
| .octets = {0x02, 0x1a, 0x11, 0x00, 0x01, 0x01}, | |
| }; | |
| static constexpr fuchsia::virtualization::NetSpec kSecondNicNetSpec = { | |
| .mac_address = kSecondNicMacAddress, | |
| .enable_bridge = true, | |
| }; | |
| static constexpr char kDefaultMacString[] = "02:1a:11:00:01:00"; | |
| static constexpr char kSecondNicMacString[] = "02:1a:11:00:01:01"; | |
| [[maybe_unused]] static constexpr char kHostMacString[] = "02:1a:11:00:00:00"; | |
| // Run the two promises, returning the result of the first that completes. | |
| // | |
| // TODO(https://fxbug.dev/42139156): When a library version becomes available, use that | |
| // instead. | |
| template <typename V, typename E> | |
| fpromise::promise<V, E> SelectPromise(fpromise::promise<V, E>& a, fpromise::promise<V, E>& b) { | |
| return fpromise::make_promise( | |
| [&a, &b](fpromise::context& context) mutable -> fpromise::result<V, E> { | |
| fpromise::result<V, E> a_result = a(context); | |
| if (!a_result.is_pending()) { | |
| return std::move(a_result); | |
| } | |
| fpromise::result<V, E> b_result = b(context); | |
| if (!b_result.is_pending()) { | |
| return std::move(b_result); | |
| } | |
| return fpromise::pending(); | |
| }); | |
| } | |
| static void TestThread(fuchsia::net::MacAddress mac_addr, FakeNetstack* netstack, | |
| uint8_t receive_byte, uint8_t send_byte, bool rotate_bytes, | |
| bool use_raw_packets, fpromise::consumer<void, void> consumer) { | |
| async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread); | |
| // This thread will loop indefinitely until it receives the correct packet. | |
| // The test will time out via RunUtil in the test fixture if we fail to | |
| // receive the correct packet. | |
| using Promise = fpromise::promise<std::optional<std::vector<uint8_t>>, zx_status_t>; | |
| using PromiseResult = fpromise::result<std::optional<std::vector<uint8_t>>, zx_status_t>; | |
| Promise consumer_promise = | |
| consumer.promise().then([](fpromise::result<void, void>&) -> PromiseResult { | |
| return fpromise::ok(std::optional<std::vector<uint8_t>>()); | |
| }); | |
| while (true) { | |
| Promise netstack_promise = | |
| netstack->ReceivePacket(mac_addr).and_then([](std::vector<uint8_t>& v) { | |
| return fpromise::ok(std::optional<std::vector<uint8_t>>(std::move(v))); | |
| }); | |
| auto result = fpromise::run_single_threaded(SelectPromise(netstack_promise, consumer_promise)); | |
| ASSERT_TRUE(result.is_ok()); | |
| std::optional opt_value = result.take_value(); | |
| if (!opt_value.has_value()) { | |
| // The consumer promise has completed, so we can break from the while loop here. | |
| break; | |
| } | |
| std::vector<uint8_t> packet = std::move(opt_value.value()); | |
| bool match_test_packet = false; | |
| size_t headers_size = use_raw_packets ? 0 : kHeadersSize; | |
| if (packet.size() == headers_size + kTestPacketSize) { | |
| match_test_packet = true; | |
| for (size_t i = headers_size; i != packet.size(); ++i) { | |
| if (packet[i] != receive_byte) { | |
| match_test_packet = false; | |
| break; | |
| } | |
| } | |
| } | |
| if (!match_test_packet) { | |
| // The packet is incorrect, don't echo it back to the target | |
| continue; | |
| } | |
| std::vector<uint8_t> send_packet(kTestPacketSize); | |
| memset(send_packet.data(), send_byte, kTestPacketSize); | |
| if (rotate_bytes) { | |
| receive_byte++; | |
| send_byte++; | |
| } | |
| fpromise::promise<void, zx_status_t> promise; | |
| if (use_raw_packets) { | |
| promise = netstack->SendPacket(mac_addr, std::move(send_packet)); | |
| } else { | |
| promise = netstack->SendUdpPacket(mac_addr, std::move(send_packet)); | |
| } | |
| auto send_result = fpromise::run_single_threaded(std::move(promise)); | |
| ASSERT_TRUE(send_result.is_ok()); | |
| } | |
| } | |
| class VirtioNetMultipleInterfacesZirconGuest : public ZirconEnclosedGuest { | |
| public: | |
| VirtioNetMultipleInterfacesZirconGuest(async_dispatcher_t* dispatcher, | |
| RunLoopUntilFunc run_loop_until) | |
| : ZirconEnclosedGuest(dispatcher, std::move(run_loop_until)) {} | |
| zx_status_t BuildLaunchInfo(GuestLaunchInfo* launch_info) override { | |
| zx_status_t status = ZirconEnclosedGuest::BuildLaunchInfo(launch_info); | |
| if (status != ZX_OK) { | |
| return status; | |
| } | |
| launch_info->config.set_virtio_gpu(false); | |
| launch_info->config.mutable_net_devices()->emplace_back(kSecondNicNetSpec); | |
| return ZX_OK; | |
| } | |
| }; | |
| using VirtioNetMultipleInterfacesZirconGuestTest = | |
| GuestTest<VirtioNetMultipleInterfacesZirconGuest>; | |
| TEST_F(VirtioNetMultipleInterfacesZirconGuestTest, ReceiveAndSend) { | |
| // Both the value and error are void here, as we're only using the bridge as a signal. | |
| fpromise::bridge<void, void> bridge; | |
| // Loop back some data over the default network interface to verify that it is functional. | |
| auto handle = std::async(std::launch::async, [this, &bridge] { | |
| FakeNetstack* netstack = this->GetEnclosedGuest().GetNetstack(); | |
| // Pass the consumer into the test thread here. | |
| TestThread(kDefaultMacAddress, netstack, 0xab, 0xba, /*rotate_bytes=*/false, | |
| /*use_raw_packets=*/true, std::move(bridge.consumer)); | |
| }); | |
| std::string result; | |
| EXPECT_EQ(this->RunUtil(kVirtioNetUtil, | |
| {fxl::StringPrintf("%u", 0xab), fxl::StringPrintf("%u", 0xba), | |
| fxl::StringPrintf("%zu", kTestPacketSize), kDefaultMacString}, | |
| &result), | |
| ZX_OK); | |
| EXPECT_THAT(result, HasSubstr("PASS")); | |
| bridge.completer.complete_ok(); | |
| handle.wait(); | |
| bridge = fpromise::bridge<void, void>(); | |
| // Ensure that the guest's second NIC works as well. | |
| handle = std::async(std::launch::async, [this, &bridge] { | |
| FakeNetstack* netstack = this->GetEnclosedGuest().GetNetstack(); | |
| TestThread(kSecondNicMacAddress, netstack, 0xcd, 0xdc, /*rotate_bytes=*/false, | |
| /*use_raw_packets=*/true, std::move(bridge.consumer)); | |
| }); | |
| EXPECT_EQ(this->RunUtil(kVirtioNetUtil, | |
| {fxl::StringPrintf("%u", 0xcd), fxl::StringPrintf("%u", 0xdc), | |
| fxl::StringPrintf("%zu", kTestPacketSize), kSecondNicMacString}, | |
| &result), | |
| ZX_OK); | |
| EXPECT_THAT(result, HasSubstr("PASS")); | |
| bridge.completer.complete_ok(); | |
| handle.wait(); | |
| } | |
| #if __x86_64__ | |
| class VirtioNetMultipleInterfacesDebianGuest : public DebianEnclosedGuest { | |
| public: | |
| VirtioNetMultipleInterfacesDebianGuest(async_dispatcher_t* dispatcher, | |
| RunLoopUntilFunc run_loop_until) | |
| : DebianEnclosedGuest(dispatcher, std::move(run_loop_until)) {} | |
| zx_status_t BuildLaunchInfo(struct GuestLaunchInfo* launch_info) override { | |
| zx_status_t status = DebianEnclosedGuest::BuildLaunchInfo(launch_info); | |
| if (status != ZX_OK) { | |
| return status; | |
| } | |
| launch_info->config.set_virtio_gpu(false); | |
| launch_info->config.mutable_net_devices()->emplace_back(kSecondNicNetSpec); | |
| return ZX_OK; | |
| } | |
| }; | |
| using VirtioNetMultipleInterfacesDebianGuestTest = | |
| GuestTest<VirtioNetMultipleInterfacesDebianGuest>; | |
| TEST_F(VirtioNetMultipleInterfacesDebianGuestTest, ReceiveAndEchoMultiple) { | |
| fpromise::bridge<void, void> bridge; | |
| auto handle = std::async(std::launch::async, [this, &bridge] { | |
| FakeNetstack* netstack = this->GetEnclosedGuest().GetNetstack(); | |
| TestThread(kDefaultMacAddress, netstack, 0xab, 0xab, /*rotate_bytes=*/true, | |
| /*use_raw_packets=*/false, std::move(bridge.consumer)); | |
| }); | |
| // The NetworkManager service tries to detect whether there is a working network, and as we | |
| // simply drop all unexpected packets this times out and fails during longer running tests. | |
| // We can just disable this since we don't actually want our networks managed, but longer term | |
| // we need to improve the fake network logic. | |
| // | |
| // TODO(https://fxbug.dev/42065907): Improve fake network to reply to NetworkManager. | |
| EXPECT_EQ(this->Execute({"sudo", "systemctl", "mask", "NetworkManager.service"}), ZX_OK); | |
| EXPECT_EQ(this->Execute({"sudo", "systemctl", "stop", "NetworkManager.service"}), ZX_OK); | |
| // Find the network interface corresponding to the guest's first ethernet device MAC address. | |
| std::string network_interface; | |
| ASSERT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "Find", | |
| kDefaultMacString, | |
| }, | |
| &network_interface), | |
| ZX_OK); | |
| network_interface = std::string(fxl::TrimString(network_interface, "\n")); | |
| ASSERT_FALSE(network_interface.empty()); | |
| // Configure the guest IPv4 address. | |
| EXPECT_EQ(this->Execute({"ifconfig", network_interface, "192.168.0.10"}), ZX_OK); | |
| // Manually add a route to the host. | |
| EXPECT_EQ(this->Execute({"arp", "-s", "192.168.0.1", kHostMacString}), ZX_OK); | |
| std::string result; | |
| EXPECT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "RotatingTransfer", | |
| fxl::StringPrintf("%u", 0xab), | |
| fxl::StringPrintf("%u", 50000), // Roughly 50MB of data. | |
| fxl::StringPrintf("%zu", kTestPacketSize), | |
| }, | |
| &result), | |
| ZX_OK); | |
| EXPECT_THAT(result, HasSubstr("PASS")); | |
| bridge.completer.complete_ok(); | |
| handle.wait(); | |
| } | |
| TEST_F(VirtioNetMultipleInterfacesDebianGuestTest, ReceiveAndSend) { | |
| fpromise::bridge<void, void> bridge; | |
| auto handle = std::async(std::launch::async, [this, &bridge] { | |
| FakeNetstack* netstack = this->GetEnclosedGuest().GetNetstack(); | |
| TestThread(kDefaultMacAddress, netstack, 0xab, 0xba, /*rotate_bytes=*/false, | |
| /*use_raw_packets=*/false, std::move(bridge.consumer)); | |
| }); | |
| // Find the network interface corresponding to the guest's first ethernet device MAC address. | |
| std::string network_interface; | |
| ASSERT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "Find", | |
| kDefaultMacString, | |
| }, | |
| &network_interface), | |
| ZX_OK); | |
| network_interface = std::string(fxl::TrimString(network_interface, "\n")); | |
| ASSERT_FALSE(network_interface.empty()); | |
| // Configure the guest IPv4 address. | |
| EXPECT_EQ(this->Execute({"ifconfig", network_interface, "192.168.0.10"}), ZX_OK); | |
| // Manually add a route to the host. | |
| EXPECT_EQ(this->Execute({"arp", "-s", "192.168.0.1", kHostMacString}), ZX_OK); | |
| std::string result; | |
| EXPECT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "Transfer", | |
| fxl::StringPrintf("%u", 0xab), | |
| fxl::StringPrintf("%u", 0xba), | |
| fxl::StringPrintf("%zu", kTestPacketSize), | |
| }, | |
| &result), | |
| ZX_OK); | |
| EXPECT_THAT(result, HasSubstr("PASS")); | |
| bridge.completer.complete_ok(); | |
| handle.wait(); | |
| bridge = fpromise::bridge<void, void>(); | |
| // Bring down the first interface | |
| EXPECT_EQ(this->Execute({"ifconfig", network_interface, "down"}), ZX_OK); | |
| // Find the network interface corresponding to the guest's second ethernet device MAC address. | |
| ASSERT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "Find", | |
| kSecondNicMacString, | |
| }, | |
| &network_interface), | |
| ZX_OK); | |
| network_interface = std::string(fxl::TrimString(network_interface, "\n")); | |
| ASSERT_FALSE(network_interface.empty()); | |
| // Configure the guest's second interface with the same settings as the first interface. | |
| EXPECT_EQ(this->Execute({"ifconfig", network_interface, "192.168.0.10"}), ZX_OK); | |
| EXPECT_EQ(this->Execute({"arp", "-s", "192.168.0.1", kHostMacString}), ZX_OK); | |
| // Start a new handler thread to validate the data sent over the second NIC. | |
| handle = std::async(std::launch::async, [this, &bridge] { | |
| FakeNetstack* netstack = this->GetEnclosedGuest().GetNetstack(); | |
| TestThread(kSecondNicMacAddress, netstack, 0xcd, 0xdc, /*rotate_bytes=*/false, | |
| /*use_raw_packets=*/false, std::move(bridge.consumer)); | |
| }); | |
| // Run the net util to generate and validate the data | |
| EXPECT_EQ(this->RunUtil(kVirtioNetUtil, | |
| { | |
| "Transfer", | |
| fxl::StringPrintf("%u", 0xcd), | |
| fxl::StringPrintf("%u", 0xdc), | |
| fxl::StringPrintf("%zu", kTestPacketSize), | |
| }, | |
| &result), | |
| ZX_OK); | |
| EXPECT_THAT(result, HasSubstr("PASS")); | |
| bridge.completer.complete_ok(); | |
| handle.wait(); | |
| } | |
| #endif // __x86_64__ |