src/developer/debug/zxdb/console/commands/verb_stack_usage_unittest.cc

// Copyright 2022 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 "src/developer/debug/zxdb/console/commands/verb_stack_usage.h"

#include <gtest/gtest.h>

#include "src/developer/debug/zxdb/client/mock_frame.h"
#include "src/developer/debug/zxdb/client/session.h"
#include "src/developer/debug/zxdb/console/console_test.h"

namespace zxdb {

namespace {

class VerbStackUsage : public ConsoleTest {};

}  // namespace

TEST_F(VerbStackUsage, GetThreadStackUsage) {
  const uint64_t kPageSize = session().arch_info().page_size();

  const uint64_t kStackBase = 0x100000;  // HIGH address of stack region.
  const uint64_t kStackSizeInPages = 20;
  const uint64_t kStackSize = kStackSizeInPages * kPageSize;

  // This test expects the page size to be larger than the used bytes for the below computations.
  const uint64_t kUsedBytes = 0x5e;
  ASSERT_GE(kPageSize, kUsedBytes);
  const uint64_t kStackPointer = kStackBase - kUsedBytes;

  // Same values for the unsafe stack.
  const uint64_t kUnsafeStackBase = 0x9000000;
  const uint64_t kUnsafeStackSizeInPages = 20;
  const uint64_t kUnsafeStackSize = kUnsafeStackSizeInPages * kPageSize;
  const uint64_t kUnsafeUsedBytes = 0x103;
  ASSERT_GE(kPageSize, kUnsafeUsedBytes);
  const uint64_t kUnsafeStackPointer = kUnsafeStackBase - kUnsafeUsedBytes;

  // Set up the thread to be stopped with the given stack pointer.
  std::vector<std::unique_ptr<Frame>> frames;
  Location location(Location::State::kSymbolized, 0x1000);
  frames.push_back(std::make_unique<MockFrame>(&session(), thread(), location, kStackPointer));
  InjectExceptionWithStack(ConsoleTest::kProcessKoid, ConsoleTest::kThreadKoid,
                           debug_ipc::ExceptionType::kSingleStep, std::move(frames), true);

  std::vector<debug_ipc::AddressRegion> aspace;
  debug_ipc::AddressRegion& containing_region = aspace.emplace_back();
  containing_region.base = 0;
  containing_region.size = 0x100000000000ull;
  containing_region.depth = 0;

  debug_ipc::AddressRegion& other_region = aspace.emplace_back();
  other_region.base = 0x1000;
  other_region.size = 0x1000;
  other_region.depth = 1;
  other_region.vmo_koid = 1234;

  // Safe stack region.
  debug_ipc::AddressRegion& stack_region = aspace.emplace_back();
  stack_region.base = kStackBase - kStackSize;
  stack_region.size = kStackSize;
  stack_region.depth = 1;
  stack_region.vmo_koid = 45678;
  const uint64_t kCommittedBytes = 3 * kPageSize;
  stack_region.committed_bytes = kCommittedBytes;

  // Unused region.
  debug_ipc::AddressRegion& other_region2 = aspace.emplace_back();
  other_region2.base = kStackBase + 0x1000;
  other_region2.size = 0x1000;
  other_region2.depth = 1;
  other_region2.vmo_koid = 99990;

  // Unsafe stack region.
  debug_ipc::AddressRegion& unsafe_region = aspace.emplace_back();
  unsafe_region.base = kUnsafeStackBase - kUnsafeStackSize;
  unsafe_region.size = kUnsafeStackSize;
  unsafe_region.depth = 1;
  unsafe_region.vmo_koid = 64291;
  const uint64_t kUnsafeCommittedBytes = 5 * kPageSize;
  unsafe_region.committed_bytes = kUnsafeCommittedBytes;

  // Good query.
  ThreadStackUsage usage =
      GetThreadStackUsage(&console().context(), aspace, thread(), kUnsafeStackPointer);
  ASSERT_TRUE(usage.safe_stack.ok());
  EXPECT_EQ(usage.safe_stack.value().total, kStackSize);
  EXPECT_EQ(usage.safe_stack.value().used, kUsedBytes);
  EXPECT_EQ(usage.safe_stack.value().committed, kCommittedBytes);
  EXPECT_EQ(usage.safe_stack.value().wasted, kCommittedBytes - kUsedBytes);

  ASSERT_TRUE(usage.unsafe_stack.ok());
  EXPECT_EQ(usage.unsafe_stack.value().total, kUnsafeStackSize);
  EXPECT_EQ(usage.unsafe_stack.value().used, kUnsafeUsedBytes);
  EXPECT_EQ(usage.unsafe_stack.value().committed, kUnsafeCommittedBytes);
  EXPECT_EQ(usage.unsafe_stack.value().wasted, kUnsafeCommittedBytes - kUnsafeUsedBytes);
}

}  // namespace zxdb