shared_alloc_win32.c

/*
 +----------------------------------------------------------------------+
 | Zend OPcache |
 +----------------------------------------------------------------------+
 | Copyright (c) The PHP Group |
 +----------------------------------------------------------------------+
 | This source file is subject to version 3.01 of the PHP license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | https://www.php.net/license/3_01.txt |
 | If you did not receive a copy of the PHP license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@php.net so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 | Stanislav Malyshev <stas@zend.com> |
 | Dmitry Stogov <dmitry@php.net> |
 +----------------------------------------------------------------------+
*/

#include"php.h"
#include"ZendAccelerator.h"
#include"zend_shared_alloc.h"
#include"zend_accelerator_util_funcs.h"
#include"zend_execute.h"
#include"zend_system_id.h"
#include"SAPI.h"
#include"tsrm_win32.h"
#include"win32/winutil.h"
#include<winbase.h>
#include<process.h>
#include<LMCONS.H>

#defineACCEL_FILEMAP_NAME "ZendOPcache.SharedMemoryArea"
#defineACCEL_MUTEX_NAME "ZendOPcache.SharedMemoryMutex"
#defineACCEL_EVENT_SOURCE "Zend OPcache"

/* address of mapping base and address of execute_ex */
#defineACCEL_BASE_POINTER_SIZE (2 * sizeof(void*))

staticHANDLEmemfile=NULL, memory_mutex=NULL;
staticvoid*mapping_base;

#defineMAX_MAP_RETRIES 25

staticvoidzend_win_error_message(inttype, char*msg, interr)
{
HANDLEh;
char*ev_msgs[2];
char*buf=php_win32_error_to_msg(err);

h=RegisterEventSource(NULL, TEXT(ACCEL_EVENT_SOURCE));
ev_msgs[0] =msg;
ev_msgs[1] =buf;
ReportEvent(h, // event log handle
EVENTLOG_ERROR_TYPE, // event type
0, // category zero
err, // event identifier
NULL, // no user security identifier
2, // one substitution string
0, // no data
ev_msgs, // pointer to string array
NULL); // pointer to data
DeregisterEventSource(h);

zend_accel_error(type, "%s", msg);

php_win32_error_msg_free(buf);
}

staticchar*create_name_with_username(char*name)
{
staticcharnewname[MAXPATHLEN+1+32+1+20+1+32+1];
char*p=newname;
p+=strlcpy(newname, name, MAXPATHLEN+1);
*(p++) ='@';
p=zend_mempcpy(p, accel_uname_id, 32);
*(p++) ='@';
p+=strlcpy(p, sapi_module.name, 21);
*(p++) ='@';
p=zend_mempcpy(p, zend_system_id, 32);
*(p++) ='\0';
ZEND_ASSERT(p-newname <= sizeof(newname));

returnnewname;
}

voidzend_shared_alloc_create_lock(void)
{
memory_mutex=CreateMutex(NULL, FALSE, create_name_with_username(ACCEL_MUTEX_NAME));
if (!memory_mutex) {
zend_accel_error(ACCEL_LOG_FATAL, "Cannot create mutex (error %u)", GetLastError());
return;
 }
ReleaseMutex(memory_mutex);
}

voidzend_shared_alloc_lock_win32(void)
{
DWORDwaitRes=WaitForSingleObject(memory_mutex, INFINITE);

if (waitRes==WAIT_FAILED) {
zend_accel_error(ACCEL_LOG_ERROR, "Cannot lock mutex");
 }
}

voidzend_shared_alloc_unlock_win32(void)
{
ReleaseMutex(memory_mutex);
}

staticintzend_shared_alloc_reattach(size_trequested_size, constchar**error_in)
{
interr;
void*wanted_mapping_base;
MEMORY_BASIC_INFORMATIONinfo;
void*execute_ex_base;
intexecute_ex_moved;

mapping_base=MapViewOfFileEx(memfile, FILE_MAP_ALL_ACCESS, 0, 0, ACCEL_BASE_POINTER_SIZE, NULL);
if (mapping_base==NULL) {
err=GetLastError();
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to read base address", err);
*error_in="read mapping base";
returnALLOC_FAILURE;
 }
wanted_mapping_base= ((void**)mapping_base)[0];
execute_ex_base= ((void**)mapping_base)[1];
UnmapViewOfFile(mapping_base);

execute_ex_moved= (void*)execute_ex!=execute_ex_base;

/* Check if execute_ex is at the same address and if the requested address space is free */
if (execute_ex_moved||
VirtualQuery(wanted_mapping_base, &info, sizeof(info)) ==0||
info.State!=MEM_FREE||
info.RegionSize<requested_size) {
#ifENABLE_FILE_CACHE_FALLBACK
if (ZCG(accel_directives).file_cache&&ZCG(accel_directives).file_cache_fallback) {
size_tpre_size, wanted_mb_save;

wanted_mb_save= (size_t)wanted_mapping_base;

if (execute_ex_moved) {
err=ERROR_INVALID_ADDRESS;
zend_win_error_message(ACCEL_LOG_WARNING, "Opcode handlers are unusable due to ASLR (fall-back to file cache)", err);
 } else {
err=ERROR_INVALID_ADDRESS;
zend_win_error_message(ACCEL_LOG_WARNING, "Base address marks unusable memory region (fall-back to file cache)", err);
 }

pre_size=ZEND_ALIGNED_SIZE(sizeof(zend_smm_shared_globals)) +ZEND_ALIGNED_SIZE(sizeof(zend_shared_segment)) +ZEND_ALIGNED_SIZE(sizeof(void*)) +ZEND_ALIGNED_SIZE(sizeof(int));
/* Map only part of SHM to have access to opcache shared globals */
mapping_base=MapViewOfFileEx(memfile, FILE_MAP_ALL_ACCESS, 0, 0, pre_size+ZEND_ALIGNED_SIZE(sizeof(zend_accel_shared_globals)), NULL);
if (mapping_base==NULL) {
err=GetLastError();
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to reattach to opcache shared globals", err);
returnALLOC_FAILURE;
 }
accel_shared_globals= (zend_accel_shared_globals*)((char*)((zend_smm_shared_globals*)mapping_base)->app_shared_globals+ ((char*)mapping_base- (char*)wanted_mb_save));

returnALLOC_FALLBACK;
 }
#endif
if (execute_ex_moved) {
err=ERROR_INVALID_ADDRESS;
zend_win_error_message(ACCEL_LOG_FATAL, "Opcode handlers are unusable due to ASLR. Please setup opcache.file_cache and opcache.file_cache_fallback directives for more convenient Opcache usage", err);
 } else {
err=ERROR_INVALID_ADDRESS;
zend_win_error_message(ACCEL_LOG_FATAL, "Base address marks unusable memory region. Please setup opcache.file_cache and opcache.file_cache_fallback directives for more convenient Opcache usage", err);
 }
returnALLOC_FAILURE;
 }

mapping_base=MapViewOfFileEx(memfile, FILE_MAP_ALL_ACCESS|FILE_MAP_EXECUTE, 0, 0, 0, wanted_mapping_base);

if (mapping_base==NULL) {
err=GetLastError();
if (err==ERROR_INVALID_ADDRESS) {
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to reattach to base address", err);
returnALLOC_FAILURE;
 }
returnALLOC_FAIL_MAPPING;
 } else {
DWORDold;

if (!VirtualProtect(mapping_base, requested_size, PAGE_READWRITE, &old)) {
err=GetLastError();
zend_win_error_message(ACCEL_LOG_FATAL, "VirtualProtect() failed", err);
returnALLOC_FAIL_MAPPING;
 }
 }

smm_shared_globals= (zend_smm_shared_globals*) ((char*)mapping_base+ACCEL_BASE_POINTER_SIZE);

returnSUCCESSFULLY_REATTACHED;
}

staticintcreate_segments(size_trequested_size, zend_shared_segment***shared_segments_p, int*shared_segments_count, constchar**error_in)
{
interr=0, ret;
zend_shared_segment*shared_segment;
intmap_retries=0;
void*default_mapping_base_set[] = { 0, 0 };
/* TODO:
 improve fixed addresses on x64. It still makes no sense to do it as Windows addresses are virtual per se and can or should be randomized anyway
 through Address Space Layout Radomization (ASLR). We can still let the OS do its job and be sure that each process gets the same address if
 desired. Not done yet, @zend refused but did not remember the exact reason, pls add info here if one of you know why :)
 */
#if defined(_WIN64)
void*vista_mapping_base_set[] = { (void*) 0x0000100000000000, (void*) 0x0000200000000000, (void*) 0x0000300000000000, (void*) 0x0000700000000000, 0 };
DWORDsize_high= (requested_size >> 32), size_low= (requested_size&0xffffffff);
#else
void*vista_mapping_base_set[] = { (void*) 0x20000000, (void*) 0x21000000, (void*) 0x30000000, (void*) 0x31000000, (void*) 0x50000000, 0 };
DWORDsize_high=0, size_low=requested_size;
#endif
void**wanted_mapping_base=default_mapping_base_set;

zend_shared_alloc_lock_win32();
/* Mapping retries: When Apache2 restarts, the parent process startup routine
 can be called before the child process is killed. In this case, the mapping will fail
 and we have to sleep some time (until the child releases the mapping object) and retry.*/
do {
memfile=OpenFileMapping(FILE_MAP_READ|FILE_MAP_WRITE|FILE_MAP_EXECUTE, 0, create_name_with_username(ACCEL_FILEMAP_NAME));
if (memfile==NULL) {
err=GetLastError();
break;
 }

ret=zend_shared_alloc_reattach(requested_size, error_in);
if (ret==ALLOC_FAIL_MAPPING) {
err=GetLastError();
/* Mapping failed, wait for mapping object to get freed and retry */
CloseHandle(memfile);
memfile=NULL;
if (++map_retries >= MAX_MAP_RETRIES) {
break;
 }
zend_shared_alloc_unlock_win32();
Sleep(1000* (map_retries+1));
zend_shared_alloc_lock_win32();
 } else {
zend_shared_alloc_unlock_win32();
returnret;
 }
 } while (1);

if (map_retries==MAX_MAP_RETRIES) {
zend_shared_alloc_unlock_win32();
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to open file mapping", err);
*error_in="OpenFileMapping";
returnALLOC_FAILURE;
 }

/* creating segment here */
*shared_segments_count=1;
*shared_segments_p= (zend_shared_segment**) calloc(1, sizeof(zend_shared_segment)+sizeof(void*));
if (!*shared_segments_p) {
err=GetLastError();
zend_shared_alloc_unlock_win32();
zend_win_error_message(ACCEL_LOG_FATAL, "calloc() failed", err);
*error_in="calloc";
returnALLOC_FAILURE;
 }
shared_segment= (zend_shared_segment*)((char*)(*shared_segments_p) +sizeof(void*));
 (*shared_segments_p)[0] =shared_segment;

memfile=CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE | SEC_COMMIT, size_high, size_low,
create_name_with_username(ACCEL_FILEMAP_NAME));
if (memfile==NULL) {
err=GetLastError();
zend_shared_alloc_unlock_win32();
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to create file mapping", err);
*error_in="CreateFileMapping";
returnALLOC_FAILURE;
 }

/* Starting from Windows Vista, heap randomization occurs which might cause our mapping base to
 be taken (fail to map). So we try to map into one of the hard coded predefined addresses
 in high memory. */
if (!ZCG(accel_directives).mmap_base|| !*ZCG(accel_directives).mmap_base) {
wanted_mapping_base=vista_mapping_base_set;
 } else {
char*s=ZCG(accel_directives).mmap_base;

/* skip leading 0x, %p assumes hexdecimal format anyway */
if (*s=='0'&&*(s+1) =='x') {
s+=2;
 }
if (sscanf(s, "%p", &default_mapping_base_set[0]) !=1) {
zend_shared_alloc_unlock_win32();
zend_win_error_message(ACCEL_LOG_FATAL, "Bad mapping address specified in opcache.mmap_base", err);
returnALLOC_FAILURE;
 }
 }

do {
shared_segment->p=mapping_base=MapViewOfFileEx(memfile, FILE_MAP_ALL_ACCESS|FILE_MAP_EXECUTE, 0, 0, 0, *wanted_mapping_base);
if (*wanted_mapping_base==NULL) { /* Auto address (NULL) is the last option on the array */
break;
 }
wanted_mapping_base++;
 } while (!mapping_base);

if (mapping_base==NULL) {
err=GetLastError();
zend_shared_alloc_unlock_win32();
zend_win_error_message(ACCEL_LOG_FATAL, "Unable to create view for file mapping", err);
*error_in="MapViewOfFile";
returnALLOC_FAILURE;
 } else {
DWORDold;

if (!VirtualProtect(mapping_base, requested_size, PAGE_READWRITE, &old)) {
err=GetLastError();
zend_win_error_message(ACCEL_LOG_FATAL, "VirtualProtect() failed", err);
returnALLOC_FAILURE;
 }

 ((void**)mapping_base)[0] =mapping_base;
 ((void**)mapping_base)[1] = (void*)execute_ex;
 }

shared_segment->pos=ACCEL_BASE_POINTER_SIZE;
shared_segment->size=requested_size-ACCEL_BASE_POINTER_SIZE;

zend_shared_alloc_unlock_win32();

returnALLOC_SUCCESS;
}

staticintdetach_segment(zend_shared_segment*shared_segment)
{
zend_shared_alloc_lock_win32();
if (mapping_base) {
UnmapViewOfFile(mapping_base);
mapping_base=NULL;
 }
CloseHandle(memfile);
memfile=NULL;
zend_shared_alloc_unlock_win32();
CloseHandle(memory_mutex);
memory_mutex=NULL;
return0;
}

staticsize_tsegment_type_size(void)
{
returnsizeof(zend_shared_segment);
}

constzend_shared_memory_handlerszend_alloc_win32_handlers= {
create_segments,
detach_segment,
segment_type_size
};