Archipelago » qemu

/*

 *  mmap support for qemu

 *  Copyright (c) 2003 Fabrice Bellard

 *

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

        return -EINVAL;

    if (len == 0)

        return 0;

    host_start = start & qemu_host_page_mask;

    host_end = HOST_PAGE_ALIGN(end);

    if (start > host_start) {

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

            prot1 |= page_get_flags(addr);

        }

                       prot1 & PAGE_BITS);

        if (ret != 0)

            return ret;

        host_end -= qemu_host_page_size;

    }

    /* handle the pages in the middle */

    if (host_start < host_end) {

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

}

/* map an incomplete host page */

                     int prot, int flags, int fd, target_ulong offset)

{

    target_ulong real_end, ret, addr;

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

            prot1 |= page_get_flags(addr);

    }

    if (prot1 == 0) {

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

                         flags | MAP_ANONYMOUS, -1, 0);

        if (ret == -1)

            return ret;

        /* adjust protection to be able to read */

        if (!(prot1 & PROT_WRITE))

            mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);

        /* read the corresponding file data */

        pread(fd, g2h(start), end - start, offset);

        /* put final protection */

        if (prot_new != (prot1 | PROT_WRITE))

            mprotect(host_start, qemu_host_page_size, prot_new);

}

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

                 int flags, int fd, target_ulong offset)

{

    target_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;

#ifdef DEBUG_MMAP

    {

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

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

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

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

            /* ??? This needs fixing for remapping.  */

abort();

            host_len = HOST_PAGE_ALIGN(len) + qemu_host_page_size - TARGET_PAGE_SIZE;

                                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

            if (real_start == -1)

                return real_start;

            if (host_start == -1)

                return host_start;

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

                host_start += offset - host_offset;

            start = h2g(host_start);

            goto the_end1;

        }

    }

    if (start & ~TARGET_PAGE_MASK) {

        errno = EINVAL;

        return -1;

            errno = EINVAL;

            return -1;

        }

                              -1, 0);

        if (retaddr == -1)

            return retaddr;

    }

    /* handle the end of the mapping */

    if (end < real_end) {

                        real_end - qemu_host_page_size, real_end,

                        offset + real_end - qemu_host_page_size - start);

        if (ret == -1)

            return ret;

        real_end -= qemu_host_page_size;

    }

    /* map the middle (easier) */

    if (real_start < real_end) {

        unsigned long offset1;

	  offset1 = 0;

	else

	  offset1 = offset + real_start - start;

                         prot, flags, fd, offset1);

        if (ret == -1)

            return ret;

        if (prot != 0)

            real_end -= qemu_host_page_size;

    }

    /* unmap what we can */

    if (real_start < real_end) {

        ret = munmap((void *)real_start, real_end - real_start);

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

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

                   target_ulong new_size, unsigned long flags,

                   target_ulong new_addr)

{

        return -EINVAL;

    if (end == start)

        return 0;

    start &= qemu_host_page_mask;

    return msync(g2h(start), end - start, flags);

}