Use Structured Exception Handler on Windows to gracefully handle guard page faults

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 23 matching lines @@
 #else
   DEFINE_FLAG(int, profile_period, 1000,
               "Time between profiler samples in microseconds. Minimum 50.");
 #endif
 DEFINE_FLAG(int, profile_depth, 8,
             "Maximum number stack frames walked. Minimum 1. Maximum 255.");
 #if defined(USING_SIMULATOR)
 DEFINE_FLAG(bool, profile_vm, true,
             "Always collect native stack traces.");
 #else
-DEFINE_FLAG(bool, profile_vm, false,
+DEFINE_FLAG(bool, profile_vm, true,

[koda, 2015/05/12 19:28:02]

Please note in the CL description that you are changing this default value
(assuming you intend to commit it like this).

[Cutch, 2015/05/13 17:59:10]

Done.

             "Always collect native stack traces.");
 #endif
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 static intptr_t NumberOfFramesToCollect() {
   if (FLAG_profile_depth <= 0) {
     return 0;
   }
@@ skipping 835 matching lines @@
   if (sample->vm_tag() != VMTag::kDartTagId) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     return;
   }
   uword* fp = reinterpret_cast<uword*>(sample->fp());
   uword* sp = reinterpret_cast<uword*>(sample->sp());
 
   // If FP == SP, the pc marker hasn't been pushed.
   if (fp > sp) {
-#if defined(TARGET_OS_WINDOWS)
-    COMPILE_ASSERT(kPcMarkerSlotFromFp < 0);
-    // If the fp is at the beginning of a page, it may be unsafe to access
-    // the pc marker, because we are reading it from a different thread on
-    // Windows. The marker is below fp and the previous page may be a guard
-    // page.
-    const intptr_t kPageMask = VirtualMemory::PageSize() - 1;
-    if ((sample->fp() & kPageMask) == 0) {
-      return;
-    }
-#endif
     uword* pc_marker_ptr = fp + kPcMarkerSlotFromFp;
     // MSan/ASan are unaware of frames initialized by generated code.
     MSAN_UNPOISON(pc_marker_ptr, kWordSize);
     ASAN_UNPOISON(pc_marker_ptr, kWordSize);
     sample->set_pc_marker(*pc_marker_ptr);
   }
 }
 
 
 static void CopyStackBuffer(Sample* sample) {
   ASSERT(sample != NULL);
   if (sample->vm_tag() != VMTag::kDartTagId) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     return;
   }
   uword* sp = reinterpret_cast<uword*>(sample->sp());
   uword* buffer = sample->GetStackBuffer();
   if (sp != NULL) {
     for (intptr_t i = 0; i < Sample::kStackBufferSizeInWords; i++) {
       MSAN_UNPOISON(sp, kWordSize);
       ASAN_UNPOISON(sp, kWordSize);
       buffer[i] = *sp;
       sp++;
     }
   }
 }
 
 
+#if defined(TARGET_OS_WINDOWS)
+// On Windows this code is synchronously executed from the thread interrupter
+// thread. This means we can safely have a static fault_address.
+static uword fault_address = 0;
+static LONG GuardPageExceptionFilter(EXCEPTION_POINTERS* ep) {
+  fault_address = 0;
+  if (ep->ExceptionRecord->ExceptionCode != STATUS_GUARD_PAGE_VIOLATION) {
+    return EXCEPTION_CONTINUE_SEARCH;
+  }
+  // https://goo.gl/p5Fe10
+  fault_address = ep->ExceptionRecord->ExceptionInformation[1];

[koda, 2015/05/12 19:28:03]

Since I suppose we only expect this to be caused by reads, consider adding an
ASSERT that the first component is 0.

[Vyacheslav Egorov (Google), 2015/05/12 19:46:18]

I wonder if you could just do VirtualProtect in the filter instead of stashing
the fault address into a global.

[Cutch, 2015/05/13 17:59:10]

Acknowledged. I need an exception handler to jump to so I'd rather put the
virtual protected there.

[Cutch, 2015/05/13 17:59:10]

Done.

+  return EXCEPTION_EXECUTE_HANDLER;
+}
+#endif
+
+// All memory access done to collect the sample is performed in CollectSample.
+static void CollectSample(Isolate* isolate,
+                          bool exited_dart_code,
+                          bool in_dart_code,
+                          Sample* sample,
+                          uword stack_lower,
+                          uword stack_upper,
+                          uword pc,
+                          uword fp,
+                          uword sp) {
+#if defined(TARGET_OS_WINDOWS)
+  // Use structured exception handling to trap guard page access on Windows.
+  __try {
+#endif
+
+  CopyStackBuffer(sample);
+  CopyPCMarkerIfSafe(sample);
+
+  if (FLAG_profile_vm) {
+    // Always walk the native stack collecting both native and Dart frames.
+    ProfilerNativeStackWalker stackWalker(sample,
+                                          stack_lower,
+                                          stack_upper,
+                                          pc,
+                                          fp,
+                                          sp);
+    stackWalker.walk();
+  } else if (exited_dart_code) {
+    // We have a valid exit frame info, use the Dart stack walker.
+    ProfilerDartExitStackWalker stackWalker(isolate, sample);
+    stackWalker.walk();
+  } else if (in_dart_code) {
+    // We are executing Dart code. We have frame pointers.
+    ProfilerDartStackWalker stackWalker(isolate,
+                                        sample,
+                                        stack_lower,
+                                        stack_upper,
+                                        pc,
+                                        fp,
+                                        sp);
+    stackWalker.walk();
+  } else {
+    sample->set_vm_tag(VMTag::kEmbedderTagId);
+    sample->SetAt(0, pc);
+  }
+
+#if defined(TARGET_OS_WINDOWS)
+  // Use structured exception handling to trap guard page access.
+  } __except(GuardPageExceptionFilter(GetExceptionInformation())) {
+    // Sample collection triggered a guard page fault:
+    // 1) discard entire sample.
+    sample->set_ignore_sample(true);
+
+    // 2) Reenable guard bit on page that triggered the fault.
+    // https://goo.gl/5mCsXW
+    DWORD newProtect = PAGE_READWRITE | PAGE_GUARD;

[koda, 2015/05/12 19:28:03]

newProtect -> new_protect, etc.

[Cutch, 2015/05/13 17:59:10]

Done.

+    DWORD oldProtect = 0;
+    BOOL r = VirtualProtect(reinterpret_cast<void*>(fault_address),

[koda, 2015/05/12 19:28:02]

r -> success

[Cutch, 2015/05/13 17:59:10]

Done.

+                            sizeof(fault_address),
+                            newProtect,
+                            &oldProtect);
+    ASSERT(r);
+    ASSERT(oldProtect == PAGE_READWRITE);
+  }
+#endif
+}
+
+
 void Profiler::RecordSampleInterruptCallback(
     const InterruptedThreadState& state,
     void* data) {
   Isolate* isolate = reinterpret_cast<Isolate*>(data);
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return;
   }
 
   ASSERT(isolate != Dart::vm_isolate());
@@ skipping 118 matching lines @@
 #endif
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(vm_tag);
   sample->set_vm_tag(vm_tag);
   sample->set_user_tag(isolate->user_tag());
   sample->set_sp(sp);
   sample->set_fp(fp);
   sample->set_lr(lr);
-  CopyStackBuffer(sample);
-  CopyPCMarkerIfSafe(sample);
 
-  if (FLAG_profile_vm) {
-    // Always walk the native stack collecting both native and Dart frames.
-    ProfilerNativeStackWalker stackWalker(sample,
-                                          stack_lower,
-                                          stack_upper,
-                                          pc,
-                                          fp,
-                                          sp);
-    stackWalker.walk();
-  } else if (exited_dart_code) {
-    // We have a valid exit frame info, use the Dart stack walker.
-    ProfilerDartExitStackWalker stackWalker(isolate, sample);
-    stackWalker.walk();
-  } else if (in_dart_code) {
-    // We are executing Dart code. We have frame pointers.
-    ProfilerDartStackWalker stackWalker(isolate,
-                                        sample,
-                                        stack_lower,
-                                        stack_upper,
-                                        pc,
-                                        fp,
-                                        sp);
-    stackWalker.walk();
-  } else {
-    sample->set_vm_tag(VMTag::kEmbedderTagId);
-    sample->SetAt(0, pc);
-  }
+  // All memory access is done inside CollectSample.
+  CollectSample(isolate,
+                exited_dart_code,
+                in_dart_code,
+                sample,
+                stack_lower,
+                stack_upper,
+                pc,
+                fp,
+                sp);
 }
 
 }  // namespace dart