libs/newlib-cygwin
libs/newlib-cygwin
4
0
Fork 0
mirror of git://sourceware.org/git/newlib-cygwin.git synced 2025-02-20 16:01:10 +08:00
Code Issues Projects Releases Wiki Activity

* cygheap.cc (cygheap_fixup_in_child): Clear cygheap->base so that heap is not

Browse Source 
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.
This commit is contained in:
Christopher Faylor 2001-09-09 19:06:50 +00:00
parent c386775867
commit de05a524ca
8 changed files with 82 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,16 @@
Sun Sep 9 15:02:44 2001 Christopher Faylor <cgf@cygnus.com>
* 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 <cgf@cygnus.com>
* child_info.h (PROC_MAGIC): Bump magic number.

1
winsup/cygwin/cygheap.cc
View File

@ -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)

9
winsup/cygwin/cygheap.h
View File

@ -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;

65
winsup/cygwin/heap.cc
View File

@ -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;
}

7
winsup/cygwin/heap.h
View File

@ -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 ())

38
winsup/cygwin/shared.cc
View File

@ -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;
}

4
winsup/cygwin/shared_info.h
View File

@ -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;

10
winsup/cygwin/smallprint.c
View File

@ -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);