/*
 * Qemu save VM loader
 *
 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.
 * Written by Paolo Bonzini.
 *
 * Portions Copyright (C) 2009 David Anderson
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#define _GNU_SOURCE
#include "qemu-load.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/mman.h>

#include "kvmdump.h"

struct qemu_device *
device_alloc (struct qemu_device_list *dl, size_t sz,
	     struct qemu_device_vtbl *vtbl,
             uint32_t section_id, uint32_t instance_id, uint32_t version_id)
{
	struct qemu_device *d = calloc (1, sz);
	d->vtbl = vtbl;
	d->list = dl;
	d->section_id = section_id;
	d->instance_id = instance_id;
	d->version_id = version_id;

	if (!dl->head)
		dl->head = dl->tail = d;
	else {
		dl->tail->next = d;
		d->prev = dl->tail;
		dl->tail = d;
	}
	return d;
}

struct qemu_device *
device_find (struct qemu_device_list *dl, uint32_t section_id)
{
	struct qemu_device *d;
	d = dl->head;
	while (d && d->section_id != section_id)
		d = d->next;

	return d;
}

struct qemu_device *
device_find_instance (struct qemu_device_list *dl, const char *name,
		      uint32_t instance_id)
{
	struct qemu_device *d;
	d = dl->head;
	while (d && (strcmp (d->vtbl->name, name) || d->instance_id != instance_id))
		d = d->next;

	return d;
}

void
device_free (struct qemu_device *d)
{
	struct qemu_device_list *dl = d->list;
	if (d->prev)
		d->prev->next = d->next;
	else
		dl->head = d->next;
	if (d->next)
		d->next->prev = d->prev;
	else
		dl->tail = d->prev;

	d->prev = d->next = NULL;
	if (d->vtbl->free)
		d->vtbl->free (d, dl);
}

void
device_list_free (struct qemu_device_list *l)
{
	if (!l)
		return;

	while (l->head)
		device_free (l->head);
}


/* File access.  */

static inline uint16_t
get_be16 (FILE *fp)
{
	uint8_t a = getc (fp);
	uint8_t b = getc (fp);
	return (a << 8) | b;
}

static inline uint16_t
get_le16 (FILE *fp)
{
	uint8_t b = getc (fp);
	uint8_t a = getc (fp);
	return (a << 8) | b;
}

static inline uint32_t
get_be32 (FILE *fp)
{
	uint16_t a = get_be16 (fp);
	uint16_t b = get_be16 (fp);
	return (a << 16) | b;
}

static inline uint32_t
get_le32 (FILE *fp)
{
	uint16_t b = get_le16 (fp);
	uint16_t a = get_le16 (fp);
	return (a << 16) | b;
}

static inline uint64_t
get_be64 (FILE *fp)
{
	uint32_t a = get_be32 (fp);
	uint32_t b = get_be32 (fp);
	return ((uint64_t)a << 32) | b;
}

static inline uint64_t
get_le64 (FILE *fp)
{
	uint32_t b = get_le32 (fp);
	uint32_t a = get_le32 (fp);
	return ((uint64_t)a << 32) | b;
}

static inline void
get_qemu128 (FILE *fp, union qemu_uint128_t *result)
{
	result->i[1] = get_le32 (fp);
	result->i[0] = get_le32 (fp);
	result->i[3] = get_le32 (fp);
	result->i[2] = get_le32 (fp);
}




/* RAM loader.  */

#define RAM_SAVE_FLAG_FULL	0x01
#define RAM_SAVE_FLAG_COMPRESS	0x02
#define RAM_SAVE_FLAG_MEM_SIZE	0x04
#define RAM_SAVE_FLAG_PAGE	0x08
#define RAM_SAVE_FLAG_EOS	0x10
#define RAM_SAVE_FLAG_CONTINUE	0x20
#define RAM_SAVE_ADDR_MASK	(~4095LL)

#define RAM_OFFSET_COMPRESSED	(~(off_t)255)

static void
ram_alloc (struct qemu_device_ram *dram, uint64_t size)
{
//	size_t old_npages = dram->offsets ? 0 : dram->last_ram_offset / 4096;
//	size_t new_npages = size / 4096;
//	assert (size <= SIZE_MAX);
//	if (dram->offsets)
//		dram->offsets = realloc (dram->offsets,
//					 new_npages * sizeof (off_t));
//	else
//		dram->offsets = malloc (new_npages * sizeof (off_t));
//
//	assert (dram->offsets);
//	while (old_npages < new_npages)
//		dram->offsets[old_npages++] = RAM_OFFSET_COMPRESSED | 0;

	dram->last_ram_offset = size;
}

#ifndef ATTRIBUTE_UNUSED
#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif

static int
get_string (FILE *fp, char *name)
{
	size_t items ATTRIBUTE_UNUSED;
	int sz = (uint8_t) getc (fp);
	if (sz == EOF)
		return -1;
	items = fread (name, sz, 1, fp);
	name[sz] = 0;
	return sz;
}
static int
get_string_len (FILE *fp, char *name, uint32_t sz)
{
	size_t items ATTRIBUTE_UNUSED;
	if (sz == EOF)
		return -1;
	items = fread (name, sz, 1, fp);
	name[sz] = 0;
	return sz;
}

static void
ram_read_blocks (FILE *fp, uint64_t size)
{
	char name[257];
	/* The RAM block table is a list of block names followed by
	   their sizes.  Read it until the sizes sum up to SIZE bytes.  */
	while (size) {
		get_string (fp, name);
		size -= get_be64 (fp);
	}
}

static uint32_t
ram_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	char name[257];
	struct qemu_device_ram *dram = (struct qemu_device_ram *)d;
	uint64_t header;
	static int pc_ram = 0;

	for (;;) {
		uint64_t addr;
		off_t entry;

		header = get_be64 (fp);
		if (feof (fp) || ferror (fp))
			return 0;
		if (header & RAM_SAVE_FLAG_EOS)
			break;

		assert (!(header & RAM_SAVE_FLAG_FULL));

		addr = header & RAM_SAVE_ADDR_MASK;

		if (header & RAM_SAVE_FLAG_MEM_SIZE) {
			ram_alloc (dram, addr);
			if (d->version_id >= 4)
				ram_read_blocks(fp, addr);
			continue;
		}

		if (d->version_id >= 4 && !(header & RAM_SAVE_FLAG_CONTINUE)) {
			get_string(fp, name);
			if (strcmp(name, "pc.ram") == 0)
				pc_ram = 1;
			else
				pc_ram = 0;
		}

		if (header & RAM_SAVE_FLAG_COMPRESS) {
			entry = RAM_OFFSET_COMPRESSED | getc(fp);
			if ((d->version_id == 3) || 
			    (d->version_id >= 4 && pc_ram))
				store_mapfile_offset(addr, &entry);
		}
		else if (header & RAM_SAVE_FLAG_PAGE) {
			entry = ftell(fp);
			if ((d->version_id == 3) || 
			    (d->version_id >= 4 && pc_ram))
				store_mapfile_offset(addr, &entry);
			fseek (fp, 4096, SEEK_CUR);
		}
	}

	dram->fp = fp;
	return QEMU_FEATURE_RAM;
}

static void
ram_free (struct qemu_device *d, struct qemu_device_list *dl)
{
	struct qemu_device_ram *dram = (struct qemu_device_ram *)d;
	free (dram->offsets);
}

int
ram_read_phys_page (struct qemu_device_ram *dram, void *buf, uint64_t addr)
{
	off_t ofs;
	ssize_t bytes ATTRIBUTE_UNUSED;

        if (addr >= dram->last_ram_offset)
                return false;
        assert ((addr & 0xfff) == 0);
//	ofs = dram->offsets[addr / 4096];
	if (load_mapfile_offset(addr, &ofs) < 0)
		return 0;
	if ((ofs & RAM_OFFSET_COMPRESSED) == RAM_OFFSET_COMPRESSED)
		memset (buf, ofs & 255, 4096);
	else
	        bytes = pread (fileno (dram->fp), buf, 4096, ofs);
	return true;
}

static struct qemu_device *
ram_init_load (struct qemu_device_list *dl,
	       uint32_t section_id, uint32_t instance_id,
	       uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl ram = {
		"ram", 
		ram_load, 
		ram_free
	};

	assert (version_id == 3 || version_id == 4);
	kvm->mapinfo.ram_version_id = version_id;
	return device_alloc (dl, sizeof (struct qemu_device_ram),
			     &ram, section_id, instance_id, version_id);
}


#define BLK_MIG_FLAG_EOS 2

static uint32_t
block_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	uint64_t header;

	header = get_be64 (fp);
	assert (header == BLK_MIG_FLAG_EOS);
	return 0;
}

static struct qemu_device *
block_init_load (struct qemu_device_list *dl,
		 uint32_t section_id, uint32_t instance_id,
		 uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl block = {
		"block",
		block_load, 
		NULL
	};

	return device_alloc (dl, sizeof (struct qemu_device),
			     &block, section_id, instance_id, version_id);
}

/* RHEL5 marker.  */

static uint32_t
rhel5_marker_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	return 0;
}

static struct qemu_device *
rhel5_marker_init_load (struct qemu_device_list *dl,
		      uint32_t section_id, uint32_t instance_id,
		      uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl rhel5_marker = {
		"__rhel5",
		rhel5_marker_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device),
			     &rhel5_marker, section_id, instance_id,
			     version_id);
}



/* cpu_common loader.  */

struct qemu_device_cpu_common {
	struct qemu_device	base;
	uint32_t		halted;
	uint32_t		irq;
};

static uint32_t
cpu_common_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	struct qemu_device_cpu_common *cpu = (struct qemu_device_cpu_common *)d;
	cpu->halted = get_be32 (fp);
	cpu->irq = get_be32 (fp);
	return 0;
}

static struct qemu_device *
cpu_common_init_load (struct qemu_device_list *dl,
		      uint32_t section_id, uint32_t instance_id,
		      uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl cpu_common = {
		"cpu_common",
		cpu_common_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device_cpu_common),
			     &cpu_common, section_id, instance_id, version_id);
}



/* CPU loader.  */

static inline uint64_t
get_be_long (FILE *fp, int size)
{
	uint32_t a = size == 32 ? 0 : get_be32 (fp);
	uint32_t b = get_be32 (fp);
	return ((uint64_t)a << 32) | b;
}

static inline void
get_be_fp80 (FILE *fp, union qemu_fpu_reg *result)
{
	result->mmx = get_be64 (fp);
	result->bytes[9] = getc (fp);
	result->bytes[8] = getc (fp);
}

static void
cpu_load_seg (FILE *fp, struct qemu_x86_seg *seg, int size)
{
	seg->selector = get_be32 (fp);
	seg->base = get_be_long (fp, size);
	seg->limit = get_be32 (fp);
	seg->flags = get_be32 (fp);
}

static bool
v12_has_xsave_state(FILE *fp)
{
	char name[257];
	bool ret = true;
	long offset = ftell(fp); // save offset

        /*
	 * peek into byte stream to check for APIC vmstate
	 */
	if (getc(fp) == QEMU_VM_SECTION_FULL) {
		get_be32(fp); // skip section id
		get_string(fp, name);
		if (strcmp(name, "apic") == 0)
			ret = false;
	}
	fseek(fp, offset, SEEK_SET); // restore offset

	return ret;
}

static uint32_t
cpu_load (struct qemu_device *d, FILE *fp, int size)
{
	struct qemu_device_x86 *dx86 = (struct qemu_device_x86 *)d;
	uint32_t qemu_hflags = 0, qemu_hflags2 = 0;
	int nregs;
	uint32_t version_id = dx86->dev_base.version_id;
	uint32_t rhel5_version_id;
	int i;
	off_t restart;

	struct qemu_device *drhel5;
	struct qemu_device_cpu_common *dcpu;

	if (kvm->flags & KVMHOST_32)
		size = 32;
	restart = ftello(fp);
retry:
	nregs = size == 32 ? 8 : 16;
	drhel5 = device_find_instance (d->list, "__rhel5", 0);
	if (drhel5 || (version_id >= 7 && version_id <= 9)) {
		rhel5_version_id = version_id;
		version_id = 7;
	} else {
		rhel5_version_id = 0;
	       	version_id = dx86->dev_base.version_id;
	}

	dprintf("cpu_load: rhel5_version_id: %d (effective) version_id: %d\n",
		rhel5_version_id, version_id);

	dcpu = (struct qemu_device_cpu_common *)
		device_find_instance (d->list, "cpu_common", d->instance_id);
	if (dcpu) {
		dx86->halted = dcpu->halted;
		dx86->irq = dcpu->irq;
//		device_free ((struct qemu_device *) dcpu);
	}

	for (i = 0; i < nregs; i++)
		dx86->regs[i] = get_be_long (fp, size);

	dx86->eip = get_be_long (fp, size);
	dx86->eflags = get_be_long (fp, size);
	qemu_hflags = get_be32 (fp);
	dx86->fpucw = get_be16 (fp);
	dx86->fpusw = get_be16 (fp);
	dx86->fpu_free = get_be16 (fp);

	if (get_be16 (fp))
		for (i = 0; i < 8; i++)
			dx86->st[i].mmx = get_be64 (fp);
	else
		for (i = 0; i < 8; i++)
			get_be_fp80 (fp, &dx86->st[i]);

	cpu_load_seg (fp, &dx86->es, size);
	cpu_load_seg (fp, &dx86->cs, size);
	cpu_load_seg (fp, &dx86->ss, size);
	cpu_load_seg (fp, &dx86->ds, size);
	cpu_load_seg (fp, &dx86->fs, size);
	cpu_load_seg (fp, &dx86->gs, size);
	cpu_load_seg (fp, &dx86->ldt, size);
	cpu_load_seg (fp, &dx86->tr, size);
	cpu_load_seg (fp, &dx86->gdt, size);
	cpu_load_seg (fp, &dx86->idt, size);

	dx86->sysenter.cs = get_be32 (fp);
	dx86->sysenter.esp = get_be_long (fp, version_id <= 6 ? 32 : size);
	dx86->sysenter.eip = get_be_long (fp, version_id <= 6 ? 32 : size);

	dx86->cr0 = get_be_long (fp, size);
	dx86->cr2 = get_be_long (fp, size);
	dx86->cr3 = get_be_long (fp, size);
	dx86->cr4 = get_be_long (fp, size);
	for (i = 0; i < 8; i++)
		dx86->dr[i] = get_be_long (fp, size);

	dx86->a20_masked = get_be32 (fp) != 0xffffffff;
	dx86->mxcsr = get_be32 (fp);

	for (i = 0; i < nregs; i++)
		get_qemu128 (fp, &dx86->xmm[i]);

	if (size == 64) {
		dx86->efer = get_be64 (fp);
		dx86->star = get_be64 (fp);
		dx86->lstar = get_be64 (fp);
		dx86->cstar = get_be64 (fp);
		dx86->fmask = get_be64 (fp);
		dx86->kernel_gs_base = get_be64 (fp);
	}

	dx86->smbase = get_be32 (fp);

	dx86->soft_mmu = qemu_hflags	& (1 << 2);
	dx86->smm = qemu_hflags		& (1 << 19);

	if (version_id == 4)
		goto store;

	dx86->pat = get_be64 (fp);
	qemu_hflags2 = get_be32 (fp);
	dx86->global_if = qemu_hflags2	& (1 << 0);
	dx86->in_nmi = qemu_hflags2	& (1 << 2);

	if (version_id < 6)
		dx86->halted = get_be32 (fp);

	dx86->svm.hsave = get_be64 (fp);
	dx86->svm.vmcb = get_be64 (fp);
	dx86->svm.tsc_offset = get_be64 (fp);
	dx86->svm.in_vmm = qemu_hflags	& (1 << 21);
	dx86->svm.guest_if_mask = qemu_hflags2 & (1 << 1);
	dx86->svm.guest_intr_masking = qemu_hflags2 & (1 << 3);
	dx86->svm.intercept_mask = get_be64 (fp);
	dx86->svm.cr_read_mask = get_be16 (fp);
	dx86->svm.cr_write_mask = get_be16 (fp);
	dx86->svm.dr_read_mask = get_be16 (fp);
	dx86->svm.dr_write_mask = get_be16 (fp);
	dx86->svm.exception_intercept_mask = get_be32 (fp);
	dx86->cr8 = getc (fp);

	if (version_id >= 8) {
		for (i = 0; i < 11; i++)
			dx86->fixed_mtrr[i] = get_be64 (fp);
		dx86->deftype_mtrr = get_be64 (fp);
		for (i = 0; i < 8; i++) {
			dx86->variable_mtrr[i].base = get_be64 (fp);
			dx86->variable_mtrr[i].mask = get_be64 (fp);
		}
	}

	/* This was present only when KVM was enabled up to v8.
	 * Furthermore, it changed format in v9.  */
	if (version_id >= 9) {
		int32_t pending_irq = (int32_t) get_be32 (fp);
		if (pending_irq >= 0 && pending_irq <= 255)
			dx86->kvm.int_bitmap[pending_irq / 64] |=
				(uint64_t)1 << (pending_irq & 63);

		dx86->kvm.mp_state = get_be32 (fp);
		dx86->kvm.tsc = get_be64 (fp);
	}

	else if (d->list->features & QEMU_FEATURE_KVM) {
		for (i = 0; i < 4; i++)
			dx86->kvm.int_bitmap[i] = get_be64 (fp);
		dx86->kvm.tsc = get_be64 (fp);
		if (version_id >= 5)
			dx86->kvm.mp_state = get_be32 (fp);
	}

	if (version_id >= 11) {
		dx86->kvm.exception_injected = get_be32 (fp);
	}
	if (rhel5_version_id >= 8) {
		dx86->kvm.system_time_msr = get_be64 (fp);
		dx86->kvm.wall_clock_msr = get_be64 (fp);
	}
	if (version_id >= 11 || rhel5_version_id >= 9) {
		dx86->kvm.soft_interrupt = getc (fp);
		dx86->kvm.nmi_injected = getc (fp);
		dx86->kvm.nmi_pending = getc (fp);
		dx86->kvm.has_error_code = getc (fp);
		dx86->kvm.sipi_vector = get_be32 (fp);
	}

	if (version_id >= 10) {
		dx86->mce.mcg_cap = get_be64 (fp);
		dx86->mce.mcg_status = get_be64 (fp);
		dx86->mce.mcg_ctl = get_be64 (fp);
		for (i = 0; i < 10 * 4; i++)
			dx86->mce.mce_banks[i] = get_be64 (fp);
	}

	if (version_id >= 11) {
		dx86->tsc_aux = get_be64 (fp);
		dx86->kvm.system_time_msr = get_be64 (fp);
		dx86->kvm.wall_clock_msr = get_be64 (fp);
	}

	if (version_id >= 12 && v12_has_xsave_state(fp)) {
		dx86->xcr0 = get_be64 (fp);
		dx86->xstate_bv = get_be64 (fp);

		for (i = 0; i < nregs; i++)
			get_qemu128 (fp, &dx86->ymmh_regs[i]);
	}

store:
	if (!kvmdump_regs_store(d->instance_id, dx86)) {
		size = 32;
		kvm->flags |= KVMHOST_32;
		fseeko(fp, restart, SEEK_SET);
		dprintf("cpu_load: invalid registers: retry with 32-bit host\n");
		goto retry;
	}

	if (dcpu)
		device_free ((struct qemu_device *) dcpu);

	return QEMU_FEATURE_CPU;
}

static uint32_t
cpu_load_32 (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	return cpu_load (d, fp, 32);
}

static struct qemu_device *
cpu_init_load_32 (struct qemu_device_list *dl,
		  uint32_t section_id, uint32_t instance_id,
		  uint32_t version_id, bool live, FILE *fp)
{
	struct qemu_device_x86 *dx86;
	static struct qemu_device_vtbl cpu = {
		"cpu",
		cpu_load_32,
		NULL
	};

	assert (!live);
//	assert (version_id >= 4 && version_id <= 9);
	assert (version_id >= 4 && version_id <= 12);
	kvm->mapinfo.cpu_version_id = version_id;
	dx86 = (struct qemu_device_x86 *)
		device_alloc (dl, sizeof (struct qemu_device_x86),
			      &cpu, section_id, instance_id, version_id);
	return (struct qemu_device *) dx86;
}

static uint32_t
cpu_load_64 (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	return cpu_load (d, fp, 64);
}

static struct qemu_device *
cpu_init_load_64 (struct qemu_device_list *dl,
		  uint32_t section_id, uint32_t instance_id,
		  uint32_t version_id, bool live, FILE *fp)
{
	struct qemu_device_x86 *dx86;
	static struct qemu_device_vtbl cpu = {
		"cpu",
		cpu_load_64, 
		NULL
	};

	assert (!live);
//	assert (version_id >= 4 && version_id <= 9);
	assert (version_id >= 4 && version_id <= 12);
	kvm->mapinfo.cpu_version_id = version_id;
	dx86 = (struct qemu_device_x86 *)
		device_alloc (dl, sizeof (struct qemu_device_x86),
			      &cpu, section_id, instance_id, version_id);
	return (struct qemu_device *) dx86;
}


/* IOAPIC loader.  */

static uint32_t
apic_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	switch (d->version_id) {
	case 1: fseek (fp, 173, SEEK_CUR); break;
	case 2:
	case 3: fseek (fp, 181, SEEK_CUR); break;
	}

	return 0;
}

static struct qemu_device *
apic_init_load (struct qemu_device_list *dl,
		       uint32_t section_id, uint32_t instance_id,
		       uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl apic = {
		"apic",
		apic_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device),
			     &apic, section_id, instance_id, version_id);
}



/* timer loader.  */

static uint32_t
timer_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	fseek (fp, 24, SEEK_CUR);
	return QEMU_FEATURE_TIMER;
}

static struct qemu_device *
timer_init_load (struct qemu_device_list *dl,
		       uint32_t section_id, uint32_t instance_id,
		       uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl timer = {
		"timer",
		timer_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device),
			     &timer, section_id, instance_id, version_id);
}


/* kvmclock loader.  */

static uint32_t
kvmclock_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	fseek (fp, 8, SEEK_CUR);
	return QEMU_FEATURE_KVM;
}

static struct qemu_device *
kvmclock_init_load (struct qemu_device_list *dl,
		       uint32_t section_id, uint32_t instance_id,
		       uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl kvmclock = {
		"kvmclock",
		kvmclock_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device),
			     &kvmclock, section_id, instance_id, version_id);
}


/* kvm-tpr-opt loader.  */

static uint32_t
kvm_tpr_opt_load (struct qemu_device *d, FILE *fp, enum qemu_save_section sec)
{
	fseek (fp, 144, SEEK_CUR);
	return QEMU_FEATURE_KVM;
}

static struct qemu_device *
kvm_tpr_opt_init_load (struct qemu_device_list *dl,
		       uint32_t section_id, uint32_t instance_id,
		       uint32_t version_id, bool live, FILE *fp)
{
	static struct qemu_device_vtbl kvm_tpr_opt = {
		"kvm-tpr-opt",
		kvm_tpr_opt_load, 
		NULL
	};

	assert (!live);
	return device_alloc (dl, sizeof (struct qemu_device),
			     &kvm_tpr_opt, section_id, instance_id, version_id);
}


/* Putting it together.  */

const struct qemu_device_loader devices_x86_64[] = {
	{ "__rhel5", rhel5_marker_init_load },
	{ "cpu_common", cpu_common_init_load },
	{ "kvm-tpr-opt", kvm_tpr_opt_init_load },
	{ "kvmclock", kvmclock_init_load },
	{ "cpu", cpu_init_load_64 },
	{ "apic", apic_init_load },
	{ "block", block_init_load },
	{ "ram", ram_init_load },
	{ "timer", timer_init_load },
	{ NULL, NULL }
};

const struct qemu_device_loader devices_x86_32[] = {
	{ "__rhel5", rhel5_marker_init_load },
	{ "cpu_common", cpu_common_init_load },
	{ "kvm-tpr-opt", kvm_tpr_opt_init_load },
	{ "kvmclock", kvmclock_init_load },
	{ "cpu", cpu_init_load_32 },
	{ "apic", apic_init_load },
	{ "block", block_init_load },
	{ "ram", ram_init_load },
	{ "timer", timer_init_load },
	{ NULL, NULL }
};


#define QEMU_VM_FILE_MAGIC	0x5145564D
#define LIBVIRT_QEMU_VM_FILE_MAGIC	0x4c696276

struct libvirt_header {
	char		magic[16];
	uint32_t	version;
	uint32_t	xml_length;
	uint32_t	was_running;
	uint32_t	padding[16];
};

static long device_search(const struct qemu_device_loader *, FILE *);

static struct qemu_device *
device_get (const struct qemu_device_loader *devices,
	    struct qemu_device_list *dl, enum qemu_save_section sec, FILE *fp)
{
	char name[257];
	uint32_t section_id, instance_id, version_id;
//	bool live;
	const struct qemu_device_loader *devp;
	long next_device_offset;

next_device:
	devp = devices;
	if (sec == QEMU_VM_SUBSECTION) {
		get_string(fp, name);
		goto search_device;
	}
	section_id = get_be32 (fp);
	if (sec != QEMU_VM_SECTION_START &&
	    sec != QEMU_VM_SECTION_FULL)
		return device_find (dl, section_id);

	get_string(fp, name);

	instance_id = get_be32 (fp);
	version_id = get_be32 (fp);

	while (devp->name && strcmp (devp->name, name))
		devp++;
	if (!devp->name) {
search_device:
		dprintf("device_get: unknown/unsupported: \"%s\"\n", name);
		if ((next_device_offset = device_search(devices, fp))) {
			fseek(fp, next_device_offset, SEEK_CUR);
			sec = getc(fp);
			if (sec == QEMU_VM_EOF)
				return NULL;
			goto next_device;
		}
		return NULL;
	}

	return devp->init_load (dl, section_id, instance_id, version_id,
				   sec == QEMU_VM_SECTION_START, fp);
}

struct qemu_device_list *
qemu_load (const struct qemu_device_loader *devices, uint32_t required_features,
	   FILE *fp)
{
	struct qemu_device_list *result = NULL;
	struct qemu_device *last = NULL;;
	size_t items ATTRIBUTE_UNUSED;
	uint32_t footerSecId ATTRIBUTE_UNUSED;
	char name[257];

	switch (get_be32 (fp)) {
	case QEMU_VM_FILE_MAGIC:
		break;

	case LIBVIRT_QEMU_VM_FILE_MAGIC: {
		struct libvirt_header header;
		memcpy (header.magic, "Libv", 4);
		items = fread (&header.magic[4], sizeof (header) - 4, 1, fp);
		if (memcmp ("LibvirtQemudSave", header.magic, 16))
			goto fail;

		fseek (fp, header.xml_length, SEEK_CUR);
		if (get_be32 (fp) != QEMU_VM_FILE_MAGIC)
			goto fail;
		break;
	}

	default:
		goto fail;
	}

	if (get_be32 (fp) != 3)
		return NULL;

	dprintf("\n");

	result = calloc (1, sizeof (struct qemu_device_list));
	for (;;) {
		struct qemu_device *d;
		uint32_t features;
		enum qemu_save_section sec = getc (fp);

		if (feof (fp) || ferror (fp))
			break;
		if (sec == QEMU_VM_EOF)
			break;
		if (sec == QEMU_VM_SECTION_FOOTER) {
			footerSecId = get_be32 (fp);
			continue;
                }
		if (sec == QEMU_VM_CONFIGURATION) {
			uint32_t len = get_be32 (fp);
			get_string_len (fp, name, len);
			continue;
                }

		d = device_get (devices, result, sec, fp);
		if (!d)
			break;

		if (d != last) {
			dprintf("qemu_load: \"%s\"\n", d->vtbl->name);
			last = d;
		}

		features = d->vtbl->load (d, fp, sec);
		if (feof (fp) || ferror (fp))
			break;

		if (sec == QEMU_VM_SECTION_END || sec == QEMU_VM_SECTION_FULL)
			result->features |= features;
	}

	if (ferror (fp) ||
	    (result->features & required_features) != required_features)
		goto fail;

	return result;

fail:
	device_list_free (result);
	free (result);
	return NULL;
}

/*
 *  crash utility adaptation.
 */

#include "defs.h"

int
is_qemu_vm_file(char *filename)
{
	struct libvirt_header header;
	FILE *vmp;
	int retval;
	size_t items ATTRIBUTE_UNUSED;
	char *xml;

	if ((vmp = fopen(filename, "r")) == NULL) {
		error(INFO, "%s: %s\n", filename, strerror(errno));
		return FALSE;
	}

	retval = FALSE;
	xml = NULL;

	switch (get_be32(vmp)) 
	{
	case QEMU_VM_FILE_MAGIC:
		retval = TRUE;
		break;

	case LIBVIRT_QEMU_VM_FILE_MAGIC: 
		rewind(vmp);
		items = fread(&header.magic[0], sizeof(header), 1, vmp); 
		if (STRNEQ(header.magic, "LibvirtQemudSave")) {
			if ((xml = (char *)malloc(header.xml_length))) {
				items = fread(xml, header.xml_length, 1, vmp);
				/*
				 *  Parse here if necessary or desirable.
				 */
			} else
				fseek(vmp, header.xml_length, SEEK_CUR);

			if (get_be32(vmp) == QEMU_VM_FILE_MAGIC)
				retval = TRUE;
		}
		break;

	default:
		retval = FALSE;
	}

	if (xml)
		free(xml);

	switch (retval) 
	{
	case TRUE:
		kvm->vmp = vmp;
		kvm->vmfd = fileno(vmp);
		break;
	case FALSE:
		fclose(vmp);
		break;
	}

	return retval;
}

void
dump_qemu_header(FILE *out)
{
	int i;
	struct libvirt_header header;
	char magic[4];
	uint8_t c;
	size_t items ATTRIBUTE_UNUSED;

	rewind(kvm->vmp);
	if (get_be32(kvm->vmp) == QEMU_VM_FILE_MAGIC) {
		fprintf(out, "%s: QEMU_VM_FILE_MAGIC\n", pc->dumpfile);
		return; 
	}

	rewind(kvm->vmp);
	items = fread(&header, sizeof(header), 1, kvm->vmp);

	fprintf(out, "%s: libvirt_header:\n\n", pc->dumpfile);
	fprintf(out, "      magic: ");
	for (i = 0; i < 16; i++)
		fprintf(out, "%c", header.magic[i]);
	fprintf(out, "\n");
	fprintf(out, "      version: %d\n", header.version);
	fprintf(out, "   xml_length: %d\n", header.xml_length);
	fprintf(out, "  was_running: %d\n", header.was_running);
	fprintf(out, "      padding: (not shown)\n\n");
	for (i = 0; i < header.xml_length; i++) {
		c = getc(kvm->vmp);
		if (c)
			fprintf(out, "%c", c);
	}
	fprintf(out, "\n");
	items = fread(&magic, sizeof(char), 4, kvm->vmp);
	for (i = 0; i < 4; i++)
		fprintf(out, "%c", magic[i]);
	fprintf(out, "\n");
}

static long
device_search(const struct qemu_device_loader *devices, FILE *fp)
{
	uint sz;
	char *p1, *p2;
	long next_device_offset;
	long remaining;
	char buf[4096];
	off_t current;

	BZERO(buf, 4096);

	current = ftello(fp);
	if (fread(buf, sizeof(char), 4096, fp) != 4096) {
		fseeko(fp, current, SEEK_SET);
		return 0;
	}
	fseeko(fp, current, SEEK_SET);

        while (devices->name) {
		for (p1 = buf, remaining = 4096; 
	     	    (p2 = memchr(p1, devices->name[0], remaining));
	     	     p1 = p2+1, remaining = 4096 - (p1-buf)) {
			sz = *((unsigned char *)p2-1);
			if (STRNEQ(p2, devices->name) && 
			    (strlen(devices->name) == sz)) {
				*(p2+sz) = '\0';
				dprintf("device_search: %s\n", p2);
				next_device_offset = (p2-buf) - 6;
				return next_device_offset;
			}
		}
		devices++;
	}

	return 0;
}