Hannes Landeholm

diff -crB apc_vanilla/apc_cache.c apc/apc_cache.c
*** apc_vanilla/apc_cache.c 2011-01-11 19:06:38.000000000 +0000
--- apc/apc_cache.c 2011-01-16 06:50:35.000000000 +0000
***************
*** 229,235 ****
  /* }}} */

  /* {{{ apc_cache_create */
! apc_cache_t* apc_cache_create(int size_hint, int gc_ttl, int ttl TSRMLS_DC)
  {
      apc_cache_t* cache;
      int cache_size;
--- 229,237 ----
  /* }}} */

  /* {{{ apc_cache_create */
! /* SHARED MMAP HACK CODE START */
! apc_cache_t* apc_cache_create(int size_hint, int gc_ttl, int ttl TSRMLS_DC, int static_cache_id)
! /* SHARED MMAP HACK CODE END */
  {
      apc_cache_t* cache;
      int cache_size;
***************
*** 240,272 ****
      cache = (apc_cache_t*) apc_emalloc(sizeof(apc_cache_t) TSRMLS_CC);
      cache_size = sizeof(cache_header_t) + num_slots*sizeof(slot_t*);

!     cache->shmaddr = apc_sma_malloc(cache_size TSRMLS_CC);
!     if(!cache->shmaddr) {
!         apc_error("Unable to allocate shared memory for cache structures.  (Perhaps your shared memory size isn't large enough?). " TSRMLS_CC);
!         return NULL;
!     }
!     memset(cache->shmaddr, 0, cache_size);
!
!     cache->header = (cache_header_t*) cache->shmaddr;
!     cache->header->num_hits = 0;
!     cache->header->num_misses = 0;
!     cache->header->deleted_list = NULL;
!     cache->header->start_time = time(NULL);
!     cache->header->expunges = 0;
!     cache->header->busy = 0;
!
!     cache->slots = (slot_t**) (((char*) cache->shmaddr) + sizeof(cache_header_t));
      cache->num_slots = num_slots;
      cache->gc_ttl = gc_ttl;
      cache->ttl = ttl;
-     CREATE_LOCK(cache->header->lock);
- #if NONBLOCKING_LOCK_AVAILABLE
-     CREATE_LOCK(cache->header->wrlock);
- #endif
-     memset(cache->slots, 0, sizeof(slot_t*)*num_slots);
      cache->expunge_cb = apc_cache_expunge;
      cache->has_lock = 0;
!
      return cache;
  }
  /* }}} */
--- 242,298 ----
      cache = (apc_cache_t*) apc_emalloc(sizeof(apc_cache_t) TSRMLS_CC);
      cache_size = sizeof(cache_header_t) + num_slots*sizeof(slot_t*);

!   /* SHARED MMAP HACK CODE START */
!   static pthread_mutex_t cache_init_mutex = PTHREAD_MUTEX_INITIALIZER;
!   pthread_mutex_lock(&cache_init_mutex);
!   // Get static cache pointers.
!   if (static_cache_id == APC_HACK_STATIC_CACHE_CORE)
!       cache->shmaddr = apc_sma_hack_core_cache_addr_get();
!   else if (static_cache_id == APC_HACK_STATIC_CACHE_USER)
!       cache->shmaddr = apc_sma_hack_user_cache_addr_get();
!   else
!       cache->shmaddr = (void*)0;
!   char init_header = 0;
!   if (cache->shmaddr == (void*)0) {
!       // Allocate a new shared memory address.
!       cache->shmaddr = apc_sma_malloc(cache_size TSRMLS_CC);
!       if(!cache->shmaddr) {
!           apc_error("Unable to allocate shared memory for cache structures.  (Perhaps your shared memory size isn't large enough?). " TSRMLS_CC);
!           pthread_mutex_unlock(&cache_init_mutex);
!           return NULL;
!       }
!       memset(cache->shmaddr, 0, cache_size);
!       // Set static cache pointers.
!       if (static_cache_id == APC_HACK_STATIC_CACHE_CORE)
!           apc_sma_hack_core_cache_addr_set(cache->shmaddr);
!       else if (static_cache_id == APC_HACK_STATIC_CACHE_USER)
!           apc_sma_hack_user_cache_addr_set(cache->shmaddr);
!       init_header = 1;
!   }
!   cache->slots = (slot_t**) (((char*) cache->shmaddr) + sizeof(cache_header_t));
!   cache->header = (cache_header_t*) cache->shmaddr;
!   if (init_header == 1) {
!       cache->header->num_hits = 0;
!       cache->header->num_misses = 0;
!       cache->header->deleted_list = NULL;
!       cache->header->start_time = time(NULL);
!       cache->header->expunges = 0;
!       cache->header->busy = 0;
!       CREATE_LOCK(cache->header->lock);
!   #if NONBLOCKING_LOCK_AVAILABLE
!       CREATE_LOCK(cache->header->wrlock);
!   #endif
!       memset(cache->slots, 0, sizeof(slot_t*)*num_slots);
!   }
!   pthread_mutex_unlock(&cache_init_mutex);
!   // Thread local cache data...
      cache->num_slots = num_slots;
      cache->gc_ttl = gc_ttl;
      cache->ttl = ttl;
      cache->expunge_cb = apc_cache_expunge;
      cache->has_lock = 0;
!   /* SHARED MMAP HACK CODE END */
!
      return cache;
  }
  /* }}} */
diff -crB apc_vanilla/apc_cache.h apc/apc_cache.h
*** apc_vanilla/apc_cache.h 2011-01-11 19:06:38.000000000 +0000
--- apc/apc_cache.h 2011-01-16 02:05:48.000000000 +0000
***************
*** 149,154 ****
--- 149,156 ----
  };
  /* }}} */

+ /* SHARED MMAP HACK CODE START */
+
  /*
   * apc_cache_create creates the shared memory compiler cache. This function
   * should be called just once (ideally in the web server parent process, e.g.
***************
*** 167,173 ****
   * is needed.  This helps in cleaning up the cache and ensuring that entries
   * hit frequently stay cached and ones not hit very often eventually disappear.
   */
! extern T apc_cache_create(int size_hint, int gc_ttl, int ttl TSRMLS_DC);

  /*
   * apc_cache_destroy releases any OS resources associated with a cache object.
--- 169,177 ----
   * is needed.  This helps in cleaning up the cache and ensuring that entries
   * hit frequently stay cached and ones not hit very often eventually disappear.
   */
! extern T apc_cache_create(int size_hint, int gc_ttl, int ttl TSRMLS_DC, int static_cache_id);
!
! /* SHARED MMAP HACK CODE END */

  /*
   * apc_cache_destroy releases any OS resources associated with a cache object.
diff -crB apc_vanilla/apc_globals.h apc/apc_globals.h
*** apc_vanilla/apc_globals.h   2011-01-11 19:06:38.000000000 +0000
--- apc/apc_globals.h   2011-01-16 01:54:50.000000000 +0000
***************
*** 76,82 ****
  #endif
      char** filters;         /* array of regex filters that prevent caching */
      void* compiled_filters; /* compiled regex filters */
!
      /* module variables */
      zend_bool initialized;       /* true if module was initialized */
      apc_stack_t* cache_stack;    /* the stack of cached executable code */
--- 76,87 ----
  #endif
      char** filters;         /* array of regex filters that prevent caching */
      void* compiled_filters; /* compiled regex filters */
!
!   /* SHARED MMAP HACK CODE START */
!   time_t init_time;            /* time when module was initialized */
!   void* reserved_mmap_addr;    /* reserved address to use when mmap'ing memory */
!   /* SHARED MMAP HACK CODE END */
!
      /* module variables */
      zend_bool initialized;       /* true if module was initialized */
      apc_stack_t* cache_stack;    /* the stack of cached executable code */
diff -crB apc_vanilla/apc.h apc/apc.h
*** apc_vanilla/apc.h   2011-01-11 19:06:38.000000000 +0000
--- apc/apc.h   2011-01-16 00:57:56.000000000 +0000
***************
*** 109,114 ****
--- 109,120 ----
  #define APC_NEGATIVE_MATCH 1
  #define APC_POSITIVE_MATCH 2

+ /* SHARED MMAP HACK CODE START */
+ #define APC_HACK_STATIC_CACHE_NONE 0
+ #define APC_HACK_STATIC_CACHE_CORE 1
+ #define APC_HACK_STATIC_CACHE_USER 2
+ /* SHARED MMAP HACK CODE END */
+
  #define apc_time() \
      (APCG(use_request_time) ? (time_t) sapi_get_request_time(TSRMLS_C) : time(0));

diff -crB apc_vanilla/apc_main.c apc/apc_main.c
*** apc_vanilla/apc_main.c  2011-01-11 19:06:38.000000000 +0000
--- apc/apc_main.c  2011-01-16 02:17:15.000000000 +0000
***************
*** 799,813 ****
  /* {{{ module init and shutdown */

  int apc_module_init(int module_number TSRMLS_DC)
! {
      /* apc initialization */
  #if APC_MMAP
      apc_sma_init(APCG(shm_segments), APCG(shm_size), APCG(mmap_file_mask) TSRMLS_CC);
  #else
      apc_sma_init(APCG(shm_segments), APCG(shm_size), NULL TSRMLS_CC);
  #endif
!     apc_cache = apc_cache_create(APCG(num_files_hint), APCG(gc_ttl), APCG(ttl) TSRMLS_CC);
!     apc_user_cache = apc_cache_create(APCG(user_entries_hint), APCG(gc_ttl), APCG(user_ttl) TSRMLS_CC);

      /* override compilation */
      old_compile_file = zend_compile_file;
--- 799,813 ----
  /* {{{ module init and shutdown */

  int apc_module_init(int module_number TSRMLS_DC)
! {
      /* apc initialization */
  #if APC_MMAP
      apc_sma_init(APCG(shm_segments), APCG(shm_size), APCG(mmap_file_mask) TSRMLS_CC);
  #else
      apc_sma_init(APCG(shm_segments), APCG(shm_size), NULL TSRMLS_CC);
  #endif
!     apc_cache = apc_cache_create(APCG(num_files_hint), APCG(gc_ttl), APCG(ttl) TSRMLS_CC, APC_HACK_STATIC_CACHE_CORE);
!     apc_user_cache = apc_cache_create(APCG(user_entries_hint), APCG(gc_ttl), APCG(user_ttl) TSRMLS_CC, APC_HACK_STATIC_CACHE_USER);

      /* override compilation */
      old_compile_file = zend_compile_file;
diff -crB apc_vanilla/apc_mmap.c apc/apc_mmap.c
*** apc_vanilla/apc_mmap.c  2011-01-11 19:06:38.000000000 +0000
--- apc/apc_mmap.c  2011-01-17 00:00:27.000000000 +0000
***************
*** 30,35 ****
--- 30,36 ----
  #include "apc.h"
  #include "apc_mmap.h"
  #include "apc_lock.h"
+ #include "apc_globals.h"

  #if APC_MMAP

***************
*** 53,148 ****
  # define MAP_ANON MAP_ANONYMOUS
  #endif

  apc_segment_t apc_mmap(char *file_mask, size_t size TSRMLS_DC)
  {
!     apc_segment_t segment;

!     int fd = -1;
!     int flags = MAP_SHARED | MAP_NOSYNC;
      int remap = 1;
!
      /* If no filename was provided, do an anonymous mmap */
!     if(!file_mask || (file_mask && !strlen(file_mask))) {
! #if !defined(MAP_ANON)
!         apc_error("Anonymous mmap does not apear to be available on this system (MAP_ANON/MAP_ANONYMOUS).  Please see the apc.mmap_file_mask INI option." TSRMLS_CC);
! #else
!         fd = -1;
!         flags = MAP_SHARED | MAP_ANON;
!         remap = 0;
! #endif
!     } else if(!strcmp(file_mask,"/dev/zero")) {
!         fd = open("/dev/zero", O_RDWR, S_IRUSR | S_IWUSR);
!         if(fd == -1) {
!             apc_error("apc_mmap: open on /dev/zero failed:" TSRMLS_CC);
!             goto error;
!         }
!         remap = 0; /* cannot remap */
!     } else if(strstr(file_mask,".shm")) {
!         /*
!          * If the filemask contains .shm we try to do a POSIX-compliant shared memory
!          * backed mmap which should avoid synchs on some platforms.  At least on
!          * FreeBSD this implies MAP_NOSYNC and on Linux it is equivalent of mmap'ing
!          * a file in a mounted shmfs.  For this to work on Linux you need to make sure
!          * you actually have shmfs mounted.  Also on Linux, make sure the file_mask you
!          * pass in has a leading / and no other /'s.  eg.  /apc.shm.XXXXXX
!          * On FreeBSD these are mapped onto the regular filesystem so you can put whatever
!          * path you want here.
!          */
!         if(!mktemp(file_mask)) {
!             apc_error("apc_mmap: mktemp on %s failed:" TSRMLS_CC, file_mask);
!             goto error;
!         }
!         fd = shm_open(file_mask, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR);
!         if(fd == -1) {
!             apc_error("apc_mmap: shm_open on %s failed:" TSRMLS_CC, file_mask);
!             goto error;
!         }
!         if (ftruncate(fd, size) < 0) {
!             close(fd);
!             shm_unlink(file_mask);
!             apc_error("apc_mmap: ftruncate failed:" TSRMLS_CC);
!             goto error;
!         }
!         shm_unlink(file_mask);
      } else {
!         /*
!          * Otherwise we do a normal filesystem mmap
!          */
!         fd = mkstemp(file_mask);
!         if(fd == -1) {
!             apc_error("apc_mmap: mkstemp on %s failed:" TSRMLS_CC, file_mask);
!             goto error;
!         }
!         if (ftruncate(fd, size) < 0) {
!             close(fd);
!             unlink(file_mask);
!             apc_error("apc_mmap: ftruncate failed:" TSRMLS_CC);
!             goto error;
!         }
!         unlink(file_mask);
!     }
!
!     segment.shmaddr = (void *)mmap(NULL, size, PROT_READ | PROT_WRITE, flags, fd, 0);
      segment.size = size;

  #ifdef APC_MEMPROTECT
!     if(remap) {
!         segment.roaddr = (void *)mmap(NULL, size, PROT_READ, flags, fd, 0);
!     } else {
!         segment.roaddr = NULL;
!     }
  #endif

!     if((long)segment.shmaddr == -1) {
          apc_error("apc_mmap: mmap failed:" TSRMLS_CC);
!     }
!
!     if(fd != -1) close(fd);
!
      return segment;

  error:
!
      segment.shmaddr = (void*)-1;
      segment.size = 0;
  #ifdef APC_MEMPROTECT
--- 54,105 ----
  # define MAP_ANON MAP_ANONYMOUS
  #endif

+ /* SHARED MMAP HACK CODE START */
+
  apc_segment_t apc_mmap(char *file_mask, size_t size TSRMLS_DC)
  {
!   if (size != APCG(shm_size)) {
!       apc_error("apc_mmap: allocation request with incorrect shm_size!" TSRMLS_CC);
!       goto error;
!   }

!     apc_segment_t segment;
!
!     int flags = MAP_SHARED | MAP_NOSYNC | MAP_FIXED;
      int remap = 1;
!   int fd = -1;
!
      /* If no filename was provided, do an anonymous mmap */
!     if(!file_mask || (file_mask && !strlen(file_mask)) || !strcmp(file_mask,"/dev/zero")) {
!       apc_error("apc_mmap: no file mask (or /dev/zero) was used. this a mmap hacked APC version which require this." TSRMLS_CC);
!       goto error;
      } else {
!         fd = open(file_mask, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
!       if (fd == -1) {
!           apc_error("open: open on %s failed: %s (%d)" TSRMLS_CC, file_mask, strerror(errno), errno);
!           goto error;
!       }
!       if (ftruncate(fd, size) < 0) {
!           apc_error("apc_mmap: ftruncate failed:" TSRMLS_CC);
!           goto error;
!       }
!   }
!
!     segment.shmaddr = (void *)mmap(APCG(reserved_mmap_addr), size, PROT_READ | PROT_WRITE, flags, fd, 0);
      segment.size = size;
+   close(fd);

  #ifdef APC_MEMPROTECT
!     #error APC_MEMPROTECT IS NOT SUPPORTED IN THIS MMAP HACKED APC VERSION
  #endif

!     if((long)segment.shmaddr == -1)
          apc_error("apc_mmap: mmap failed:" TSRMLS_CC);
!
      return segment;

  error:
!   close(fd);
      segment.shmaddr = (void*)-1;
      segment.size = 0;
  #ifdef APC_MEMPROTECT
***************
*** 165,172 ****
--- 123,133 ----

  }

+ /* SHARED MMAP HACK CODE END */
+
  #endif

+
  /*
   * Local variables:
   * tab-width: 4
diff -crB apc_vanilla/apc_sma.c apc/apc_sma.c
*** apc_vanilla/apc_sma.c   2011-01-11 19:06:38.000000000 +0000
--- apc/apc_sma.c   2011-01-16 06:32:02.000000000 +0000
***************
*** 55,60 ****
--- 55,65 ----
      apc_lck_t sma_lock;     /* segment lock, MUST BE ALIGNED for futex locks */
      size_t segsize;         /* size of entire segment */
      size_t avail;           /* bytes available (not necessarily contiguous) */
+   /* SHARED MMAP HACK CODE START */
+   time_t session_id;      /* comparing this to know if this is an old or new session */
+   void* core_cache_addr;  /* static shared core cache address */
+     void* user_cache_addr;  /* static shared user cache address */
+   /* SHARED MMAP HACK CODE END */
  #if ALLOC_DISTRIBUTION
      size_t adist[30];
  #endif
***************
*** 77,82 ****
--- 82,105 ----
  static volatile size_t block_id = 0;
  #endif

+ /* SHARED MMAP HACK CODE START */
+ void* apc_sma_hack_core_cache_addr_get() {
+   return SMA_HDR(0)->core_cache_addr;
+ }
+
+ void apc_sma_hack_core_cache_addr_set(void* addr) {
+   SMA_HDR(0)->core_cache_addr = addr;
+ }
+
+ void* apc_sma_hack_user_cache_addr_get() {
+   return SMA_HDR(0)->user_cache_addr;
+ }
+
+ void apc_sma_hack_user_cache_addr_set(void* addr) {
+   SMA_HDR(0)->user_cache_addr = addr;
+ }
+ /* SHARED MMAP HACK CODE END */
+
  #define APC_SMA_CANARIES 1

  typedef struct block_t block_t;
***************
*** 335,421 ****

  void apc_sma_init(int numseg, size_t segsize, char *mmap_file_mask TSRMLS_DC)
  {
!     uint i;
!
      if (sma_initialized) {
          return;
      }
      sma_initialized = 1;
!
! #if APC_MMAP
!     /*
!      * I don't think multiple anonymous mmaps makes any sense
!      * so force sma_numseg to 1 in this case
!      */
!     if(!mmap_file_mask ||
!        (mmap_file_mask && !strlen(mmap_file_mask)) ||
!        (mmap_file_mask && !strcmp(mmap_file_mask, "/dev/zero"))) {
!         sma_numseg = 1;
!     } else {
!         sma_numseg = numseg > 0 ? numseg : DEFAULT_NUMSEG;
!     }
! #else
!     sma_numseg = numseg > 0 ? numseg : DEFAULT_NUMSEG;
! #endif
!
!     sma_segsize = segsize > 0 ? segsize : DEFAULT_SEGSIZE;
!
      sma_segments = (apc_segment_t*) apc_emalloc((sma_numseg * sizeof(apc_segment_t)) TSRMLS_CC);
!
!     for (i = 0; i < sma_numseg; i++) {
!         sma_header_t*   header;
!         block_t     *first, *empty, *last;
!         void*       shmaddr;
!
! #if APC_MMAP
!         sma_segments[i] = apc_mmap(mmap_file_mask, sma_segsize TSRMLS_CC);
!         if(sma_numseg != 1) memcpy(&mmap_file_mask[strlen(mmap_file_mask)-6], "XXXXXX", 6);
! #else
!         sma_segments[i] = apc_shm_attach(apc_shm_create(i, sma_segsize TSRMLS_CC), sma_segsize TSRMLS_CC);
! #endif
!
!         sma_segments[i].size = sma_segsize;
!
!         shmaddr = sma_segments[i].shmaddr;
!
!         header = (sma_header_t*) shmaddr;
!         apc_lck_create(NULL, 0, 1, header->sma_lock);
!         header->segsize = sma_segsize;
!         header->avail = sma_segsize - ALIGNWORD(sizeof(sma_header_t)) - ALIGNWORD(sizeof(block_t)) - ALIGNWORD(sizeof(block_t));
  #if ALLOC_DISTRIBUTION
!         {
!            int j;
!            for(j=0; j<30; j++) header->adist[j] = 0;
!         }
! #endif
!         first = BLOCKAT(ALIGNWORD(sizeof(sma_header_t)));
!         first->size = 0;
!         first->fnext = ALIGNWORD(sizeof(sma_header_t)) + ALIGNWORD(sizeof(block_t));
!         first->fprev = 0;
!         first->prev_size = 0;
!         SET_CANARY(first);
  #ifdef __APC_SMA_DEBUG__
!         block->id = -1;
  #endif
!         empty = BLOCKAT(first->fnext);
!         empty->size = header->avail - ALIGNWORD(sizeof(block_t));
!         empty->fnext = OFFSET(empty) + empty->size;
!         empty->fprev = ALIGNWORD(sizeof(sma_header_t));
!         empty->prev_size = 0;
!         SET_CANARY(empty);
  #ifdef __APC_SMA_DEBUG__
!         empty->id = -1;
  #endif
!         last = BLOCKAT(empty->fnext);
!         last->size = 0;
!         last->fnext = 0;
!         last->fprev =  OFFSET(empty);
!         last->prev_size = empty->size;
!         SET_CANARY(last);
  #ifdef __APC_SMA_DEBUG__
!         last->id = -1;
  #endif
!     }
  }
  /* }}} */

--- 358,438 ----

  void apc_sma_init(int numseg, size_t segsize, char *mmap_file_mask TSRMLS_DC)
  {
!   /* SHARED MMAP HACK CODE START */
!
!   if (sma_numseg > 0) {
!       apc_error("apc_mmap: this hacked apc version requires number of segments to be exactly one!" TSRMLS_CC);
!       return;
!   }
!   sma_numseg = 1;
!   sma_segsize = segsize;
!
!   // Making this function a critical section since it is called
!   // multiple times for each new request...
!   static pthread_mutex_t sma_init_mutex = PTHREAD_MUTEX_INITIALIZER;
!   pthread_mutex_lock(&sma_init_mutex);
!
      if (sma_initialized) {
+       pthread_mutex_unlock(&sma_init_mutex);
          return;
      }
      sma_initialized = 1;
!
      sma_segments = (apc_segment_t*) apc_emalloc((sma_numseg * sizeof(apc_segment_t)) TSRMLS_CC);
!   sma_segments[0] = apc_mmap(mmap_file_mask, sma_segsize TSRMLS_CC);
!   char* shmaddr = SMA_ADDR(0);
!   sma_header_t* header = (sma_header_t*) shmaddr;
!   // Compare session id with current session id to know
!   // if the segment needs to be initialized or not.
!   if (header->session_id == APCG(init_time)) {
!       pthread_mutex_unlock(&sma_init_mutex);
!       return;
!   }
!   apc_lck_create(NULL, 0, 1, header->sma_lock);
!   header->session_id = APCG(init_time);
!   header->core_cache_addr = NULL;
!   header->user_cache_addr = NULL;
!   header->segsize = sma_segsize;
!   header->avail = sma_segsize - ALIGNWORD(sizeof(sma_header_t)) - ALIGNWORD(sizeof(block_t)) - ALIGNWORD(sizeof(block_t));
  #if ALLOC_DISTRIBUTION
!   {
!      int j;
!      for(j=0; j<30; j++) header->adist[j] = 0;
!   }
! #endif
!     block_t     *first, *empty, *last;
!
!   first = BLOCKAT(ALIGNWORD(sizeof(sma_header_t)));
!   first->size = 0;
!   first->fnext = ALIGNWORD(sizeof(sma_header_t)) + ALIGNWORD(sizeof(block_t));
!   first->fprev = 0;
!   first->prev_size = 0;
!   SET_CANARY(first);
  #ifdef __APC_SMA_DEBUG__
!   block->id = -1;
  #endif
!   empty = BLOCKAT(first->fnext);
!   empty->size = header->avail - ALIGNWORD(sizeof(block_t));
!   empty->fnext = OFFSET(empty) + empty->size;
!   empty->fprev = ALIGNWORD(sizeof(sma_header_t));
!   empty->prev_size = 0;
!   SET_CANARY(empty);
  #ifdef __APC_SMA_DEBUG__
!   empty->id = -1;
  #endif
!   last = BLOCKAT(empty->fnext);
!   last->size = 0;
!   last->fnext = 0;
!   last->fprev =  OFFSET(empty);
!   last->prev_size = empty->size;
!   SET_CANARY(last);
  #ifdef __APC_SMA_DEBUG__
!   last->id = -1;
  #endif
!
!   pthread_mutex_unlock(&sma_init_mutex);
!
!   /* SHARED MMAP HACK CODE END */
  }
  /* }}} */

diff -crB apc_vanilla/apc_sma.h apc/apc_sma.h
*** apc_vanilla/apc_sma.h   2011-01-11 19:06:38.000000000 +0000
--- apc/apc_sma.h   2011-01-16 02:10:07.000000000 +0000
***************
*** 46,51 ****
--- 46,58 ----
  #endif
  };

+ /* SHARED MMAP HACK CODE START */
+ extern void* apc_sma_hack_core_cache_addr_get();
+ extern void apc_sma_hack_core_cache_addr_set(void* addr);
+ extern void* apc_sma_hack_user_cache_addr_get();
+ extern void apc_sma_hack_user_cache_addr_set(void* addr);
+ /* SHARED MMAP HACK CODE END */
+
  extern void apc_sma_init(int numseg, size_t segsize, char *mmap_file_mask TSRMLS_DC);
  extern void apc_sma_cleanup(TSRMLS_D);
  extern void* apc_sma_malloc(size_t size TSRMLS_DC);
diff -crB apc_vanilla/php_apc.c apc/php_apc.c
*** apc_vanilla/php_apc.c   2011-01-11 19:06:38.000000000 +0000
--- apc/php_apc.c   2011-01-16 22:17:26.000000000 +0000
***************
*** 289,294 ****
--- 289,295 ----
      php_info_print_table_start();
      php_info_print_table_header(2, "APC Support", APCG(enabled) ? "enabled" : "disabled");
      php_info_print_table_row(2, "Version", PHP_APC_VERSION);
+     php_info_print_table_row(2, "Hacks", "Hacked for shared MMAP support");
  #ifdef __DEBUG_APC__
      php_info_print_table_row(2, "APC Debugging", "Enabled");
  #else
***************
*** 334,365 ****
      ZEND_INIT_MODULE_GLOBALS(apc, php_apc_init_globals, php_apc_shutdown_globals);

      REGISTER_INI_ENTRIES();

      /* Disable APC in cli mode unless overridden by apc.enable_cli */
      if(!APCG(enable_cli) && !strcmp(sapi_module.name, "cli")) {
          APCG(enabled) = 0;
      }

-     if (APCG(enabled)) {
-         if(APCG(initialized)) {
-             apc_process_init(module_number TSRMLS_CC);
-         } else {
-             apc_module_init(module_number TSRMLS_CC);
-             apc_zend_init(TSRMLS_C);
-             apc_process_init(module_number TSRMLS_CC);
- #ifdef MULTIPART_EVENT_FORMDATA
-             /* File upload progress tracking */
-             if(APCG(rfc1867)) {
-                 php_rfc1867_callback = apc_rfc1867_progress;
-             }
- #endif
-             apc_iterator_init(module_number TSRMLS_CC);
-         }
-
-         zend_register_long_constant("APC_BIN_VERIFY_MD5", sizeof("APC_BIN_VERIFY_MD5"), APC_BIN_VERIFY_MD5, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
-         zend_register_long_constant("APC_BIN_VERIFY_CRC32", sizeof("APC_BIN_VERIFY_CRC32"), APC_BIN_VERIFY_CRC32, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
-     }
-
      return SUCCESS;
  }
  /* }}} */
--- 335,363 ----
      ZEND_INIT_MODULE_GLOBALS(apc, php_apc_init_globals, php_apc_shutdown_globals);

      REGISTER_INI_ENTRIES();
+
+   /* SHARED MMAP HACK CODE START */
+   APCG(init_time) = time(0);
+   // Reserved page aligned memory for mmap so that addresses will be the same for all cloned childs.
+   // We must page align since this address will be fed into mmap with MAP_FIXED.
+   long mmap_shm_size = APCG(shm_size);
+   long page_size = getpagesize();
+   if ((mmap_shm_size % page_size) > 0)
+       mmap_shm_size += (page_size - (mmap_shm_size % page_size));
+   void* reserved_mmap_addr;
+   int ret = posix_memalign(&reserved_mmap_addr, page_size, mmap_shm_size);
+   if (ret != 0) {
+       apc_error("posix_memalign failed: %d" TSRMLS_CC, ret);
+       return FAILURE;
+   }
+   APCG(reserved_mmap_addr) = reserved_mmap_addr;
+   /* SHARED MMAP HACK CODE END */

      /* Disable APC in cli mode unless overridden by apc.enable_cli */
      if(!APCG(enable_cli) && !strcmp(sapi_module.name, "cli")) {
          APCG(enabled) = 0;
      }

      return SUCCESS;
  }
  /* }}} */
***************
*** 389,401 ****
  /* {{{ PHP_RINIT_FUNCTION(apc) */
  static PHP_RINIT_FUNCTION(apc)
  {
!     if(APCG(enabled)) {
          apc_request_init(TSRMLS_C);

  #if HAVE_SIGACTION
          apc_set_signals(TSRMLS_C);
  #endif
      }
      return SUCCESS;
  }
  /* }}} */
--- 387,418 ----
  /* {{{ PHP_RINIT_FUNCTION(apc) */
  static PHP_RINIT_FUNCTION(apc)
  {
!   /* SHARED MMAP HACK CODE START */
!     if (APCG(enabled)) {
!         if(!APCG(initialized)) {
!             apc_module_init(module_number TSRMLS_CC);
!             apc_zend_init(TSRMLS_C);
!             apc_process_init(module_number TSRMLS_CC);
! #ifdef MULTIPART_EVENT_FORMDATA
!             /* File upload progress tracking */
!             if(APCG(rfc1867)) {
!                 php_rfc1867_callback = apc_rfc1867_progress;
!             }
! #endif
!             apc_iterator_init(module_number TSRMLS_CC);
!           zend_register_long_constant("APC_BIN_VERIFY_MD5", sizeof("APC_BIN_VERIFY_MD5"), APC_BIN_VERIFY_MD5, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
!           zend_register_long_constant("APC_BIN_VERIFY_CRC32", sizeof("APC_BIN_VERIFY_CRC32"), APC_BIN_VERIFY_CRC32, (CONST_CS | CONST_PERSISTENT), module_number TSRMLS_CC);
!         }
!
          apc_request_init(TSRMLS_C);

  #if HAVE_SIGACTION
          apc_set_signals(TSRMLS_C);
  #endif
      }
+   /* SHARED MMAP HACK CODE END */
+
+
      return SUCCESS;
  }
  /* }}} */