win: Save contents of TEBs allowing !teb and !gle to work in windbg

minidump/minidump_thread_writer_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // 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 "minidump/minidump_thread_writer.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 #include <sys/types.h>
 
+#include <string>
+
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_context_writer.h"
 #include "minidump/minidump_memory_writer.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_thread_id_map.h"
 #include "minidump/test/minidump_context_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
@@ skipping 489 matching lines @@
   }
 };
 
 template <typename Traits>
 void RunInitializeFromSnapshotTest(bool thread_id_collision) {
   using MinidumpContextType = typename Traits::MinidumpContextType;
   MINIDUMP_THREAD expect_threads[3] = {};
   uint64_t thread_ids[arraysize(expect_threads)] = {};
   uint8_t memory_values[arraysize(expect_threads)] = {};
   uint32_t context_seeds[arraysize(expect_threads)] = {};
+  MINIDUMP_MEMORY_DESCRIPTOR tebs[arraysize(expect_threads)] = {};
+
+  const size_t kTebSize = 1024;
 
   expect_threads[0].ThreadId = 1;
   expect_threads[0].SuspendCount = 2;
   expect_threads[0].Priority = 3;
   expect_threads[0].Teb = 0x0123456789abcdef;
   expect_threads[0].Stack.StartOfMemoryRange = 0x1000;
   expect_threads[0].Stack.Memory.DataSize = 0x100;
   expect_threads[0].ThreadContext.DataSize = sizeof(MinidumpContextType);
   memory_values[0] = 'A';
   context_seeds[0] = 0x80000000;
+  tebs[0].StartOfMemoryRange = expect_threads[0].Teb;
+  tebs[0].Memory.DataSize = kTebSize;
 
   // The thread at index 1 has no stack.
   expect_threads[1].ThreadId = 11;
   expect_threads[1].SuspendCount = 12;
   expect_threads[1].Priority = 13;
   expect_threads[1].Teb = 0xfedcba9876543210;
   expect_threads[1].ThreadContext.DataSize = sizeof(MinidumpContextType);
   context_seeds[1] = 0x40000001;
+  tebs[1].StartOfMemoryRange = expect_threads[1].Teb;
+  tebs[1].Memory.DataSize = kTebSize;
 
   expect_threads[2].ThreadId = 21;
   expect_threads[2].SuspendCount = 22;
   expect_threads[2].Priority = 23;
   expect_threads[2].Teb = 0x1111111111111111;
   expect_threads[2].Stack.StartOfMemoryRange = 0x3000;
   expect_threads[2].Stack.Memory.DataSize = 0x300;
   expect_threads[2].ThreadContext.DataSize = sizeof(MinidumpContextType);
   memory_values[2] = 'd';
   context_seeds[2] = 0x20000002;
+  tebs[2].StartOfMemoryRange = expect_threads[2].Teb;
+  tebs[2].Memory.DataSize = kTebSize;
 
   if (thread_id_collision) {
     thread_ids[0] = 0x0123456700000001;
     thread_ids[1] = 0x89abcdef00000001;
     thread_ids[2] = 4;
     expect_threads[0].ThreadId = 0;
     expect_threads[1].ThreadId = 1;
     expect_threads[2].ThreadId = 2;
   } else {
     thread_ids[0] = 1;
@@ skipping 20 matching lines @@
       memory_snapshot->SetAddress(
           expect_threads[index].Stack.StartOfMemoryRange);
       memory_snapshot->SetSize(expect_threads[index].Stack.Memory.DataSize);
       memory_snapshot->SetValue(memory_values[index]);
       thread_snapshot->SetStack(memory_snapshot.Pass());
     }
 
     Traits::InitializeCPUContext(thread_snapshot->MutableContext(),
                                  context_seeds[index]);
 
+    auto teb_snapshot = make_scoped_ptr(new TestMemorySnapshot());
+    teb_snapshot->SetAddress(expect_threads[index].Teb);
+    teb_snapshot->SetSize(kTebSize);
+    teb_snapshot->SetValue(static_cast<char>('t' + index));
+    thread_snapshot->AddExtraMemory(teb_snapshot.Pass());
+
     thread_snapshots.push_back(thread_snapshot);
   }
 
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   thread_list_writer->SetMemoryListWriter(memory_list_writer.get());
   MinidumpThreadIDMap thread_id_map;
   thread_list_writer->InitializeFromSnapshot(thread_snapshots, &thread_id_map);
 
   MinidumpFileWriter minidump_file_writer;
   minidump_file_writer.AddStream(thread_list_writer.Pass());
   minidump_file_writer.AddStream(memory_list_writer.Pass());
 
   StringFile string_file;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       GetThreadListStream(string_file.string(), &thread_list, &memory_list));
 
   ASSERT_EQ(3u, thread_list->NumberOfThreads);
-  ASSERT_EQ(2u, memory_list->NumberOfMemoryRanges);
+  ASSERT_EQ(5u, memory_list->NumberOfMemoryRanges);
 
   size_t memory_index = 0;
   for (size_t index = 0; index < thread_list->NumberOfThreads; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
 
     const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MINIDUMP_MEMORY_DESCRIPTOR** observed_stack_p =
         expect_threads[index].Stack.Memory.DataSize ? &observed_stack : nullptr;
     const MinidumpContextType* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expect_threads[index],
                      &thread_list->Threads[index],
                      string_file.string(),
                      observed_stack_p,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(Traits::ExpectMinidumpContext(
         context_seeds[index], observed_context, true));
 
     if (observed_stack_p) {
       ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptorAndContents(
           &expect_threads[index].Stack,
           observed_stack,
           string_file.string(),
           memory_values[index],
-          index == thread_list->NumberOfThreads - 1));
+          false));
 
       ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
           observed_stack, &memory_list->MemoryRanges[memory_index]));
 
       ++memory_index;
     }
   }
+
+  for (size_t index = 0; index < thread_list->NumberOfThreads; ++index) {
+    const MINIDUMP_MEMORY_DESCRIPTOR* memory =
+        &memory_list->MemoryRanges[memory_index];
+    ASSERT_NO_FATAL_FAILURE(
+        ExpectMinidumpMemoryDescriptor(&tebs[index], memory));
+    std::string expected_data(kTebSize, static_cast<char>('t' + index));
+    std::string observed_data(&string_file.string()[memory->Memory.Rva],
+                              memory->Memory.DataSize);
+    EXPECT_EQ(expected_data, observed_data);
+    ++memory_index;
+  }
 }
 
 TEST(MinidumpThreadWriter, InitializeFromSnapshot_x86) {
   RunInitializeFromSnapshotTest<InitializeFromSnapshotX86Traits>(false);
 }
 
 TEST(MinidumpThreadWriter, InitializeFromSnapshot_AMD64) {
   RunInitializeFromSnapshotTest<InitializeFromSnapshotAMD64Traits>(false);
 }
 
@@ skipping 17 matching lines @@
 
 TEST(MinidumpThreadWriterDeathTest, InitializeFromSnapshot_NoContext) {
   ASSERT_DEATH_CHECK(
       RunInitializeFromSnapshotTest<InitializeFromSnapshotNoContextTraits>(
           false), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad