src/developer/debug/debug_agent/watchpoint_unittest.cc

// 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 "src/developer/debug/debug_agent/watchpoint.h"

#include <zircon/status.h>

#include <gtest/gtest.h>

#include "src/developer/debug/debug_agent/arch.h"
#include "src/developer/debug/debug_agent/breakpoint.h"
#include "src/developer/debug/debug_agent/mock_process.h"
#include "src/developer/debug/debug_agent/mock_thread.h"

namespace debug_agent {
namespace {

using AddressRange = ::debug_ipc::AddressRange;

class MockProcessDelegate : public Breakpoint::ProcessDelegate {
 public:
  zx_status_t RegisterBreakpoint(Breakpoint*, zx_koid_t, uint64_t) override { return ZX_OK; }
  void UnregisterBreakpoint(Breakpoint* bp, zx_koid_t process_koid, uint64_t address) override {}

  zx_status_t RegisterWatchpoint(Breakpoint*, zx_koid_t, const debug_ipc::AddressRange&) override {
    return ZX_OK;
  }
  void UnregisterWatchpoint(Breakpoint*, zx_koid_t, const debug_ipc::AddressRange&) override {}
};

// If |thread| is null, it means a process-wide breakpoint.
debug_ipc::ProcessBreakpointSettings CreateLocation(const MockProcess& process,
                                                    const MockThread* thread,
                                                    const debug_ipc::AddressRange& range) {
  debug_ipc::ProcessBreakpointSettings location = {};
  location.process_koid = process.koid();
  if (thread)
    location.thread_koid = thread->koid();
  location.address = 0;
  location.address_range = range;

  return location;
}

bool ContainsKoids(const Watchpoint& watchpoint, const std::vector<zx_koid_t>& koids) {
  auto& installed_koids = watchpoint.installed_threads();
  if (installed_koids.size() != koids.size()) {
    ADD_FAILURE() << "Expected " << koids.size() << " koids, got " << installed_koids.size();
    return false;
  }

  for (zx_koid_t koid : koids) {
    if (installed_koids.count(koid) == 0) {
      ADD_FAILURE() << "Expected koid " << koid << " to be present.";
      return false;
    }
  }

  return true;
}

// Tests -------------------------------------------------------------------------------------------

const AddressRange kAddressRange = {0x1000, 0x2000};

TEST(Watchpoint, SimpleInstallAndRemove) {
  MockProcess process(nullptr, 0x1, "process");
  MockThread* thread1 = process.AddThread(0x1001);

  MockProcessDelegate process_delegate;

  debug_ipc::BreakpointSettings settings;
  settings.type = debug_ipc::BreakpointType::kWrite;
  settings.locations.push_back(CreateLocation(process, thread1, kAddressRange));

  Breakpoint breakpoint1(&process_delegate);
  breakpoint1.SetSettings(settings);

  Watchpoint watchpoint(debug_ipc::BreakpointType::kWrite, &breakpoint1, &process, kAddressRange);
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

  // Update should install one thread
  ASSERT_EQ(watchpoint.Update(), ZX_OK);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

  EXPECT_EQ(thread1->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);
  EXPECT_EQ(thread1->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);

  // Binding again to the same breakpoint should fail.

  ASSERT_EQ(watchpoint.RegisterBreakpoint(&breakpoint1), ZX_ERR_ALREADY_BOUND);
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

  // Unregistering the breakpoint should issue an uninstall. As there are no more breakpoints,
  // unregistering should return false.

  ASSERT_FALSE(watchpoint.UnregisterBreakpoint(&breakpoint1));
  ASSERT_EQ(watchpoint.breakpoints().size(), 0u);
  ASSERT_TRUE(ContainsKoids(watchpoint, {}));

  EXPECT_EQ(thread1->mock_thread_handle().WatchpointUninstallCount(kAddressRange), 1u);

  // Registering again should add the breakpoint again.

  ASSERT_EQ(watchpoint.RegisterBreakpoint(&breakpoint1), ZX_OK);
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

  EXPECT_EQ(thread1->mock_thread_handle().WatchpointInstallCount(kAddressRange), 2u);

  // Create two other threads.

  MockThread* thread2 = process.AddThread(0x1002);
  MockThread* thread3 = process.AddThread(0x1003);

  // Create a breakpoint that targets the second thread with the correct size.
  // Registering the breakpoint should only add one more install.

  debug_ipc::BreakpointSettings settings2;
  settings2.type = debug_ipc::BreakpointType::kWrite;
  settings2.locations.push_back(CreateLocation(process, thread2, kAddressRange));
  debug_ipc::AddressRange address_range2(kAddressRange.begin(), kAddressRange.end() + 8);
  settings2.locations.push_back(CreateLocation(process, thread3, address_range2));

  Breakpoint breakpoint2(&process_delegate);
  breakpoint2.SetSettings(settings2);

  ASSERT_EQ(watchpoint.RegisterBreakpoint(&breakpoint2), ZX_OK);
  ASSERT_EQ(watchpoint.breakpoints().size(), 2u);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid(), thread2->koid()}));
  EXPECT_EQ(thread2->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);

  // Removing the first breakpoint should remove the first install.
  // Returning true means that there are more breakpoints registered.

  ASSERT_TRUE(watchpoint.UnregisterBreakpoint(&breakpoint1));
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread2->koid()}));
  EXPECT_EQ(thread1->mock_thread_handle().WatchpointUninstallCount(kAddressRange), 2u);

  // Add a location for another address to the already bound breakpoint.
  // Add a location to the already bound breakpoint.

  settings2.locations.push_back(CreateLocation(process, thread3, kAddressRange));
  breakpoint2.SetSettings(settings2);

  // Updating should've only installed for the third thread.

  ASSERT_EQ(watchpoint.Update(), ZX_OK);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread2->koid(), thread3->koid()}));
  EXPECT_EQ(thread3->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);

  // Create moar threads.

  MockThread* thread4 = process.AddThread(0x1004);
  MockThread* thread5 = process.AddThread(0x1005);
  MockThread* thread6 = process.AddThread(0x1006);

  // Create a breakpoint that spans all locations.

  debug_ipc::BreakpointSettings settings3;
  settings3.type = debug_ipc::BreakpointType::kWrite;
  settings3.locations.push_back(CreateLocation(process, nullptr, kAddressRange));

  Breakpoint breakpoint3(&process_delegate);
  breakpoint3.SetSettings(settings3);

  // Registering the breakpoint should add a breakpoint for all threads, but only updating the ones
  // that are not currently installed.

  ASSERT_EQ(watchpoint.RegisterBreakpoint(&breakpoint3), ZX_OK);
  ASSERT_EQ(watchpoint.breakpoints().size(), 2u);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid(), thread2->koid(), thread3->koid(),
                                         thread4->koid(), thread5->koid(), thread6->koid()}));

  EXPECT_EQ(thread4->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);
  EXPECT_EQ(thread5->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);
  EXPECT_EQ(thread6->mock_thread_handle().WatchpointInstallCount(kAddressRange), 1u);

  // Removing the other breakpoint should not remove installs.

  ASSERT_TRUE(watchpoint.UnregisterBreakpoint(&breakpoint2));
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid(), thread2->koid(), thread3->koid(),
                                         thread4->koid(), thread5->koid(), thread6->koid()}));

  EXPECT_EQ(thread1->mock_thread_handle().TotalWatchpointUninstallCalls(), 2u);
  EXPECT_EQ(thread3->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);
  EXPECT_EQ(thread4->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);
  EXPECT_EQ(thread5->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);
  EXPECT_EQ(thread6->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);

  // Removing the last breakpoint should remove all the installations.
  // Returns false because there are no more registered breakpoints.

  ASSERT_FALSE(watchpoint.UnregisterBreakpoint(&breakpoint3));
  ASSERT_EQ(watchpoint.breakpoints().size(), 0u);

  ASSERT_TRUE(ContainsKoids(watchpoint, {}));

  EXPECT_EQ(thread1->mock_thread_handle().TotalWatchpointUninstallCalls(), 3u);
  EXPECT_EQ(thread2->mock_thread_handle().TotalWatchpointUninstallCalls(), 1u);
  EXPECT_EQ(thread3->mock_thread_handle().TotalWatchpointUninstallCalls(), 1u);
  EXPECT_EQ(thread4->mock_thread_handle().TotalWatchpointUninstallCalls(), 1u);
  EXPECT_EQ(thread5->mock_thread_handle().TotalWatchpointUninstallCalls(), 1u);
  EXPECT_EQ(thread6->mock_thread_handle().TotalWatchpointUninstallCalls(), 1u);
}

TEST(Watchpoint, InstalledRanges) {
  MockProcess process(nullptr, 0x1, "process");
  MockThread* thread1 = process.AddThread(0x1001);

  MockProcessDelegate process_delegate;

  debug_ipc::BreakpointSettings settings;
  settings.type = debug_ipc::BreakpointType::kWrite;
  settings.locations.push_back(CreateLocation(process, thread1, kAddressRange));

  Breakpoint breakpoint1(&process_delegate);
  breakpoint1.SetSettings(settings);

  Watchpoint watchpoint(debug_ipc::BreakpointType::kWrite, &breakpoint1, &process, kAddressRange);
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

  const debug_ipc::AddressRange kSubRange = {0x900, 0x2100};
  constexpr int kSlot = 1;
  thread1->mock_thread_handle().set_watchpoint_range_to_return(kSubRange);
  thread1->mock_thread_handle().set_watchpoint_slot_to_return(kSlot);

  // Update should install one thread
  ASSERT_EQ(watchpoint.Update(), ZX_OK);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

  // There should be an install with a different sub range.
  auto installs = thread1->mock_thread_handle().watchpoint_installs();
  ASSERT_EQ(installs.size(), 1u);
  EXPECT_EQ(installs[0].address_range, kAddressRange);
  EXPECT_EQ(installs[0].type, debug_ipc::BreakpointType::kWrite);
  EXPECT_EQ(thread1->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);

  // The installed and actual range should be differnt.
  {
    auto& installations = watchpoint.installed_threads();

    ASSERT_EQ(installations.size(), 1u);

    auto it = installations.find(thread1->koid());
    ASSERT_NE(it, installations.end());
    EXPECT_EQ(it->second.range, kSubRange);
    EXPECT_EQ(it->second.slot, kSlot);
  }
}

TEST(Watchpoint, MatchesException) {
  MockProcess process(nullptr, 0x1, "process");
  MockThread* thread1 = process.AddThread(0x1001);
  MockThread* thread2 = process.AddThread(0x1002);

  MockProcessDelegate process_delegate;

  debug_ipc::BreakpointSettings settings;
  settings.type = debug_ipc::BreakpointType::kWrite;
  settings.locations.push_back(CreateLocation(process, thread1, kAddressRange));

  Breakpoint breakpoint1(&process_delegate);
  breakpoint1.SetSettings(settings);

  Watchpoint watchpoint(debug_ipc::BreakpointType::kWrite, &breakpoint1, &process, kAddressRange);
  ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

  const debug_ipc::AddressRange kSubRange = {0x900, 0x2100};
  constexpr int kSlot = 1;
  thread1->mock_thread_handle().set_watchpoint_range_to_return(kSubRange);
  thread1->mock_thread_handle().set_watchpoint_slot_to_return(kSlot);

  // Update should install one thread
  ASSERT_EQ(watchpoint.Update(), ZX_OK);
  ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

  // There should be an install with a different sub range.
  auto installs = thread1->mock_thread_handle().watchpoint_installs();
  ASSERT_EQ(installs.size(), 1u);
  EXPECT_EQ(installs[0].address_range, kAddressRange);
  EXPECT_EQ(thread1->mock_thread_handle().TotalWatchpointUninstallCalls(), 0u);

  // The installed and actual range should be differnt.
  {
    auto& installations = watchpoint.installed_threads();

    ASSERT_EQ(installations.size(), 1u);

    auto it = installations.find(thread1->koid());
    ASSERT_NE(it, installations.end());
    EXPECT_EQ(it->second.range, kSubRange);
    EXPECT_EQ(it->second.slot, kSlot);

    // Only same slot and within range should work.
    EXPECT_FALSE(watchpoint.MatchesException(thread1->koid(), kSubRange.begin() - 1, kSlot));
    EXPECT_TRUE(watchpoint.MatchesException(thread1->koid(), kSubRange.begin(), kSlot));
    EXPECT_TRUE(watchpoint.MatchesException(thread1->koid(), kSubRange.begin() + 1, kSlot));
    EXPECT_TRUE(watchpoint.MatchesException(thread1->koid(), kSubRange.end() - 1, kSlot));
    EXPECT_FALSE(watchpoint.MatchesException(thread1->koid(), kSubRange.end(), kSlot));

    // Different slot should fail.
    EXPECT_FALSE(watchpoint.MatchesException(thread1->koid(), kSubRange.begin(), kSlot + 1));

    // Different thread should fail.
    EXPECT_FALSE(watchpoint.MatchesException(thread2->koid(), kSubRange.begin(), kSlot));
  }
}

TEST(Watchpoint, DifferentTypes) {
  MockProcess process(nullptr, 0x1, "process");
  MockThread* thread1 = process.AddThread(0x1001);

  MockProcessDelegate process_delegate;

  debug_ipc::BreakpointSettings settings;
  settings.locations.push_back(CreateLocation(process, thread1, kAddressRange));

  {
    Breakpoint breakpoint1(&process_delegate);
    settings.type = debug_ipc::BreakpointType::kWrite;
    breakpoint1.SetSettings(settings);

    Watchpoint watchpoint(debug_ipc::BreakpointType::kWrite, &breakpoint1, &process, kAddressRange);
    ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

    ASSERT_EQ(watchpoint.Update(), ZX_OK);
    ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

    // There should be an install with a different sub range.
    auto installs = thread1->mock_thread_handle().watchpoint_installs();
    ASSERT_EQ(installs.size(), 1u);
    EXPECT_EQ(installs[0].address_range, kAddressRange);
    EXPECT_EQ(installs[0].type, debug_ipc::BreakpointType::kWrite);
  }

  {
    Breakpoint breakpoint1(&process_delegate);
    settings.type = debug_ipc::BreakpointType::kReadWrite;
    breakpoint1.SetSettings(settings);

    Watchpoint watchpoint(debug_ipc::BreakpointType::kReadWrite, &breakpoint1, &process,
                          kAddressRange);
    ASSERT_EQ(watchpoint.breakpoints().size(), 1u);

    ASSERT_EQ(watchpoint.Update(), ZX_OK);
    ASSERT_TRUE(ContainsKoids(watchpoint, {thread1->koid()}));

    // There should be an install with a different sub range.
    auto installs = thread1->mock_thread_handle().watchpoint_installs();
    ASSERT_EQ(installs.size(), 2u);
    EXPECT_EQ(installs[1].address_range, kAddressRange);
    EXPECT_EQ(installs[1].type, debug_ipc::BreakpointType::kReadWrite);
  }
}

}  // namespace
}  // namespace debug_agent