(init_cheap): Ditto for declaration.
* fork.cc (fork_parent): Use user_heap element in cygheap.
* heap.h (inheap): Ditto.
* heap.cc (sbrk): Ditto.
(heap_init): Ditto. Reorganize to shrink heap chunk as required and record new
value in cygheap.
* dcrt0.cc (dll_crt0_1): More "move the cygthread init" games.
* shared.cc (open_shared): Rework memory protection to properly deal with
relocated shared segment.
(shared_info::heap_chunk_size): Rename element to 'heap_chunk'.
* shared_info.h (shared_info): Ditto for declaration.
* strace.cc (strace::hello): Report on heap chunk size from cygheap since it
may shrink.
+2002-10-22 Christopher Faylor <cgf@redhat.com>
+
+ * cygheap.cc (cygheap_fixup_in_child): Use user_heap element in
+ cygheap.
+ (init_cheap): Ditto for declaration.
+ * fork.cc (fork_parent): Use user_heap element in cygheap.
+ * heap.h (inheap): Ditto.
+ * heap.cc (sbrk): Ditto.
+ (heap_init): Ditto. Reorganize to shrink heap chunk as required and
+ record new value in cygheap.
+ * dcrt0.cc (dll_crt0_1): More "move the cygthread init" games.
+ * shared.cc (open_shared): Rework memory protection to properly deal
+ with relocated shared segment.
+ (shared_info::heap_chunk_size): Rename element to 'heap_chunk'.
+ * shared_info.h (shared_info): Ditto for declaration.
+ * strace.cc (strace::hello): Report on heap chunk size from cygheap
+ since it may shrink.
+
2002-10-20 Christopher Faylor <cgf@redhat.com>
Change _function() to function() throughout.
if (execed)
{
- cygheap->heapbase = NULL; /* We can allocate the heap anywhere */
+ cygheap->user_heap.base = NULL; /* We can allocate the heap anywhere */
/* Walk the allocated memory chain looking for orphaned memory from
previous execs */
for (_cmalloc_entry *rvc = cygheap->chain; rvc; rvc = rvc->prev)
};
#endif
+struct user_heap_info
+{
+ void *base;
+ void *ptr;
+ void *top;
+ unsigned chunk;
+};
+
struct init_cygheap
{
_cmalloc_entry *chain;
char *buckets[32];
- struct /* User heap stuff. */
- {
- void *heapbase;
- void *heapptr;
- void *heaptop;
- };
cygheap_root root;
cygheap_user user;
+ user_heap_info user_heap;
mode_t umask;
HANDLE shared_h;
HANDLE console_h;
{
case _PROC_FORK:
alloc_stack (fork_info);
- cygthread::init ();
cygheap_fixup_in_child (0);
- close_ppid_handle = !!child_proc_info->pppid_handle;
memory_init ();
+ cygthread::init ();
set_myself (mypid);
+ close_ppid_handle = !!child_proc_info->pppid_handle;
break;
case _PROC_SPAWN:
/* Have to delay closes until after cygheap is setup */
{
size = mb.RegionSize;
if (!(mb.State == MEM_RESERVE && mb.AllocationProtect == PAGE_NOACCESS &&
- (((void *) start < cygheap->heapbase || (void *) start > cygheap->heaptop) &&
- ((void *) start < (void *) cygheap || (void *) start > (void *) ((char *) cygheap + CYGHEAPSIZE)))))
+ (((void *) start < cygheap->user_heap.base
+ || (void *) start > cygheap->user_heap.top) &&
+ ((void *) start < (void *) cygheap
+ | (void *) start > (void *) ((char *) cygheap + CYGHEAPSIZE)))))
continue;
if (!VirtualFree ((void *) start, 0, MEM_RELEASE))
api_fatal ("couldn't release memory %p(%d) for '%s' alignment, %E\n",
rc = fork_copy (pi, "user/cygwin data",
user_data->data_start, user_data->data_end,
user_data->bss_start, user_data->bss_end,
- cygheap->heapbase, cygheap->heapptr,
+ cygheap->user_heap.base, cygheap->user_heap.ptr,
stack_here, ch.stackbottom,
dll_data_start, dll_data_end,
dll_bss_start, dll_bss_end, NULL);
#include "path.h"
#include "dtable.h"
#include "cygheap.h"
+#include "registry.h"
+#include "cygwin_version.h"
#define assert(x)
extern "C" size_t getpagesize ();
+#define MINHEAP_SIZE (4 * 1024 * 1024)
+
/* Initialize the heap at process start up. */
void
as our parent. If not, we don't care where it ends up. */
page_const = system_info.dwPageSize;
- if (cygheap->heapbase)
+ if (!cygheap->user_heap.base)
+ {
+ cygheap->user_heap.chunk = cygwin_shared->heap_chunk_size ();
+ while (cygheap->user_heap.chunk >= MINHEAP_SIZE)
+ {
+ /* Initialize page mask and default heap size. Preallocate a heap
+ * to assure contiguous memory. */
+ cygheap->user_heap.ptr = cygheap->user_heap.top =
+ cygheap->user_heap.base =
+ VirtualAlloc (NULL, cygheap->user_heap.chunk, MEM_RESERVE, PAGE_NOACCESS);
+ if (cygheap->user_heap.base)
+ break;
+ cygheap->user_heap.chunk -= 1 * 1024 * 1024;
+ }
+ if (cygheap->user_heap.base == NULL)
+ api_fatal ("unable to allocate heap, heap_chunk_size %d, %E",
+ cygheap->user_heap.chunk);
+ }
+ else
{
- DWORD chunk = cygwin_shared->heap_chunk_size (); /* allocation chunk */
+ DWORD chunk = cygheap->user_heap.chunk; /* allocation chunk */
/* total size commited in parent */
- DWORD allocsize = (char *) cygheap->heaptop - (char *) cygheap->heapbase;
+ DWORD allocsize = (char *) cygheap->user_heap.top -
+ (char *) cygheap->user_heap.base;
/* 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;
+MEMORY_BASIC_INFORMATION m;
+(void) VirtualQuery (cygheap->user_heap.base, &m, sizeof (m));
for (;;)
{
- p = (char *) VirtualAlloc (cygheap->heapbase, reserve_size,
+ p = (char *) VirtualAlloc (cygheap->user_heap.base, reserve_size,
MEM_RESERVE, PAGE_READWRITE);
if (p)
break;
break;
}
if (p == NULL)
- api_fatal ("1. unable to allocate heap %p, heap_chunk_size %d, pid %d, %E",
- cygheap->heapbase, cygwin_shared->heap_chunk_size (), myself->pid);
- if (p != cygheap->heapbase)
- api_fatal ("heap allocated but not at %p", cygheap->heapbase);
- if (!VirtualAlloc (cygheap->heapbase, allocsize, MEM_COMMIT, PAGE_READWRITE))
+{
+system_printf ("unable to allocate heap %p, chunk %u, reserve %u, alloc %u, %E",
+cygheap->user_heap.base, cygheap->user_heap.chunk,
+reserve_size, allocsize);
+system_printf ("base %p mem alloc base %p, state %p, size %d, %E",
+cygheap->user_heap.base, m.AllocationBase, m.State, m.RegionSize);
+error_start_init ("h:/gdbtest/gdb.exe < con > con"); try_to_debug ();
+ api_fatal ("unable to allocate heap %p, chunk %u, reserve %u, alloc %u, %E",
+ cygheap->user_heap.base, cygheap->user_heap.chunk,
+ reserve_size, allocsize);
+}
+ if (p != cygheap->user_heap.base)
+ api_fatal ("heap allocated but not at %p", cygheap->user_heap.base);
+ if (!VirtualAlloc (cygheap->user_heap.base, 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. */
- cygheap->heapptr = cygheap->heaptop = cygheap->heapbase =
- VirtualAlloc (NULL, cygwin_shared->heap_chunk_size (), MEM_RESERVE,
- PAGE_NOACCESS);
- if (cygheap->heapbase == NULL)
- api_fatal ("2. unable to allocate heap, heap_chunk_size %d, %E",
- cygwin_shared->heap_chunk_size ());
- }
- debug_printf ("heap base %p, heap top %p", cygheap->heapbase,
- cygheap->heaptop);
+ debug_printf ("heap base %p, heap top %p", cygheap->user_heap.base,
+ cygheap->user_heap.top);
page_const--;
malloc_init ();
}
unsigned commitbytes, newbrksize;
if (n == 0)
- return cygheap->heapptr; /* Just wanted to find current cygheap->heapptr address */
+ return cygheap->user_heap.ptr; /* Just wanted to find current cygheap->user_heap.ptr address */
- newbrk = (char *) cygheap->heapptr + n; /* Where new cygheap->heapptr will be */
+ newbrk = (char *) cygheap->user_heap.ptr + n; /* Where new cygheap->user_heap.ptr will be */
newtop = (char *) pround (newbrk); /* Actual top of allocated memory -
on page boundary */
- if (newtop == cygheap->heaptop)
+ if (newtop == cygheap->user_heap.top)
goto good;
if (n < 0)
{ /* Freeing memory */
- assert (newtop < cygheap->heaptop);
- n = (char *) cygheap->heaptop - newtop;
+ assert (newtop < cygheap->user_heap.top);
+ n = (char *) cygheap->user_heap.top - newtop;
if (VirtualFree (newtop, n, MEM_DECOMMIT)) /* Give it back to OS */
goto good; /* Didn't take */
else
goto err;
}
- assert (newtop > cygheap->heaptop);
+ assert (newtop > cygheap->user_heap.top);
/* 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 *) cygheap->heaptop);
- if (VirtualAlloc (cygheap->heaptop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)
+ commitbytes = pround (newtop - (char *) cygheap->user_heap.top);
+ if (VirtualAlloc (cygheap->user_heap.top, 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 cygwin_shared->heap_chunk_size () or the requested
amount. Then attempt to actually allocate it. */
- if ((newbrksize = cygwin_shared->heap_chunk_size ()) < commitbytes)
+ if ((newbrksize = cygheap->user_heap.chunk) < commitbytes)
newbrksize = commitbytes;
- if ((VirtualAlloc (cygheap->heaptop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) &&
- (VirtualAlloc (cygheap->heaptop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL))
+ if ((VirtualAlloc (cygheap->user_heap.top, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) &&
+ (VirtualAlloc (cygheap->user_heap.top, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL))
goto good;
err:
return (void *) -1;
good:
- void *oldbrk = cygheap->heapptr;
- cygheap->heapptr = newbrk;
- cygheap->heaptop = newtop;
+ void *oldbrk = cygheap->user_heap.ptr;
+ cygheap->user_heap.ptr = newbrk;
+ cygheap->user_heap.top = newtop;
return oldbrk;
}
void malloc_init ();
#define inheap(s) \
- (cygheap->heapptr && s && ((char *) (s) >= (char *) cygheap->heapbase) \
- && ((char *) (s) <= (char *) cygheap->heaptop))
+ (cygheap->user_heap.ptr && s \
+ && ((char *) (s) >= (char *) cygheap->user_heap.base) \
+ && ((char *) (s) <= (char *) cygheap->user_heap.top))
#define page_const (65535)
#define pround(n) (((size_t) (n) + page_const) & ~page_const)
+static char *offsets[] =
+{
+ (char *) cygwin_shared_address,
+ (char *) cygwin_shared_address
+ + pround (sizeof (shared_info)),
+ (char *) cygwin_shared_address
+ + pround (sizeof (shared_info))
+ + pround (sizeof (mount_info)),
+ (char *) cygwin_shared_address
+ + pround (sizeof (shared_info))
+ + pround (sizeof (mount_info))
+ + pround (sizeof (console_state)),
+ (char *) cygwin_shared_address
+ + pround (sizeof (shared_info))
+ + pround (sizeof (mount_info))
+ + pround (sizeof (console_state))
+ + pround (sizeof (_pinfo))
+};
+
void * __stdcall
open_shared (const char *name, int n, HANDLE &shared_h, DWORD size, shared_locations m)
{
void *shared;
- static char *offsets[] =
- {
- (char *) cygwin_shared_address,
- (char *) cygwin_shared_address
- + pround (sizeof (shared_info)),
- (char *) cygwin_shared_address
- + pround (sizeof (shared_info))
- + pround (sizeof (mount_info)),
- (char *) cygwin_shared_address
- + pround (sizeof (shared_info))
- + pround (sizeof (mount_info))
- + pround (sizeof (console_state)),
- (char *) cygwin_shared_address
- + pround (sizeof (shared_info))
- + pround (sizeof (mount_info))
- + pround (sizeof (console_state))
- + pround (sizeof (_pinfo))
- };
void *addr;
if (!wincap.needs_memory_protection ())
if (!shared)
api_fatal ("MapViewOfFileEx '%s'(%p), %E. Terminating.", name, shared_h);
- if (m == SH_CYGWIN_SHARED)
+ if (m == SH_CYGWIN_SHARED && wincap.needs_memory_protection ())
{
+ unsigned delta = (char *) shared - offsets[0];
+ offsets[0] = (char *) shared;
for (int i = SH_CYGWIN_SHARED + 1; i < SH_TOTAL_SIZE; i++)
{
- offsets[i] += (char *) shared - offsets[0];
- if (!VirtualAlloc (offsets[i], offsets[i + 1] - offsets[i],
- MEM_RESERVE, PAGE_NOACCESS))
+ unsigned size = offsets[i + 1] - offsets[i];
+ offsets[i] += delta;
+ if (!VirtualAlloc (offsets[i], size, MEM_RESERVE, PAGE_NOACCESS))
continue; /* oh well */
- offsets[0] = (char *) shared;
}
+ offsets[SH_TOTAL_SIZE] += delta;
#if 0
if (!child_proc_info && wincap.needs_memory_protection ())
debug_printf ("name %s, shared %p (wanted %p), h %p", name, shared, addr, shared_h);
- /* FIXME: I couldn't find anywhere in the documentation a note about
- whether the memory is initialized to zero. The code assumes it does
- and since this part seems to be working, we'll leave it as is. */
return shared;
}
unsigned
shared_info::heap_chunk_size ()
{
- if (!initial_heap_size)
+ if (!heap_chunk)
{
/* Fetch misc. registry entries. */
/* FIXME: We should not be restricted to a fixed size heap no matter
what the fixed size is. */
- initial_heap_size = reg.get_int ("heap_chunk_in_mb", 0);
- if (!initial_heap_size) {
+ heap_chunk = reg.get_int ("heap_chunk_in_mb", 0);
+ if (!heap_chunk) {
reg_key r1 (HKEY_LOCAL_MACHINE, KEY_READ, "SOFTWARE",
CYGWIN_INFO_CYGNUS_REGISTRY_NAME,
CYGWIN_INFO_CYGWIN_REGISTRY_NAME, NULL);
- initial_heap_size = reg.get_int ("heap_chunk_in_mb", 384);
+ heap_chunk = reg.get_int ("heap_chunk_in_mb", 384);
}
- if (initial_heap_size < 4)
- initial_heap_size = 4 * 1024 * 1024;
+ if (heap_chunk < 4)
+ heap_chunk = 4 * 1024 * 1024;
else
- initial_heap_size <<= 20;
- debug_printf ("fixed heap size is %u", initial_heap_size);
+ heap_chunk <<= 20;
+ debug_printf ("fixed heap size is %u", heap_chunk);
}
- return initial_heap_size;
+ return heap_chunk;
}
#define SHARED_INFO_CB 47112
-#define CURR_SHARED_MAGIC 0xd9e0bc22U
+#define CURR_SHARED_MAGIC 0x359218a2U
/* NOTE: Do not make gratuitous changes to the names or organization of the
below class. The layout is checksummed to determine compatibility between
DWORD version;
DWORD cb;
public:
- unsigned initial_heap_size;
+ unsigned heap_chunk;
DWORD sys_mount_table_counter;
tty_list tty;
#include <wingdi.h>
#include <winuser.h>
#include <ctype.h>
+#include <errno.h>
#include "pinfo.h"
#include "perprocess.h"
#include "cygwin_version.h"
#include "hires.h"
+#include "security.h"
#include "cygthread.h"
-#include "shared_info.h"
+#include "fhandler.h"
+#include "path.h"
+#include "dtable.h"
+#include "cygerrno.h"
+#include "cygheap.h"
#define PROTECT(x) x[sizeof (x)-1] = 0
#define CHECK(x) if (x[sizeof (x)-1] != 0) { small_printf ("array bound exceeded %d\n", __LINE__); ExitProcess (1); }
cygwin_version.api_major, cygwin_version.api_minor);
prntf (1, NULL, "DLL build: %s", cygwin_version.dll_build_date);
prntf (1, NULL, "OS version: Windows %s", wincap.osname ());
- prntf (1, NULL, "Heap size: %u", cygwin_shared->heap_chunk_size ());
+ prntf (1, NULL, "Heap size: %u", cygheap->user_heap.chunk);
prntf (1, NULL, "**********************************************");
}
}
OSDN Git Service
