drew
/
acadia-newlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* mmap.cc: Convert usage of dynamically growing cmalloced arrays to 

cmalloced linked lists throughout.
	(class mmap_record): Add LIST_ENTRY element.
	(mmap_record::match): New method, taking over match algorithm from
	list::search_record.
	(class mmap_list): Rename from class list.  Add LIST_ENTRY.  Convert
	recs to a LIST_HEAD.  Drop nrecs and maxrecs members.
	(mmap_list::get_record): Drop entirely.
	(mmap_list::free_recs): Drop entirely.
	(mmap_list::del_record): Take mmap_record to delete as parameter.
	(mmap_list::search_record): Convert to mmap_record::match.
	(class mmap_areas): Rename from class map.  Convert lists to LIST_HEAD.
	(mmap_areas::get_list): Drop entirely.
	(mmap_areas::del_list): Take mmap_list to delete as parameter.
	(mprotect): Fix indentation.
This commit is contained in:
Corinna Vinschen 2007-11-27 10:09:05 +00:00
parent 4694cc18c2
commit 230a3c86d1
2 changed files with 176 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,21 @@
2007-11-27 Corinna Vinschen <corinna@vinschen.de>
* mmap.cc: Convert usage of dynamically growing cmalloced arrays to
cmalloced linked lists throughout.
(class mmap_record): Add LIST_ENTRY element.
(mmap_record::match): New method, taking over match algorithm from
list::search_record.
(class mmap_list): Rename from class list. Add LIST_ENTRY. Convert
recs to a LIST_HEAD. Drop nrecs and maxrecs members.
(mmap_list::get_record): Drop entirely.
(mmap_list::free_recs): Drop entirely.
(mmap_list::del_record): Take mmap_record to delete as parameter.
(mmap_list::search_record): Convert to mmap_record::match.
(class mmap_areas): Rename from class map. Convert lists to LIST_HEAD.
(mmap_areas::get_list): Drop entirely.
(mmap_areas::del_list): Take mmap_list to delete as parameter.
(mprotect): Fix indentation.
2007-11-26 Christopher Faylor <me+cygwin@cgf.cx> 2007-11-26 Christopher Faylor <me+cygwin@cgf.cx>
Change many cygheap allocation routines to their *_abort analogs. Change many cygheap allocation routines to their *_abort analogs.

358
winsup/cygwin/mmap.cc
View File

@ -24,6 +24,7 @@ details. */
#include "pinfo.h" #include "pinfo.h"
#include "sys/cygwin.h" #include "sys/cygwin.h"
#include "ntdll.h" #include "ntdll.h"
#include <sys/queue.h>
/* __PROT_ATTACH indicates an anonymous mapping which is supposed to be /* __PROT_ATTACH indicates an anonymous mapping which is supposed to be
attached to a file mapping for pages beyond the file's EOF. The idea attached to a file mapping for pages beyond the file's EOF. The idea
@ -231,16 +232,20 @@ MapView (HANDLE h, void *addr, size_t len, DWORD openflags,
The class structure: The class structure:
One member of class map per process, global variable mmapped_areas. One member of class map per process, global variable mmapped_areas.
Contains a dynamic class list array. Each list entry represents all Contains a singly-linked list of type class mmap_list. Each mmap_list
mapping to a file, keyed by file descriptor and file name hash. entry represents all mapping to a file, keyed by file descriptor and
Each list entry contains a dynamic class mmap_record array. Each file name hash.
mmap_record represents exactly one mapping. For each mapping, there's Each list entry contains a singly-linked list of type class mmap_record.
Each mmap_record represents exactly one mapping. For each mapping, there's
an additional so called `page_map'. It's an array of bits, one bit an additional so called `page_map'. It's an array of bits, one bit
per mapped memory page. The bit is set if the page is accessible, per mapped memory page. The bit is set if the page is accessible,
unset otherwise. */ unset otherwise. */
class mmap_record class mmap_record
{ {
public:
LIST_ENTRY (mmap_record) mr_next;
private: private:
int fd; int fd;
HANDLE mapping_hdl; HANDLE mapping_hdl;
@ -294,6 +299,7 @@ class mmap_record
void free_page_map () { if (page_map) cfree (page_map); } void free_page_map () { if (page_map) cfree (page_map); }
DWORD find_unused_pages (DWORD pages) const; DWORD find_unused_pages (DWORD pages) const;
bool match (caddr_t addr, DWORD len, caddr_t &m_addr, DWORD &m_len);
_off64_t map_pages (_off64_t off, DWORD len); _off64_t map_pages (_off64_t off, DWORD len);
bool map_pages (caddr_t addr, DWORD len); bool map_pages (caddr_t addr, DWORD len);
bool unmap_pages (caddr_t addr, DWORD len); bool unmap_pages (caddr_t addr, DWORD len);
@ -309,45 +315,40 @@ class mmap_record
bool compatible_flags (int fl) const; bool compatible_flags (int fl) const;
}; };
class list class mmap_list
{ {
public:
LIST_ENTRY (mmap_list) ml_next;
LIST_HEAD (, mmap_record) recs;
private: private:
mmap_record *recs;
int nrecs, maxrecs;
int fd; int fd;
__ino64_t hash; __ino64_t hash;
public: public:
int get_fd () const { return fd; } int get_fd () const { return fd; }
__ino64_t get_hash () const { return hash; } __ino64_t get_hash () const { return hash; }
mmap_record *get_record (int i) { return i >= nrecs ? NULL : recs + i; }
bool anonymous () const { return fd == -1; } bool anonymous () const { return fd == -1; }
void set (int nfd, struct __stat64 *st); void set (int nfd, struct __stat64 *st);
mmap_record *add_record (mmap_record r); mmap_record *add_record (mmap_record r);
bool del_record (int i); bool del_record (mmap_record *rec);
void free_recs () { if (recs) cfree (recs); }
mmap_record *search_record (_off64_t off, DWORD len); mmap_record *search_record (_off64_t off, DWORD len);
long search_record (caddr_t addr, DWORD len, caddr_t &m_addr, DWORD &m_len,
long start);
caddr_t try_map (void *addr, size_t len, int flags, _off64_t off); caddr_t try_map (void *addr, size_t len, int flags, _off64_t off);
}; };
class map class mmap_areas
{ {
private:
list *lists;
unsigned nlists, maxlists;
public: public:
list *get_list (unsigned i) { return i >= nlists ? NULL : lists + i; } LIST_HEAD (, mmap_list) lists;
list *get_list_by_fd (int fd, struct __stat64 *st);
list *add_list (int fd, struct __stat64 *st); mmap_list *get_list_by_fd (int fd, struct __stat64 *st);
void del_list (unsigned i); mmap_list *add_list (int fd, struct __stat64 *st);
void del_list (mmap_list *ml);
}; };
/* This is the global map structure pointer. */ /* This is the global map structure pointer. */
static map mmapped_areas; static mmap_areas mmapped_areas;
bool bool
mmap_record::compatible_flags (int fl) const mmap_record::compatible_flags (int fl) const
@ -377,6 +378,25 @@ mmap_record::find_unused_pages (DWORD pages) const
return (DWORD)-1; return (DWORD)-1;
} }
bool
mmap_record::match (caddr_t addr, DWORD len, caddr_t &m_addr, DWORD &m_len)
{
caddr_t low = (addr >= get_address ()) ? addr : get_address ();
caddr_t high = get_address ();
if (filler ())
high += get_len ();
else
high += (PAGE_CNT (get_len ()) * getsystempagesize ());
high = (addr + len < high) ? addr + len : high;
if (low < high)
{
m_addr = low;
m_len = high - low;
return true;
}
return false;
}
bool bool
mmap_record::alloc_page_map () mmap_record::alloc_page_map ()
{ {
@ -517,79 +537,48 @@ mmap_record::free_fh (fhandler_base *fh)
} }
mmap_record * mmap_record *
list::add_record (mmap_record r) mmap_list::add_record (mmap_record r)
{ {
if (nrecs == maxrecs) mmap_record *rec = (mmap_record *) cmalloc (HEAP_MMAP, sizeof (mmap_record));
{ if (!rec)
mmap_record *new_recs;
if (maxrecs == 0)
new_recs = (mmap_record *)
cmalloc (HEAP_MMAP, 5 * sizeof (mmap_record));
else
new_recs = (mmap_record *)
crealloc (recs, (maxrecs + 5) * sizeof (mmap_record));
if (!new_recs)
return NULL;
maxrecs += 5;
recs = new_recs;
}
recs[nrecs] = r;
if (!recs[nrecs].alloc_page_map ())
return NULL; return NULL;
return recs + nrecs++; *rec = r;
if (!rec->alloc_page_map ())
{
cfree (rec);
return NULL;
}
LIST_INSERT_HEAD (&recs, rec, mr_next);
return rec;
} }
/* Used in mmap() */ /* Used in mmap() */
mmap_record * mmap_record *
list::search_record (_off64_t off, DWORD len) mmap_list::search_record (_off64_t off, DWORD len)
{ {
mmap_record *rec;
if (anonymous () && !off) if (anonymous () && !off)
{ {
len = PAGE_CNT (len); len = PAGE_CNT (len);
for (int i = 0; i < nrecs; ++i) LIST_FOREACH (rec, &recs, mr_next)
if (recs[i].find_unused_pages (len) != (DWORD)-1) if (rec->find_unused_pages (len) != (DWORD)-1)
return recs + i; return rec;
} }
else else
{ {
for (int i = 0; i < nrecs; ++i) LIST_FOREACH (rec, &recs, mr_next)
if (off >= recs[i].get_offset () if (off >= rec->get_offset ()
&& off + len && off + len
<= recs[i].get_offset () <= rec->get_offset ()
+ (PAGE_CNT (recs[i].get_len ()) * getsystempagesize ())) + (PAGE_CNT (rec->get_len ()) * getsystempagesize ()))
return recs + i; return rec;
} }
return NULL; return NULL;
} }
/* Used in munmap() */
long
list::search_record (caddr_t addr, DWORD len, caddr_t &m_addr, DWORD &m_len,
long start)
{
caddr_t low, high;
for (long i = start + 1; i < nrecs; ++i)
{
low = (addr >= recs[i].get_address ()) ? addr : recs[i].get_address ();
high = recs[i].get_address ();
if (recs[i].filler ())
high += recs[i].get_len ();
else
high += (PAGE_CNT (recs[i].get_len ()) * getsystempagesize ());
high = (addr + len < high) ? addr + len : high;
if (low < high)
{
m_addr = low;
m_len = high - low;
return i;
}
}
return -1;
}
void void
list::set (int nfd, struct __stat64 *st) mmap_list::set (int nfd, struct __stat64 *st)
{ {
fd = nfd; fd = nfd;
if (!anonymous ()) if (!anonymous ())
@ -599,27 +588,22 @@ list::set (int nfd, struct __stat64 *st)
the file. */ the file. */
hash = st ? st->st_ino : (__ino64_t) 0; hash = st ? st->st_ino : (__ino64_t) 0;
} }
nrecs = maxrecs = 0; LIST_INIT (&recs);
recs = NULL;
} }
bool bool
list::del_record (int i) mmap_list::del_record (mmap_record *rec)
{ {
if (i < nrecs) rec->free_page_map ();
{ LIST_REMOVE (rec, mr_next);
recs[i].free_page_map (); cfree (rec);
for (; i < nrecs - 1; i++)
recs[i] = recs[i + 1];
nrecs--;
}
/* Return true if the list is empty which allows the caller to remove /* Return true if the list is empty which allows the caller to remove
this list from the list array. */ this list from the list of lists. */
return !nrecs; return !LIST_FIRST(&recs);
} }
caddr_t caddr_t
list::try_map (void *addr, size_t len, int flags, _off64_t off) mmap_list::try_map (void *addr, size_t len, int flags, _off64_t off)
{ {
mmap_record *rec; mmap_record *rec;
@ -642,11 +626,12 @@ list::try_map (void *addr, size_t len, int flags, _off64_t off)
if a memory region is unmapped and remapped with MAP_FIXED. */ if a memory region is unmapped and remapped with MAP_FIXED. */
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; DWORD u_len;
long record_idx = -1;
if ((record_idx = search_record ((caddr_t) addr, len, u_addr, u_len, LIST_FOREACH (rec, &recs, mr_next)
record_idx)) >= 0) if (rec->match ((caddr_t) addr, len, u_addr, u_len))
break;
if (rec)
{ {
rec = get_record (record_idx);
if (u_addr > (caddr_t) addr || u_addr + len < (caddr_t) addr + len if (u_addr > (caddr_t) addr || u_addr + len < (caddr_t) addr + len
|| !rec->compatible_flags (flags)) || !rec->compatible_flags (flags))
{ {
@ -664,52 +649,39 @@ list::try_map (void *addr, size_t len, int flags, _off64_t off)
return NULL; return NULL;
} }
list * mmap_list *
map::get_list_by_fd (int fd, struct __stat64 *st) mmap_areas::get_list_by_fd (int fd, struct __stat64 *st)
{ {
unsigned i; mmap_list *ml;
for (i = 0; i < nlists; i++) LIST_FOREACH (ml, &lists, ml_next)
{ {
if (fd == -1 && lists[i].anonymous ()) if (fd == -1 && ml->anonymous ())
return lists + i; return ml;
/* The fd isn't sufficient since it could already be the fd of another /* The fd isn't sufficient since it could already be the fd of another
file. So we use the inode number as evaluated by fstat to identify file. So we use the inode number as evaluated by fstat to identify
the file. */ the file. */
if (fd != -1 && st && lists[i].get_hash () == st->st_ino) if (fd != -1 && st && ml->get_hash () == st->st_ino)
return lists + i; return ml;
} }
return 0; return 0;
} }
list * mmap_list *
map::add_list (int fd, struct __stat64 *st) mmap_areas::add_list (int fd, struct __stat64 *st)
{ {
if (nlists == maxlists) mmap_list *ml = (mmap_list *) cmalloc (HEAP_MMAP, sizeof (mmap_list));
{ if (!ml)
list *new_lists; return NULL;
if (maxlists == 0) ml->set (fd, st);
new_lists = (list *) cmalloc (HEAP_MMAP, 5 * sizeof (list)); LIST_INSERT_HEAD (&lists, ml, ml_next);
else return ml;
new_lists = (list *) crealloc (lists, (maxlists + 5) * sizeof (list));
if (!new_lists)
return NULL;
maxlists += 5;
lists = new_lists;
}
lists[nlists].set (fd, st);
return lists + nlists++;
} }
void void
map::del_list (unsigned i) mmap_areas::del_list (mmap_list *ml)
{ {
if (i < nlists) LIST_REMOVE (ml, ml_next);
{ cfree (ml);
lists[i].free_recs ();
for (; i < nlists - 1; i++)
lists[i] = lists[i + 1];
nlists--;
}
} }
/* This function is called from exception_handler when a segmentation /* This function is called from exception_handler when a segmentation
@ -733,7 +705,7 @@ map::del_list (unsigned i)
mmap_region_status mmap_region_status
mmap_is_attached_or_noreserve (void *addr, size_t len) mmap_is_attached_or_noreserve (void *addr, size_t len)
{ {
list *map_list = mmapped_areas.get_list_by_fd (-1, NULL); mmap_list *map_list = mmapped_areas.get_list_by_fd (-1, NULL);
size_t pagesize = getpagesize (); size_t pagesize = getpagesize ();
caddr_t start_addr = (caddr_t) rounddown ((uintptr_t) addr, pagesize); caddr_t start_addr = (caddr_t) rounddown ((uintptr_t) addr, pagesize);
@ -743,16 +715,14 @@ mmap_is_attached_or_noreserve (void *addr, size_t len)
if (map_list == NULL) if (map_list == NULL)
return MMAP_NONE; return MMAP_NONE;
while (len > 0) mmap_record *rec;
{ caddr_t u_addr;
caddr_t u_addr; DWORD u_len;
DWORD u_len;
long record_idx = map_list->search_record (start_addr, len,
u_addr, u_len, -1);
if (record_idx < 0)
return MMAP_NONE;
mmap_record *rec = map_list->get_record (record_idx); LIST_FOREACH (rec, &map_list->recs, mr_next)
{
if (!rec->match (start_addr, len, u_addr, u_len))
continue;
if (rec->attached ()) if (rec->attached ())
return MMAP_RAISE_SIGBUS; return MMAP_RAISE_SIGBUS;
if (!rec->noreserve ()) if (!rec->noreserve ())
@ -768,13 +738,14 @@ mmap_is_attached_or_noreserve (void *addr, size_t len)
start_addr += commit_len; start_addr += commit_len;
len -= commit_len; len -= commit_len;
if (!len)
return MMAP_NORESERVE_COMMITED;
} }
return MMAP_NONE;
return MMAP_NORESERVE_COMMITED;
} }
static caddr_t static caddr_t
mmap_worker (list *map_list, fhandler_base *fh, caddr_t base, size_t len, mmap_worker (mmap_list *map_list, fhandler_base *fh, caddr_t base, size_t len,
int prot, int flags, int fd, _off64_t off, struct __stat64 *st) int prot, int flags, int fd, _off64_t off, struct __stat64 *st)
{ {
HANDLE h = fh->mmap (&base, len, prot, flags, off); HANDLE h = fh->mmap (&base, len, prot, flags, off);
@ -807,7 +778,7 @@ mmap64 (void *addr, size_t len, int prot, int flags, int fd, _off64_t off)
fhandler_base *fh = NULL; fhandler_base *fh = NULL;
fhandler_disk_file *fh_disk_file = NULL; /* Used for reopening a disk file fhandler_disk_file *fh_disk_file = NULL; /* Used for reopening a disk file
when necessary. */ when necessary. */
list *map_list = NULL; mmap_list *map_list = NULL;
size_t orig_len = 0; size_t orig_len = 0;
caddr_t base = NULL; caddr_t base = NULL;
struct __stat64 st; struct __stat64 st;
@ -1113,19 +1084,17 @@ munmap (void *addr, size_t len)
/* Iterate through the map, unmap pages between addr and addr+len /* Iterate through the map, unmap pages between addr and addr+len
in all maps. */ in all maps. */
list *map_list; mmap_list *map_list, *next_map_list;
for (unsigned list_idx = 0; LIST_FOREACH_SAFE (map_list, &mmapped_areas.lists, ml_next, next_map_list)
(map_list = mmapped_areas.get_list (list_idx));
++list_idx)
{ {
long record_idx = -1; mmap_record *rec, *next_rec;
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; DWORD u_len;
while ((record_idx = map_list->search_record((caddr_t)addr, len, u_addr, LIST_FOREACH_SAFE (rec, &map_list->recs, mr_next, next_rec)
u_len, record_idx)) >= 0) {
{ if (!rec->match ((caddr_t) addr, len, u_addr, u_len))
mmap_record *rec = map_list->get_record (record_idx); continue;
if (rec->unmap_pages (u_addr, u_len)) if (rec->unmap_pages (u_addr, u_len))
{ {
/* The whole record has been unmapped, so we now actually /* The whole record has been unmapped, so we now actually
@ -1137,11 +1106,11 @@ munmap (void *addr, size_t len)
rec->free_fh (fh); rec->free_fh (fh);
/* ...and delete the record. */ /* ...and delete the record. */
if (map_list->del_record (record_idx--)) if (map_list->del_record (rec))
{ {
/* Yay, the last record has been removed from the list, /* Yay, the last record has been removed from the list,
we can remove the list now, too. */ we can remove the list now, too. */
mmapped_areas.del_list (list_idx--); mmapped_areas.del_list (map_list);
break; break;
} }
} }
@ -1159,7 +1128,7 @@ extern "C" int
msync (void *addr, size_t len, int flags) msync (void *addr, size_t len, int flags)
{ {
int ret = -1; int ret = -1;
list *map_list; mmap_list *map_list;
syscall_printf ("msync (addr: %p, len %u, flags %x)", addr, len, flags); syscall_printf ("msync (addr: %p, len %u, flags %x)", addr, len, flags);
@ -1178,26 +1147,22 @@ msync (void *addr, size_t len, int flags)
/* Iterate through the map, looking for the mmapped area. /* Iterate through the map, looking for the mmapped area.
Error if not found. */ Error if not found. */
for (unsigned list_idx = 0; LIST_FOREACH (map_list, &mmapped_areas.lists, ml_next)
(map_list = mmapped_areas.get_list (list_idx));
++list_idx)
{ {
mmap_record *rec; mmap_record *rec;
for (int record_idx = 0; LIST_FOREACH (rec, &map_list->recs, mr_next)
(rec = map_list->get_record (record_idx));
++record_idx)
{ {
if (rec->access ((caddr_t)addr)) if (rec->access ((caddr_t) addr))
{ {
/* Check whole area given by len. */ /* Check whole area given by len. */
for (DWORD i = getpagesize (); i < len; i += getpagesize ()) for (DWORD i = getpagesize (); i < len; i += getpagesize ())
if (!rec->access ((caddr_t)addr + i)) if (!rec->access ((caddr_t) addr + i))
{ {
set_errno (ENOMEM); set_errno (ENOMEM);
goto out; goto out;
} }
fhandler_base *fh = rec->alloc_fh (); fhandler_base *fh = rec->alloc_fh ();
ret = fh->msync (rec->get_handle (), (caddr_t)addr, len, flags); ret = fh->msync (rec->get_handle (), (caddr_t) addr, len, flags);
rec->free_fh (fh); rec->free_fh (fh);
goto out; goto out;
} }
@ -1238,40 +1203,37 @@ mprotect (void *addr, size_t len, int prot)
/* Iterate through the map, protect pages between addr and addr+len /* Iterate through the map, protect pages between addr and addr+len
in all maps. */ in all maps. */
list *map_list; mmap_list *map_list;
for (unsigned list_idx = 0; LIST_FOREACH (map_list, &mmapped_areas.lists, ml_next)
(map_list = mmapped_areas.get_list (list_idx)); {
++list_idx) mmap_record *rec;
{ caddr_t u_addr;
long record_idx = -1; DWORD u_len;
caddr_t u_addr;
DWORD u_len;
while ((record_idx = map_list->search_record((caddr_t)addr, len, LIST_FOREACH (rec, &map_list->recs, mr_next)
u_addr, u_len, {
record_idx)) >= 0) if (!rec->match ((caddr_t) addr, len, u_addr, u_len))
{ continue;
mmap_record *rec = map_list->get_record (record_idx); in_mapped = true;
in_mapped = true; if (rec->attached ())
if (rec->attached ()) continue;
continue; new_prot = gen_protect (prot, rec->get_flags ());
new_prot = gen_protect (prot, rec->get_flags ()); if (rec->noreserve ())
if (rec->noreserve ()) {
{ if (new_prot == PAGE_NOACCESS)
if (new_prot == PAGE_NOACCESS) ret = VirtualFree (u_addr, u_len, MEM_DECOMMIT);
ret = VirtualFree (u_addr, u_len, MEM_DECOMMIT); else
else ret = !!VirtualAlloc (u_addr, u_len, MEM_COMMIT, new_prot);
ret = !!VirtualAlloc (u_addr, u_len, MEM_COMMIT, new_prot); }
} else
else ret = VirtualProtect (u_addr, u_len, new_prot, &old_prot);
ret = VirtualProtect (u_addr, u_len, new_prot, &old_prot); if (!ret)
if (!ret) {
{ __seterrno ();
__seterrno (); break;
break; }
} }
} }
}
ReleaseResourceLock (LOCK_MMAP_LIST, WRITE_LOCK | READ_LOCK, "mprotect"); ReleaseResourceLock (LOCK_MMAP_LIST, WRITE_LOCK | READ_LOCK, "mprotect");
@ -1757,15 +1719,11 @@ int __stdcall
fixup_mmaps_after_fork (HANDLE parent) fixup_mmaps_after_fork (HANDLE parent)
{ {
/* Iterate through the map */ /* Iterate through the map */
list *map_list; mmap_list *map_list;
for (unsigned list_idx = 0; LIST_FOREACH (map_list, &mmapped_areas.lists, ml_next)
(map_list = mmapped_areas.get_list (list_idx));
++list_idx)
{ {
mmap_record *rec; mmap_record *rec;
for (int record_idx = 0; LIST_FOREACH (rec, &map_list->recs, mr_next)
(rec = map_list->get_record (record_idx));
++record_idx)
{ {
debug_printf ("fd %d, h 0x%x, address %p, len 0x%x, prot: 0x%x, " debug_printf ("fd %d, h 0x%x, address %p, len 0x%x, prot: 0x%x, "
"flags: 0x%x, offset %X", "flags: 0x%x, offset %X",