static uintptr_t
get_rusage_data_via_iterator (void)
{
# if ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) || defined __BEOS__ || defined __HAIKU__
/* On native Windows, there is no sbrk() function.
On Haiku, sbrk(0) always returns 0. */
static void *brk_value;
if (brk_value == NULL)
{
brk_value = malloc (1);
if (brk_value == NULL)
return 0;
}
# else
void *brk_value;
brk_value = sbrk (0);
if (brk_value == (void *)-1)
return 0;
# endif
{
struct locals l;
l.brk_value = (uintptr_t) brk_value;
l.data_segment_size = 0;
vma_iterate (vma_iterate_callback, &l);
return l.data_segment_size;
}
}
static uintptr_t
get_rusage_as_via_iterator (void)
{
uintptr_t total = 0;
vma_iterate (vma_iterate_callback, &total);
return total;
}
int
main ()
{
vma_iterate (vma_iterate_callback, NULL);
/* Let the user interactively look at the /proc file system. */
sleep (10);
return 0;
}
SIZE_T WINAPI VirtualQuery(LPCVOID lpAddress,PMEMORY_BASIC_INFORMATION lpBuffer,SIZE_T dwLength)
{
#ifdef OS_UNIX_STRUCT
SIZE_T returnValue=0;
static BOOL HAVE_PAGE_SIZE = FALSE;
#if defined(USE_NEW_SBRK_ADDRESS_ALGO) && defined(OS_UNIX_STRUCT)
static void * LAST_END_ADDRESS = NULL;
if(LAST_END_ADDRESS == NULL)
{
LAST_END_ADDRESS = GET_VIRTUAL_END_ADDRESS();
}
#endif
if(HAVE_PAGE_SIZE == FALSE)
{
HAVE_PAGE_SIZE = MY_HAS_PAGE_SIZE();
if(HAVE_PAGE_SIZE==FALSE) {
returnValue=0;
return returnValue;
}
}
if(lpAddress==NULL&&lpBuffer==NULL||dwLength<=0)
{
returnValue=0;
return returnValue;
}
#if defined(OS_UNIX_STRUCT) && defined(USE_UNIX_IMAGE_EXTENSION_VQ)
BOOL is_imaged = (lpBuffer->Type==MEM_IMAGE)?(TRUE):(FALSE);
#endif
unsigned char free_mem=(lpBuffer->State==MEM_FREE&&lpBuffer->AllocationProtect==PAGE_WRITECOPY)?1:0;
memset((void*)lpBuffer,0,sizeof(MEMORY_BASIC_INFORMATION));
unsigned long long pagesize=MY_GET_SYSTEM_PAGE_SIZE();
vma_it_func zz;
int x=0;
int y=0;
int errno_ = 0;
void * address=NULL;
void * test_address=NULL;
unsigned long long nsize_ = MY_ROUND_UP_PAGE_SIZE((unsigned long long)dwLength);
unsigned long long psp = 0;
unsigned long long rpsp = 0;
address = (void*)MY_ROUND_DOWN_PAGE_SIZE((unsigned long long)lpAddress);
if(free_mem==1&&vma_last_resolve((unsigned long long)address,(unsigned long long)nsize_,&zz)==1)
{
goto VMA_RESOLVE_FUNC_LABEL;
}
void * testx_address = NULL;
BOOL reassign_address = FALSE;
#if defined(USE_NEW_SBRK_ADDRESS_ALGO) && defined(OS_UNIX_STRUCT)
testx_address=__VOID__POINTER__PROTECTOR((__SBRK__WRAPPER(0)));
if(LAST_END_ADDRESS!=NULL&&testx_address!=NULL)
{
if((((unsigned long long)(testx_address))+((unsigned long long)nsize_)<((unsigned long long)(LAST_END_ADDRESS)))
{
reassign_address=TRUE;
}
}
#endif
if(reassign_address==TRUE)
{
zz.complete_free_region=1;
} else {
x = msync(address, (size_t)(nsize_), 0);
errno_=errno;
if(x==-1&&errno_==ENOMEM)
{
zz.complete_free_region=1;
} else {
zz.complete_free_region=0;
}
}
if(zz.complete_free_region==0)
{
x = 0;
zz.start_address=(unsigned long long)lpAddress;
zz.end_address=(unsigned long long)lpAddress;
zz.base_start_address=0;
zz.base_end_address=0;
zz.ret=0;
#if defined(OS_UNIX_STRUCT) && defined(USE_UNIX_IMAGE_EXTENSION_VQ)
if(is_imaged==TRUE)
{
vma_iterate(((vma_iterate_callback_fn)&vma_iterate_image_func),(void*)&zz);
if(zz.ret!=2&&zz.ret!=1)
{
zz.ret=0;
} else {
zz.ret=1;
}
}
if(zz.ret==0)
{
#endif
vma_iterate(((vma_iterate_callback_fn)&vma_iterate_func),(void*)&zz);
if(zz.ret!=1)
{
zz.ret=0;
vma_iterate(((vma_iterate_callback_fn)&vma_iterate_full_addressing_func),(void*)&zz);
if(zz.ret!=0)
{
returnValue=0;
return returnValue;
}
x=1;
}
#if defined(OS_UNIX_STRUCT) && defined(USE_UNIX_IMAGE_EXTENSION_VQ)
}
#endif
if(x==1)
{
zz.start_address=(unsigned long long)address;
zz.end_address=(unsigned long long)(address+nsize_-1);
zz.size=(unsigned long long)dwLength;
zz.page_size=pagesize;
zz.page_alignment_size=nsize_;
zz.free_pages=0;
zz.free_pages_size=0;
zz.reserved_pages_size=nsize_;
zz.reserved_pages=(zz.reserved_pages_size/zz.page_size);
} else {
/*
test_address=(void*)zz.base_start_address;
for(rpsp = 0; rpsp < nsize_; rpsp+=pagesize)
{
x = msync(test_address, (size_t)(rpsp+pagesize), 0);
errno_=errno;
if(x==-1&&errno_=ENOMEM)
{
break;
} else {
continue;
}
}
test_address=(void*)(((unsigned long long)test_address)+rpsp);
for(psp = 0; psp < nsize_; psp+=pagesize)
{
x = msync(test_address, (size_t)(psp+pagesize), 0);
errno_=errno;
if(x=-1&&errno_=ENOMEM)
{
continue;
} else {
break;
}
}
}
int partwise_free=0;
if(rpsp==0)
{
partwise_free=1;
} else {
partwise_free=0;
}*/
if(zz.base_end_address<=zz.base_start_address)
{
returnValue=0;
return returnValue;
}
psp=(zz.base_end_address-zz.base_start_address);
psp=MY_ROUND_DOWN_PAGE_SIZE((unsigned long long)psp);
//vma_it_func zz;
zz.start_address=(unsigned long long)(zz.base_start_address);
zz.end_address=(unsigned long long)(zz.base_end_address-1);
zz.size=(unsigned long long)dwLength;
zz.page_size=pagesize;
zz.page_alignment_size=psp;
zz.free_pages=0;
zz.free_pages_size=0;
zz.reserved_pages_size=psp;
zz.reserved_pages=(zz.reserved_pages_size/zz.page_size);
}
} else {
zz.start_address=(unsigned long long)address;
zz.end_address=(unsigned long long)(address+nsize_-1);
zz.size=(unsigned long long)dwLength;
zz.page_alignment_size=nsize_;
VMA_RESOLVE_FUNC_LABEL: ;
zz.page_size=pagesize;
zz.free_pages=(zz.page_alignment_size/zz.page_size);
zz.free_pages_size=zz.page_alignment_size;
zz.reserved_pages_size=0;
zz.reserved_pages=0;
}
/*int y = vma_iterate((void*)&zz,&vma_iterate_func);
x = msync(address, (size_t)(nsize_), 0);
errno_=errno;
if(x==-1&&errno_=ENOMEM)
{
zz.complete_free_region=1;
} else {
zz.complete_free_region=0;
}
if(zz.complete_free_region==1)
{
lpBuffer->BaseAddress=zz.base_start_address;
lpBuffer->RegionSize=nsize_;
lpBuffer->State=MEM_FREE;
} else if(free_pages_size>0)
{
}*/
int flags=zz.base_flags;
int cflags=VMA_GET_PERMS(flags);
unsigned char is_found=0;
fpi_s * fp;
if(zz.complete_free_region==1)
{
lpBuffer->BaseAddress=(void*)zz.start_address;
lpBuffer->AllocationBase=(void*)zz.start_address;
lpBuffer->RegionSize=zz.page_alignment_size;
lpBuffer->State=MEM_FREE;
//FREE_REGION_MANAGE_EX((unsigned long long)lpBuffer->BaseAddress,(unsigned long long)lpBuffer->RegionSize,1,(FRM_SEARCH_ADDRESS|FRM_SEARCH_SIZE|FRM_SEARCH_REMOVE),&is_found,&fp);
//FREE_REGION_MANAGE_EX((unsigned long long)lpBuffer->BaseAddress,(unsigned long long)lpBuffer->RegionSize,3,(FRM_SEARCH_FREE|FRM_SEARCH_ADDRESS|FRM_SEARCH_REMOVE),&is_found,&fp);
//printf("fffcccc %d\n",is_found);
} else {
lpBuffer->BaseAddress=(void*)zz.start_address;
lpBuffer->AllocationBase=(void*)zz.base_start_address;
//int is_free=FREE_REGION_MANAGE_EX((unsigned long long)lpBuffer->BaseAddress,(unsigned long long)lpBuffer->RegionSize,3,(FRM_SEARCH_ADDRESS|FRM_SEARCH_SIZE),&is_found,&fp);
//if(is_found==1&&is_free==1)
//{
// lpBuffer->AllocationBase=(void*)zz.start_address;
// lpBuffer->State=MEM_FREE;
// return sizeof(MEMORY_BASIC_INFORMATION);
//}
if(VMA_PAGE_EXECUTE_READWRITE==cflags)
{
lpBuffer->AllocationProtect=PAGE_EXECUTE_READWRITE;
} else if(VMA_PAGE_EXECUTE_READ==cflags)
{
lpBuffer->AllocationProtect=PAGE_EXECUTE_READ;
} else if(VMA_PAGE_READWRITE==cflags)
{
lpBuffer->AllocationProtect=PAGE_READWRITE;
} else if(VMA_PAGE_READONLY==cflags)
{
lpBuffer->AllocationProtect=PAGE_READONLY;
} else if(cflags==VMA_PAGE_EXECUTE)
{
lpBuffer->AllocationProtect=PAGE_EXECUTE;
} else if(flags > 0) {
lpBuffer->AllocationProtect=PAGE_READWRITE;
} else {
lpBuffer->AllocationProtect=PAGE_NOACCESS;
}
lpBuffer->RegionSize=zz.page_alignment_size;
lpBuffer->State=(flags&VMA_PRIVATE)?MEM_RESERVE:MEM_COMMIT;
lpBuffer->Type=(flags&VMA_PRIVATE)?MEM_PRIVATE:MEM_MAPPED;
#if defined(OS_UNIX_STRUCT) && defined(USE_UNIX_IMAGE_EXTENSION_VQ)
if(is_imaged==TRUE)
{
int image_flags=0;
if(lpBuffer->AllocationProtect==PAGE_EXECUTE_READRITE)
image_flags = MY_PAGE_EXECUTE_READWRITE;
else if(lpBuffer->AllocationProtect==PAGE_EXECUTE_READ)
image_flags = MY_PAGE_EXECUTE_READ;
else if(lpBuffer->AllocationProtect==PAGE_READWRITE)
image_flags = MY_PAGE_READWRITE;
else if(lpBuffer->AllocationProtect==PAGE_EXECUTE)
image_flags = MY_PAGE_EXECUTE;
else if(lpBuffer->AllocationProtect==PAGE_READONLY)
image_flags = MY_PAGE_READONLY;
else if(lpBuffer->AllocationProtect==PAGE_NOACCESS)
image_flags = MY_PAGE_NOACCESS;
int image_ret = mprotect((void*)lpBuffer->AllocationBase,(size_t)lpBuffer->RegionSize,image_flags);
if(image_ret==-1)
{
returnValue=0;
return returnValue;
}
}
#endif
}
returnValue=(SIZE_T)sizeof(MEMORY_BASIC_INFORMATION);
return returnValue;
#endif
}
