Archipelago » qemu

extern const char *mem_path;

extern int mem_prealloc;

#if defined(__linux__) && !defined(TARGET_S390X)

#include <sys/vfs.h>

#define HUGETLBFS_MAGIC       0x958458f6

static long gethugepagesize(const char *path)

{

    struct statfs fs;

    int ret;

    do {

	    ret = statfs(path, &fs);

    } while (ret != 0 && errno == EINTR);

    if (ret != 0) {

	    perror("statfs");

	    return 0;

    }

    if (fs.f_type != HUGETLBFS_MAGIC)

	    fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);

    return fs.f_bsize;

}

static void *file_ram_alloc(ram_addr_t memory, const char *path)

{

    char *filename;

    void *area;

    int fd;

#ifdef MAP_POPULATE

    int flags;

#endif

    unsigned long hpagesize;

    hpagesize = gethugepagesize(path);

    if (!hpagesize) {

	return NULL;

    }

    if (memory < hpagesize) {

        return NULL;

    }

    if (kvm_enabled() && !kvm_has_sync_mmu()) {

        fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");

        return NULL;

    }

    if (asprintf(&filename, "%s/qemu_back_mem.XXXXXX", path) == -1) {

	return NULL;

    }

    fd = mkstemp(filename);

    if (fd < 0) {

	perror("mkstemp");

	free(filename);

	return NULL;

    }

    unlink(filename);

    free(filename);

    memory = (memory+hpagesize-1) & ~(hpagesize-1);

    /*

     * ftruncate is not supported by hugetlbfs in older

     * hosts, so don't bother bailing out on errors.

     * If anything goes wrong with it under other filesystems,

     * mmap will fail.

     */

    if (ftruncate(fd, memory))

	perror("ftruncate");

#ifdef MAP_POPULATE

    /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case

     * MAP_PRIVATE is requested.  For mem_prealloc we mmap as MAP_SHARED

     * to sidestep this quirk.

     */

    flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE;

    area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0);

#else

    area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);

#endif

    if (area == MAP_FAILED) {

	perror("file_ram_alloc: can't mmap RAM pages");

	close(fd);

	return (NULL);

    }

    return area;

}

#endif

    if (mem_path) {

#if defined (__linux__) && !defined(TARGET_S390X)

        new_block->host = file_ram_alloc(size, mem_path);

        if (!new_block->host)

            exit(1);

#else

        fprintf(stderr, "-mem-path option unsupported\n");

        exit(1);

#endif

    } else {

        /* XXX S390 KVM requires the topmost vma of the RAM to be < 256GB */

        new_block->host = mmap((void*)0x1000000, size,

                                PROT_EXEC|PROT_READ|PROT_WRITE,

                                MAP_SHARED | MAP_ANONYMOUS, -1, 0);

        new_block->host = qemu_vmalloc(size);

        madvise(new_block->host, size, MADV_MERGEABLE);

    }

DEF("mem-path", HAS_ARG, QEMU_OPTION_mempath,

    "-mem-path FILE  provide backing storage for guest RAM\n")

STEXI

@item -mem-path @var{path}

Allocate guest RAM from a temporarily created file in @var{path}.

ETEXI

#ifdef MAP_POPULATE

DEF("mem-prealloc", 0, QEMU_OPTION_mem_prealloc,

    "-mem-prealloc   preallocate guest memory (use with -mem-path)\n")

STEXI

@item -mem-prealloc

Preallocate memory when using -mem-path.

ETEXI

#endif

const char *mem_path = NULL;

#ifdef MAP_POPULATE

int mem_prealloc = 0; /* force preallocation of physical target memory */

#endif

            case QEMU_OPTION_mempath:

                mem_path = optarg;

                break;

#ifdef MAP_POPULATE

            case QEMU_OPTION_mem_prealloc:

                mem_prealloc = 1;

                break;

#endif