Landing: Write protect executable pages in the VM.

runtime/vm/pages.cc

 // Copyright (c) 2012, 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 "vm/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 13 matching lines @@
 DEFINE_FLAG(bool, print_free_list_after_gc, false,
             "Print free list statistics after a GC");
 DEFINE_FLAG(bool, collect_code, true,
             "Attempt to GC infrequently used code.");
 DEFINE_FLAG(int, code_collection_interval_in_us, 30000000,
             "Time between attempts to collect unused code.");
 DEFINE_FLAG(bool, log_code_drop, false,
             "Emit a log message when pointers to unused code are dropped.");
 DEFINE_FLAG(bool, always_drop_code, false,
             "Always try to drop code if the function's usage counter is >= 0");
+DECLARE_FLAG(bool, write_protect_code);
 
 HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
   ASSERT(memory->size() > VirtualMemory::PageSize());
   bool is_executable = (type == kExecutable);
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->executable_ = is_executable;
@@ skipping 59 matching lines @@
 void HeapPage::WriteProtect(bool read_only) {
   VirtualMemory::Protection prot;
   if (read_only) {
     if (executable_) {
       prot = VirtualMemory::kReadExecute;
     } else {
       prot = VirtualMemory::kReadOnly;
     }
   } else {
     if (executable_) {
       prot = VirtualMemory::kReadWriteExecute;

[Ivan Posva, 2014/02/03 05:44:35]

This should not be a legal state.

[Florian Schneider, 2014/02/10 11:56:17]

Done. Should rwx then be removed completely from the code?

     } else {
       prot = VirtualMemory::kReadWrite;
     }
   }
-  memory_->Protect(prot);
+  bool status = memory_->Protect(prot);
+  ASSERT(status);
 }
 
 
 PageSpace::PageSpace(Heap* heap, intptr_t max_capacity_in_words)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
       max_capacity_in_words_(max_capacity_in_words),
@@ skipping 19 matching lines @@
                                       VirtualMemory::PageSize());
   return page_size >> kWordSizeLog2;
 }
 
 
 HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
   HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type);
   if (pages_ == NULL) {
     pages_ = page;
   } else {
+    const bool is_protected = (pages_tail_->type() == HeapPage::kExecutable)
+        && FLAG_write_protect_code;
+    if (is_protected) {
+      pages_tail_->WriteProtect(false);
+    }
     pages_tail_->set_next(page);
+    if (is_protected) {
+      pages_tail_->WriteProtect(true);
+    }
   }
   pages_tail_ = page;
   capacity_in_words_ += kPageSizeInWords;
   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
   intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
@@ skipping 45 matching lines @@
 }
 
 
 uword PageSpace::TryAllocate(intptr_t size,
                              HeapPage::PageType type,
                              GrowthPolicy growth_policy) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   if (size < kAllocatablePageSize) {
-    result = freelist_[type].TryAllocate(size);
+    const bool is_protected = (type == HeapPage::kExecutable)
+        && FLAG_write_protect_code;
+    result = freelist_[type].TryAllocate(size, is_protected);
     if ((result == 0) &&
         (page_space_controller_.CanGrowPageSpace(size) ||
          growth_policy == kForceGrowth) &&
         CanIncreaseCapacityInWords(kPageSizeInWords)) {
       HeapPage* page = AllocatePage(type);
       ASSERT(page != NULL);
       // Start of the newly allocated page is the allocated object.
       result = page->object_start();
       // Enqueue the remainder in the free list.
       uword free_start = result + size;
@@ skipping 205 matching lines @@
   }
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before MarkSweep...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   const int64_t start = OS::GetCurrentTimeMicros();
 
+  if (FLAG_write_protect_code) {
+    // Make code pages writable.
+    HeapPage* current_page = pages_;
+    while (current_page != NULL) {
+      if (current_page->type() == HeapPage::kExecutable) {
+        current_page->WriteProtect(false);
+      }
+      current_page = current_page->next();
+    }
+    current_page = large_pages_;
+    while (current_page != NULL) {
+      if (current_page->type() == HeapPage::kExecutable) {
+        current_page->WriteProtect(false);
+      }
+      current_page = current_page->next();
+    }
+  }
+
   // Mark all reachable old-gen objects.
   bool collect_code = FLAG_collect_code && ShouldCollectCode();
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
   // Reset the bump allocation page to unused.
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
@@ skipping 29 matching lines @@
     if (page_in_use == 0) {
       FreeLargePage(page, prev_page);
     } else {
       used_in_words += (page_in_use >> kWordSizeLog2);
       prev_page = page;
     }
     // Advance to the next page.
     page = next_page;
   }
 
+  if (FLAG_write_protect_code) {
+    // Make code pages read-only.
+    HeapPage* current_page = pages_;
+    while (current_page != NULL) {
+      if (current_page->type() == HeapPage::kExecutable) {
+        current_page->WriteProtect(true);
+      }
+      current_page = current_page->next();
+    }
+    current_page = large_pages_;
+    while (current_page != NULL) {
+      if (current_page->type() == HeapPage::kExecutable) {
+        current_page->WriteProtect(true);
+      }
+      current_page = current_page->next();
+    }
+  }
+
   // Record data and print if requested.
   intptr_t used_before_in_words = used_in_words_;
   used_in_words_ = used_in_words;
 
   int64_t end = OS::GetCurrentTimeMicros();
 
   // Record signals for growth control.
   page_space_controller_.EvaluateGarbageCollection(used_before_in_words,
                                                    used_in_words,
                                                    start, end);
@@ skipping 132 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart