1 /*

     2  *  mmap support for qemu

     3  *

     4  *  Copyright (c) 2003 Fabrice Bellard

     5  *

     6  *  This program is free software; you can redistribute it and/or modify

     7  *  it under the terms of the GNU General Public License as published by

     8  *  the Free Software Foundation; either version 2 of the License, or

     9  *  (at your option) any later version.

    10  *

    11  *  This program is distributed in the hope that it will be useful,

    12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14  *  GNU General Public License for more details.

    15  *

    16  *  You should have received a copy of the GNU General Public License

    17  *  along with this program; if not, write to the Free Software

    18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    19  */

    20 #include <stdlib.h>

    21 #include <stdio.h>

    22 #include <stdarg.h>

    23 #include <string.h>

    24 #include <unistd.h>

    25 #include <errno.h>

    26 #include <sys/mman.h>

    27 

    28 #include "qemu.h"

    29 

    30 //#define DEBUG_MMAP

    31 

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

    33 int target_mprotect(unsigned long start, unsigned long len, int prot)

    34 {

    35     unsigned long end, host_start, host_end, addr;

    36     int prot1, ret;

    37 

    38 #ifdef DEBUG_MMAP

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

    40            prot & PROT_READ ? 'r' : '-',

    41            prot & PROT_WRITE ? 'w' : '-',

    42            prot & PROT_EXEC ? 'x' : '-');

    43 #endif

    44 

    45     if ((start & ~TARGET_PAGE_MASK) != 0)

    46         return -EINVAL;

    47     len = TARGET_PAGE_ALIGN(len);

    48     end = start + len;

    49     if (end < start)

    50         return -EINVAL;

    51     if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))

    52         return -EINVAL;

    53     if (len == 0)

    54         return 0;

    55 

    56     host_start = start & qemu_host_page_mask;

    57     host_end = HOST_PAGE_ALIGN(end);

    58     if (start > host_start) {

    59         /* handle host page containing start */

    60         prot1 = prot;

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

    62             prot1 |= page_get_flags(addr);

    63         }

    64         if (host_end == host_start + qemu_host_page_size) {

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

    66                 prot1 |= page_get_flags(addr);

    67             }

    68             end = host_end;

    69         }

    70         ret = mprotect((void *)host_start, qemu_host_page_size, prot1 & PAGE_BITS);

    71         if (ret != 0)

    72             return ret;

    73         host_start += qemu_host_page_size;

    74     }

    75     if (end < host_end) {

    76         prot1 = prot;

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

    78             prot1 |= page_get_flags(addr);

    79         }

    80         ret = mprotect((void *)(host_end - qemu_host_page_size), qemu_host_page_size,

    81                        prot1 & PAGE_BITS);

    82         if (ret != 0)

    83             return ret;

    84         host_end -= qemu_host_page_size;

    85     }

    86 

    87     /* handle the pages in the middle */

    88     if (host_start < host_end) {

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

    90         if (ret != 0)

    91             return ret;

    92     }

    93     page_set_flags(start, start + len, prot | PAGE_VALID);

    94     return 0;

    95 }

    96 

    97 /* map an incomplete host page */

    98 int mmap_frag(unsigned long host_start,

    99                unsigned long start, unsigned long end,

   100                int prot, int flags, int fd, unsigned long offset)

   101 {

   102     unsigned long host_end, ret, addr;

   103     int prot1, prot_new;

   104 

   105     host_end = host_start + qemu_host_page_size;

   106 

   107     /* get the protection of the target pages outside the mapping */

   108     prot1 = 0;

   109     for(addr = host_start; addr < host_end; addr++) {

   110         if (addr < start || addr >= end)

   111             prot1 |= page_get_flags(addr);

   112     }

   113 

   114     if (prot1 == 0) {

   115         /* no page was there, so we allocate one */

   116         ret = (long)mmap((void *)host_start, qemu_host_page_size, prot,

   117                          flags | MAP_ANONYMOUS, -1, 0);

   118         if (ret == -1)

   119             return ret;

   120     }

   121     prot1 &= PAGE_BITS;

   122 

   123     prot_new = prot | prot1;

   124     if (!(flags & MAP_ANONYMOUS)) {

   125         /* msync() won't work here, so we return an error if write is

   126            possible while it is a shared mapping */

   127 #ifndef __APPLE__

   128         if ((flags & MAP_TYPE) == MAP_SHARED &&

   129 #else

   130         if ((flags &  MAP_SHARED) &&

   131 #endif

   132             (prot & PROT_WRITE))

   133             return -EINVAL;

   134 

   135         /* adjust protection to be able to read */

   136         if (!(prot1 & PROT_WRITE))

   137             mprotect((void *)host_start, qemu_host_page_size, prot1 | PROT_WRITE);

   138 

   139         /* read the corresponding file data */

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

   141 

   142         /* put final protection */

   143         if (prot_new != (prot1 | PROT_WRITE))

   144             mprotect((void *)host_start, qemu_host_page_size, prot_new);

   145     } else {

   146         /* just update the protection */

   147         if (prot_new != prot1) {

   148             mprotect((void *)host_start, qemu_host_page_size, prot_new);

   149         }

   150     }

   151     return 0;

   152 }

   153 

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

   155 long target_mmap(unsigned long start, unsigned long len, int prot,

   156                  int flags, int fd, unsigned long offset)

   157 {

   158     unsigned long ret, end, host_start, host_end, retaddr, host_offset, host_len;

   159 #if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__)

   160     static unsigned long last_start = 0x40000000;

   161 #endif

   162 

   163 #ifdef DEBUG_MMAP

   164     {

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

   166                start, len,

   167                prot & PROT_READ ? 'r' : '-',

   168                prot & PROT_WRITE ? 'w' : '-',

   169                prot & PROT_EXEC ? 'x' : '-');

   170         if (flags & MAP_FIXED)

   171             printf("MAP_FIXED ");

   172         if (flags & MAP_ANONYMOUS)

   173             printf("MAP_ANON ");

   174 #ifndef MAP_TYPE

   175 # define MAP_TYPE 0x3

   176 #endif

   177         switch(flags & MAP_TYPE) {

   178         case MAP_PRIVATE:

   179             printf("MAP_PRIVATE ");

   180             break;

   181         case MAP_SHARED:

   182             printf("MAP_SHARED ");

   183             break;

   184         default:

   185             printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);

   186             break;

   187         }

   188         printf("fd=%d offset=%lx\n", fd, offset);

   189     }

   190 #endif

   191 

   192     if (offset & ~TARGET_PAGE_MASK)

   193         return -EINVAL;

   194 

   195     len = TARGET_PAGE_ALIGN(len);

   196     if (len == 0)

   197         return start;

   198     host_start = start & qemu_host_page_mask;

   199 

   200     if (!(flags & MAP_FIXED)) {

   201 #if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__)

   202         /* tell the kernel to search at the same place as i386 */

   203         if (host_start == 0) {

   204             host_start = last_start;

   205             last_start += HOST_PAGE_ALIGN(len);

   206         }

   207 #endif

   208         if (qemu_host_page_size != qemu_real_host_page_size) {

   209             /* NOTE: this code is only for debugging with '-p' option */

   210             /* reserve a memory area */

   211             host_len = HOST_PAGE_ALIGN(len) + qemu_host_page_size - TARGET_PAGE_SIZE;

   212             host_start = (long)mmap((void *)host_start, host_len, PROT_NONE,

   213                                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

   214             if (host_start == -1)

   215                 return host_start;

   216             host_end = host_start + host_len;

   217             start = HOST_PAGE_ALIGN(host_start);

   218             end = start + HOST_PAGE_ALIGN(len);

   219             if (start > host_start)

   220                 munmap((void *)host_start, start - host_start);

   221             if (end < host_end)

   222                 munmap((void *)end, host_end - end);

   223             /* use it as a fixed mapping */

   224             flags |= MAP_FIXED;

   225         } else {

   226             /* if not fixed, no need to do anything */

   227             host_offset = offset & qemu_host_page_mask;

   228             host_len = len + offset - host_offset;

   229             start = (long)mmap((void *)host_start, host_len,

   230                                prot, flags, fd, host_offset);

   231             if (start == -1)

   232                 return start;

   233             /* update start so that it points to the file position at 'offset' */

   234             if (!(flags & MAP_ANONYMOUS))

   235                 start += offset - host_offset;

   236             goto the_end1;

   237         }

   238     }

   239 

   240     if (start & ~TARGET_PAGE_MASK)

   241         return -EINVAL;

   242     end = start + len;

   243     host_end = HOST_PAGE_ALIGN(end);

   244 

   245     /* worst case: we cannot map the file because the offset is not

   246        aligned, so we read it */

   247     if (!(flags & MAP_ANONYMOUS) &&

   248         (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {

   249         /* msync() won't work here, so we return an error if write is

   250            possible while it is a shared mapping */

   251 #ifndef __APPLE__

   252         if ((flags & MAP_TYPE) == MAP_SHARED &&

   253 #else

   254         if ((flags & MAP_SHARED) &&

   255 #endif

   256             (prot & PROT_WRITE))

   257             return -EINVAL;

   258         retaddr = target_mmap(start, len, prot | PROT_WRITE,

   259                               MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,

   260                               -1, 0);

   261         if (retaddr == -1)

   262             return retaddr;

   263         pread(fd, (void *)start, len, offset);

   264         if (!(prot & PROT_WRITE)) {

   265             ret = target_mprotect(start, len, prot);

   266             if (ret != 0)

   267                 return ret;

   268         }

   269         goto the_end;

   270     }

   271 

   272     /* handle the start of the mapping */

   273     if (start > host_start) {

   274         if (host_end == host_start + qemu_host_page_size) {

   275             /* one single host page */

   276             ret = mmap_frag(host_start, start, end,

   277                             prot, flags, fd, offset);

   278             if (ret == -1)

   279                 return ret;

   280             goto the_end1;

   281         }

   282         ret = mmap_frag(host_start, start, host_start + qemu_host_page_size,

   283                         prot, flags, fd, offset);

   284         if (ret == -1)

   285             return ret;

   286         host_start += qemu_host_page_size;

   287     }

   288     /* handle the end of the mapping */

   289     if (end < host_end) {

   290         ret = mmap_frag(host_end - qemu_host_page_size,

   291                         host_end - qemu_host_page_size, host_end,

   292                         prot, flags, fd,

   293                         offset + host_end - qemu_host_page_size - start);

   294         if (ret == -1)

   295             return ret;

   296         host_end -= qemu_host_page_size;

   297     }

   298 

   299     /* map the middle (easier) */

   300     if (host_start < host_end) {

   301         unsigned long offset1;

   302 	if (flags & MAP_ANONYMOUS)

   303 	  offset1 = 0;

   304 	else

   305 	  offset1 = offset + host_start - start;

   306         ret = (long)mmap((void *)host_start, host_end - host_start,

   307                          prot, flags, fd, offset1);

   308         if (ret == -1)

   309             return ret;

   310     }

   311  the_end1:

   312     page_set_flags(start, start + len, prot | PAGE_VALID);

   313  the_end:

   314 #ifdef DEBUG_MMAP

   315     printf("target_mmap: ret=0x%lx\n", (long)start);

   316     page_dump(stdout);

   317     printf("\n");

   318 #endif

   319     return start;

   320 }

   321 

   322 int target_munmap(unsigned long start, unsigned long len)

   323 {

   324     unsigned long end, host_start, host_end, addr;

   325     int prot, ret;

   326 

   327 #ifdef DEBUG_MMAP

   328     printf("munmap: start=0x%lx len=0x%lx\n", start, len);

   329 #endif

   330     if (start & ~TARGET_PAGE_MASK)

   331         return -EINVAL;

   332     len = TARGET_PAGE_ALIGN(len);

   333     if (len == 0)

   334         return -EINVAL;

   335     end = start + len;

   336     host_start = start & qemu_host_page_mask;

   337     host_end = HOST_PAGE_ALIGN(end);

   338 

   339     if (start > host_start) {

   340         /* handle host page containing start */

   341         prot = 0;

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

   343             prot |= page_get_flags(addr);

   344         }

   345         if (host_end == host_start + qemu_host_page_size) {

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

   347                 prot |= page_get_flags(addr);

   348             }

   349             end = host_end;

   350         }

   351         if (prot != 0)

   352             host_start += qemu_host_page_size;

   353     }

   354     if (end < host_end) {

   355         prot = 0;

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

   357             prot |= page_get_flags(addr);

   358         }

   359         if (prot != 0)

   360             host_end -= qemu_host_page_size;

   361     }

   362 

   363     /* unmap what we can */

   364     if (host_start < host_end) {

   365         ret = munmap((void *)host_start, host_end - host_start);

   366         if (ret != 0)

   367             return ret;

   368     }

   369 

   370     page_set_flags(start, start + len, 0);

   371     return 0;

   372 }

   373 

   374 /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED

   375    blocks which have been allocated starting on a host page */

   376 long target_mremap(unsigned long old_addr, unsigned long old_size,

   377                    unsigned long new_size, unsigned long flags,

   378                    unsigned long new_addr)

   379 {

   380 #ifndef __APPLE__

   381     /* XXX: use 5 args syscall */

   382     new_addr = (long)mremap((void *)old_addr, old_size, new_size, flags);

   383     if (new_addr == -1)

   384         return new_addr;

   385     prot = page_get_flags(old_addr);

   386     page_set_flags(old_addr, old_addr + old_size, 0);

   387     page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);

   388     return new_addr;

   389 #else

   390     qerror("target_mremap: unsupported\n");

   391 #endif

   392 

   393 }

   394 

   395 int target_msync(unsigned long start, unsigned long len, int flags)

   396 {

   397     unsigned long end;

   398 

   399     if (start & ~TARGET_PAGE_MASK)

   400         return -EINVAL;

   401     len = TARGET_PAGE_ALIGN(len);

   402     end = start + len;

   403     if (end < start)

   404         return -EINVAL;

   405     if (end == start)

   406         return 0;

   407 

   408     start &= qemu_host_page_mask;

   409     return msync((void *)start, end - start, flags);

   410 }