qemu-load.h

/*
 * Qemu save VM file description
 *
 * Copyright (C) 2009 Red Hat, Inc.
 * Written by Paolo Bonzini.
 *
 * 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.
 */

#ifndef QEMU_LOAD_H
#define QEMU_LOAD_H 1

#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>

enum qemu_save_section {
  QEMU_VM_EOF,
  QEMU_VM_SECTION_START,
  QEMU_VM_SECTION_PART,
  QEMU_VM_SECTION_END,
  QEMU_VM_SECTION_FULL,
  QEMU_VM_SUBSECTION,
  QEMU_VM_CONFIGURATION = 0x07,
  QEMU_VM_SECTION_FOOTER = 0x7e
};

enum qemu_features {
  QEMU_FEATURE_RAM = 1,
  QEMU_FEATURE_CPU = 2,
  QEMU_FEATURE_TIMER = 4,
  QEMU_FEATURE_KVM = 8
};

struct qemu_device_list {
	struct qemu_device	*head, *tail;
	uint32_t		features;
};

struct qemu_device_loader {
	const char	   *name;
	struct qemu_device *(*init_load) (struct qemu_device_list *, uint32_t,
					  uint32_t, uint32_t, bool, FILE *);
};

struct qemu_device_vtbl {
	const char	   *name;
	uint32_t	   (*load) (struct qemu_device *, FILE *,
				    enum qemu_save_section);
	void		   (*free) (struct qemu_device *,
				    struct qemu_device_list *);
};

struct qemu_device {
	struct qemu_device_vtbl *vtbl;
	struct qemu_device_list *list;
	struct qemu_device	*next;
	struct qemu_device	*prev;
	uint32_t		section_id;
	uint32_t		instance_id;
	uint32_t		version_id;
};

struct qemu_device_ram {
	struct qemu_device	dev_base;
	uint64_t		last_ram_offset;
	FILE			*fp;
	off_t			*offsets;
};

union qemu_uint128_t {
	uint32_t	i[4];
	unsigned	i128 __attribute__ ((vector_size (16)));
};

struct qemu_x86_seg {
	uint64_t	base;
	uint32_t	selector;
	uint32_t	limit;
	uint32_t	flags;
};

struct qemu_x86_sysenter {
	uint32_t	cs;
	uint64_t	esp;
	uint64_t	eip;
};

union qemu_fpu_reg {
	long double	ld;
	char		bytes[10];
	uint64_t	mmx;
};


struct qemu_x86_vmtrr {
	uint64_t		base;
	uint64_t		mask;
};

struct qemu_x86_svm {
	uint64_t		hsave;
	uint64_t		vmcb;
	uint64_t		tsc_offset;
	uint8_t			in_vmm : 1;
	uint8_t			guest_if_mask : 1;
	uint8_t			guest_intr_masking : 1;
	uint16_t		cr_read_mask;
	uint16_t		cr_write_mask;
	uint16_t		dr_read_mask;
	uint16_t		dr_write_mask;
	uint32_t		exception_intercept_mask;
	uint64_t		intercept_mask;
};

struct qemu_x86_kvm {
	uint64_t		int_bitmap[4];
	uint64_t		tsc;
	uint32_t		mp_state;
	uint32_t		exception_injected;
	uint8_t			soft_interrupt;
	uint8_t			nmi_injected;
	uint8_t			nmi_pending;
	uint8_t			has_error_code;
	uint32_t		sipi_vector;
	uint64_t		system_time_msr;
	uint64_t		wall_clock_msr;
};

struct qemu_x86_mce {
	uint64_t		mcg_cap;
	uint64_t		mcg_status;
	uint64_t		mcg_ctl;
	uint64_t		mce_banks[10 * 4];
};

struct qemu_device_x86 {
	struct qemu_device	dev_base;

	uint32_t		halted;
	uint32_t		irq;

	uint64_t		regs[16];
	uint64_t		eip;
	uint64_t		eflags;
	uint16_t		fpucw;
	uint16_t		fpusw;
	uint16_t		fpu_free;
	union qemu_fpu_reg	st[8];
	struct qemu_x86_seg	cs;
	struct qemu_x86_seg	ds;
	struct qemu_x86_seg	es;
	struct qemu_x86_seg	ss;
	struct qemu_x86_seg	fs;
	struct qemu_x86_seg	gs;
	struct qemu_x86_seg	ldt;
	struct qemu_x86_seg	tr;
	struct qemu_x86_seg	gdt;
	struct qemu_x86_seg	idt;
	struct qemu_x86_sysenter sysenter;
	uint64_t		cr0;
	uint64_t		cr2;
	uint64_t		cr3;
	uint64_t		cr4;
	uint64_t		dr[8];
	uint8_t			cr8;
	uint8_t			soft_mmu : 1;
	uint8_t			smm : 1;
	uint8_t			a20_masked : 1;
	uint8_t			global_if : 1;
	uint8_t			in_nmi : 1;
	uint32_t		mxcsr;
	union qemu_uint128_t	xmm[16];
	uint64_t		efer;
	uint64_t		star;
	uint64_t		lstar;
	uint64_t		cstar;
	uint64_t		fmask;
	uint64_t		kernel_gs_base;
	uint64_t		pat;
	uint32_t		smbase;
	struct qemu_x86_svm	svm;
	uint64_t		fixed_mtrr[11];
	uint64_t		deftype_mtrr;
	struct qemu_x86_vmtrr	variable_mtrr[8];
	struct qemu_x86_kvm	kvm;
	struct qemu_x86_mce	mce;
	uint64_t		tsc_aux;
	uint64_t		xcr0;
	uint64_t		xstate_bv;
	union qemu_uint128_t	ymmh_regs[16];
};

struct qemu_timer {
	uint64_t		cpu_ticks_offset;
	uint64_t		ticks_per_sec;
	uint64_t		cpu_clock_offset;
};

struct qemu_device *device_alloc (struct qemu_device_list *, size_t,
				  struct qemu_device_vtbl *, uint32_t,
				  uint32_t, uint32_t);
void device_free (struct qemu_device *);
void device_list_free (struct qemu_device_list *);
struct qemu_device *device_find (struct qemu_device_list *, uint32_t);
struct qemu_device *device_find_instance (struct qemu_device_list *,
					  const char *, uint32_t);

struct qemu_device_list *qemu_load (const struct qemu_device_loader *,
				    uint32_t, FILE *);

int ram_read_phys_page (struct qemu_device_ram *, void *, uint64_t);

/* For a 32-bit KVM host.  */
extern const struct qemu_device_loader devices_x86_32[];

/* For a 64-bit KVM host.  */
extern const struct qemu_device_loader devices_x86_64[];

#endif