1ff9f4b937
* include/sys/cygwin.h (perprocess): Remove heap pointers. * dcrt0.cc (__cygwin_user_data): Reflect obsolete perprocess stuff. (_dll_crt0): Don't initialize heap pointers. (cygwin_dll_init): Ditto. (release_upto): Use heap pointers from cygheap. * heap.h: Ditto. * fork.cc (fork_parent): Ditto. Don't set heap pointers in ch. (fork_child): Remove obsolete sigproc_fixup_after_fork. * shared.cc (memory_init): Reorganize so that cygheap initialization is called prior to regular heap since regular heap uses cygheap now. * sigproc.cc (proc_subproc): Eliminate zombies allocation. (sigproc_init): Move zombies alloation here. Don't free up array on fork, just reuse it. (sigproc_fixup_after_fork): Eliminate. * sigproc.h: Ditto. * include/cygwin/version.h: Reflect change to perprocess structure.
142 lines
3.8 KiB
C++
142 lines
3.8 KiB
C++
/* heap.cc: Cygwin heap manager.
|
|
|
|
Copyright 1996, 1997, 1998, 1999, 2000, 2001 Red Hat, Inc.
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include <errno.h>
|
|
#include "cygerrno.h"
|
|
#include "sync.h"
|
|
#include "sigproc.h"
|
|
#include "pinfo.h"
|
|
#include "heap.h"
|
|
#include "shared_info.h"
|
|
#include "security.h"
|
|
#include "fhandler.h"
|
|
#include "dtable.h"
|
|
#include "cygheap.h"
|
|
|
|
#define assert(x)
|
|
|
|
static unsigned page_const;
|
|
|
|
extern "C" size_t getpagesize ();
|
|
|
|
/* Initialize the heap at process start up. */
|
|
|
|
void
|
|
heap_init ()
|
|
{
|
|
/* If we're the forkee, we must allocate the heap at exactly the same place
|
|
as our parent. If not, we don't care where it ends up. */
|
|
|
|
page_const = system_info.dwPageSize;
|
|
if (brkbase)
|
|
{
|
|
DWORD chunk = brkchunk; /* allocation chunk */
|
|
/* total size commited in parent */
|
|
DWORD allocsize = (char *) brktop - (char *) brkbase;
|
|
/* round up by chunk size */
|
|
DWORD reserve_size = chunk * ((allocsize + (chunk - 1)) / chunk);
|
|
|
|
/* Loop until we've managed to reserve an adequate amount of memory. */
|
|
char *p;
|
|
for (;;)
|
|
{
|
|
p = (char *) VirtualAlloc (brkbase, reserve_size,
|
|
MEM_RESERVE, PAGE_READWRITE);
|
|
if (p)
|
|
break;
|
|
if ((reserve_size -= page_const) <= allocsize)
|
|
break;
|
|
}
|
|
if (p == NULL)
|
|
api_fatal ("1. unable to allocate heap %p, heap_chunk_size %d, pid %d, %E",
|
|
brkbase, brkchunk, myself->pid);
|
|
if (p != brkbase)
|
|
api_fatal ("heap allocated but not at %p", brkbase);
|
|
if (! VirtualAlloc (brkbase, allocsize, MEM_COMMIT, PAGE_READWRITE))
|
|
api_fatal ("MEM_COMMIT failed, %E");
|
|
}
|
|
else
|
|
{
|
|
/* Initialize page mask and default heap size. Preallocate a heap
|
|
* to assure contiguous memory. */
|
|
brk = brktop = brkbase = VirtualAlloc(NULL, brkchunk, MEM_RESERVE, PAGE_NOACCESS);
|
|
if (brkbase == NULL)
|
|
api_fatal ("2. unable to allocate heap, heap_chunk_size %d, %E",
|
|
brkchunk);
|
|
}
|
|
|
|
debug_printf ("heap base %p, heap top %p", brkbase, brktop);
|
|
page_const--;
|
|
malloc_init ();
|
|
}
|
|
|
|
#define pround(n) (((size_t)(n) + page_const) & ~page_const)
|
|
|
|
/* FIXME: This function no longer handles "split heaps". */
|
|
|
|
extern "C" void *
|
|
_sbrk(int n)
|
|
{
|
|
sigframe thisframe (mainthread);
|
|
char *newtop, *newbrk;
|
|
unsigned commitbytes, newbrksize;
|
|
|
|
if (n == 0)
|
|
return brk; /* Just wanted to find current brk address */
|
|
|
|
newbrk = (char *) brk + n; /* Where new brk will be */
|
|
newtop = (char *) pround (newbrk); /* Actual top of allocated memory -
|
|
on page boundary */
|
|
|
|
if (newtop == brktop)
|
|
goto good;
|
|
|
|
if (n < 0)
|
|
{ /* Freeing memory */
|
|
assert(newtop < brktop);
|
|
n = (char *) brktop - newtop;
|
|
if (VirtualFree(newtop, n, MEM_DECOMMIT)) /* Give it back to OS */
|
|
goto good; /* Didn't take */
|
|
else
|
|
goto err;
|
|
}
|
|
|
|
assert(newtop > brktop);
|
|
|
|
/* Need to grab more pages from the OS. If this fails it may be because
|
|
* we have used up previously reserved memory. Or, we're just plumb out
|
|
* of memory. */
|
|
commitbytes = pround (newtop - (char *) brktop);
|
|
if (VirtualAlloc(brktop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)
|
|
goto good;
|
|
|
|
/* Couldn't allocate memory. Maybe we can reserve some more.
|
|
Reserve either the maximum of the standard brkchunk or the requested
|
|
amount. Then attempt to actually allocate it. */
|
|
|
|
if ((newbrksize = brkchunk) < commitbytes)
|
|
newbrksize = commitbytes;
|
|
|
|
if ((VirtualAlloc(brktop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) &&
|
|
(VirtualAlloc(brktop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL))
|
|
goto good;
|
|
|
|
err:
|
|
set_errno (ENOMEM);
|
|
return (void *) -1;
|
|
|
|
good:
|
|
void *oldbrk = brk;
|
|
brk = newbrk;
|
|
brktop = newtop;
|
|
return oldbrk;
|
|
}
|