configure cleanup [v2]

[qemu.git] / linux-user / mmap.c

diff --git a/linux-user/mmap.c b/linux-user/mmap.c
index 0c2fe8dc1a1daf3a20d4aa55bf2ba5a8c6d2ed4c..d459c61b290a224ab9a9ce6803ec24f1c6de9aae 100644 (file)
--- a/linux-user/mmap.c
+++ b/linux-user/mmap.c
@@ -1,6 +1,6 @@
 /*
  *  mmap support for qemu
 /*
  *  mmap support for qemu

- * 
+ *

  *  Copyright (c) 2003 Fabrice Bellard
  *
  *  This program is free software; you can redistribute it and/or modify
  *  Copyright (c) 2003 Fabrice Bellard
  *
  *  This program is free software; you can redistribute it and/or modify


@@ -29,14 +29,15 @@
 
 //#define DEBUG_MMAP
 
 
 //#define DEBUG_MMAP
 

-/* NOTE: all the constants are the HOST ones */
-int target_mprotect(unsigned long start, unsigned long len, int prot)
+/* NOTE: all the constants are the HOST ones, but addresses are target. */
+int target_mprotect(abi_ulong start, abi_ulong len, int prot)

 {
 {

-    unsigned long end, host_start, host_end, addr;
+    abi_ulong end, host_start, host_end, addr;

     int prot1, ret;
 
 #ifdef DEBUG_MMAP
     int prot1, ret;
 
 #ifdef DEBUG_MMAP

-    printf("mprotect: start=0x%lx len=0x%lx prot=%c%c%c\n", start, len,
+    printf("mprotect: start=0x" TARGET_FMT_lx
+           "len=0x" TARGET_FMT_lx " prot=%c%c%c\n", start, len,

            prot & PROT_READ ? 'r' : '-',
            prot & PROT_WRITE ? 'w' : '-',
            prot & PROT_EXEC ? 'x' : '-');
            prot & PROT_READ ? 'r' : '-',
            prot & PROT_WRITE ? 'w' : '-',
            prot & PROT_EXEC ? 'x' : '-');


@@ -52,8 +53,8 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
         return -EINVAL;
     if (len == 0)
         return 0;
         return -EINVAL;
     if (len == 0)
         return 0;

-    
-    host_start = start & host_page_mask;
+
+    host_start = start & qemu_host_page_mask;

     host_end = HOST_PAGE_ALIGN(end);
     if (start > host_start) {
         /* handle host page containing start */
     host_end = HOST_PAGE_ALIGN(end);
     if (start > host_start) {
         /* handle host page containing start */


@@ -61,32 +62,32 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
         for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
             prot1 |= page_get_flags(addr);
         }
         for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
             prot1 |= page_get_flags(addr);
         }

-        if (host_end == host_start + host_page_size) {
+        if (host_end == host_start + qemu_host_page_size) {

             for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
                 prot1 |= page_get_flags(addr);
             }
             end = host_end;
         }
             for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
                 prot1 |= page_get_flags(addr);
             }
             end = host_end;
         }

-        ret = mprotect((void *)host_start, host_page_size, prot1 & PAGE_BITS);
+        ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS);

         if (ret != 0)
             return ret;
         if (ret != 0)
             return ret;

-        host_start += host_page_size;
+        host_start += qemu_host_page_size;

     }
     if (end < host_end) {
         prot1 = prot;
         for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
             prot1 |= page_get_flags(addr);
         }
     }
     if (end < host_end) {
         prot1 = prot;
         for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
             prot1 |= page_get_flags(addr);
         }

-        ret = mprotect((void *)(host_end - host_page_size), host_page_size, 
+        ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size,

                        prot1 & PAGE_BITS);
         if (ret != 0)
             return ret;
                        prot1 & PAGE_BITS);
         if (ret != 0)
             return ret;

-        host_end -= host_page_size;
+        host_end -= qemu_host_page_size;

     }
     }

-    
+

     /* handle the pages in the middle */
     if (host_start < host_end) {
     /* handle the pages in the middle */
     if (host_start < host_end) {

-        ret = mprotect((void *)host_start, host_end - host_start, prot);
+        ret = mprotect(g2h(host_start), host_end - host_start, prot);

         if (ret != 0)
             return ret;
     }
         if (ret != 0)
             return ret;
     }


@@ -95,28 +96,31 @@ int target_mprotect(unsigned long start, unsigned long len, int prot)
 }
 
 /* map an incomplete host page */
 }
 
 /* map an incomplete host page */

-int mmap_frag(unsigned long host_start, 
-               unsigned long start, unsigned long end, 
-               int prot, int flags, int fd, unsigned long offset)
+static int mmap_frag(abi_ulong real_start,
+                     abi_ulong start, abi_ulong end,
+                     int prot, int flags, int fd, abi_ulong offset)

 {
 {

-    unsigned long host_end, ret, addr;
+    abi_ulong real_end, addr;
+    void *host_start;

     int prot1, prot_new;
 
     int prot1, prot_new;
 

-    host_end = host_start + host_page_size;
+    real_end = real_start + qemu_host_page_size;
+    host_start = g2h(real_start);

 
     /* get the protection of the target pages outside the mapping */
     prot1 = 0;
 
     /* get the protection of the target pages outside the mapping */
     prot1 = 0;

-    for(addr = host_start; addr < host_end; addr++) {
+    for(addr = real_start; addr < real_end; addr++) {

         if (addr < start || addr >= end)
             prot1 |= page_get_flags(addr);
     }
         if (addr < start || addr >= end)
             prot1 |= page_get_flags(addr);
     }

-    
+

     if (prot1 == 0) {
         /* no page was there, so we allocate one */
     if (prot1 == 0) {
         /* no page was there, so we allocate one */

-        ret = (long)mmap((void *)host_start, host_page_size, prot, 
-                         flags | MAP_ANONYMOUS, -1, 0);
-        if (ret == -1)
-            return ret;
+        void *p = mmap(host_start, qemu_host_page_size, prot,
+                       flags | MAP_ANONYMOUS, -1, 0);
+        if (p == MAP_FAILED)
+            return -1;
+        prot1 = prot;

     }
     prot1 &= PAGE_BITS;
 
     }
     prot1 &= PAGE_BITS;
 


@@ -130,33 +134,76 @@ int mmap_frag(unsigned long host_start,
 
         /* adjust protection to be able to read */
         if (!(prot1 & PROT_WRITE))
 
         /* adjust protection to be able to read */
         if (!(prot1 & PROT_WRITE))

-            mprotect((void *)host_start, host_page_size, prot1 | PROT_WRITE);
-        
+            mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);
+

         /* read the corresponding file data */
         /* read the corresponding file data */

-        pread(fd, (void *)start, end - start, offset);
-        
+        pread(fd, g2h(start), end - start, offset);
+

         /* put final protection */
         if (prot_new != (prot1 | PROT_WRITE))
         /* put final protection */
         if (prot_new != (prot1 | PROT_WRITE))

-            mprotect((void *)host_start, host_page_size, prot_new);
+            mprotect(host_start, qemu_host_page_size, prot_new);

     } else {
         /* just update the protection */
         if (prot_new != prot1) {
     } else {
         /* just update the protection */
         if (prot_new != prot1) {

-            mprotect((void *)host_start, host_page_size, prot_new);
+            mprotect(host_start, qemu_host_page_size, prot_new);

         }
     }
     return 0;
 }
 
         }
     }
     return 0;
 }
 

+#if defined(__CYGWIN__)
+/* Cygwin doesn't have a whole lot of address space.  */
+static abi_ulong mmap_next_start = 0x18000000;
+#else
+static abi_ulong mmap_next_start = 0x40000000;
+#endif
+
+/* find a free memory area of size 'size'. The search starts at
+   'start'. If 'start' == 0, then a default start address is used.
+   Return -1 if error.
+*/
+/* page_init() marks pages used by the host as reserved to be sure not
+   to use them. */
+static abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
+{
+    abi_ulong addr, addr1, addr_start;
+    int prot;
+
+    size = HOST_PAGE_ALIGN(size);
+    start = start & qemu_host_page_mask;
+    addr = start;
+    if (addr == 0)
+        addr = mmap_next_start;
+    addr_start = addr;
+    for(;;) {
+        prot = 0;
+        for(addr1 = addr; addr1 < (addr + size); addr1 += TARGET_PAGE_SIZE) {
+            prot |= page_get_flags(addr1);
+        }
+        if (prot == 0)
+            break;
+        addr += qemu_host_page_size;
+        /* we found nothing */
+        if (addr == addr_start)
+            return (abi_ulong)-1;
+    }
+    if (start == 0)
+        mmap_next_start = addr + size;
+    return addr;
+}
+

 /* NOTE: all the constants are the HOST ones */
 /* NOTE: all the constants are the HOST ones */

-long target_mmap(unsigned long start, unsigned long len, int prot, 
-                 int flags, int fd, unsigned long offset)
+abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
+                     int flags, int fd, abi_ulong offset)

 {
 {

-    unsigned long ret, end, host_start, host_end, retaddr, host_offset, host_len;
+    abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
+    unsigned long host_start;

 
 #ifdef DEBUG_MMAP
     {
 
 #ifdef DEBUG_MMAP
     {

-        printf("mmap: start=0x%lx len=0x%lx prot=%c%c%c flags=",
-               start, len, 
+        printf("mmap: start=0x" TARGET_FMT_lx
+               " len=0x" TARGET_FMT_lx " prot=%c%c%c flags=",
+               start, len,

                prot & PROT_READ ? 'r' : '-',
                prot & PROT_WRITE ? 'w' : '-',
                prot & PROT_EXEC ? 'x' : '-');
                prot & PROT_READ ? 'r' : '-',
                prot & PROT_WRITE ? 'w' : '-',
                prot & PROT_EXEC ? 'x' : '-');


@@ -175,137 +222,131 @@ long target_mmap(unsigned long start, unsigned long len, int prot,
             printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);
             break;
         }
             printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);
             break;
         }

-        printf("fd=%d offset=%lx\n", fd, offset);
+        printf("fd=%d offset=" TARGET_FMT_lx "\n", fd, offset);

     }
 #endif
 
     }
 #endif
 

-    if (offset & ~TARGET_PAGE_MASK)
-        return -EINVAL;
+    if (offset & ~TARGET_PAGE_MASK) {
+        errno = EINVAL;
+        return -1;
+    }

 
     len = TARGET_PAGE_ALIGN(len);
     if (len == 0)
         return start;
 
     len = TARGET_PAGE_ALIGN(len);
     if (len == 0)
         return start;

-    host_start = start & host_page_mask;
+    real_start = start & qemu_host_page_mask;

 
     if (!(flags & MAP_FIXED)) {
 
     if (!(flags & MAP_FIXED)) {

-#if defined(__alpha__) || defined(__sparc__)
-        /* tell the kenel to search at the same place as i386 */
-        if (host_start == 0)
-            host_start = 0x40000000;
-#endif
-        if (host_page_size != real_host_page_size) {
-            /* NOTE: this code is only for debugging with '-p' option */
-            /* reserve a memory area */
-            host_len = HOST_PAGE_ALIGN(len) + host_page_size - TARGET_PAGE_SIZE;
-            host_start = (long)mmap((void *)host_start, host_len, PROT_NONE, 
-                                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-            if (host_start == -1)
-                return host_start;
-            host_end = host_start + host_len;
-            start = HOST_PAGE_ALIGN(host_start);
-            end = start + HOST_PAGE_ALIGN(len);
-            if (start > host_start)
-                munmap((void *)host_start, start - host_start);
-            if (end < host_end)
-                munmap((void *)end, host_end - end);
-            /* use it as a fixed mapping */
-            flags |= MAP_FIXED;
-        } else {
-            /* if not fixed, no need to do anything */
-            host_offset = offset & host_page_mask;
-            host_len = len + offset - host_offset;
-            start = (long)mmap((void *)host_start, host_len, 
-                               prot, flags, fd, host_offset);
-            if (start == -1)
-                return start;
-            /* update start so that it points to the file position at 'offset' */
-            if (!(flags & MAP_ANONYMOUS)) 
-                start += offset - host_offset;
-            goto the_end1;
+        abi_ulong mmap_start;
+        void *p;
+        host_offset = offset & qemu_host_page_mask;
+        host_len = len + offset - host_offset;
+        host_len = HOST_PAGE_ALIGN(host_len);
+        mmap_start = mmap_find_vma(real_start, host_len);
+        if (mmap_start == (abi_ulong)-1) {
+            errno = ENOMEM;
+            return -1;

         }
         }

-    }
-    
-    if (start & ~TARGET_PAGE_MASK)
-        return -EINVAL;
-    end = start + len;
-    host_end = HOST_PAGE_ALIGN(end);
-
-    /* worst case: we cannot map the file because the offset is not
-       aligned, so we read it */
-    if (!(flags & MAP_ANONYMOUS) &&
-        (offset & ~host_page_mask) != (start & ~host_page_mask)) {
-        /* msync() won't work here, so we return an error if write is
-           possible while it is a shared mapping */
-        if ((flags & MAP_TYPE) == MAP_SHARED &&
-            (prot & PROT_WRITE))
-            return -EINVAL;
-        retaddr = target_mmap(start, len, prot | PROT_WRITE, 
-                              MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, 
-                              -1, 0);
-        if (retaddr == -1)
-            return retaddr;
-        pread(fd, (void *)start, len, offset);
-        if (!(prot & PROT_WRITE)) {
-            ret = target_mprotect(start, len, prot);
-            if (ret != 0)
-                return ret;
+        /* Note: we prefer to control the mapping address. It is
+           especially important if qemu_host_page_size >
+           qemu_real_host_page_size */
+        p = mmap(g2h(mmap_start),
+                 host_len, prot, flags | MAP_FIXED, fd, host_offset);
+        if (p == MAP_FAILED)
+            return -1;
+        /* update start so that it points to the file position at 'offset' */
+        host_start = (unsigned long)p;
+        if (!(flags & MAP_ANONYMOUS))
+            host_start += offset - host_offset;
+        start = h2g(host_start);
+    } else {
+        if (start & ~TARGET_PAGE_MASK) {
+            errno = EINVAL;
+            return -1;

         }
         }

-        goto the_end;
-    }
-
-    /* handle the start of the mapping */
-    if (start > host_start) {
-        if (host_end == host_start + host_page_size) {
-            /* one single host page */
-            ret = mmap_frag(host_start, start, end,
+        end = start + len;
+        real_end = HOST_PAGE_ALIGN(end);
+        
+        /* worst case: we cannot map the file because the offset is not
+           aligned, so we read it */
+        if (!(flags & MAP_ANONYMOUS) &&
+            (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {
+            /* msync() won't work here, so we return an error if write is
+               possible while it is a shared mapping */
+            if ((flags & MAP_TYPE) == MAP_SHARED &&
+                (prot & PROT_WRITE)) {
+                errno = EINVAL;
+                return -1;
+            }
+            retaddr = target_mmap(start, len, prot | PROT_WRITE,
+                                  MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
+                                  -1, 0);
+            if (retaddr == -1)
+                return -1;
+            pread(fd, g2h(start), len, offset);
+            if (!(prot & PROT_WRITE)) {
+                ret = target_mprotect(start, len, prot);
+                if (ret != 0)
+                    return ret;
+            }
+            goto the_end;
+        }
+        
+        /* handle the start of the mapping */
+        if (start > real_start) {
+            if (real_end == real_start + qemu_host_page_size) {
+                /* one single host page */
+                ret = mmap_frag(real_start, start, end,
+                                prot, flags, fd, offset);
+                if (ret == -1)
+                    return ret;
+                goto the_end1;
+            }
+            ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,

                             prot, flags, fd, offset);
             if (ret == -1)
                 return ret;
                             prot, flags, fd, offset);
             if (ret == -1)
                 return ret;

-            goto the_end1;
+            real_start += qemu_host_page_size;
+        }
+        /* handle the end of the mapping */
+        if (end < real_end) {
+            ret = mmap_frag(real_end - qemu_host_page_size,
+                            real_end - qemu_host_page_size, real_end,
+                            prot, flags, fd,
+                            offset + real_end - qemu_host_page_size - start);
+            if (ret == -1)
+                return -1;
+            real_end -= qemu_host_page_size;
+        }
+
+        /* map the middle (easier) */
+        if (real_start < real_end) {
+            void *p;
+            unsigned long offset1;
+            if (flags & MAP_ANONYMOUS)
+                offset1 = 0;
+            else
+                offset1 = offset + real_start - start;
+            p = mmap(g2h(real_start), real_end - real_start,
+                     prot, flags, fd, offset1);
+            if (p == MAP_FAILED)
+                return -1;

         }
         }

-        ret = mmap_frag(host_start, start, host_start + host_page_size,
-                        prot, flags, fd, offset);
-        if (ret == -1)
-            return ret;
-        host_start += host_page_size;
-    }
-    /* handle the end of the mapping */
-    if (end < host_end) {
-        ret = mmap_frag(host_end - host_page_size, 
-                        host_end - host_page_size, host_end,
-                        prot, flags, fd, 
-                        offset + host_end - host_page_size - start);
-        if (ret == -1)
-            return ret;
-        host_end -= host_page_size;
-    }
-    
-    /* map the middle (easier) */
-    if (host_start < host_end) {
-        unsigned long offset1;
-       if (flags & MAP_ANONYMOUS)
-         offset1 = 0;
-       else
-         offset1 = offset + host_start - start;
-        ret = (long)mmap((void *)host_start, host_end - host_start, 
-                         prot, flags, fd, offset1);
-        if (ret == -1)
-            return ret;

     }
  the_end1:
     page_set_flags(start, start + len, prot | PAGE_VALID);
  the_end:
 #ifdef DEBUG_MMAP
     }
  the_end1:
     page_set_flags(start, start + len, prot | PAGE_VALID);
  the_end:
 #ifdef DEBUG_MMAP

-    printf("ret=0x%lx\n", (long)start);
+    printf("ret=0x" TARGET_FMT_lx "\n", start);

     page_dump(stdout);
     printf("\n");
 #endif
     return start;
 }
 
     page_dump(stdout);
     printf("\n");
 #endif
     return start;
 }
 

-int target_munmap(unsigned long start, unsigned long len)
+int target_munmap(abi_ulong start, abi_ulong len)

 {
 {

-    unsigned long end, host_start, host_end, addr;
+    abi_ulong end, real_start, real_end, addr;

     int prot, ret;
 
 #ifdef DEBUG_MMAP
     int prot, ret;
 
 #ifdef DEBUG_MMAP


@@ -317,36 +358,36 @@ int target_munmap(unsigned long start, unsigned long len)
     if (len == 0)
         return -EINVAL;
     end = start + len;
     if (len == 0)
         return -EINVAL;
     end = start + len;

-    host_start = start & host_page_mask;
-    host_end = HOST_PAGE_ALIGN(end);
+    real_start = start & qemu_host_page_mask;
+    real_end = HOST_PAGE_ALIGN(end);

 
 

-    if (start > host_start) {
+    if (start > real_start) {

         /* handle host page containing start */
         prot = 0;
         /* handle host page containing start */
         prot = 0;

-        for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
+        for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {

             prot |= page_get_flags(addr);
         }
             prot |= page_get_flags(addr);
         }

-        if (host_end == host_start + host_page_size) {
-            for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
+        if (real_end == real_start + qemu_host_page_size) {
+            for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {

                 prot |= page_get_flags(addr);
             }
                 prot |= page_get_flags(addr);
             }

-            end = host_end;
+            end = real_end;

         }
         if (prot != 0)
         }
         if (prot != 0)

-            host_start += host_page_size;
+            real_start += qemu_host_page_size;

     }
     }

-    if (end < host_end) {
+    if (end < real_end) {

         prot = 0;
         prot = 0;

-        for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
+        for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {

             prot |= page_get_flags(addr);
         }
         if (prot != 0)
             prot |= page_get_flags(addr);
         }
         if (prot != 0)

-            host_end -= host_page_size;
+            real_end -= qemu_host_page_size;

     }
     }

-    
+

     /* unmap what we can */
     /* unmap what we can */

-    if (host_start < host_end) {
-        ret = munmap((void *)host_start, host_end - host_start);
+    if (real_start < real_end) {
+        ret = munmap(g2h(real_start), real_end - real_start);

         if (ret != 0)
             return ret;
     }
         if (ret != 0)
             return ret;
     }


@@ -357,25 +398,27 @@ int target_munmap(unsigned long start, unsigned long len)
 
 /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED
    blocks which have been allocated starting on a host page */
 
 /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED
    blocks which have been allocated starting on a host page */

-long target_mremap(unsigned long old_addr, unsigned long old_size, 
-                   unsigned long new_size, unsigned long flags,
-                   unsigned long new_addr)
+abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
+                       abi_ulong new_size, unsigned long flags,
+                       abi_ulong new_addr)

 {
     int prot;
 {
     int prot;

+    unsigned long host_addr;

 
     /* XXX: use 5 args syscall */
 
     /* XXX: use 5 args syscall */

-    new_addr = (long)mremap((void *)old_addr, old_size, new_size, flags);
-    if (new_addr == -1)
-        return new_addr;
+    host_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags);
+    if (host_addr == -1)
+        return -1;
+    new_addr = h2g(host_addr);

     prot = page_get_flags(old_addr);
     page_set_flags(old_addr, old_addr + old_size, 0);
     page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
     return new_addr;
 }
 
     prot = page_get_flags(old_addr);
     page_set_flags(old_addr, old_addr + old_size, 0);
     page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
     return new_addr;
 }
 

-int target_msync(unsigned long start, unsigned long len, int flags)
+int target_msync(abi_ulong start, abi_ulong len, int flags)

 {
 {

-    unsigned long end;
+    abi_ulong end;

 
     if (start & ~TARGET_PAGE_MASK)
         return -EINVAL;
 
     if (start & ~TARGET_PAGE_MASK)
         return -EINVAL;


@@ -385,8 +428,7 @@ int target_msync(unsigned long start, unsigned long len, int flags)
         return -EINVAL;
     if (end == start)
         return 0;
         return -EINVAL;
     if (end == start)
         return 0;

-    
-    start &= host_page_mask;
-    return msync((void *)start, end - start, flags);
-}

 
 

+    start &= qemu_host_page_mask;
+    return msync(g2h(start), end - start, flags);
+}