JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mmap: Fix size restriction of maps due to using 32 bit size type

Browse Source 
Throughout mmap, size-related variables and parameters are still using
DWORD as type, which disallows mapping ranges > 4Gigs.  Fix this by
using SIZE_T throughout for those vars and parameters.
Also, drop unused off parameter from 1st variant of mmap_record::map_pages.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>
This commit is contained in:
Corinna Vinschen 2016-05-20 21:48:10 +02:00
parent 2e62d68ba5
commit 0aa738220b
2 changed files with 36 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
winsup/cygwin/fhandler.h
View File

@ -385,7 +385,7 @@ public:
virtual int munmap (HANDLE h, caddr_t addr, size_t len); virtual int munmap (HANDLE h, caddr_t addr, size_t len);
virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags); virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags);
virtual bool fixup_mmap_after_fork (HANDLE h, int prot, int flags, virtual bool fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, off_t offset, SIZE_T size,
void *address); void *address);
void *operator new (size_t, void *p) __attribute__ ((nothrow)) {return p;} void *operator new (size_t, void *p) __attribute__ ((nothrow)) {return p;}
@ -1028,7 +1028,7 @@ class fhandler_disk_file: public fhandler_base
int munmap (HANDLE h, caddr_t addr, size_t len); int munmap (HANDLE h, caddr_t addr, size_t len);
int msync (HANDLE h, caddr_t addr, size_t len, int flags); int msync (HANDLE h, caddr_t addr, size_t len, int flags);
bool fixup_mmap_after_fork (HANDLE h, int prot, int flags, bool fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, void *address); off_t offset, SIZE_T size, void *address);
int mkdir (mode_t mode); int mkdir (mode_t mode);
int rmdir (); int rmdir ();
DIR __reg2 *opendir (int fd); DIR __reg2 *opendir (int fd);
@ -1699,7 +1699,7 @@ class fhandler_dev_zero: public fhandler_base
virtual int munmap (HANDLE h, caddr_t addr, size_t len); virtual int munmap (HANDLE h, caddr_t addr, size_t len);
virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags); virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags);
virtual bool fixup_mmap_after_fork (HANDLE h, int prot, int flags, virtual bool fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, off_t offset, SIZE_T size,
void *address); void *address);
fhandler_dev_zero (void *) {} fhandler_dev_zero (void *) {}

65
winsup/cygwin/mmap.cc
View File

@ -272,7 +272,7 @@ class mmap_record
DWORD page_map[0]; DWORD page_map[0];
public: public:
mmap_record (int nfd, HANDLE h, DWORD of, int p, int f, off_t o, DWORD l, mmap_record (int nfd, HANDLE h, DWORD of, int p, int f, off_t o, SIZE_T l,
caddr_t b) : caddr_t b) :
mapping_hdl (h), mapping_hdl (h),
len (l), len (l),
@ -309,9 +309,9 @@ class mmap_record
void init_page_map (mmap_record &r); void init_page_map (mmap_record &r);
DWORD find_unused_pages (DWORD pages) const; SIZE_T find_unused_pages (SIZE_T pages) const;
bool match (caddr_t addr, SIZE_T len, caddr_t &m_addr, DWORD &m_len); bool match (caddr_t addr, SIZE_T len, caddr_t &m_addr, SIZE_T &m_len);
off_t map_pages (off_t off, SIZE_T len); off_t map_pages (SIZE_T len);
bool map_pages (caddr_t addr, SIZE_T len); bool map_pages (caddr_t addr, SIZE_T len);
bool unmap_pages (caddr_t addr, SIZE_T len); bool unmap_pages (caddr_t addr, SIZE_T len);
int access (caddr_t address); int access (caddr_t address);
@ -368,29 +368,29 @@ mmap_record::compatible_flags (int fl) const
return (get_flags () & MAP_COMPATMASK) == (fl & MAP_COMPATMASK); return (get_flags () & MAP_COMPATMASK) == (fl & MAP_COMPATMASK);
} }
DWORD SIZE_T
mmap_record::find_unused_pages (DWORD pages) const mmap_record::find_unused_pages (SIZE_T pages) const
{ {
DWORD mapped_pages = PAGE_CNT (get_len ()); SIZE_T mapped_pages = PAGE_CNT (get_len ());
DWORD start; SIZE_T start;
if (pages > mapped_pages) if (pages > mapped_pages)
return (DWORD)-1; return (SIZE_T) -1;
for (start = 0; start <= mapped_pages - pages; ++start) for (start = 0; start <= mapped_pages - pages; ++start)
if (!MAP_ISSET (start)) if (!MAP_ISSET (start))
{ {
DWORD cnt; SIZE_T cnt;
for (cnt = 0; cnt < pages; ++cnt) for (cnt = 0; cnt < pages; ++cnt)
if (MAP_ISSET (start + cnt)) if (MAP_ISSET (start + cnt))
break; break;
if (cnt >= pages) if (cnt >= pages)
return start; return start;
} }
return (DWORD)-1; return (SIZE_T) -1;
} }
bool bool
mmap_record::match (caddr_t addr, SIZE_T len, caddr_t &m_addr, DWORD &m_len) mmap_record::match (caddr_t addr, SIZE_T len, caddr_t &m_addr, SIZE_T &m_len)
{ {
caddr_t low = (addr >= get_address ()) ? addr : get_address (); caddr_t low = (addr >= get_address ()) ? addr : get_address ();
caddr_t high = get_address (); caddr_t high = get_address ();
@ -427,25 +427,26 @@ mmap_record::init_page_map (mmap_record &r)
} }
off_t off_t
mmap_record::map_pages (off_t off, SIZE_T len) mmap_record::map_pages (SIZE_T len)
{ {
/* Used ONLY if this mapping matches into the chunk of another already /* Used ONLY if this mapping matches into the chunk of another already
performed mapping in a special case of MAP_ANON|MAP_PRIVATE. performed mapping in a special case of MAP_ANON|MAP_PRIVATE.
Otherwise it's job is now done by init_page_map(). */ Otherwise it's job is now done by init_page_map(). */
DWORD old_prot; DWORD old_prot;
debug_printf ("map_pages (fd=%d, off=%Y, len=%lu)", get_fd (), off, len); debug_printf ("map_pages (fd=%d, len=%lu)", get_fd (), len);
len = PAGE_CNT (len); len = PAGE_CNT (len);
if ((off = find_unused_pages (len)) == (DWORD)-1) off_t off = find_unused_pages (len);
return 0L; if (off == (off_t) -1)
return (off_t) 0;
if (!noreserve () if (!noreserve ()
&& !VirtualProtect (get_address () + off * wincap.page_size (), && !VirtualProtect (get_address () + off * wincap.page_size (),
len * wincap.page_size (), gen_protect (), len * wincap.page_size (), gen_protect (),
&old_prot)) &old_prot))
{ {
__seterrno (); __seterrno ();
return (off_t)-1; return (off_t) -1;
} }
while (len-- > 0) while (len-- > 0)
@ -458,11 +459,11 @@ mmap_record::map_pages (caddr_t addr, SIZE_T len)
{ {
debug_printf ("map_pages (addr=%p, len=%lu)", addr, len); debug_printf ("map_pages (addr=%p, len=%lu)", addr, len);
DWORD old_prot; DWORD old_prot;
DWORD off = addr - get_address (); off_t off = addr - get_address ();
off /= wincap.page_size (); off /= wincap.page_size ();
len = PAGE_CNT (len); len = PAGE_CNT (len);
/* First check if the area is unused right now. */ /* First check if the area is unused right now. */
for (DWORD l = 0; l < len; ++l) for (SIZE_T l = 0; l < len; ++l)
if (MAP_ISSET (off + l)) if (MAP_ISSET (off + l))
{ {
set_errno (EINVAL); set_errno (EINVAL);
@ -485,7 +486,7 @@ bool
mmap_record::unmap_pages (caddr_t addr, SIZE_T len) mmap_record::unmap_pages (caddr_t addr, SIZE_T len)
{ {
DWORD old_prot; DWORD old_prot;
DWORD off = addr - get_address (); SIZE_T off = addr - get_address ();
if (noreserve () if (noreserve ()
&& !VirtualFree (get_address () + off, len, MEM_DECOMMIT)) && !VirtualFree (get_address () + off, len, MEM_DECOMMIT))
debug_printf ("VirtualFree in unmap_pages () failed, %E"); debug_printf ("VirtualFree in unmap_pages () failed, %E");
@ -510,7 +511,7 @@ mmap_record::access (caddr_t address)
{ {
if (address < get_address () || address >= get_address () + get_len ()) if (address < get_address () || address >= get_address () + get_len ())
return 0; return 0;
DWORD off = (address - get_address ()) / wincap.page_size (); SIZE_T off = (address - get_address ()) / wincap.page_size ();
return MAP_ISSET (off); return MAP_ISSET (off);
} }
@ -594,11 +595,11 @@ mmap_list::try_map (void *addr, size_t len, int flags, off_t off)
chunk of another already performed mapping. */ chunk of another already performed mapping. */
SIZE_T plen = PAGE_CNT (len); SIZE_T plen = PAGE_CNT (len);
LIST_FOREACH (rec, &recs, mr_next) LIST_FOREACH (rec, &recs, mr_next)
if (rec->find_unused_pages (plen) != (DWORD) -1) if (rec->find_unused_pages (plen) != (SIZE_T) -1)
break; break;
if (rec && rec->compatible_flags (flags)) if (rec && rec->compatible_flags (flags))
{ {
if ((off = rec->map_pages (off, len)) == (off_t) -1) if ((off = rec->map_pages (len)) == (off_t) -1)
return (caddr_t) MAP_FAILED; return (caddr_t) MAP_FAILED;
return (caddr_t) rec->get_address () + off; return (caddr_t) rec->get_address () + off;
} }
@ -609,7 +610,7 @@ mmap_list::try_map (void *addr, size_t len, int flags, off_t off)
unmapped part of an still active mapping. This can happen unmapped part of an still active mapping. This can happen
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; SIZE_T u_len;
LIST_FOREACH (rec, &recs, mr_next) LIST_FOREACH (rec, &recs, mr_next)
if (rec->match ((caddr_t) addr, len, u_addr, u_len)) if (rec->match ((caddr_t) addr, len, u_addr, u_len))
@ -686,7 +687,7 @@ is_mmapped_region (caddr_t start_addr, caddr_t end_address)
mmap_record *rec; mmap_record *rec;
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; SIZE_T u_len;
bool ret = false; bool ret = false;
LIST_FOREACH (rec, &map_list->recs, mr_next) LIST_FOREACH (rec, &map_list->recs, mr_next)
@ -738,7 +739,7 @@ mmap_is_attached_or_noreserve (void *addr, size_t len)
mmap_record *rec; mmap_record *rec;
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; SIZE_T u_len;
LIST_FOREACH (rec, &map_list->recs, mr_next) LIST_FOREACH (rec, &map_list->recs, mr_next)
{ {
@ -1268,7 +1269,7 @@ munmap (void *addr, size_t len)
{ {
mmap_record *rec, *next_rec; mmap_record *rec, *next_rec;
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; SIZE_T u_len;
LIST_FOREACH_SAFE (rec, &map_list->recs, mr_next, next_rec) LIST_FOREACH_SAFE (rec, &map_list->recs, mr_next, next_rec)
{ {
@ -1335,7 +1336,7 @@ msync (void *addr, size_t len, int flags)
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 = wincap.allocation_granularity (); for (SIZE_T i = wincap.allocation_granularity ();
i < len; i < len;
i += wincap.allocation_granularity ()) i += wincap.allocation_granularity ())
if (!rec->access ((caddr_t) addr + i)) if (!rec->access ((caddr_t) addr + i))
@ -1389,7 +1390,7 @@ mprotect (void *addr, size_t len, int prot)
{ {
mmap_record *rec; mmap_record *rec;
caddr_t u_addr; caddr_t u_addr;
DWORD u_len; SIZE_T u_len;
LIST_FOREACH (rec, &map_list->recs, mr_next) LIST_FOREACH (rec, &map_list->recs, mr_next)
{ {
@ -1674,7 +1675,7 @@ fhandler_base::msync (HANDLE h, caddr_t addr, size_t len, int flags)
bool bool
fhandler_base::fixup_mmap_after_fork (HANDLE h, int prot, int flags, fhandler_base::fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, off_t offset, SIZE_T size,
void *address) void *address)
{ {
set_errno (ENODEV); set_errno (ENODEV);
@ -1772,7 +1773,7 @@ fhandler_dev_zero::msync (HANDLE h, caddr_t addr, size_t len, int flags)
bool bool
fhandler_dev_zero::fixup_mmap_after_fork (HANDLE h, int prot, int flags, fhandler_dev_zero::fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, off_t offset, SIZE_T size,
void *address) void *address)
{ {
/* Re-create the map */ /* Re-create the map */
@ -1868,7 +1869,7 @@ fhandler_disk_file::msync (HANDLE h, caddr_t addr, size_t len, int flags)
bool bool
fhandler_disk_file::fixup_mmap_after_fork (HANDLE h, int prot, int flags, fhandler_disk_file::fixup_mmap_after_fork (HANDLE h, int prot, int flags,
off_t offset, DWORD size, off_t offset, SIZE_T size,
void *address) void *address)
{ {
/* Re-create the map */ /* Re-create the map */