Add basic infrastructure for protecting V8's heap when leaving the VM...

src/spaces.h

 // Copyright 2006-2008 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 259 matching lines @@
 #endif
 };
 
 
 // ----------------------------------------------------------------------------
 // Space is the abstract superclass for all allocation spaces.
 class Space : public Malloced {
  public:
   Space(AllocationSpace id, Executability executable)
       : id_(id), executable_(executable) {}
+
   virtual ~Space() {}
+
   // Does the space need executable memory?
   Executability executable() { return executable_; }
+
   // Identity used in error reporting.
   AllocationSpace identity() { return id_; }
+
   virtual int Size() = 0;
+
 #ifdef DEBUG
   virtual void Verify() = 0;
   virtual void Print() = 0;
 #endif
+
  private:
   AllocationSpace id_;
   Executability executable_;
 };
 
 
 // ----------------------------------------------------------------------------
 // A space acquires chunks of memory from the operating system. The memory
 // allocator manages chunks for the paged heap spaces (old space and map
 // space).  A paged chunk consists of pages. Pages in a chunk have contiguous
@@ skipping 89 matching lines @@
   // Checks whether a page belongs to a space.
   static inline bool IsPageInSpace(Page* p, PagedSpace* space);
 
   // Returns the space that owns the given page.
   static inline PagedSpace* PageOwner(Page* page);
 
   // Finds the first/last page in the same chunk as a given page.
   static Page* FindFirstPageInSameChunk(Page* p);
   static Page* FindLastPageInSameChunk(Page* p);
 
+#ifdef ENABLE_HEAP_PROTECTION
+  // Protect/unprotect a block of memory by marking it read-only/writable.
+  static inline void Protect(Address start, size_t size);
+  static inline void Unprotect(Address start, size_t size,
+                               Executability executable);
+
+  // Protect/unprotect a chunk given a page in the chunk.
+  static inline void ProtectChunkFromPage(Page* page);
+  static inline void UnprotectChunkFromPage(Page* page);
+#endif
+
 #ifdef DEBUG
   // Reports statistic info of the space.
   static void ReportStatistics();
 #endif
 
   // Due to encoding limitation, we can only have 8K chunks.
   static const int kMaxNofChunks = 1 << Page::kPageSizeBits;
   // If a chunk has at least 32 pages, the maximum heap size is about
   // 8 * 1024 * 32 * 8K = 2G bytes.
   static const int kPagesPerChunk = 64;
@@ skipping 44 matching lines @@
 
   // Basic check whether a chunk id is in the valid range.
   static inline bool IsValidChunkId(int chunk_id);
 
   // Checks whether a chunk id identifies an allocated chunk.
   static inline bool IsValidChunk(int chunk_id);
 
   // Returns the chunk id that a page belongs to.
   static inline int GetChunkId(Page* p);
 
+  // True if the address lies in the initial chunk.
+  static inline bool InInitialChunk(Address address);
+
   // Initializes pages in a chunk. Returns the first page address.
   // This function and GetChunkId() are provided for the mark-compact
   // collector to rebuild page headers in the from space, which is
   // used as a marking stack and its page headers are destroyed.
   static Page* InitializePagesInChunk(int chunk_id, int pages_in_chunk,
                                       PagedSpace* owner);
 };
 
 
 // -----------------------------------------------------------------------------
@@ skipping 189 matching lines @@
 
  private:
   int capacity_;
   int available_;
   int size_;
   int waste_;
 };
 
 
 class PagedSpace : public Space {
-  friend class PageIterator;
  public:
   // Creates a space with a maximum capacity, and an id.
   PagedSpace(int max_capacity, AllocationSpace id, Executability executable);
 
   virtual ~PagedSpace() {}
 
   // Set up the space using the given address range of virtual memory (from
   // the memory allocator's initial chunk) if possible.  If the block of
   // addresses is not big enough to contain a single page-aligned page, a
   // fresh chunk will be allocated.
@@ skipping 74 matching lines @@
   // Updates the allocation pointer to the relocation top after a mark-compact
   // collection.
   virtual void MCCommitRelocationInfo() = 0;
 
   // Releases half of unused pages.
   void Shrink();
 
   // Ensures that the capacity is at least 'capacity'. Returns false on failure.
   bool EnsureCapacity(int capacity);
 
+#ifdef ENABLE_HEAP_PROTECTION
+  // Protect/unprotect the space by marking it read-only/writable.
+  void Protect();
+  void Unprotect();
+#endif
+
 #ifdef DEBUG
   // Print meta info and objects in this space.
   virtual void Print();
 
   // Report code object related statistics
   void CollectCodeStatistics();
   static void ReportCodeStatistics();
   static void ResetCodeStatistics();
 #endif
 
@@ skipping 50 matching lines @@
   // Returns the page of the allocation pointer.
   Page* AllocationTopPage() { return TopPageOf(allocation_info_); }
 
   // Returns a pointer to the page of the relocation pointer.
   Page* MCRelocationTopPage() { return TopPageOf(mc_forwarding_info_); }
 
 #ifdef DEBUG
   // Returns the number of total pages in this space.
   int CountTotalPages();
 #endif
+
+  friend class PageIterator;
 };
 
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
 // HistogramInfo class for recording a single "bar" of a histogram.  This
 // class is used for collecting statistics to print to stdout (when compiled
 // with DEBUG) or to the log file (when compiled with
 // ENABLE_LOGGING_AND_PROFILING).
 class HistogramInfo BASE_EMBEDDED {
  public:
@@ skipping 263 matching lines @@
 
   // True if the object is a heap object in the address range of the
   // respective semispace (not necessarily below the allocation pointer of the
   // semispace).
   bool ToSpaceContains(Object* o) { return to_space_.Contains(o); }
   bool FromSpaceContains(Object* o) { return from_space_.Contains(o); }
 
   bool ToSpaceContains(Address a) { return to_space_.Contains(a); }
   bool FromSpaceContains(Address a) { return from_space_.Contains(a); }
 
+#ifdef ENABLE_HEAP_PROTECTION
+  // Protect/unprotect the space by marking it read-only/writable.
+  virtual void Protect();
+  virtual void Unprotect();
+#endif
+
 #ifdef DEBUG
   // Verify the active semispace.
   virtual void Verify();
   // Print the active semispace.
   virtual void Print() { to_space_.Print(); }
 #endif
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   // Iterates the active semispace to collect statistics.
   void CollectStatistics();
@@ skipping 417 matching lines @@
 
   // The size of this chunk.
   size_t size_;
 
  public:
   TRACK_MEMORY("LargeObjectChunk")
 };
 
 
 class LargeObjectSpace : public Space {
-  friend class LargeObjectIterator;
  public:
   explicit LargeObjectSpace(AllocationSpace id);
   virtual ~LargeObjectSpace() {}
 
   // Initializes internal data structures.
   bool Setup();
 
   // Releases internal resources, frees objects in this space.
   void TearDown();
 
@@ skipping 31 matching lines @@
 
   // Frees unmarked objects.
   void FreeUnmarkedObjects();
 
   // Checks whether a heap object is in this space; O(1).
   bool Contains(HeapObject* obj);
 
   // Checks whether the space is empty.
   bool IsEmpty() { return first_chunk_ == NULL; }
 
+#ifdef ENABLE_LOGGING_AND_PROFILING

[Kevin Millikin (Chromium), 2009/03/24 11:42:43]

Ooops.  Fixed.

+  // Protect/unprotect the space by marking it read-only/writable.
+  void Protect();
+  void Unprotect();
+#endif
+
 #ifdef DEBUG
   virtual void Verify();
   virtual void Print();
   void ReportStatistics();
   void CollectCodeStatistics();
   // Dump the remembered sets in the space to stdout.
   void PrintRSet();
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return !FindObject(addr)->IsFailure(); }
 
  private:
   // The head of the linked list of large object chunks.
   LargeObjectChunk* first_chunk_;
   int size_;  // allocated bytes
   int page_count_;  // number of chunks
 
 
   // Shared implementation of AllocateRaw, AllocateRawCode and
   // AllocateRawFixedArray.
   Object* AllocateRawInternal(int requested_size,
                               int object_size,
                               Executability executable);
 
   // Returns the number of extra bytes (rounded up to the nearest full word)
   // required for extra_object_bytes of extra pointers (in bytes).
   static inline int ExtraRSetBytesFor(int extra_object_bytes);
 
+  friend class LargeObjectIterator;
+
  public:
   TRACK_MEMORY("LargeObjectSpace")
 };
 
 
 class LargeObjectIterator: public ObjectIterator {
  public:
   explicit LargeObjectIterator(LargeObjectSpace* space);
   LargeObjectIterator(LargeObjectSpace* space, HeapObjectCallback size_func);
 
   bool has_next() { return current_ != NULL; }
   HeapObject* next();
 
   // implementation of ObjectIterator.
   virtual bool has_next_object() { return has_next(); }
   virtual HeapObject* next_object() { return next(); }
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_