[heap] Register executable MemoryChunks.

hannespayer · Commit Bot · commit e97daee2e5a5 · 2018-01-16T09:56:03.000Z
Bug: chromium:774108,v8:6792 Change-Id: If0ff62b959b74b7be4e00b04d7a734ab95b8ecb6 Reviewed-on: https://chromium-review.googlesource.com/867040 Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Commit-Queue: Hannes Payer <hpayer@chromium.org> Cr-Commit-Position: refs/heads/master@{#50610}
diff --git a/src/heap/heap-inl.h b/src/heap/heap-inl.h
@@ -624,6 +624,7 @@ CodeSpaceMemoryModificationScope::CodeSpaceMemoryModificationScope(Heap* heap)
     LargePage* page = heap_->lo_space()->first_page();
     while (page != nullptr) {
       if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {
+        CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
         page->SetReadAndWritable();
       }
       page = page->next_page();
@@ -638,6 +639,7 @@ CodeSpaceMemoryModificationScope::~CodeSpaceMemoryModificationScope() {
     LargePage* page = heap_->lo_space()->first_page();
     while (page != nullptr) {
       if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {
+        CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
         page->SetReadAndExecutable();
       }
       page = page->next_page();
@@ -654,12 +656,14 @@ CodePageMemoryModificationScope::CodePageMemoryModificationScope(
     DCHECK(chunk_->owner()->identity() == CODE_SPACE ||
            (chunk_->owner()->identity() == LO_SPACE &&
             chunk_->IsFlagSet(MemoryChunk::IS_EXECUTABLE)));
+    CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));
     chunk_->SetReadAndWritable();
   }
 }
 
 CodePageMemoryModificationScope::~CodePageMemoryModificationScope() {
   if (scope_active_) {
+    CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));
     chunk_->SetReadAndExecutable();
   }
 }
diff --git a/src/heap/spaces.cc b/src/heap/spaces.cc
@@ -826,8 +826,13 @@ MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,
                          owner);
   }
 
-  return MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,
-                                 executable, owner, &reservation);
+  MemoryChunk* chunk =
+      MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,
+                              executable, owner, &reservation);
+
+  if (executable) RegisterExecutableMemoryChunk(chunk);
+
+  return chunk;
 }
 
 void Page::ResetAllocatedBytes() { allocated_bytes_ = area_size(); }
@@ -970,6 +975,8 @@ void MemoryAllocator::PreFreeMemory(MemoryChunk* chunk) {
   }
 
   chunk->SetFlag(MemoryChunk::PRE_FREED);
+
+  if (chunk->executable()) UnregisterExecutableMemoryChunk(chunk);
 }
 
 
@@ -1722,13 +1729,15 @@ void PagedSpace::ReleasePage(Page* page) {
 void PagedSpace::SetReadAndExecutable() {
   DCHECK(identity() == CODE_SPACE);
   for (Page* page : *this) {
+    CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
     page->SetReadAndExecutable();
   }
 }
 
 void PagedSpace::SetReadAndWritable() {
   DCHECK(identity() == CODE_SPACE);
   for (Page* page : *this) {
+    CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));
     page->SetReadAndWritable();
   }
 }
diff --git a/src/heap/spaces.h b/src/heap/spaces.h
@@ -1359,6 +1359,12 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
   // and false otherwise.
   bool CommitBlock(Address start, size_t size, Executability executable);
 
+  // Checks if an allocated MemoryChunk was intended to be used for executable
+  // memory.
+  bool IsMemoryChunkExecutable(MemoryChunk* chunk) {
+    return executable_memory_.find(chunk) != executable_memory_.end();
+  }
+
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not nullptr, the size is greater than zero, and the
   // block is contained in the initial chunk.  Returns true if it succeeded
@@ -1409,6 +1415,17 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
     } while ((high > ptr) && !highest_ever_allocated_.TrySetValue(ptr, high));
   }
 
+  void RegisterExecutableMemoryChunk(MemoryChunk* chunk) {
+    DCHECK(chunk->IsFlagSet(MemoryChunk::IS_EXECUTABLE));
+    DCHECK_EQ(executable_memory_.find(chunk), executable_memory_.end());
+    executable_memory_.insert(chunk);
+  }
+
+  void UnregisterExecutableMemoryChunk(MemoryChunk* chunk) {
+    DCHECK_NE(executable_memory_.find(chunk), executable_memory_.end());
+    executable_memory_.erase(chunk);
+  }
+
   Isolate* isolate_;
   CodeRange* code_range_;
 
@@ -1431,6 +1448,9 @@ class V8_EXPORT_PRIVATE MemoryAllocator {
   VirtualMemory last_chunk_;
   Unmapper unmapper_;
 
+  // Data structure to remember allocated executable memory chunks.
+  std::unordered_set<MemoryChunk*> executable_memory_;
+
   friend class heap::TestCodeRangeScope;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MemoryAllocator);

Original file line number	Diff line number	Diff line change
`@@ -624,6 +624,7 @@ CodeSpaceMemoryModificationScope::CodeSpaceMemoryModificationScope(Heap* heap)`
`624`	`624`	`LargePage* page = heap_->lo_space()->first_page();`
`625`	`625`	`while (page != nullptr) {`
`626`	`626`	`if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {`
	`627`	`+ CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`627`	`628`	`page->SetReadAndWritable();`
`628`	`629`	`}`
`629`	`630`	`page = page->next_page();`
`@@ -638,6 +639,7 @@ CodeSpaceMemoryModificationScope::~CodeSpaceMemoryModificationScope() {`
`638`	`639`	`LargePage* page = heap_->lo_space()->first_page();`
`639`	`640`	`while (page != nullptr) {`
`640`	`641`	`if (page->IsFlagSet(MemoryChunk::IS_EXECUTABLE)) {`
	`642`	`+ CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`641`	`643`	`page->SetReadAndExecutable();`
`642`	`644`	`}`
`643`	`645`	`page = page->next_page();`
`@@ -654,12 +656,14 @@ CodePageMemoryModificationScope::CodePageMemoryModificationScope(`
`654`	`656`	`DCHECK(chunk_->owner()->identity() == CODE_SPACE \|\|`
`655`	`657`	`(chunk_->owner()->identity() == LO_SPACE &&`
`656`	`658`	`chunk_->IsFlagSet(MemoryChunk::IS_EXECUTABLE)));`
	`659`	`+ CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));`
`657`	`660`	`chunk_->SetReadAndWritable();`
`658`	`661`	`}`
`659`	`662`	`}`
`660`	`663`
`661`	`664`	`CodePageMemoryModificationScope::~CodePageMemoryModificationScope() {`
`662`	`665`	`if (scope_active_) {`
	`666`	`+ CHECK(chunk_->heap()->memory_allocator()->IsMemoryChunkExecutable(chunk_));`
`663`	`667`	`chunk_->SetReadAndExecutable();`
`664`	`668`	`}`
`665`	`669`	`}`
Original file line number	Diff line number	Diff line change
`@@ -826,8 +826,13 @@ MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,`
`826`	`826`	`owner);`
`827`	`827`	`}`
`828`	`828`
`829`		`- return MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,`
`830`		`- executable, owner, &reservation);`
	`829`	`+ MemoryChunk* chunk =`
	`830`	`+ MemoryChunk::Initialize(heap, base, chunk_size, area_start, area_end,`
	`831`	`+ executable, owner, &reservation);`
	`832`	`+`
	`833`	`+ if (executable) RegisterExecutableMemoryChunk(chunk);`
	`834`	`+`
	`835`	`+ return chunk;`
`831`	`836`	`}`
`832`	`837`
`833`	`838`	`void Page::ResetAllocatedBytes() { allocated_bytes_ = area_size(); }`
`@@ -970,6 +975,8 @@ void MemoryAllocator::PreFreeMemory(MemoryChunk* chunk) {`
`970`	`975`	`}`
`971`	`976`
`972`	`977`	`chunk->SetFlag(MemoryChunk::PRE_FREED);`
	`978`	`+`
	`979`	`+ if (chunk->executable()) UnregisterExecutableMemoryChunk(chunk);`
`973`	`980`	`}`
`974`	`981`
`975`	`982`
`@@ -1722,13 +1729,15 @@ void PagedSpace::ReleasePage(Page* page) {`
`1722`	`1729`	`void PagedSpace::SetReadAndExecutable() {`
`1723`	`1730`	`DCHECK(identity() == CODE_SPACE);`
`1724`	`1731`	`for (Page* page : *this) {`
	`1732`	`+ CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`1725`	`1733`	`page->SetReadAndExecutable();`
`1726`	`1734`	`}`
`1727`	`1735`	`}`
`1728`	`1736`
`1729`	`1737`	`void PagedSpace::SetReadAndWritable() {`
`1730`	`1738`	`DCHECK(identity() == CODE_SPACE);`
`1731`	`1739`	`for (Page* page : *this) {`
	`1740`	`+ CHECK(heap_->memory_allocator()->IsMemoryChunkExecutable(page));`
`1732`	`1741`	`page->SetReadAndWritable();`
`1733`	`1742`	`}`
`1734`	`1743`	`}`