src/bringup/lib/restricted-machine/tests/machine-tests.cc

// Copyright 2025 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/elfldltl/constants.h>

#include <bringup/lib/restricted-machine/machine.h>
#include <zxtest/zxtest.h>

namespace {

class MachineTests : public zxtest::TestWithParam<restricted_machine::MachineType> {
 public:
  void SetUp() override {
    environment_ = fbl::AdoptRef(new restricted_machine::Environment);
    machine_type_ = GetParam();
    if (!restricted_machine::Environment::HardwareSupported(machine_type_)) {
      ZXTEST_SKIP() << "unsupported machine type: " << machine_type_.AsString();
      return;
    }
    ASSERT_TRUE(environment_->Initialize(machine_type_));
  }

 protected:
  restricted_machine::MachineType machine_type_;
  fbl::RefPtr<restricted_machine::Environment> environment_{};
};

TEST_P(MachineTests, PingValueArgs) {
  restricted_machine::Machine machine(environment_);
  if (environment_->address_limit() != 0) {
    ZXTEST_SKIP() << "this cannot be run on address limited environments";
  }
  ASSERT_TRUE(machine.Initialize());
  auto r = machine.Call(restricted_machine::Environment::kPingFunctionName, 1, 2, 3, 4);
  EXPECT_TRUE(r.is_error());
  EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, r.error_value());
}

TEST_P(MachineTests, Ping) {
  restricted_machine::Machine machine(environment_);
  ASSERT_TRUE(machine.Initialize());
  auto arg0 = environment_->MakeArgument<uint64_t>(2);
  auto arg1 = environment_->MakeArgument<uint64_t>(3);
  auto arg2 = environment_->MakeArgument<uint64_t>(4);
  auto arg3 = environment_->MakeArgument<uint64_t>(5);
  auto r = machine.Call(restricted_machine::Environment::kPingFunctionName, arg0.get(), arg1.get(),
                        arg2.get(), arg3.get());
  ASSERT_TRUE(r.is_ok());
  EXPECT_EQ(14, r.value());
}

// Derive a machine to test arg prepping
class ArgMachine : public restricted_machine::Machine {
 public:
  ArgMachine(fbl::RefPtr<restricted_machine::Environment> e) : restricted_machine::Machine(e) {}
  ~ArgMachine() = default;
  template <typename... Args>
  zx::result<> doPrepArgs(std::vector<uint64_t> *args, Args... vargs) {
    return prepArgs(args, vargs...);
  }
};

TEST_P(MachineTests, PrepArgsAllocationLimit) {
  auto e = AdoptRef(new restricted_machine::Environment);
  uint64_t limit = 0x4fffffff;
  ASSERT_TRUE(e->Initialize(machine_type_, 4096 * 12, limit));

  ArgMachine machine(e);
  ASSERT_TRUE(machine.Initialize());
  auto arg0 = e->MakeArgument<std::string>("Hello World");
  auto arg1 = e->MakeArgument<uint64_t>(1);
  auto arg2 = e->MakeArgument<uint64_t>(2);
  auto arg3 = e->MakeArgument<uint64_t>(3);
  std::vector<uint64_t> args;
  auto result = machine.doPrepArgs(&args, arg0.get(), arg1.get(), arg2.get(), arg3.get());
  EXPECT_OK(result);
  ASSERT_EQ(args.size(), 4);
  EXPECT_GT(limit, args[0]);
  EXPECT_GT(limit, args[1]);
  EXPECT_GT(limit, args[2]);
  EXPECT_GT(limit, args[3]);
  EXPECT_STREQ(reinterpret_cast<std::string *>(args[0])->c_str(), arg0->c_str());
  EXPECT_GT(limit, reinterpret_cast<uint64_t>(reinterpret_cast<std::string *>(args[0])->data()));
  EXPECT_EQ(*reinterpret_cast<uint64_t *>(args[1]), 1ULL);
  EXPECT_EQ(*reinterpret_cast<uint64_t *>(args[2]), 2ULL);
  EXPECT_EQ(*reinterpret_cast<uint64_t *>(args[3]), 3ULL);
}

TEST_P(MachineTests, PrepArgsOutOfRange) {
  auto e = AdoptRef(new restricted_machine::Environment);
  uint64_t limit = 0x4fffffff;
  ASSERT_TRUE(e->Initialize(machine_type_, 4096 * 12, limit));
  ArgMachine machine(e);
  ASSERT_TRUE(machine.Initialize());
  auto arg = e->MakeArgument<std::string>("Hello World");
  // The stack-based value should be out of range reliably.
  std::vector<uint64_t> args;
  uint64_t stack_arg = 2;
  auto result = machine.doPrepArgs(&args, &stack_arg, arg.get());
  EXPECT_TRUE(result.is_error());
  EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, result.error_value());
  EXPECT_EQ(args.size(), 0);

  args.clear();
  result = machine.doPrepArgs(&args, arg.get(), &stack_arg);
  EXPECT_TRUE(result.is_error());
  EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, result.error_value());
  EXPECT_EQ(args.size(), 1);

  args.clear();
  result = machine.doPrepArgs(&args, arg.get(), arg.get(), &stack_arg);
  EXPECT_TRUE(result.is_error());
  EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, result.error_value());
  EXPECT_EQ(args.size(), 2);

  args.clear();
  result = machine.doPrepArgs(&args, arg.get(), arg.get(), arg.get(), &stack_arg);
  EXPECT_TRUE(result.is_error());
  EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, result.error_value());
  EXPECT_EQ(args.size(), 3);
}

// This test validates the FPU registers workflow ensuring a value is returned
// in the FPU registers from the restricted environment.
TEST_P(MachineTests, FpuRegisterPreservation) {
  restricted_machine::Machine machine(environment_);
  ASSERT_TRUE(machine.Initialize());
  machine.enable_fpu_registers(true);

  // Make a buffer and fill it with known values
  std::vector<char> expected_fpu_buffer;
  memset(machine.FpuRegisters()->data(), 0xAA, machine.FpuRegisters()->size());
  // Ping will set the first 64-bits of FPU register space to the first
  // argument's value.
  auto arg0 = environment_->MakeArgument<uint64_t>(2);

  // Call ping()
  auto arg1 = environment_->MakeArgument<uint64_t>(5);
  auto arg2 = environment_->MakeArgument<uint64_t>(4);
  auto arg3 = environment_->MakeArgument<uint64_t>(3);
  auto r = machine.Call(restricted_machine::Environment::kPingFunctionName, arg0.get(), arg1.get(),
                        arg2.get(), arg3.get());
  ASSERT_TRUE(r.is_ok());
  EXPECT_EQ(14, r.value());

  // Ping will set the first 64-bits of FPU register space to the first
  // argument's value.
  uint8_t *value = reinterpret_cast<uint8_t *>(arg0.get());
  for (uint16_t i = 0; i < 8; i++) {
    EXPECT_EQ(machine.FpuRegisters()->at(i), value[i]);
  }
  // Now we can see if the other FPU registers survived.
  for (uint16_t i = 8; i < machine.FpuRegisters()->size(); i++) {
    EXPECT_EQ(0xAA, machine.FpuRegisters()->at(i)) << "i: " << i;
  }
}

}  // anonymous namespace

INSTANTIATE_TEST_SUITE_P(, MachineTests, zxtest::ValuesIn(restricted_machine::kSupportedMachines),
                         [](const zxtest::TestParamInfo<MachineTests::ParamType> &info) {
                           return std::string(info.param.AsString());
                         });

int main(int argc, char **argv) { return RUN_ALL_TESTS(argc, argv); }