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: }
  411: