From de05a524ca9636914d8c228551f27feb6b509c4d Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Sun, 9 Sep 2001 19:06:50 +0000 Subject: [PATCH] * cygheap.cc (cygheap_fixup_in_child): Clear cygheap->base so that heap is not forced to start at the same place in execed process. * heap.cc: Remove brk* macros for clarity throughout. * heap.h: Ditto. * shared.cc (shared_info::initialize): Move heap_chunk test into heap_chunk_size(). (heap_chunk_size): Check for chunk size here. Don't go to registry if heap_chunk_in_mb is already set. * smallprint.c (console_printf): Add Windows 95 concessions. --- winsup/cygwin/ChangeLog | 13 ++++++++ winsup/cygwin/cygheap.cc | 1 + winsup/cygwin/cygheap.h | 9 +++-- winsup/cygwin/heap.cc | 65 +++++++++++++++++++------------------ winsup/cygwin/heap.h | 7 ---- winsup/cygwin/shared.cc | 38 +++++++++++----------- winsup/cygwin/shared_info.h | 4 +-- winsup/cygwin/smallprint.c | 10 ++++-- 8 files changed, 82 insertions(+), 65 deletions(-) diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index b168c3d97..73085b0a9 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,3 +1,16 @@ +Sun Sep 9 15:02:44 2001 Christopher Faylor + + * cygheap.cc (cygheap_fixup_in_child): Clear cygheap->base so that heap + is not forced to start at the same place in execed process. + * heap.cc: Remove brk* macros for clarity throughout. + * heap.h: Ditto. + * shared.cc (shared_info::initialize): Move heap_chunk test into + heap_chunk_size(). + (heap_chunk_size): Check for chunk size here. Don't go to registry if + heap_chunk_in_mb is already set. + + * smallprint.c (console_printf): Add Windows 95 concessions. + Sun Sep 9 13:01:06 2001 Christopher Faylor * child_info.h (PROC_MAGIC): Bump magic number. diff --git a/winsup/cygwin/cygheap.cc b/winsup/cygwin/cygheap.cc index be52f0446..c6ea68419 100644 --- a/winsup/cygwin/cygheap.cc +++ b/winsup/cygwin/cygheap.cc @@ -132,6 +132,7 @@ cygheap_fixup_in_child (child_info *ci, bool execed) if (execed) { + cygheap->heapbase = 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) diff --git a/winsup/cygwin/cygheap.h b/winsup/cygwin/cygheap.h index 8d34e671a..c268ebaac 100644 --- a/winsup/cygwin/cygheap.h +++ b/winsup/cygwin/cygheap.h @@ -153,9 +153,12 @@ struct init_cygheap { _cmalloc_entry *chain; char *buckets[32]; - void *heapbase; - void *heapptr; - void *heaptop; + struct /* User heap stuff. */ + { + void *heapbase; + void *heapptr; + void *heaptop; + }; cygheap_root root; cygheap_user user; mode_t umask; diff --git a/winsup/cygwin/heap.cc b/winsup/cygwin/heap.cc index 6ee295817..1a3c2a8e9 100644 --- a/winsup/cygwin/heap.cc +++ b/winsup/cygwin/heap.cc @@ -36,11 +36,11 @@ heap_init () as our parent. If not, we don't care where it ends up. */ page_const = system_info.dwPageSize; - if (brkbase) + if (cygheap->heapbase) { - DWORD chunk = brkchunk; /* allocation chunk */ + DWORD chunk = cygwin_shared->heap_chunk_size (); /* allocation chunk */ /* total size commited in parent */ - DWORD allocsize = (char *) brktop - (char *) brkbase; + DWORD allocsize = (char *) cygheap->heaptop - (char *) cygheap->heapbase; /* round up by chunk size */ DWORD reserve_size = chunk * ((allocsize + (chunk - 1)) / chunk); @@ -48,7 +48,7 @@ heap_init () char *p; for (;;) { - p = (char *) VirtualAlloc (brkbase, reserve_size, + p = (char *) VirtualAlloc (cygheap->heapbase, reserve_size, MEM_RESERVE, PAGE_READWRITE); if (p) break; @@ -57,23 +57,26 @@ heap_init () } 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)) + 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)) 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) + 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", - brkchunk); + cygwin_shared->heap_chunk_size ()); } - debug_printf ("heap base %p, heap top %p", brkbase, brktop); + debug_printf ("heap base %p, heap top %p", cygheap->heapbase, + cygheap->heaptop); page_const--; malloc_init (); } @@ -90,43 +93,43 @@ _sbrk(int n) unsigned commitbytes, newbrksize; if (n == 0) - return brk; /* Just wanted to find current brk address */ + return cygheap->heapptr; /* Just wanted to find current cygheap->heapptr address */ - newbrk = (char *) brk + n; /* Where new brk will be */ - newtop = (char *) pround (newbrk); /* Actual top of allocated memory - - on page boundary */ + newbrk = (char *) cygheap->heapptr + n; /* Where new cygheap->heapptr will be */ + newtop = (char *) pround (newbrk); /* Actual top of allocated memory - + on page boundary */ - if (newtop == brktop) + if (newtop == cygheap->heaptop) goto good; if (n < 0) - { /* Freeing memory */ - assert(newtop < brktop); - n = (char *) brktop - newtop; + { /* Freeing memory */ + assert(newtop < cygheap->heaptop); + n = (char *) cygheap->heaptop - newtop; if (VirtualFree(newtop, n, MEM_DECOMMIT)) /* Give it back to OS */ - goto good; /* Didn't take */ + goto good; /* Didn't take */ else goto err; } - assert(newtop > brktop); + assert(newtop > cygheap->heaptop); /* 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) + commitbytes = pround (newtop - (char *) cygheap->heaptop); + if (VirtualAlloc(cygheap->heaptop, 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 + Reserve either the maximum of the standard cygwin_shared->heap_chunk_size () or the requested amount. Then attempt to actually allocate it. */ - if ((newbrksize = brkchunk) < commitbytes) + if ((newbrksize = cygwin_shared->heap_chunk_size ()) < commitbytes) newbrksize = commitbytes; - if ((VirtualAlloc(brktop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) && - (VirtualAlloc(brktop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)) + if ((VirtualAlloc(cygheap->heaptop, newbrksize, MEM_RESERVE, PAGE_NOACCESS) != NULL) && + (VirtualAlloc(cygheap->heaptop, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)) goto good; err: @@ -134,8 +137,8 @@ err: return (void *) -1; good: - void *oldbrk = brk; - brk = newbrk; - brktop = newtop; + void *oldbrk = cygheap->heapptr; + cygheap->heapptr = newbrk; + cygheap->heaptop = newtop; return oldbrk; } diff --git a/winsup/cygwin/heap.h b/winsup/cygwin/heap.h index fca9d9e5c..96046cbb9 100644 --- a/winsup/cygwin/heap.h +++ b/winsup/cygwin/heap.h @@ -15,10 +15,3 @@ void heap_init (); void malloc_init (); #define inheap(s) (brk && ((char *) (s) >= (char *) brkbase) && ((char *) (s) <= (char *) brktop)) - -#define brksize ((char *) cygheap->heaptop - (char *) cygheap->heapbase) -#define brk (cygheap->heapptr) -#define brkbase (cygheap->heapbase) -#define brktop (cygheap->heaptop) -#define brkchunk (cygwin_shared->heap_chunk_size ()) - diff --git a/winsup/cygwin/shared.cc b/winsup/cygwin/shared.cc index 2fe5b85a9..1a267ea4c 100644 --- a/winsup/cygwin/shared.cc +++ b/winsup/cygwin/shared.cc @@ -103,8 +103,6 @@ open_shared (const char *name, HANDLE &shared_h, DWORD size, void *addr) void shared_info::initialize () { - /* Ya, Win32 provides a way for a dll to watch when it's first loaded. - We may eventually want to use it but for now we have this. */ if (inited) { if (inited != SHAREDVER) @@ -120,23 +118,6 @@ shared_info::initialize () /* Initialize tty table. */ tty.init (); - - /* Fetch misc. registry entries. */ - - reg_key reg (KEY_READ, NULL); - - /* Note that reserving a huge amount of heap space does not result in - the use of swap since we are not committing it. */ - /* FIXME: We should not be restricted to a fixed size heap no matter - what the fixed size is. */ - - heap_chunk_in_mb = reg.get_int ("heap_chunk_in_mb", 256); - if (heap_chunk_in_mb < 4) - { - heap_chunk_in_mb = 4; - reg.set_int ("heap_chunk_in_mb", heap_chunk_in_mb); - } - inited = SHAREDVER; } @@ -198,6 +179,25 @@ shared_terminate () unsigned shared_info::heap_chunk_size () { + if (!heap_chunk_in_mb) + { + /* Fetch misc. registry entries. */ + + reg_key reg (KEY_READ, NULL); + + /* Note that reserving a huge amount of heap space does not result in + the use of swap since we are not committing it. */ + /* FIXME: We should not be restricted to a fixed size heap no matter + what the fixed size is. */ + + heap_chunk_in_mb = reg.get_int ("heap_chunk_in_mb", 256); + if (heap_chunk_in_mb < 4) + { + heap_chunk_in_mb = 4; + reg.set_int ("heap_chunk_in_mb", heap_chunk_in_mb); + } + } + return heap_chunk_in_mb << 20; } diff --git a/winsup/cygwin/shared_info.h b/winsup/cygwin/shared_info.h index 2a814afbb..cd252eb61 100644 --- a/winsup/cygwin/shared_info.h +++ b/winsup/cygwin/shared_info.h @@ -137,8 +137,8 @@ class shared_info tty_list tty; delqueue_list delqueue; - void initialize (void); - unsigned heap_chunk_size (void); + void initialize (); + unsigned heap_chunk_size (); }; extern shared_info *cygwin_shared; diff --git a/winsup/cygwin/smallprint.c b/winsup/cygwin/smallprint.c index 7e23d1a6d..02dfb42ea 100644 --- a/winsup/cygwin/smallprint.c +++ b/winsup/cygwin/smallprint.c @@ -212,11 +212,15 @@ console_printf (const char *fmt,...) va_list ap; DWORD done; int count; - extern SECURITY_ATTRIBUTES sec_none; if (!console_handle) - console_handle = CreateFileA ("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, - &sec_none, OPEN_EXISTING, 0, 0); + console_handle = CreateFileA ("CON", GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, 0, 0); + + if (console_handle == INVALID_HANDLE_VALUE) + console_handle = GetStdHandle (STD_ERROR_HANDLE); + va_start (ap, fmt); count = __small_vsprintf (buf, fmt, ap); va_end (ap); -- 2.43.5