Add guard pages in front of platform allocations

src/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 389 matching lines @@
 
 void MemoryAllocator::FreeRawMemory(void* mem,
                                     size_t length,
                                     Executability executable) {
 #ifdef DEBUG
   ZapBlock(reinterpret_cast<Address>(mem), length);
 #endif
   if (isolate_->code_range()->contains(static_cast<Address>(mem))) {
     isolate_->code_range()->FreeRawMemory(mem, length);
   } else {
-    OS::Free(mem, length);
+    size_t guardsize = (executable == EXECUTABLE) ? Page::kPageSize : 0;
+    OS::Free(static_cast<char*>(mem) - guardsize, length + guardsize);

[Mads Ager (chromium), 2011/07/17 09:47:53]

This looks nasty to me. Doesn't this mean that to free executable memory you
have to pass in another address than the one you got from AllocateRawMemory? We
should avoid that.

[Cris Neckar, 2011/07/18 23:55:12]

Done.

   }
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(length));
   size_ -= static_cast<int>(length);
   if (executable == EXECUTABLE) size_executable_ -= static_cast<int>(length);
 
   ASSERT(size_ >= 0);
   ASSERT(size_executable_ >= 0);
 }
 
 
@@ skipping 75 matching lines @@
 Page* MemoryAllocator::AllocatePages(int requested_pages,
                                      int* allocated_pages,
                                      PagedSpace* owner) {
   if (requested_pages <= 0) return Page::FromAddress(NULL);
   size_t chunk_size = requested_pages * Page::kPageSize;
 
   void* chunk = AllocateRawMemory(chunk_size, &chunk_size, owner->executable());
   if (chunk == NULL) return Page::FromAddress(NULL);
   LOG(isolate_, NewEvent("PagedChunk", chunk, chunk_size));
 
+  if (owner->executable() == EXECUTABLE) {
+    OS::Guard(chunk, Page::kPageSize);
+    chunk_size -= Page::kPageSize;
+    chunk = static_cast<Address>(chunk) + Page::kPageSize;
+  }
   *allocated_pages = PagesInChunk(static_cast<Address>(chunk), chunk_size);
   // We may 'lose' a page due to alignment.
   ASSERT(*allocated_pages >= kPagesPerChunk - 1);
   if (*allocated_pages == 0) {
     FreeRawMemory(chunk, chunk_size, owner->executable());
     LOG(isolate_, DeleteEvent("PagedChunk", chunk));
     return Page::FromAddress(NULL);
   }
 
   int chunk_id = Pop();
@@ skipping 2149 matching lines @@
 }
 
 
 // -----------------------------------------------------------------------------
 // LargeObjectChunk
 
 LargeObjectChunk* LargeObjectChunk::New(int size_in_bytes,
                                         Executability executable) {
   size_t requested = ChunkSizeFor(size_in_bytes);
   size_t size;
+  size_t guardsize = (executable == EXECUTABLE) ? Page::kPageSize : 0;
   Isolate* isolate = Isolate::Current();
   void* mem = isolate->memory_allocator()->AllocateRawMemory(
-      requested, &size, executable);
+      requested + guardsize, &size, executable);
   if (mem == NULL) return NULL;
 
   // The start of the chunk may be overlayed with a page so we have to
   // make sure that the page flags fit in the size field.
   ASSERT((size & Page::kPageFlagMask) == 0);
 
   LOG(isolate, NewEvent("LargeObjectChunk", mem, size));
   if (size < requested) {

[Mads Ager (chromium), 2011/07/17 09:47:53]

Shouldn't you add guardsize to requested before you get here? Otherwise you
might not have enough space for the guard page.

[Cris Neckar, 2011/07/18 23:55:12]

Done.

     isolate->memory_allocator()->FreeRawMemory(
-        mem, size, executable);
+        static_cast<Address>(mem) - guardsize, size + guardsize, executable);

[Mads Ager (chromium), 2011/07/17 09:47:53]

I'm getting confused here. Does this add up? FreeRawMemory will subtract
guardsize again, right?

[Cris Neckar, 2011/07/18 23:55:12]

Yeah this was a mistake, I had initially planned to do it the way that you asked
and forgot to get rid of this.

Done.

     LOG(isolate, DeleteEvent("LargeObjectChunk", mem));
     return NULL;
   }
 
+  if (guardsize != 0) {
+    OS::Guard(mem, guardsize);
+    size -= guardsize;
+    mem = static_cast<Address>(mem) + guardsize;
+  }
+
   ObjectSpace space = (executable == EXECUTABLE)
       ? kObjectSpaceCodeSpace
       : kObjectSpaceLoSpace;
   isolate->memory_allocator()->PerformAllocationCallback(
       space, kAllocationActionAllocate, size);
 
   LargeObjectChunk* chunk = reinterpret_cast<LargeObjectChunk*>(mem);
   chunk->size_ = size;
   Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize));
   page->heap_ = isolate->heap();
@@ skipping 355 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal