Add MinidumpContextWriter::CreateFromSnapshot(), everything downstream, and its test

minidump/minidump_context_writer.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_context_writer.h"
 
+#include <string.h>
+
 #include "base/logging.h"
+#include "snapshot/cpu_context.h"
 #include "util/file/file_writer.h"
 
 namespace crashpad {
 
 MinidumpContextWriter::~MinidumpContextWriter() {
 }
 
+// static
+scoped_ptr<MinidumpContextWriter> MinidumpContextWriter::CreateFromSnapshot(
+    const CPUContext* context_snapshot) {
+  scoped_ptr<MinidumpContextWriter> context;
+
+  switch (context_snapshot->architecture) {
+    case kCPUArchitectureX86: {
+      MinidumpContextX86Writer* context_x86 = new MinidumpContextX86Writer();
+      context.reset(context_x86);
+      context_x86->InitializeFromSnapshot(context_snapshot->x86);
+      break;
+    }
+
+    case kCPUArchitectureX86_64: {
+      MinidumpContextAMD64Writer* context_amd64 =
+          new MinidumpContextAMD64Writer();
+      context.reset(context_amd64);
+      context_amd64->InitializeFromSnapshot(context_snapshot->x86_64);
+      break;
+    }
+
+    default: {
+      LOG(ERROR) << "unknown context architecture "
+                 << context_snapshot->architecture;
+      break;
+    }
+  }
+
+  return context;
+}
+
 size_t MinidumpContextWriter::SizeOfObject() {
   DCHECK_GE(state(), kStateFrozen);
 
   return ContextSize();
 }
 
 MinidumpContextX86Writer::MinidumpContextX86Writer()
     : MinidumpContextWriter(), context_() {
   context_.context_flags = kMinidumpContextX86;
 }
 
 MinidumpContextX86Writer::~MinidumpContextX86Writer() {
 }
 
+
+void MinidumpContextX86Writer::InitializeFromSnapshot(
+    const CPUContextX86* context_snapshot) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK_EQ(context_.context_flags, kMinidumpContextX86);
+
+  context_.context_flags |= kMinidumpContextX86All;

[Robert Sesek, 2014/11/03 21:26:57]

Why |= here? The other operations of this method all clobber data.

+
+  context_.dr0 = context_snapshot->dr0;
+  context_.dr1 = context_snapshot->dr1;
+  context_.dr2 = context_snapshot->dr2;
+  context_.dr3 = context_snapshot->dr3;
+  context_.dr6 = context_snapshot->dr6;
+  context_.dr7 = context_snapshot->dr7;
+
+  context_.float_save.control_word = context_snapshot->fxsave.fcw;
+  context_.float_save.status_word = context_snapshot->fxsave.fsw;
+  context_.float_save.tag_word =
+      CPUContextX86::FxsaveToFsaveTagWord(context_snapshot->fxsave.fsw,
+                                          context_snapshot->fxsave.ftw,
+                                          context_snapshot->fxsave.st_mm);
+  context_.float_save.error_offset = context_snapshot->fxsave.fpu_ip;
+  context_.float_save.error_selector = context_snapshot->fxsave.fpu_cs;
+  context_.float_save.data_offset = context_snapshot->fxsave.fpu_dp;
+  context_.float_save.data_selector = context_snapshot->fxsave.fpu_ds;
+
+  for (size_t index = 0, offset = 0;
+       index < arraysize(context_snapshot->fxsave.st_mm);
+       offset += sizeof(context_snapshot->fxsave.st_mm[index].st), ++index) {
+    memcpy(&context_.float_save.register_area[offset],
+           &context_snapshot->fxsave.st_mm[index].st,
+           sizeof(context_snapshot->fxsave.st_mm[index].st));
+  }

[Robert Sesek, 2014/11/03 21:26:57]

What about fxsave.xmm ?

[Mark Mentovai, 2014/11/03 22:01:21]

Robert Sesek wrote:
Doesn’t show up in context.float_save. I’ll add some clarifying commentary.

+
+  context_.gs = context_snapshot->gs;
+  context_.fs = context_snapshot->fs;
+  context_.es = context_snapshot->es;
+  context_.ds = context_snapshot->ds;
+  context_.edi = context_snapshot->edi;
+  context_.esi = context_snapshot->esi;
+  context_.ebx = context_snapshot->ebx;
+  context_.edx = context_snapshot->edx;
+  context_.ecx = context_snapshot->ecx;
+  context_.eax = context_snapshot->eax;
+  context_.ebp = context_snapshot->ebp;
+  context_.eip = context_snapshot->eip;
+  context_.cs = context_snapshot->cs;
+  context_.eflags = context_snapshot->eflags;
+  context_.esp = context_snapshot->esp;
+  context_.ss = context_snapshot->ss;
+
+  context_.fxsave = context_snapshot->fxsave;
+}
+
 bool MinidumpContextX86Writer::WriteObject(FileWriterInterface* file_writer) {
   DCHECK_EQ(state(), kStateWritable);
 
   return file_writer->Write(&context_, sizeof(context_));
 }
 
 size_t MinidumpContextX86Writer::ContextSize() const {
   DCHECK_GE(state(), kStateFrozen);
 
   return sizeof(context_);
 }
 
 MinidumpContextAMD64Writer::MinidumpContextAMD64Writer()
     : MinidumpContextWriter(), context_() {
   context_.context_flags = kMinidumpContextAMD64;
 }
 
 MinidumpContextAMD64Writer::~MinidumpContextAMD64Writer() {
 }
 
+void MinidumpContextAMD64Writer::InitializeFromSnapshot(
+    const CPUContextX86_64* context_snapshot) {
+  DCHECK_EQ(state(), kStateMutable);
+  DCHECK_EQ(context_.context_flags, kMinidumpContextAMD64);
+
+  context_.context_flags |= kMinidumpContextAMD64All;

[Robert Sesek, 2014/11/03 21:26:57]

Same, why |= ?

+
+  context_.mx_csr = context_snapshot->fxsave.mxcsr;
+  context_.cs = context_snapshot->cs;

[Robert Sesek, 2014/11/03 21:26:57]

Why does Context have cs if it's supposed to be zero (like ds, es, and ss) in
64-bit mode, per IA3264 Vol. 1 §3.4.2.1? fs and gs make sense.

[Mark Mentovai, 2014/11/03 22:01:21]

Robert Sesek wrote:
%cs is tricky. Your cited documentation says:

“In 64-bit mode: CS, DS, ES, SS are treated as if each segment base is 0,
regardless of the value of the associated segment descriptor base. This creates
a flat address space for code, data, and stack.”

This refers to the base field of a segment descriptor. The segment registers
store offsets to a specific segment descriptor in a segment descriptor table,
not the segment descriptor itself. The layout of a segment descriptor is given
in volume 3A §3.4.5. The base is a 32-bit field within the segment descriptor.
Volume 1 §3.4.2.1 is just saying that regardless of what the segment descriptor
has in that position, the CPU will treat the base as 0, which forces all
addressing to be linear (non-segmented).

%cs is, however, still useful in the 64-bit environment. The L (“long”) bit of a
segment descriptor is what determines whether code executes in 32-bit or 64-bit
mode, and it is possible to transition between 32-bit and 64-bit-native code by
changing %cs to reference a segment descriptor formatted as desired. This is in
fact how the CPU makes the switch.

%ds, %es, and %ss become meaningless in 64-bit mode, because their contents
would have no impact on anything—there’s nothing in a segment descriptor that’s
relevant to them. %cs is different because it directly impacts how the CPU
interprets code.

You can also look for USER64_CS in xnu, which will show you where it’s
constructed, how it’s used, and the bug that doesn’t preserve the segment
registers other than %fs and %gs correctly through context switches.

[Robert Sesek, 2014/11/03 22:22:06]

Acknowledged. Thanks for the details.

[Mark Mentovai, 2014/11/03 22:43:21]

I think the AMD doc is a lot clearer on this. AMD 24593 rev.3.24 §4.5.3.

Technically, operating systems should save and restore all segment registers to
support programs that want to flip back to 32-bit mode on their own, because at
that point the segment registers do become relevant again. Mac OS X doesn’t do
this (but like I pointed out, it’s also got other bugs with these registers
during context switches). I don’t think Windows does either, but I do think
Linux does.

+  context_.fs = context_snapshot->fs;
+  context_.gs = context_snapshot->gs;
+  context_.eflags = context_snapshot->rflags;
+  context_.dr0 = context_snapshot->dr0;
+  context_.dr1 = context_snapshot->dr1;
+  context_.dr2 = context_snapshot->dr2;
+  context_.dr3 = context_snapshot->dr3;
+  context_.dr6 = context_snapshot->dr6;
+  context_.dr7 = context_snapshot->dr7;
+  context_.rax = context_snapshot->rax;
+  context_.rcx = context_snapshot->rcx;
+  context_.rdx = context_snapshot->rdx;
+  context_.rbx = context_snapshot->rbx;
+  context_.rsp = context_snapshot->rsp;
+  context_.rbp = context_snapshot->rbp;
+  context_.rsi = context_snapshot->rsi;
+  context_.rdi = context_snapshot->rdi;
+  context_.r8 = context_snapshot->r8;
+  context_.r9 = context_snapshot->r9;
+  context_.r10 = context_snapshot->r10;
+  context_.r11 = context_snapshot->r11;
+  context_.r12 = context_snapshot->r12;
+  context_.r13 = context_snapshot->r13;
+  context_.r14 = context_snapshot->r14;
+  context_.r15 = context_snapshot->r15;
+  context_.rip = context_snapshot->rip;
+
+  context_.fxsave = context_snapshot->fxsave;
+}
+
 size_t MinidumpContextAMD64Writer::Alignment() {
   DCHECK_GE(state(), kStateFrozen);
 
   // Match the alignment of MinidumpContextAMD64.
   return 16;
 }
 
 bool MinidumpContextAMD64Writer::WriteObject(FileWriterInterface* file_writer) {
   DCHECK_EQ(state(), kStateWritable);
 
   return file_writer->Write(&context_, sizeof(context_));
 }
 
 size_t MinidumpContextAMD64Writer::ContextSize() const {
   DCHECK_GE(state(), kStateFrozen);
 
   return sizeof(context_);
 }
 
 }  // namespace crashpad