qemu/linux-user/mmap.c

   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, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <stdarg.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/mman.h>
  28 #include <linux/mman.h>
  29 #include <linux/unistd.h>
  30
  31 #include "qemu.h"
  32 #include "qemu-common.h"
  33 #include "translate-all.h"
  34
  35 //#define DEBUG_MMAP
  36
  37 static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
  38 static __thread int mmap_lock_count;
  39
  40 void mmap_lock(void)
  41 {
  42     if (mmap_lock_count++ == 0) {
  43         pthread_mutex_lock(&mmap_mutex);
  44     }
  45 }
  46
  47 void mmap_unlock(void)
  48 {
  49     if (--mmap_lock_count == 0) {
  50         pthread_mutex_unlock(&mmap_mutex);
  51     }
  52 }
  53
  54 /* Grab lock to make sure things are in a consistent state after fork().  */
  55 void mmap_fork_start(void)
  56 {
  57     if (mmap_lock_count)
  58         abort();
  59     pthread_mutex_lock(&mmap_mutex);
  60 }
  61
  62 void mmap_fork_end(int child)
  63 {
  64     if (child)
  65         pthread_mutex_init(&mmap_mutex, NULL);
  66     else
  67         pthread_mutex_unlock(&mmap_mutex);
  68 }
  69
  70 /* NOTE: all the constants are the HOST ones, but addresses are target. */
  71 int target_mprotect(abi_ulong start, abi_ulong len, int prot)
  72 {
  73     abi_ulong end, host_start, host_end, addr;
  74     int prot1, ret;
  75
  76 #ifdef DEBUG_MMAP
  77     printf("mprotect: start=0x" TARGET_ABI_FMT_lx
  78            "len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c\n", start, len,
  79            prot & PROT_READ ? 'r' : '-',
  80            prot & PROT_WRITE ? 'w' : '-',
  81            prot & PROT_EXEC ? 'x' : '-');
  82 #endif
  83
  84     if ((start & ~TARGET_PAGE_MASK) != 0)
  85         return -EINVAL;
  86     len = TARGET_PAGE_ALIGN(len);
  87     end = start + len;
  88     if (end < start)
  89         return -EINVAL;
  90     prot &= PROT_READ | PROT_WRITE | PROT_EXEC;
  91     if (len == 0)
  92         return 0;
  93
  94     mmap_lock();
  95     host_start = start & qemu_host_page_mask;
  96     host_end = HOST_PAGE_ALIGN(end);
  97     if (start > host_start) {
  98         /* handle host page containing start */
  99         prot1 = prot;
 100         for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
 101             prot1 |= page_get_flags(addr);
 102         }
 103         if (host_end == host_start + qemu_host_page_size) {
 104             for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
 105                 prot1 |= page_get_flags(addr);
 106             }
 107             end = host_end;
 108         }
 109         ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS);
 110         if (ret != 0)
 111             goto error;
 112         host_start += qemu_host_page_size;
 113     }
 114     if (end < host_end) {
 115         prot1 = prot;
 116         for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
 117             prot1 |= page_get_flags(addr);
 118         }
 119         ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size,
 120                        prot1 & PAGE_BITS);
 121         if (ret != 0)
 122             goto error;
 123         host_end -= qemu_host_page_size;
 124     }
 125
 126     /* handle the pages in the middle */
 127     if (host_start < host_end) {
 128         ret = mprotect(g2h(host_start), host_end - host_start, prot);
 129         if (ret != 0)
 130             goto error;
 131     }
 132     page_set_flags(start, start + len, prot | PAGE_VALID);
 133     mmap_unlock();
 134     return 0;
 135 error:
 136     mmap_unlock();
 137     return ret;
 138 }
 139
 140 /* map an incomplete host page */
 141 static int mmap_frag(abi_ulong real_start,
 142                      abi_ulong start, abi_ulong end,
 143                      int prot, int flags, int fd, abi_ulong offset)
 144 {
 145     abi_ulong real_end, addr;
 146     void *host_start;
 147     int prot1, prot_new;
 148
 149     real_end = real_start + qemu_host_page_size;
 150     host_start = g2h(real_start);
 151
 152     /* get the protection of the target pages outside the mapping */
 153     prot1 = 0;
 154     for(addr = real_start; addr < real_end; addr++) {
 155         if (addr < start || addr >= end)
 156             prot1 |= page_get_flags(addr);
 157     }
 158
 159     if (prot1 == 0) {
 160         /* no page was there, so we allocate one */
 161         void *p = mmap(host_start, qemu_host_page_size, prot,
 162                        flags | MAP_ANONYMOUS, -1, 0);
 163         if (p == MAP_FAILED)
 164             return -1;
 165         prot1 = prot;
 166     }
 167     prot1 &= PAGE_BITS;
 168
 169     prot_new = prot | prot1;
 170     if (!(flags & MAP_ANONYMOUS)) {
 171         /* msync() won't work here, so we return an error if write is
 172            possible while it is a shared mapping */
 173         if ((flags & MAP_TYPE) == MAP_SHARED &&
 174             (prot & PROT_WRITE))
 175             return -1;
 176
 177         /* adjust protection to be able to read */
 178         if (!(prot1 & PROT_WRITE))
 179             mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);
 180
 181         /* read the corresponding file data */
 182         if (pread(fd, g2h(start), end - start, offset) == -1)
 183             return -1;
 184
 185         /* put final protection */
 186         if (prot_new != (prot1 | PROT_WRITE))
 187             mprotect(host_start, qemu_host_page_size, prot_new);
 188     } else {
 189         /* just update the protection */
 190         if (prot_new != prot1) {
 191             mprotect(host_start, qemu_host_page_size, prot_new);
 192         }
 193     }
 194     return 0;
 195 }
 196
 197 #if HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
 198 # define TASK_UNMAPPED_BASE  (1ul << 38)
 199 #elif defined(__CYGWIN__)
 200 /* Cygwin doesn't have a whole lot of address space.  */
 201 # define TASK_UNMAPPED_BASE  0x18000000
 202 #else
 203 # define TASK_UNMAPPED_BASE  0x40000000
 204 #endif
 205 abi_ulong mmap_next_start = TASK_UNMAPPED_BASE;
 206
 207 unsigned long last_brk;
 208
 209 #ifdef CONFIG_USE_GUEST_BASE
 210 /* Subroutine of mmap_find_vma, used when we have pre-allocated a chunk
 211    of guest address space.  */
 212 static abi_ulong mmap_find_vma_reserved(abi_ulong start, abi_ulong size)
 213 {
 214     abi_ulong addr;
 215     abi_ulong end_addr;
 216     int prot;
 217     int looped = 0;
 218
 219     if (size > RESERVED_VA) {
 220         return (abi_ulong)-1;
 221     }
 222
 223     size = HOST_PAGE_ALIGN(size);
 224     end_addr = start + size;
 225     if (end_addr > RESERVED_VA) {
 226         end_addr = RESERVED_VA;
 227     }
 228     addr = end_addr - qemu_host_page_size;
 229
 230     while (1) {
 231         if (addr > end_addr) {
 232             if (looped) {
 233                 return (abi_ulong)-1;
 234             }
 235             end_addr = RESERVED_VA;
 236             addr = end_addr - qemu_host_page_size;
 237             looped = 1;
 238             continue;
 239         }
 240         prot = page_get_flags(addr);
 241         if (prot) {
 242             end_addr = addr;
 243         }
 244         if (addr + size == end_addr) {
 245             break;
 246         }
 247         addr -= qemu_host_page_size;
 248     }
 249
 250     if (start == mmap_next_start) {
 251         mmap_next_start = addr;
 252     }
 253
 254     return addr;
 255 }
 256 #endif
 257
 258 /*
 259  * Find and reserve a free memory area of size 'size'. The search
 260  * starts at 'start'.
 261  * It must be called with mmap_lock() held.
 262  * Return -1 if error.
 263  */
 264 abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
 265 {
 266     void *ptr, *prev;
 267     abi_ulong addr;
 268     int wrapped, repeat;
 269
 270     /* If 'start' == 0, then a default start address is used. */
 271     if (start == 0) {
 272         start = mmap_next_start;
 273     } else {
 274         start &= qemu_host_page_mask;
 275     }
 276
 277     size = HOST_PAGE_ALIGN(size);
 278
 279 #ifdef CONFIG_USE_GUEST_BASE
 280     if (RESERVED_VA) {
 281         return mmap_find_vma_reserved(start, size);
 282     }
 283 #endif
 284
 285     addr = start;
 286     wrapped = repeat = 0;
 287     prev = 0;
 288
 289     for (;; prev = ptr) {
 290         /*
 291          * Reserve needed memory area to avoid a race.
 292          * It should be discarded using:
 293          *  - mmap() with MAP_FIXED flag
 294          *  - mremap() with MREMAP_FIXED flag
 295          *  - shmat() with SHM_REMAP flag
 296          */
 297         ptr = mmap(g2h(addr), size, PROT_NONE,
 298                    MAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0);
 299
 300         /* ENOMEM, if host address space has no memory */
 301         if (ptr == MAP_FAILED) {
 302             return (abi_ulong)-1;
 303         }
 304
 305         /* Count the number of sequential returns of the same address.
 306            This is used to modify the search algorithm below.  */
 307         repeat = (ptr == prev ? repeat + 1 : 0);
 308
 309         if (h2g_valid(ptr + size - 1)) {
 310             addr = h2g(ptr);
 311
 312             if ((addr & ~TARGET_PAGE_MASK) == 0) {
 313                 /* Success.  */
 314                 if (start == mmap_next_start && addr >= TASK_UNMAPPED_BASE) {
 315                     mmap_next_start = addr + size;
 316                 }
 317                 return addr;
 318             }
 319
 320             /* The address is not properly aligned for the target.  */
 321             switch (repeat) {
 322             case 0:
 323                 /* Assume the result that the kernel gave us is the
 324                    first with enough free space, so start again at the
 325                    next higher target page.  */
 326                 addr = TARGET_PAGE_ALIGN(addr);
 327                 break;
 328             case 1:
 329                 /* Sometimes the kernel decides to perform the allocation
 330                    at the top end of memory instead.  */
 331                 addr &= TARGET_PAGE_MASK;
 332                 break;
 333             case 2:
 334                 /* Start over at low memory.  */
 335                 addr = 0;
 336                 break;
 337             default:
 338                 /* Fail.  This unaligned block must the last.  */
 339                 addr = -1;
 340                 break;
 341             }
 342         } else {
 343             /* Since the result the kernel gave didn't fit, start
 344                again at low memory.  If any repetition, fail.  */
 345             addr = (repeat ? -1 : 0);
 346         }
 347
 348         /* Unmap and try again.  */
 349         munmap(ptr, size);
 350
 351         /* ENOMEM if we checked the whole of the target address space.  */
 352         if (addr == (abi_ulong)-1) {
 353             return (abi_ulong)-1;
 354         } else if (addr == 0) {
 355             if (wrapped) {
 356                 return (abi_ulong)-1;
 357             }
 358             wrapped = 1;
 359             /* Don't actually use 0 when wrapping, instead indicate
 360                that we'd truly like an allocation in low memory.  */
 361             addr = (mmap_min_addr > TARGET_PAGE_SIZE
 362                      ? TARGET_PAGE_ALIGN(mmap_min_addr)
 363                      : TARGET_PAGE_SIZE);
 364         } else if (wrapped && addr >= start) {
 365             return (abi_ulong)-1;
 366         }
 367     }
 368 }
 369
 370 /* NOTE: all the constants are the HOST ones */
 371 abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
 372                      int flags, int fd, abi_ulong offset)
 373 {
 374     abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
 375
 376     mmap_lock();
 377 #ifdef DEBUG_MMAP
 378     {
 379         printf("mmap: start=0x" TARGET_ABI_FMT_lx
 380                " len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c flags=",
 381                start, len,
 382                prot & PROT_READ ? 'r' : '-',
 383                prot & PROT_WRITE ? 'w' : '-',
 384                prot & PROT_EXEC ? 'x' : '-');
 385         if (flags & MAP_FIXED)
 386             printf("MAP_FIXED ");
 387         if (flags & MAP_ANONYMOUS)
 388             printf("MAP_ANON ");
 389         switch(flags & MAP_TYPE) {
 390         case MAP_PRIVATE:
 391             printf("MAP_PRIVATE ");
 392             break;
 393         case MAP_SHARED:
 394             printf("MAP_SHARED ");
 395             break;
 396         default:
 397             printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);
 398             break;
 399         }
 400         printf("fd=%d offset=" TARGET_ABI_FMT_lx "\n", fd, offset);
 401     }
 402 #endif
 403
 404     if (offset & ~TARGET_PAGE_MASK) {
 405         errno = EINVAL;
 406         goto fail;
 407     }
 408
 409     len = TARGET_PAGE_ALIGN(len);
 410     if (len == 0)
 411         goto the_end;
 412     real_start = start & qemu_host_page_mask;
 413     host_offset = offset & qemu_host_page_mask;
 414
 415     /* If the user is asking for the kernel to find a location, do that
 416        before we truncate the length for mapping files below.  */
 417     if (!(flags & MAP_FIXED)) {
 418         host_len = len + offset - host_offset;
 419         host_len = HOST_PAGE_ALIGN(host_len);
 420         start = mmap_find_vma(real_start, host_len);
 421         if (start == (abi_ulong)-1) {
 422             errno = ENOMEM;
 423             goto fail;
 424         }
 425     }
 426
 427     /* When mapping files into a memory area larger than the file, accesses
 428        to pages beyond the file size will cause a SIGBUS.
 429
 430        For example, if mmaping a file of 100 bytes on a host with 4K pages
 431        emulating a target with 8K pages, the target expects to be able to
 432        access the first 8K. But the host will trap us on any access beyond
 433        4K.
 434
 435        When emulating a target with a larger page-size than the hosts, we
 436        may need to truncate file maps at EOF and add extra anonymous pages
 437        up to the targets page boundary.  */
 438
 439     if ((qemu_real_host_page_size < TARGET_PAGE_SIZE)
 440         && !(flags & MAP_ANONYMOUS)) {
 441        struct stat sb;
 442
 443        if (fstat (fd, &sb) == -1)
 444            goto fail;
 445
 446        /* Are we trying to create a map beyond EOF?.  */
 447        if (offset + len > sb.st_size) {
 448            /* If so, truncate the file map at eof aligned with
 449               the hosts real pagesize. Additional anonymous maps
 450               will be created beyond EOF.  */
 451            len = (sb.st_size - offset);
 452            len += qemu_real_host_page_size - 1;
 453            len &= ~(qemu_real_host_page_size - 1);
 454        }
 455     }
 456
 457     if (!(flags & MAP_FIXED)) {
 458         unsigned long host_start;
 459         void *p;
 460
 461         host_len = len + offset - host_offset;
 462         host_len = HOST_PAGE_ALIGN(host_len);
 463
 464         /* Note: we prefer to control the mapping address. It is
 465            especially important if qemu_host_page_size >
 466            qemu_real_host_page_size */
 467         p = mmap(g2h(start), host_len, prot,
 468                  flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
 469         if (p == MAP_FAILED)
 470             goto fail;
 471         /* update start so that it points to the file position at 'offset' */
 472         host_start = (unsigned long)p;
 473         if (!(flags & MAP_ANONYMOUS)) {
 474             p = mmap(g2h(start), len, prot,
 475                      flags | MAP_FIXED, fd, host_offset);
 476             if (p == MAP_FAILED) {
 477                 munmap(g2h(start), host_len);
 478                 goto fail;
 479             }
 480             host_start += offset - host_offset;
 481         }
 482         start = h2g(host_start);
 483     } else {
 484         if (start & ~TARGET_PAGE_MASK) {
 485             errno = EINVAL;
 486             goto fail;
 487         }
 488         end = start + len;
 489         real_end = HOST_PAGE_ALIGN(end);
 490
 491         /*
 492          * Test if requested memory area fits target address space
 493          * It can fail only on 64-bit host with 32-bit target.
 494          * On any other target/host host mmap() handles this error correctly.
 495          */
 496         if ((unsigned long)start + len - 1 > (abi_ulong) -1) {
 497             errno = EINVAL;
 498             goto fail;
 499         }
 500
 501         /* worst case: we cannot map the file because the offset is not
 502            aligned, so we read it */
 503         if (!(flags & MAP_ANONYMOUS) &&
 504             (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {
 505             /* msync() won't work here, so we return an error if write is
 506                possible while it is a shared mapping */
 507             if ((flags & MAP_TYPE) == MAP_SHARED &&
 508                 (prot & PROT_WRITE)) {
 509                 errno = EINVAL;
 510                 goto fail;
 511             }
 512             retaddr = target_mmap(start, len, prot | PROT_WRITE,
 513                                   MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
 514                                   -1, 0);
 515             if (retaddr == -1)
 516                 goto fail;
 517             if (pread(fd, g2h(start), len, offset) == -1)
 518                 goto fail;
 519             if (!(prot & PROT_WRITE)) {
 520                 ret = target_mprotect(start, len, prot);
 521                 if (ret != 0) {
 522                     start = ret;
 523                     goto the_end;
 524                 }
 525             }
 526             goto the_end;
 527         }
 528
 529         /* handle the start of the mapping */
 530         if (start > real_start) {
 531             if (real_end == real_start + qemu_host_page_size) {
 532                 /* one single host page */
 533                 ret = mmap_frag(real_start, start, end,
 534                                 prot, flags, fd, offset);
 535                 if (ret == -1)
 536                     goto fail;
 537                 goto the_end1;
 538             }
 539             ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,
 540                             prot, flags, fd, offset);
 541             if (ret == -1)
 542                 goto fail;
 543             real_start += qemu_host_page_size;
 544         }
 545         /* handle the end of the mapping */
 546         if (end < real_end) {
 547             ret = mmap_frag(real_end - qemu_host_page_size,
 548                             real_end - qemu_host_page_size, real_end,
 549                             prot, flags, fd,
 550                             offset + real_end - qemu_host_page_size - start);
 551             if (ret == -1)
 552                 goto fail;
 553             real_end -= qemu_host_page_size;
 554         }
 555
 556         /* map the middle (easier) */
 557         if (real_start < real_end) {
 558             void *p;
 559             unsigned long offset1;
 560             if (flags & MAP_ANONYMOUS)
 561                 offset1 = 0;
 562             else
 563                 offset1 = offset + real_start - start;
 564             p = mmap(g2h(real_start), real_end - real_start,
 565                      prot, flags, fd, offset1);
 566             if (p == MAP_FAILED)
 567                 goto fail;
 568         }
 569     }
 570  the_end1:
 571     page_set_flags(start, start + len, prot | PAGE_VALID);
 572  the_end:
 573 #ifdef DEBUG_MMAP
 574     printf("ret=0x" TARGET_ABI_FMT_lx "\n", start);
 575     page_dump(stdout);
 576     printf("\n");
 577 #endif
 578     tb_invalidate_phys_range(start, start + len);
 579     mmap_unlock();
 580     return start;
 581 fail:
 582     mmap_unlock();
 583     return -1;
 584 }
 585
 586 static void mmap_reserve(abi_ulong start, abi_ulong size)
 587 {
 588     abi_ulong real_start;
 589     abi_ulong real_end;
 590     abi_ulong addr;
 591     abi_ulong end;
 592     int prot;
 593
 594     real_start = start & qemu_host_page_mask;
 595     real_end = HOST_PAGE_ALIGN(start + size);
 596     end = start + size;
 597     if (start > real_start) {
 598         /* handle host page containing start */
 599         prot = 0;
 600         for (addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
 601             prot |= page_get_flags(addr);
 602         }
 603         if (real_end == real_start + qemu_host_page_size) {
 604             for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
 605                 prot |= page_get_flags(addr);
 606             }
 607             end = real_end;
 608         }
 609         if (prot != 0)
 610             real_start += qemu_host_page_size;
 611     }
 612     if (end < real_end) {
 613         prot = 0;
 614         for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
 615             prot |= page_get_flags(addr);
 616         }
 617         if (prot != 0)
 618             real_end -= qemu_host_page_size;
 619     }
 620     if (real_start != real_end) {
 621         mmap(g2h(real_start), real_end - real_start, PROT_NONE,
 622                  MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE,
 623                  -1, 0);
 624     }
 625 }
 626
 627 int target_munmap(abi_ulong start, abi_ulong len)
 628 {
 629     abi_ulong end, real_start, real_end, addr;
 630     int prot, ret;
 631
 632 #ifdef DEBUG_MMAP
 633     printf("munmap: start=0x" TARGET_ABI_FMT_lx " len=0x"
 634            TARGET_ABI_FMT_lx "\n",
 635            start, len);
 636 #endif
 637     if (start & ~TARGET_PAGE_MASK)
 638         return -EINVAL;
 639     len = TARGET_PAGE_ALIGN(len);
 640     if (len == 0)
 641         return -EINVAL;
 642     mmap_lock();
 643     end = start + len;
 644     real_start = start & qemu_host_page_mask;
 645     real_end = HOST_PAGE_ALIGN(end);
 646
 647     if (start > real_start) {
 648         /* handle host page containing start */
 649         prot = 0;
 650         for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
 651             prot |= page_get_flags(addr);
 652         }
 653         if (real_end == real_start + qemu_host_page_size) {
 654             for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
 655                 prot |= page_get_flags(addr);
 656             }
 657             end = real_end;
 658         }
 659         if (prot != 0)
 660             real_start += qemu_host_page_size;
 661     }
 662     if (end < real_end) {
 663         prot = 0;
 664         for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
 665             prot |= page_get_flags(addr);
 666         }
 667         if (prot != 0)
 668             real_end -= qemu_host_page_size;
 669     }
 670
 671     ret = 0;
 672     /* unmap what we can */
 673     if (real_start < real_end) {
 674         if (RESERVED_VA) {
 675             mmap_reserve(real_start, real_end - real_start);
 676         } else {
 677             ret = munmap(g2h(real_start), real_end - real_start);
 678         }
 679     }
 680
 681     if (ret == 0) {
 682         page_set_flags(start, start + len, 0);
 683         tb_invalidate_phys_range(start, start + len);
 684     }
 685     mmap_unlock();
 686     return ret;
 687 }
 688
 689 abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
 690                        abi_ulong new_size, unsigned long flags,
 691                        abi_ulong new_addr)
 692 {
 693     int prot;
 694     void *host_addr;
 695
 696     mmap_lock();
 697
 698     if (flags & MREMAP_FIXED) {
 699         host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
 700                                      old_size, new_size,
 701                                      flags,
 702                                      g2h(new_addr));
 703
 704         if (RESERVED_VA && host_addr != MAP_FAILED) {
 705             /* If new and old addresses overlap then the above mremap will
 706                already have failed with EINVAL.  */
 707             mmap_reserve(old_addr, old_size);
 708         }
 709     } else if (flags & MREMAP_MAYMOVE) {
 710         abi_ulong mmap_start;
 711
 712         mmap_start = mmap_find_vma(0, new_size);
 713
 714         if (mmap_start == -1) {
 715             errno = ENOMEM;
 716             host_addr = MAP_FAILED;
 717         } else {
 718             host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
 719                                          old_size, new_size,
 720                                          flags | MREMAP_FIXED,
 721                                          g2h(mmap_start));
 722             if ( RESERVED_VA ) {
 723                 mmap_reserve(old_addr, old_size);
 724             }
 725         }
 726     } else {
 727         int prot = 0;
 728         if (RESERVED_VA && old_size < new_size) {
 729             abi_ulong addr;
 730             for (addr = old_addr + old_size;
 731                  addr < old_addr + new_size;
 732                  addr++) {
 733                 prot |= page_get_flags(addr);
 734             }
 735         }
 736         if (prot == 0) {
 737             host_addr = mremap(g2h(old_addr), old_size, new_size, flags);
 738             if (host_addr != MAP_FAILED && RESERVED_VA && old_size > new_size) {
 739                 mmap_reserve(old_addr + old_size, new_size - old_size);
 740             }
 741         } else {
 742             errno = ENOMEM;
 743             host_addr = MAP_FAILED;
 744         }
 745         /* Check if address fits target address space */
 746         if ((unsigned long)host_addr + new_size > (abi_ulong)-1) {
 747             /* Revert mremap() changes */
 748             host_addr = mremap(g2h(old_addr), new_size, old_size, flags);
 749             errno = ENOMEM;
 750             host_addr = MAP_FAILED;
 751         }
 752     }
 753
 754     if (host_addr == MAP_FAILED) {
 755         new_addr = -1;
 756     } else {
 757         new_addr = h2g(host_addr);
 758         prot = page_get_flags(old_addr);
 759         page_set_flags(old_addr, old_addr + old_size, 0);
 760         page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
 761     }
 762     tb_invalidate_phys_range(new_addr, new_addr + new_size);
 763     mmap_unlock();
 764     return new_addr;
 765 }
 766
 767 int target_msync(abi_ulong start, abi_ulong len, int flags)
 768 {
 769     abi_ulong end;
 770
 771     if (start & ~TARGET_PAGE_MASK)
 772         return -EINVAL;
 773     len = TARGET_PAGE_ALIGN(len);
 774     end = start + len;
 775     if (end < start)
 776         return -EINVAL;
 777     if (end == start)
 778         return 0;
 779
 780     start &= qemu_host_page_mask;
 781     return msync(g2h(start), end - start, flags);
 782 }