commit a221f569d741a425beca4f111931e12177e3a3f3
author Stephen Hines <srhines@google.com> Wed Jul 10 17:59:47 2013 -0700
committer Stephen Hines <srhines@google.com> Wed Jul 10 18:06:51 2013 -0700
tree 3dc52efc7be9f68913fae4c2850af1cf58c5a1ba
parent 34b0d3119567b992f0f876a2dffc0161bdcef3e6

Implement MemChunk::registerAllocFreeCallbacks().

This function allows a driver implementation to register its own handler for
allocating/freeing MemChunk objects. MemChunk is primarily used by the ELF
loader for various code/data segments.

Change-Id: If497f07a538c714933fcaa1b0c04ed5a6febeeba

driver/linkloader/include/MemChunk.h

diff --git a/driver/linkloader/include/MemChunk.h b/driver/linkloader/include/MemChunk.h
index fb853e9..c4d78c9 100644
--- a/driver/linkloader/include/MemChunk.h
+++ b/driver/linkloader/include/MemChunk.h
@@ -18,12 +18,22 @@
 #define MEM_CHUNK_H
 
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 
+typedef void *(*AllocFunc) (size_t, uint32_t);
+typedef void (*FreeFunc) (void *);
+
 class MemChunk {
 private:
   unsigned char *buf;
   size_t buf_size;
+  bool bVendorBuf;
+
+  static AllocFunc VendorAlloc;
+  static FreeFunc VendorFree;
+
+  bool invalidBuf() const;
 
 public:
   MemChunk();
@@ -56,6 +66,12 @@
     return buf_size;
   }
 
+  // The allocation function must return page-aligned memory or we will be
+  // unable to mprotect the region appropriately.
+  static void registerAllocFreeCallbacks(AllocFunc a, FreeFunc f) {
+    VendorAlloc = a;
+    VendorFree = f;
+  }
 };
 
 #endif // MEM_CHUNK_H

driver/linkloader/lib/MemChunk.cpp

diff --git a/driver/linkloader/lib/MemChunk.cpp b/driver/linkloader/lib/MemChunk.cpp
index 24dcf8e..c01305a 100644
--- a/driver/linkloader/lib/MemChunk.cpp
+++ b/driver/linkloader/lib/MemChunk.cpp
@@ -37,32 +37,49 @@
 static uintptr_t StartAddr = 0x7e000000UL;
 #endif
 
-MemChunk::MemChunk() : buf((unsigned char *)MAP_FAILED), buf_size(0) {
+AllocFunc MemChunk::VendorAlloc = NULL;
+FreeFunc MemChunk::VendorFree = NULL;
+
+MemChunk::MemChunk() : buf(NULL), buf_size(0), bVendorBuf(true) {
 }
 
 MemChunk::~MemChunk() {
-  if (buf != MAP_FAILED) {
+  if (!invalidBuf() && bVendorBuf && VendorFree) {
+    (*VendorFree)(buf);
+    return;
+  }
+  if (!invalidBuf()) {
     munmap(buf, buf_size);
   }
 }
 
+bool MemChunk::invalidBuf() const {
+  return (buf == 0 || buf == (unsigned char *)MAP_FAILED);
+}
+
 bool MemChunk::allocate(size_t size) {
   if (size == 0) {
     return true;
   }
+  if (VendorAlloc) {
+    buf = (unsigned char*)(*VendorAlloc)(size, 0);
+  }
+  if (invalidBuf()) {
+    bVendorBuf = false;
 #if USE_FIXED_ADDR_MEM_CHUNK
-  buf = (unsigned char *)mmap((void *)StartAddr, size,
-                              PROT_READ | PROT_WRITE,
-                              MAP_PRIVATE | MAP_ANON | MAP_32BIT,
-                              -1, 0);
+    buf = (unsigned char *)mmap((void *)StartAddr, size,
+                                PROT_READ | PROT_WRITE,
+                                MAP_PRIVATE | MAP_ANON | MAP_32BIT,
+                                -1, 0);
 #else
-  buf = (unsigned char *)mmap(0, size,
-                              PROT_READ | PROT_WRITE,
-                              MAP_PRIVATE | MAP_ANON | MAP_32BIT,
-                              -1, 0);
+    buf = (unsigned char *)mmap(0, size,
+                                PROT_READ | PROT_WRITE,
+                                MAP_PRIVATE | MAP_ANON | MAP_32BIT,
+                                -1, 0);
 #endif
+  }
 
-  if (buf == MAP_FAILED) {
+  if (invalidBuf()) {
     return false;
   }
 
@@ -75,7 +92,7 @@
 }
 
 void MemChunk::print() const {
-  if (buf != MAP_FAILED) {
+  if (!invalidBuf()) {
     dump_hex(buf, buf_size, 0, buf_size);
   }
 }

driver/rsdCore.cpp

diff --git a/driver/rsdCore.cpp b/driver/rsdCore.cpp
index 3357969..4aad52a 100644
--- a/driver/rsdCore.cpp
+++ b/driver/rsdCore.cpp
@@ -20,6 +20,7 @@
 #include "rsdAllocation.h"
 #include "rsdBcc.h"
 #ifndef RS_COMPATIBILITY_LIB
+    #include "MemChunk.h"
     #include "rsdGL.h"
     #include "rsdPath.h"
     #include "rsdProgramStore.h"
@@ -189,7 +190,7 @@
     }
     rsc->mHal.drv = dc;
 
-    dc->mCpuRef = RsdCpuReference::create((Context *)c, version_major, version_minor,
+    dc->mCpuRef = RsdCpuReference::create(rsc, version_major, version_minor,
                                           &rsdLookupRuntimeStub, &LookupScript);
     if (!dc->mCpuRef) {
         ALOGE("RsdCpuReference::create for driver hal failed.");
@@ -202,6 +203,16 @@
     if (false) {
         dc->mCpuRef->setSetupCompilerCallback(NULL);
     }
+
+    // Set a callback for switching MemChunk's allocator here.
+    // Note that the allocation function must return page-aligned memory, so
+    // that it can be mprotected properly (i.e. code should be written and
+    // later switched to read+execute only).
+    if (false) {
+        MemChunk::registerAllocFreeCallbacks(
+                rsc->mHal.funcs.allocRuntimeMem,
+                rsc->mHal.funcs.freeRuntimeMem);
+    }
 #endif
 
     return true;