Fix zend_alloc aligned allocation on Windows

Author: mvorisek

Zend/zend_alloc.c

@@ -419,6 +419,14 @@ stderr_last_error(char *msg)
 static void zend_mm_munmap(void *addr, size_t size)
 {
 #ifdef _WIN32
+	MEMORY_BASIC_INFORMATION mbi;
+	if (VirtualQuery(addr, &mbi, sizeof(mbi)) == 0) {
+#if ZEND_MM_ERROR
+		stderr_last_error("VirtualQuery() failed");
+#endif
+	}
+	addr = mbi.AllocationBase;
+	
 	if (VirtualFree(addr, 0, MEM_RELEASE) == 0) {
 #if ZEND_MM_ERROR
 		stderr_last_error("VirtualFree() failed");
@@ -433,19 +441,52 @@ static void zend_mm_munmap(void *addr, size_t size)
 #endif
 }
 
-static void *zend_mm_mmap(size_t size)
-{
 #ifdef _WIN32
-	void *ptr = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+static void *zend_mm_mmap_win_reserve(size_t size)
+{
+	void *ptr = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_READWRITE);
+	if (ptr == NULL) {
+#if ZEND_MM_ERROR
+		stderr_last_error("VirtualAlloc() reserve failed");
+#endif
+		return NULL;
+	}
+	return ptr;
+}
 
+#ifndef _WIN64
+static void *zend_mm_mmap_win_reserve_fixed(void *addr, size_t size)
+{
+	void *ptr = VirtualAlloc(addr, size, MEM_RESERVE, PAGE_READWRITE);
 	if (ptr == NULL) {
+		/** ERROR_INVALID_ADDRESS is expected when addr - addr+size is not free */
+		if (GetLastError() != ERROR_INVALID_ADDRESS) {
 #if ZEND_MM_ERROR
-		stderr_last_error("VirtualAlloc() failed");
+			stderr_last_error("VirtualAlloc() reserve fixed failed");
 #endif
+		}
+		SetLastError(0);
 		return NULL;
 	}
 	return ptr;
-#else
+}
+#endif
+
+static void *zend_mm_mmap_win_commit(void *addr, size_t size)
+{
+	void *ptr = VirtualAlloc(addr, size, MEM_COMMIT, PAGE_READWRITE);
+	if (ptr == NULL) {
+#if ZEND_MM_ERROR
+		stderr_last_error("VirtualAlloc() commit failed");
+#endif
+		return NULL;
+	}
+	ZEND_ASSERT(ptr == addr);
+	return ptr;
+}
+#else /* not Windows */
+static void *zend_mm_mmap(size_t size)
+{
 	void *ptr;
 
 #ifdef MAP_HUGETLB
@@ -458,43 +499,39 @@ static void *zend_mm_mmap(size_t size)
 #endif
 
 	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, ZEND_MM_FD, 0);
-
 	if (ptr == MAP_FAILED) {
 #if ZEND_MM_ERROR
 		fprintf(stderr, "\nmmap() failed: [%d] %s\n", errno, strerror(errno));
 #endif
 		return NULL;
 	}
 	return ptr;
-#endif
 }
+#endif
 
 #ifndef HAVE_MREMAP
+#ifndef _WIN32
 static void *zend_mm_mmap_fixed(void *addr, size_t size)
 {
-#ifdef _WIN32
-	return VirtualAlloc(addr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
-#else
 	int flags = MAP_PRIVATE | MAP_ANON;
 #if defined(MAP_EXCL)
 	flags |= MAP_FIXED | MAP_EXCL;
 #endif
 	/* MAP_FIXED leads to discarding of the old mapping, so it can't be used. */
 	void *ptr = mmap(addr, size, PROT_READ | PROT_WRITE, flags /*| MAP_POPULATE | MAP_HUGETLB*/, ZEND_MM_FD, 0);
-
 	if (ptr == MAP_FAILED) {
 #if ZEND_MM_ERROR && !defined(MAP_EXCL)
-		fprintf(stderr, "\nmmap() failed: [%d] %s\n", errno, strerror(errno));
+		fprintf(stderr, "\nmmap() fixed failed: [%d] %s\n", errno, strerror(errno));
 #endif
 		return NULL;
 	} else if (ptr != addr) {
 		zend_mm_munmap(ptr, size);
 		return NULL;
 	}
 	return ptr;
-#endif
 }
 #endif
+#endif
 
 /***********/
 /* Bitmask */
@@ -660,28 +697,47 @@ static zend_always_inline int zend_mm_bitset_is_free_range(zend_mm_bitset *bitse
 
 static void *zend_mm_chunk_alloc_int(size_t size, size_t alignment)
 {
-	void *ptr = zend_mm_mmap(size);
-
+#ifdef _WIN32
+	void *ptr = NULL;
+	size_t offset;
+#ifndef _WIN64
+	/* 32-bit build has limited memory address space and partical deallocation is not supported,
+	 * try to reserve exact aligned size first, GH-9650 */
+	ptr = zend_mm_mmap_win_reserve(size + alignment);
 	if (ptr == NULL) {
 		return NULL;
-	} else if (ZEND_MM_ALIGNED_OFFSET(ptr, alignment) != 0) {
-		size_t offset;
+	}
 
-		/* chunk has to be aligned */
-		zend_mm_munmap(ptr, size);
-		ptr = zend_mm_mmap(size + alignment - REAL_PAGE_SIZE);
-#ifdef _WIN32
-		offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
-		zend_mm_munmap(ptr, size + alignment - REAL_PAGE_SIZE);
-		ptr = zend_mm_mmap_fixed((void*)((char*)ptr + (alignment - offset)), size);
-		offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
-		if (offset != 0) {
-			zend_mm_munmap(ptr, size);
+	offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
+	if (offset != 0) {
+		offset = alignment - offset;
+	}
+	zend_mm_munmap(ptr, size + alignment);
+	ptr = zend_mm_mmap_win_reserve_fixed((void*)((char*)ptr + offset), size);
+#endif
+	if (ptr == NULL) {
+		ptr = zend_mm_mmap_win_reserve(size + alignment);
+		if (ptr == NULL) {
 			return NULL;
 		}
-		return ptr;
+	}
+
+	offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
+	if (offset != 0) {
+		offset = alignment - offset;
+	}
+	return zend_mm_mmap_win_commit((void*)((char*)ptr + offset), size);
 #else
-		offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
+	void *ptr = zend_mm_mmap(size);
+	if (ptr == NULL) {
+		return NULL;
+	}
+
+	if (ZEND_MM_ALIGNED_OFFSET(ptr, alignment) != 0) {
+		zend_mm_munmap(ptr, size);
+		ptr = zend_mm_mmap(size + alignment - REAL_PAGE_SIZE);
+
+		size_t offset = ZEND_MM_ALIGNED_OFFSET(ptr, alignment);
 		if (offset != 0) {
 			offset = alignment - offset;
 			zend_mm_munmap(ptr, offset);
@@ -691,7 +747,6 @@ static void *zend_mm_chunk_alloc_int(size_t size, size_t alignment)
 		if (alignment > REAL_PAGE_SIZE) {
 			zend_mm_munmap((char*)ptr + size, alignment - REAL_PAGE_SIZE);
 		}
-#endif
 	}
 
 #ifdef MADV_HUGEPAGE
@@ -701,6 +756,7 @@ static void *zend_mm_chunk_alloc_int(size_t size, size_t alignment)
 #endif
 
 	return ptr;
+#endif
 }
 
 static void *zend_mm_chunk_alloc(zend_mm_heap *heap, size_t size, size_t alignment)
@@ -1838,11 +1894,7 @@ static zend_mm_heap *zend_mm_init(void)
 
 	if (UNEXPECTED(chunk == NULL)) {
 #if ZEND_MM_ERROR
-#ifdef _WIN32
-		stderr_last_error("Can't initialize heap");
-#else
-		fprintf(stderr, "\nCan't initialize heap: [%d] %s\n", errno, strerror(errno));
-#endif
+		fprintf(stderr, "Can't initialize heap\n");
 #endif
 		return NULL;
 	}
@@ -2969,11 +3021,7 @@ ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_handlers *handlers, void
 	chunk = (zend_mm_chunk*)handlers->chunk_alloc(&tmp_storage, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE);
 	if (UNEXPECTED(chunk == NULL)) {
 #if ZEND_MM_ERROR
-#ifdef _WIN32
-		stderr_last_error("Can't initialize heap");
-#else
-		fprintf(stderr, "\nCan't initialize heap: [%d] %s\n", errno, strerror(errno));
-#endif
+		fprintf(stderr, "Can't initialize heap\n");
 #endif
 		return NULL;
 	}
@@ -3016,11 +3064,7 @@ ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_handlers *handlers, void
 	if (!storage) {
 		handlers->chunk_free(&tmp_storage, chunk, ZEND_MM_CHUNK_SIZE);
 #if ZEND_MM_ERROR
-#ifdef _WIN32
-		stderr_last_error("Can't initialize heap");
-#else
-		fprintf(stderr, "\nCan't initialize heap: [%d] %s\n", errno, strerror(errno));
-#endif
+		fprintf(stderr, "Can't initialize heap\n");
 #endif
 		return NULL;
 	}