x86_machine.c

/*
 * PC emulator
 * 
 * Copyright (c) 2011-2017 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <inttypes.h>
#include <assert.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>

#include "cutils.h"
#include "iomem.h"
#include "virtio.h"
#include "x86_cpu.h"
#include "machine.h"
#include "pci.h"
#include "ide.h"
#include "ps2.h"

#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
#define USE_KVM
#endif

#ifdef USE_KVM
#include <linux/kvm.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <sys/time.h>
#endif

//#define DEBUG_BIOS
//#define DUMP_IOPORT

/***********************************************************/
/* cmos emulation */

//#define DEBUG_CMOS

#define RTC_SECONDS             0
#define RTC_SECONDS_ALARM       1
#define RTC_MINUTES             2
#define RTC_MINUTES_ALARM       3
#define RTC_HOURS               4
#define RTC_HOURS_ALARM         5
#define RTC_ALARM_DONT_CARE    0xC0

#define RTC_DAY_OF_WEEK         6
#define RTC_DAY_OF_MONTH        7
#define RTC_MONTH               8
#define RTC_YEAR                9

#define RTC_REG_A               10
#define RTC_REG_B               11
#define RTC_REG_C               12
#define RTC_REG_D               13

#define REG_A_UIP 0x80

#define REG_B_SET 0x80
#define REG_B_PIE 0x40
#define REG_B_AIE 0x20
#define REG_B_UIE 0x10

typedef struct {
    uint8_t cmos_index;
    uint8_t cmos_data[128];
    IRQSignal *irq;
    BOOL use_local_time;
    /* used for the periodic irq */
    uint32_t irq_timeout;
    uint32_t irq_period;
} CMOSState;

static void cmos_write(void *opaque, uint32_t offset,
                       uint32_t data, int size_log2);
static uint32_t cmos_read(void *opaque, uint32_t offset, int size_log2);

static int to_bcd(CMOSState *s, unsigned int a)
{
    if (s->cmos_data[RTC_REG_B] & 0x04) {
        return a;
    } else {
        return ((a / 10) << 4) | (a % 10);
    }
}

static void cmos_update_time(CMOSState *s, BOOL set_century)
{
    struct timeval tv;
    struct tm tm;
    time_t ti;
    int val;
    
    gettimeofday(&tv, NULL);
    ti = tv.tv_sec;
    if (s->use_local_time) {
        localtime_r(&ti, &tm);
    } else {
        gmtime_r(&ti, &tm);
    }
    
    s->cmos_data[RTC_SECONDS] = to_bcd(s, tm.tm_sec);
    s->cmos_data[RTC_MINUTES] = to_bcd(s, tm.tm_min);
    if (s->cmos_data[RTC_REG_B] & 0x02) {
        s->cmos_data[RTC_HOURS] = to_bcd(s, tm.tm_hour);
    } else {
        s->cmos_data[RTC_HOURS] = to_bcd(s, tm.tm_hour % 12);
        if (tm.tm_hour >= 12)
            s->cmos_data[RTC_HOURS] |= 0x80;
    }
    s->cmos_data[RTC_DAY_OF_WEEK] = to_bcd(s, tm.tm_wday);
    s->cmos_data[RTC_DAY_OF_MONTH] = to_bcd(s, tm.tm_mday);
    s->cmos_data[RTC_MONTH] = to_bcd(s, tm.tm_mon + 1);
    s->cmos_data[RTC_YEAR] = to_bcd(s, tm.tm_year % 100);

    if (set_century) {
        /* not set by the hardware, but easier to do it here */
        val = to_bcd(s, (tm.tm_year / 100) + 19);
        s->cmos_data[0x32] = val;
        s->cmos_data[0x37] = val;
    }
    
    /* update in progress flag: 8/32768 seconds after change */
    if (tv.tv_usec < 244) {
        s->cmos_data[RTC_REG_A] |= REG_A_UIP;
    } else {
        s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
    }
}

CMOSState *cmos_init(PhysMemoryMap *port_map, int addr,
                     IRQSignal *irq, BOOL use_local_time)
{
    CMOSState *s;
    
    s = mallocz(sizeof(*s));
    s->use_local_time = use_local_time;
    
    s->cmos_index = 0;

    s->cmos_data[RTC_REG_A] = 0x26;
    s->cmos_data[RTC_REG_B] = 0x02;
    s->cmos_data[RTC_REG_C] = 0x00;
    s->cmos_data[RTC_REG_D] = 0x80;

    cmos_update_time(s, TRUE);
    
    s->irq = irq;
    
    cpu_register_device(port_map, addr, 2, s, cmos_read, cmos_write, 
                        DEVIO_SIZE8);
    return s;
}

#define CMOS_FREQ 32768

static uint32_t cmos_get_timer(CMOSState *s)
{
    struct timespec ts;

    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint32_t)ts.tv_sec * CMOS_FREQ +
        ((uint64_t)ts.tv_nsec * CMOS_FREQ / 1000000000);
}

static void cmos_update_timer(CMOSState *s)
{
    int period_code;

    period_code = s->cmos_data[RTC_REG_A] & 0x0f;
    if ((s->cmos_data[RTC_REG_B] & REG_B_PIE) &&
        period_code != 0) {
        if (period_code <= 2)
            period_code += 7;
        s->irq_period = 1 << (period_code - 1);
        s->irq_timeout = (cmos_get_timer(s) + s->irq_period) &
            ~(s->irq_period - 1);
    }
}

/* XXX: could return a delay, but we don't need high precision
   (Windows 2000 uses it for delay calibration) */
static void cmos_update_irq(CMOSState *s)
{
    uint32_t d;
    if (s->cmos_data[RTC_REG_B] & REG_B_PIE) {
        d = cmos_get_timer(s) - s->irq_timeout;
        if ((int32_t)d >= 0) {
            /* this is not what the real RTC does. Here we sent the IRQ
               immediately */
            s->cmos_data[RTC_REG_C] |= 0xc0;
            set_irq(s->irq, 1);
            /* update for the next irq */
            s->irq_timeout += s->irq_period;
        }
    }
}

static void cmos_write(void *opaque, uint32_t offset,
                       uint32_t data, int size_log2)
{
    CMOSState *s = opaque;

    if (offset == 0) {
        s->cmos_index = data & 0x7f;
    } else {
#ifdef DEBUG_CMOS
        printf("cmos_write: reg=0x%02x val=0x%02x\n", s->cmos_index, data);
#endif
        switch(s->cmos_index) {
        case RTC_REG_A:
            s->cmos_data[RTC_REG_A] = (data & ~REG_A_UIP) |
                (s->cmos_data[RTC_REG_A] & REG_A_UIP);
            cmos_update_timer(s);
            break;
        case RTC_REG_B:
            s->cmos_data[s->cmos_index] = data;
            cmos_update_timer(s);
            break;
        default:
            s->cmos_data[s->cmos_index] = data;
            break;
        }
    }
}

static uint32_t cmos_read(void *opaque, uint32_t offset, int size_log2)
{
    CMOSState *s = opaque;
    int ret;

    if (offset == 0) {
        return 0xff;
    } else {
        switch(s->cmos_index) {
        case RTC_SECONDS:
        case RTC_MINUTES:
        case RTC_HOURS:
        case RTC_DAY_OF_WEEK:
        case RTC_DAY_OF_MONTH:
        case RTC_MONTH:
        case RTC_YEAR:
        case RTC_REG_A:
            cmos_update_time(s, FALSE);
            ret = s->cmos_data[s->cmos_index];
            break;
        case RTC_REG_C:
            ret = s->cmos_data[s->cmos_index];
            s->cmos_data[RTC_REG_C] = 0x00;
            set_irq(s->irq, 0);
            break;
        default:
            ret = s->cmos_data[s->cmos_index];
        }
#ifdef DEBUG_CMOS
        printf("cmos_read: reg=0x%02x val=0x%02x\n", s->cmos_index, ret);
#endif
        return ret;
    }
}

/***********************************************************/
/* 8259 pic emulation */

//#define DEBUG_PIC

typedef void PICUpdateIRQFunc(void *opaque);

typedef struct {
    uint8_t last_irr; /* edge detection */
    uint8_t irr; /* interrupt request register */
    uint8_t imr; /* interrupt mask register */
    uint8_t isr; /* interrupt service register */
    uint8_t priority_add; /* used to compute irq priority */
    uint8_t irq_base;
    uint8_t read_reg_select;
    uint8_t special_mask;
    uint8_t init_state;
    uint8_t auto_eoi;
    uint8_t rotate_on_autoeoi;
    uint8_t init4; /* true if 4 byte init */
    uint8_t elcr; /* PIIX edge/trigger selection*/
    uint8_t elcr_mask;
    PICUpdateIRQFunc *update_irq;
    void *opaque;
} PICState;

static void pic_reset(PICState *s);
static void pic_write(void *opaque, uint32_t offset,
                      uint32_t val, int size_log2);
static uint32_t pic_read(void *opaque, uint32_t offset, int size_log2);
static void pic_elcr_write(void *opaque, uint32_t offset,
                           uint32_t val, int size_log2);
static uint32_t pic_elcr_read(void *opaque, uint32_t offset, int size_log2);

PICState *pic_init(PhysMemoryMap *port_map, int port, int elcr_port,
                   int elcr_mask,
                   PICUpdateIRQFunc *update_irq, void *opaque)
{
    PICState *s;

    s = mallocz(sizeof(*s));
    s->elcr_mask = elcr_mask;
    s->update_irq = update_irq;
    s->opaque = opaque;
    cpu_register_device(port_map, port, 2, s,
                        pic_read, pic_write, DEVIO_SIZE8);
    cpu_register_device(port_map, elcr_port, 1, s,
                        pic_elcr_read, pic_elcr_write, DEVIO_SIZE8);
    pic_reset(s);
    return s;
}

static void pic_reset(PICState *s)
{
    /* all 8 bit registers */
    s->last_irr = 0; /* edge detection */
    s->irr = 0; /* interrupt request register */
    s->imr = 0; /* interrupt mask register */
    s->isr = 0; /* interrupt service register */
    s->priority_add = 0; /* used to compute irq priority */
    s->irq_base = 0;
    s->read_reg_select = 0;
    s->special_mask = 0;
    s->init_state = 0;
    s->auto_eoi = 0;
    s->rotate_on_autoeoi = 0;
    s->init4 = 0; /* true if 4 byte init */
}

/* set irq level. If an edge is detected, then the IRR is set to 1 */
static void pic_set_irq1(PICState *s, int irq, int level)
{
    int mask;
    mask = 1 << irq;
    if (s->elcr & mask) {
        /* level triggered */
        if (level) {
            s->irr |= mask;
            s->last_irr |= mask;
        } else {
            s->irr &= ~mask;
            s->last_irr &= ~mask;
        }
    } else {
        /* edge triggered */
        if (level) {
            if ((s->last_irr & mask) == 0)
                s->irr |= mask;
            s->last_irr |= mask;
        } else {
            s->last_irr &= ~mask;
        }
    }
}
    
static int pic_get_priority(PICState *s, int mask)
{
    int priority;
    if (mask == 0)
        return -1;
    priority = 7;
    while ((mask & (1 << ((priority + s->priority_add) & 7))) == 0)
        priority--;
    return priority;
}

/* return the pic wanted interrupt. return -1 if none */
static int pic_get_irq(PICState *s)
{
    int mask, cur_priority, priority;

    mask = s->irr & ~s->imr;
    priority = pic_get_priority(s, mask);
    if (priority < 0)
        return -1;
    /* compute current priority */
    cur_priority = pic_get_priority(s, s->isr);
    if (priority > cur_priority) {
        /* higher priority found: an irq should be generated */
        return priority;
    } else {
        return -1;
    }
}
    
/* acknowledge interrupt 'irq' */
static void pic_intack(PICState *s, int irq)
{
    if (s->auto_eoi) {
        if (s->rotate_on_autoeoi)
            s->priority_add = (irq + 1) & 7;
    } else {
        s->isr |= (1 << irq);
    }
    /* We don't clear a level sensitive interrupt here */
    if (!(s->elcr & (1 << irq)))
        s->irr &= ~(1 << irq);
}

static void pic_write(void *opaque, uint32_t offset,
                      uint32_t val, int size_log2)
{
    PICState *s = opaque;
    int priority, addr;
    
    addr = offset & 1;
#ifdef DEBUG_PIC
    console.log("pic_write: addr=" + toHex2(addr) + " val=" + toHex2(val));
#endif
    if (addr == 0) {
        if (val & 0x10) {
            /* init */
            pic_reset(s);
            s->init_state = 1;
            s->init4 = val & 1;
            if (val & 0x02)
                abort(); /* "single mode not supported" */
            if (val & 0x08)
                abort(); /* "level sensitive irq not supported" */
        } else if (val & 0x08) {
            if (val & 0x02)
                s->read_reg_select = val & 1;
            if (val & 0x40)
                s->special_mask = (val >> 5) & 1;
        } else {
            switch(val) {
            case 0x00:
            case 0x80:
                s->rotate_on_autoeoi = val >> 7;
                break;
            case 0x20: /* end of interrupt */
            case 0xa0:
                priority = pic_get_priority(s, s->isr);
                if (priority >= 0) {
                    s->isr &= ~(1 << ((priority + s->priority_add) & 7));
                }
                if (val == 0xa0)
                    s->priority_add = (s->priority_add + 1) & 7;
                break;
            case 0x60:
            case 0x61:
            case 0x62:
            case 0x63:
            case 0x64:
            case 0x65:
            case 0x66:
            case 0x67:
                priority = val & 7;
                s->isr &= ~(1 << priority);
                break;
            case 0xc0:
            case 0xc1:
            case 0xc2:
            case 0xc3:
            case 0xc4:
            case 0xc5:
            case 0xc6:
            case 0xc7:
                s->priority_add = (val + 1) & 7;
                break;
            case 0xe0:
            case 0xe1:
            case 0xe2:
            case 0xe3:
            case 0xe4:
            case 0xe5:
            case 0xe6:
            case 0xe7:
                priority = val & 7;
                s->isr &= ~(1 << priority);
                s->priority_add = (priority + 1) & 7;
                break;
            }
        }
    } else {
        switch(s->init_state) {
        case 0:
            /* normal mode */
            s->imr = val;
            s->update_irq(s->opaque);
            break;
        case 1:
            s->irq_base = val & 0xf8;
            s->init_state = 2;
            break;
        case 2:
            if (s->init4) {
                s->init_state = 3;
            } else {
                s->init_state = 0;
            }
            break;
        case 3:
            s->auto_eoi = (val >> 1) & 1;
            s->init_state = 0;
            break;
        }
    }
}

static uint32_t pic_read(void *opaque, uint32_t offset, int size_log2)
{
    PICState *s = opaque;
    int addr, ret;

    addr = offset & 1;
    if (addr == 0) {
        if (s->read_reg_select)
            ret = s->isr;
        else
            ret = s->irr;
    } else {
        ret = s->imr;
    }
#ifdef DEBUG_PIC
    console.log("pic_read: addr=" + toHex2(addr1) + " val=" + toHex2(ret));
#endif
    return ret;
}

static void pic_elcr_write(void *opaque, uint32_t offset,
                           uint32_t val, int size_log2)
{
    PICState *s = opaque;
    s->elcr = val & s->elcr_mask;
}

static uint32_t pic_elcr_read(void *opaque, uint32_t offset, int size_log2)
{
    PICState *s = opaque;
    return s->elcr;
}

typedef struct {
    PICState *pics[2];
    int irq_requested;
    void (*cpu_set_irq)(void *opaque, int level);
    void *opaque;
#if defined(DEBUG_PIC)
    uint8_t irq_level[16];
#endif
    IRQSignal *irqs;
} PIC2State;

static void pic2_update_irq(void *opaque);
static void pic2_set_irq(void *opaque, int irq, int level);

PIC2State *pic2_init(PhysMemoryMap *port_map, uint32_t addr0, uint32_t addr1,
                     uint32_t elcr_addr0, uint32_t elcr_addr1, 
                     void (*cpu_set_irq)(void *opaque, int level),
                     void *opaque, IRQSignal *irqs)
{
    PIC2State *s;
    int i;
    
    s = mallocz(sizeof(*s));

    for(i = 0; i < 16; i++) {
        irq_init(&irqs[i], pic2_set_irq, s, i);
    }
    s->cpu_set_irq = cpu_set_irq;
    s->opaque = opaque;
    s->pics[0] = pic_init(port_map, addr0, elcr_addr0, 0xf8, pic2_update_irq, s);
    s->pics[1] = pic_init(port_map, addr1, elcr_addr1, 0xde, pic2_update_irq, s);
    s->irq_requested = 0;
    return s;
}

void pic2_set_elcr(PIC2State *s, const uint8_t *elcr)
{
    int i;
    for(i = 0; i < 2; i++) {
        s->pics[i]->elcr = elcr[i] & s->pics[i]->elcr_mask;
    }
}

/* raise irq to CPU if necessary. must be called every time the active
   irq may change */
static void pic2_update_irq(void *opaque)
{
    PIC2State *s = opaque;
    int irq2, irq;

    /* first look at slave pic */
    irq2 = pic_get_irq(s->pics[1]);
    if (irq2 >= 0) {
        /* if irq request by slave pic, signal master PIC */
        pic_set_irq1(s->pics[0], 2, 1);
        pic_set_irq1(s->pics[0], 2, 0);
    }
    /* look at requested irq */
    irq = pic_get_irq(s->pics[0]);
#if 0
    console.log("irr=" + toHex2(s->pics[0].irr) + " imr=" + toHex2(s->pics[0].imr) + " isr=" + toHex2(s->pics[0].isr) + " irq="+ irq);
#endif
    if (irq >= 0) {
        /* raise IRQ request on the CPU */
        s->cpu_set_irq(s->opaque, 1);
    } else {
        /* lower irq */
        s->cpu_set_irq(s->opaque, 0);
    }
}

static void pic2_set_irq(void *opaque, int irq, int level)
{
    PIC2State *s = opaque;
#if defined(DEBUG_PIC)
    if (irq != 0 && level != s->irq_level[irq]) {
        console.log("pic_set_irq: irq=" + irq + " level=" + level);
        s->irq_level[irq] = level;
    }
#endif
    pic_set_irq1(s->pics[irq >> 3], irq & 7, level);
    pic2_update_irq(s);
}

/* called from the CPU to get the hardware interrupt number */
static int pic2_get_hard_intno(PIC2State *s)
{
    int irq, irq2, intno;

    irq = pic_get_irq(s->pics[0]);
    if (irq >= 0) {
        pic_intack(s->pics[0], irq);
        if (irq == 2) {
            irq2 = pic_get_irq(s->pics[1]);
            if (irq2 >= 0) {
                pic_intack(s->pics[1], irq2);
            } else {
                /* spurious IRQ on slave controller */
                irq2 = 7;
            }
            intno = s->pics[1]->irq_base + irq2;
            irq = irq2 + 8;
        } else {
            intno = s->pics[0]->irq_base + irq;
        }
    } else {
        /* spurious IRQ on host controller */
        irq = 7;
        intno = s->pics[0]->irq_base + irq;
    }
    pic2_update_irq(s);

#if defined(DEBUG_PIC)
    if (irq != 0 && irq != 14)
        printf("pic_interrupt: irq=%d\n", irq);
#endif
    return intno;
}

/***********************************************************/
/* 8253 PIT emulation */

#define PIT_FREQ 1193182

#define RW_STATE_LSB 0
#define RW_STATE_MSB 1
#define RW_STATE_WORD0 2
#define RW_STATE_WORD1 3
#define RW_STATE_LATCHED_WORD0 4
#define RW_STATE_LATCHED_WORD1 5

//#define DEBUG_PIT

typedef int64_t PITGetTicksFunc(void *opaque);

typedef struct PITState PITState;

typedef struct {
    PITState *pit_state;
    uint32_t count;
    uint32_t latched_count;
    uint8_t rw_state;
    uint8_t mode;
    uint8_t bcd;
    uint8_t gate;
    int64_t count_load_time;
    int64_t last_irq_time;
} PITChannel;

struct PITState {
    PITChannel pit_channels[3];
    uint8_t speaker_data_on;
    PITGetTicksFunc *get_ticks;
    IRQSignal *irq;
    void *opaque;
};

static void pit_load_count(PITChannel *pc, int val);
static void pit_write(void *opaque, uint32_t offset,
                      uint32_t val, int size_log2);
static uint32_t pit_read(void *opaque, uint32_t offset, int size_log2);
static void speaker_write(void *opaque, uint32_t offset,
                          uint32_t val, int size_log2);
static uint32_t speaker_read(void *opaque, uint32_t offset, int size_log2);

PITState *pit_init(PhysMemoryMap *port_map, int addr0, int addr1,
                   IRQSignal *irq,
                   PITGetTicksFunc *get_ticks, void *opaque)
{
    PITState *s;
    PITChannel *pc;
    int i;

    s = mallocz(sizeof(*s));

    s->irq = irq;
    s->get_ticks = get_ticks;
    s->opaque = opaque;
    
    for(i = 0; i < 3; i++) {
        pc = &s->pit_channels[i];
        pc->pit_state = s;
        pc->mode = 3;
        pc->gate = (i != 2) >> 0;
        pit_load_count(pc, 0);
    }
    s->speaker_data_on = 0;

    cpu_register_device(port_map, addr0, 4, s, pit_read, pit_write, 
                        DEVIO_SIZE8);

    cpu_register_device(port_map, addr1, 1, s, speaker_read, speaker_write, 
                        DEVIO_SIZE8);
    return s;
}

/* unit = PIT frequency  */
static int64_t pit_get_time(PITChannel *pc)
{
    PITState *s = pc->pit_state;
    return s->get_ticks(s->opaque);
}

static uint32_t pit_get_count(PITChannel *pc)
{
    uint32_t counter;
    uint64_t d;
    
    d = pit_get_time(pc) - pc->count_load_time;
    switch(pc->mode) {
    case 0:
    case 1:
    case 4:
    case 5:
        counter = (pc->count - d) & 0xffff;
        break;
    default:
        counter = pc->count - (d % pc->count);
        break;
    }
    return counter;
}

/* get pit output bit */
static int pit_get_out(PITChannel *pc)
{
    int out;
    int64_t d;
    
    d = pit_get_time(pc) - pc->count_load_time;
    switch(pc->mode) {
    default:
    case 0:
        out = (d >= pc->count) >> 0;
        break;
    case 1:
        out = (d < pc->count) >> 0;
        break;
    case 2:
        /* mode used by Linux */
        if ((d % pc->count) == 0 && d != 0)
            out = 1;
        else
            out = 0;
        break;
    case 3:
        out = ((d % pc->count) < (pc->count >> 1)) >> 0;
        break;
    case 4:
    case 5:
        out = (d == pc->count) >> 0;
        break;
    }
    return out;
}

static void pit_load_count(PITChannel *s, int val)
{
    if (val == 0)
        val = 0x10000;
    s->count_load_time = pit_get_time(s);
    s->last_irq_time = 0;
    s->count = val;
}

static void pit_write(void *opaque, uint32_t offset,
                      uint32_t val, int size_log2)
{
    PITState *pit = opaque;
    int channel, access, addr;
    PITChannel *s;

    addr = offset & 3;
#ifdef DEBUG_PIT
    printf("pit_write: off=%d val=0x%02x\n", addr, val);
#endif
    if (addr == 3) {
        channel = val >> 6;
        if (channel == 3)
            return;
        s = &pit->pit_channels[channel];
        access = (val >> 4) & 3;
        switch(access) {
        case 0:
            s->latched_count = pit_get_count(s);
            s->rw_state = RW_STATE_LATCHED_WORD0;
            break;
        default:
            s->mode = (val >> 1) & 7;
            s->bcd = val & 1;
            s->rw_state = access - 1 +  RW_STATE_LSB;
            break;
        }
    } else {
        s = &pit->pit_channels[addr];
        switch(s->rw_state) {
        case RW_STATE_LSB:
            pit_load_count(s, val);
            break;
        case RW_STATE_MSB:
            pit_load_count(s, val << 8);
            break;
        case RW_STATE_WORD0:
        case RW_STATE_WORD1:
            if (s->rw_state & 1) {
                pit_load_count(s, (s->latched_count & 0xff) | (val << 8));
            } else {
                s->latched_count = val;
            }
            s->rw_state ^= 1;
            break;
        }
    }
}

static uint32_t pit_read(void *opaque, uint32_t offset, int size_log2)
{
    PITState *pit = opaque;
    PITChannel *s;
    int ret, count, addr;
    
    addr = offset & 3;
    if (addr == 3)
        return 0xff;

    s = &pit->pit_channels[addr];
    switch(s->rw_state) {
    case RW_STATE_LSB:
    case RW_STATE_MSB:
    case RW_STATE_WORD0:
    case RW_STATE_WORD1:
        count = pit_get_count(s);
        if (s->rw_state & 1)
            ret = (count >> 8) & 0xff;
        else
            ret = count & 0xff;
        if (s->rw_state & 2)
            s->rw_state ^= 1;
        break;
    default:
    case RW_STATE_LATCHED_WORD0:
    case RW_STATE_LATCHED_WORD1:
        if (s->rw_state & 1)
            ret = s->latched_count >> 8;
        else
            ret = s->latched_count & 0xff;
        s->rw_state ^= 1;
        break;
    }
#ifdef DEBUG_PIT
    printf("pit_read: off=%d val=0x%02x\n", addr, ret);
#endif
    return ret;
}

static void speaker_write(void *opaque, uint32_t offset,
                          uint32_t val, int size_log2)
{
    PITState *pit = opaque;
    pit->speaker_data_on = (val >> 1) & 1;
    pit->pit_channels[2].gate = val & 1;
}

static uint32_t speaker_read(void *opaque, uint32_t offset, int size_log2)
{
    PITState *pit = opaque;
    PITChannel *s;
    int out, val;

    s = &pit->pit_channels[2];
    out = pit_get_out(s);
    val = (pit->speaker_data_on << 1) | s->gate | (out << 5);
#ifdef DEBUG_PIT
    //    console.log("speaker_read: addr=" + toHex2(addr) + " val=" + toHex2(val));
#endif
    return val;
}

/* set the IRQ if necessary and return the delay in ms until the next
   IRQ. Note: The code does not handle all the PIT configurations. */
static int pit_update_irq(PITState *pit)
{
    PITChannel *s;
    int64_t d, delay;
    
    s = &pit->pit_channels[0];
    
    delay = PIT_FREQ; /* could be infinity delay */
    
    d = pit_get_time(s) - s->count_load_time;
    switch(s->mode) {
    default:
    case 0:
    case 1:
    case 4:
    case 5:
        if (s->last_irq_time == 0) {
            delay = s->count - d;
            if (delay <= 0) {
                set_irq(pit->irq, 1);
                set_irq(pit->irq, 0);
                s->last_irq_time = d;
            }
        }
        break;
    case 2: /* mode used by Linux */
    case 3:
        delay = s->last_irq_time + s->count - d;
        if (delay <= 0) {
            set_irq(pit->irq, 1);
            set_irq(pit->irq, 0);
            s->last_irq_time += s->count;
        }
        break;
    }

    if (delay <= 0)
        return 0;
    else
        return delay / (PIT_FREQ / 1000);
}
    
/***********************************************************/
/* serial port emulation */

#define UART_LCR_DLAB	0x80	/* Divisor latch access bit */

#define UART_IER_MSI	0x08	/* Enable Modem status interrupt */
#define UART_IER_RLSI	0x04	/* Enable receiver line status interrupt */
#define UART_IER_THRI	0x02	/* Enable Transmitter holding register int. */
#define UART_IER_RDI	0x01	/* Enable receiver data interrupt */

#define UART_IIR_NO_INT	0x01	/* No interrupts pending */
#define UART_IIR_ID	0x06	/* Mask for the interrupt ID */

#define UART_IIR_MSI	0x00	/* Modem status interrupt */
#define UART_IIR_THRI	0x02	/* Transmitter holding register empty */
#define UART_IIR_RDI	0x04	/* Receiver data interrupt */
#define UART_IIR_RLSI	0x06	/* Receiver line status interrupt */
#define UART_IIR_FE     0xC0    /* Fifo enabled */

#define UART_LSR_TEMT	0x40	/* Transmitter empty */
#define UART_LSR_THRE	0x20	/* Transmit-hold-register empty */
#define UART_LSR_BI	0x10	/* Break interrupt indicator */
#define UART_LSR_FE	0x08	/* Frame error indicator */
#define UART_LSR_PE	0x04	/* Parity error indicator */
#define UART_LSR_OE	0x02	/* Overrun error indicator */
#define UART_LSR_DR	0x01	/* Receiver data ready */

#define UART_FCR_XFR        0x04    /* XMIT Fifo Reset */
#define UART_FCR_RFR        0x02    /* RCVR Fifo Reset */
#define UART_FCR_FE         0x01    /* FIFO Enable */

#define UART_FIFO_LENGTH    16      /* 16550A Fifo Length */

typedef struct {
    uint8_t divider; 
    uint8_t rbr; /* receive register */
    uint8_t ier;
    uint8_t iir; /* read only */
    uint8_t lcr;
    uint8_t mcr;
    uint8_t lsr; /* read only */
    uint8_t msr;
    uint8_t scr;
    uint8_t fcr;
    IRQSignal *irq;
    void (*write_func)(void *opaque, const uint8_t *buf, int buf_len);
    void *opaque;
} SerialState;

static void serial_write(void *opaque, uint32_t offset,
                         uint32_t val, int size_log2);
static uint32_t serial_read(void *opaque, uint32_t offset, int size_log2);

SerialState *serial_init(PhysMemoryMap *port_map, int addr,
                         IRQSignal *irq,
                         void (*write_func)(void *opaque, const uint8_t *buf, int buf_len), void *opaque)
{
    SerialState *s;
    s = mallocz(sizeof(*s));
    
    /* all 8 bit registers */
    s->divider = 0; 
    s->rbr = 0; /* receive register */
    s->ier = 0;
    s->iir = UART_IIR_NO_INT; /* read only */
    s->lcr = 0;
    s->mcr = 0;
    s->lsr = UART_LSR_TEMT | UART_LSR_THRE; /* read only */
    s->msr = 0;
    s->scr = 0;
    s->fcr = 0;

    s->irq = irq;
    s->write_func = write_func;
    s->opaque = opaque;

    cpu_register_device(port_map, addr, 8, s, serial_read, serial_write, 
                        DEVIO_SIZE8);
    return s;
}

static void serial_update_irq(SerialState *s)
{
    if ((s->lsr & UART_LSR_DR) && (s->ier & UART_IER_RDI)) {
        s->iir = UART_IIR_RDI;
    } else if ((s->lsr & UART_LSR_THRE) && (s->ier & UART_IER_THRI)) {
        s->iir = UART_IIR_THRI;
    } else {
        s->iir = UART_IIR_NO_INT;
    }
    if (s->iir != UART_IIR_NO_INT) {
        set_irq(s->irq, 1);
    } else {
        set_irq(s->irq, 0);
    }
}

#if 0
/* send remainining chars in fifo */
Serial.prototype.write_tx_fifo = function()
{
    if (s->tx_fifo != "") {
        s->write_func(s->tx_fifo);
        s->tx_fifo = "";
        
        s->lsr |= UART_LSR_THRE;
        s->lsr |= UART_LSR_TEMT;
        s->update_irq();
    }
}
#endif
    
static void serial_write(void *opaque, uint32_t offset,
                         uint32_t val, int size_log2)
{
    SerialState *s = opaque;
    int addr;

    addr = offset & 7;
    switch(addr) {
    default:
    case 0:
        if (s->lcr & UART_LCR_DLAB) {
            s->divider = (s->divider & 0xff00) | val;
        } else {
#if 0
            if (s->fcr & UART_FCR_FE) {
                s->tx_fifo += String.fromCharCode(val);
                s->lsr &= ~UART_LSR_THRE;
                serial_update_irq(s);
                if (s->tx_fifo.length >= UART_FIFO_LENGTH) {
                    /* write to the terminal */
                    s->write_tx_fifo();
                }
            } else
#endif
            {
                uint8_t ch;
                s->lsr &= ~UART_LSR_THRE;
                serial_update_irq(s);
                
                /* write to the terminal */
                ch = val;
                s->write_func(s->opaque, &ch, 1);
                s->lsr |= UART_LSR_THRE;
                s->lsr |= UART_LSR_TEMT;
                serial_update_irq(s);
            }
        }
        break;
    case 1:
        if (s->lcr & UART_LCR_DLAB) {
            s->divider = (s->divider & 0x00ff) | (val << 8);
        } else {
            s->ier = val;
            serial_update_irq(s);
        }
        break;
    case 2:
#if 0
        if ((s->fcr ^ val) & UART_FCR_FE) {
            /* clear fifos */
            val |= UART_FCR_XFR | UART_FCR_RFR;
        }
        if (val & UART_FCR_XFR)
            s->tx_fifo = "";
        if (val & UART_FCR_RFR)
            s->rx_fifo = "";
        s->fcr = val & UART_FCR_FE;
#endif
        break;
    case 3:
        s->lcr = val;
        break;
    case 4:
        s->mcr = val;
        break;
    case 5:
        break;
    case 6:
        s->msr = val;
        break;
    case 7:
        s->scr = val;
        break;
    }
}

static uint32_t serial_read(void *opaque, uint32_t offset, int size_log2)
{
    SerialState *s = opaque;
    int ret, addr;

    addr = offset & 7;
    switch(addr) {
    default:
    case 0:
        if (s->lcr & UART_LCR_DLAB) {
            ret = s->divider & 0xff; 
        } else {
            ret = s->rbr;
            s->lsr &= ~(UART_LSR_DR | UART_LSR_BI);
            serial_update_irq(s);
#if 0
            /* try to receive next chars */
            s->send_char_from_fifo();
#endif
        }
        break;
    case 1:
        if (s->lcr & UART_LCR_DLAB) {
            ret = (s->divider >> 8) & 0xff;
        } else {
            ret = s->ier;
        }
        break;
    case 2:
        ret = s->iir;
        if (s->fcr & UART_FCR_FE)
            ret |= UART_IIR_FE;
        break;
    case 3:
        ret = s->lcr;
        break;
    case 4:
        ret = s->mcr;
        break;
    case 5:
        ret = s->lsr;
        break;
    case 6:
        ret = s->msr;
        break;
    case 7:
        ret = s->scr;
        break;
    }
    return ret;
}

void serial_send_break(SerialState *s)
{
    s->rbr = 0;
    s->lsr |= UART_LSR_BI | UART_LSR_DR;
    serial_update_irq(s);
}

#if 0
static void serial_send_char(SerialState *s, int ch)
{
    s->rbr = ch;
    s->lsr |= UART_LSR_DR;
    serial_update_irq(s);
}

Serial.prototype.send_char_from_fifo = function()
{
    var fifo;

    fifo = s->rx_fifo;
    if (fifo != "" && !(s->lsr & UART_LSR_DR)) {
        s->send_char(fifo.charCodeAt(0));
        s->rx_fifo = fifo.substr(1, fifo.length - 1);
    }
}

/* queue the string in the UART receive fifo and send it ASAP */
Serial.prototype.send_chars = function(str)
{
    s->rx_fifo += str;
    s->send_char_from_fifo();
}
    
#endif

#ifdef DEBUG_BIOS
static void bios_debug_write(void *opaque, uint32_t offset,
                        uint32_t val, int size_log2)
{
#ifdef EMSCRIPTEN
    static char line_buf[256];
    static int line_buf_index;
    line_buf[line_buf_index++] = val;
    if (val == '\n' || line_buf_index >= sizeof(line_buf) - 1) {
        line_buf[line_buf_index] = '\0';
        printf("%s", line_buf);
        line_buf_index = 0;
    }
#else
    putchar(val & 0xff);
#endif
}

static uint32_t bios_debug_read(void *opaque, uint32_t offset, int size_log2)
{
    return 0;
}
#endif

typedef struct PCMachine {
    VirtMachine common;
    uint64_t ram_size;
    PhysMemoryMap *mem_map;
    PhysMemoryMap *port_map;
    
    X86CPUState *cpu_state;
    PIC2State *pic_state;
    IRQSignal pic_irq[16];
    PITState *pit_state;
    I440FXState *i440fx_state;
    CMOSState *cmos_state;
    SerialState *serial_state;

    /* input */
    VIRTIODevice *keyboard_dev;
    VIRTIODevice *mouse_dev;
    KBDState *kbd_state;
    PS2MouseState *ps2_mouse;
    VMMouseState *vm_mouse;
    PS2KbdState *ps2_kbd;

#ifdef USE_KVM
    BOOL kvm_enabled;
    int kvm_fd;
    int vm_fd;
    int vcpu_fd;
    int kvm_run_size;
    struct kvm_run *kvm_run;
#endif
} PCMachine;

static void copy_kernel(PCMachine *s, const uint8_t *buf, int buf_len,
                        const char *cmd_line);

static void port80_write(void *opaque, uint32_t offset,
                         uint32_t val64, int size_log2)
{
}

static uint32_t port80_read(void *opaque, uint32_t offset, int size_log2)
{
    return 0xff;
}

static void port92_write(void *opaque, uint32_t offset,
                         uint32_t val, int size_log2)
{
}

static uint32_t port92_read(void *opaque, uint32_t offset, int size_log2)
{
    int a20 = 1; /* A20=0 is not supported */
    return a20 << 1;
}

#define VMPORT_MAGIC   0x564D5868
#define REG_EAX 0
#define REG_EBX 1
#define REG_ECX 2
#define REG_EDX 3
#define REG_ESI 4
#define REG_EDI 5

static uint32_t vmport_read(void *opaque, uint32_t addr, int size_log2)
{
    PCMachine *s = opaque;
    uint32_t regs[6];

#ifdef USE_KVM
    if (s->kvm_enabled) {
        struct kvm_regs r;

        ioctl(s->vcpu_fd, KVM_GET_REGS, &r);
        regs[REG_EAX] = r.rax;
        regs[REG_EBX] = r.rbx;
        regs[REG_ECX] = r.rcx;
        regs[REG_EDX] = r.rdx;
        regs[REG_ESI] = r.rsi;
        regs[REG_EDI] = r.rdi;

        if (regs[REG_EAX] == VMPORT_MAGIC) {
            
            vmmouse_handler(s->vm_mouse, regs);
            
            /* Note: in 64 bits the high parts are reset to zero
               in all cases. */
            r.rax = regs[REG_EAX];
            r.rbx = regs[REG_EBX];
            r.rcx = regs[REG_ECX];
            r.rdx = regs[REG_EDX];
            r.rsi = regs[REG_ESI];
            r.rdi = regs[REG_EDI];
            ioctl(s->vcpu_fd, KVM_SET_REGS, &r);
        }
    } else
#endif
    {
        regs[REG_EAX] = x86_cpu_get_reg(s->cpu_state, 0);
        regs[REG_EBX] = x86_cpu_get_reg(s->cpu_state, 3);
        regs[REG_ECX] = x86_cpu_get_reg(s->cpu_state, 1);
        regs[REG_EDX] = x86_cpu_get_reg(s->cpu_state, 2);
        regs[REG_ESI] = x86_cpu_get_reg(s->cpu_state, 6);
        regs[REG_EDI] = x86_cpu_get_reg(s->cpu_state, 7);

        if (regs[REG_EAX] == VMPORT_MAGIC) {
            vmmouse_handler(s->vm_mouse, regs);

            x86_cpu_set_reg(s->cpu_state, 0, regs[REG_EAX]);
            x86_cpu_set_reg(s->cpu_state, 3, regs[REG_EBX]);
            x86_cpu_set_reg(s->cpu_state, 1, regs[REG_ECX]);
            x86_cpu_set_reg(s->cpu_state, 2, regs[REG_EDX]);
            x86_cpu_set_reg(s->cpu_state, 6, regs[REG_ESI]);
            x86_cpu_set_reg(s->cpu_state, 7, regs[REG_EDI]);
        }
    }
    return regs[REG_EAX];
}

static void vmport_write(void *opaque, uint32_t addr, uint32_t val,
                         int size_log2)
{
}

static void pic_set_irq_cb(void *opaque, int level)
{
    PCMachine *s = opaque;
    x86_cpu_set_irq(s->cpu_state, level);
}

static void serial_write_cb(void *opaque, const uint8_t *buf, int buf_len)
{
    PCMachine *s = opaque;
    if (s->common.console) {
        s->common.console->write_data(s->common.console->opaque, buf, buf_len);
    }
}

static int get_hard_intno_cb(void *opaque)
{
    PCMachine *s = opaque;
    return pic2_get_hard_intno(s->pic_state);
}

static int64_t pit_get_ticks_cb(void *opaque)
{
    struct timespec ts;

    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint64_t)ts.tv_sec * PIT_FREQ +
        ((uint64_t)ts.tv_nsec * PIT_FREQ / 1000000000);
}

#define FRAMEBUFFER_BASE_ADDR 0xf0400000

static uint8_t *get_ram_ptr(PCMachine *s, uint64_t paddr)
{
    PhysMemoryRange *pr;
    pr = get_phys_mem_range(s->mem_map, paddr);
    if (!pr || !pr->is_ram)
        return NULL;
    return pr->phys_mem + (uintptr_t)(paddr - pr->addr);
}

#ifdef DUMP_IOPORT
static BOOL dump_port(int port)
{
    return !((port >= 0x1f0 && port <= 0x1f7) ||
             (port >= 0x20 && port <= 0x21) ||
             (port >= 0xa0 && port <= 0xa1));
}
#endif

static void st_port(void *opaque, uint32_t port, uint32_t val, int size_log2)
{
    PCMachine *s = opaque;
    PhysMemoryRange *pr;
#ifdef DUMP_IOPORT
    if (dump_port(port))
        printf("write port=0x%x val=0x%x s=%d\n", port, val, 1 << size_log2);
#endif
    pr = get_phys_mem_range(s->port_map, port);
    if (!pr) {
        return;
    }
    port -= pr->addr;
    if ((pr->devio_flags >> size_log2) & 1) {
        pr->write_func(pr->opaque, port, (uint32_t)val, size_log2);
    } else if (size_log2 == 1 && (pr->devio_flags & DEVIO_SIZE8)) {
        pr->write_func(pr->opaque, port, val & 0xff, 0);
        pr->write_func(pr->opaque, port + 1, (val >> 8) & 0xff, 0);
    }
}

static uint32_t ld_port(void *opaque, uint32_t port1, int size_log2)
{
    PCMachine *s = opaque;
    PhysMemoryRange *pr;
    uint32_t val, port;
    
    port = port1;
    pr = get_phys_mem_range(s->port_map, port);
    if (!pr) {
        val = -1;
    } else {
        port -= pr->addr;
        if ((pr->devio_flags >> size_log2) & 1) {
            val = pr->read_func(pr->opaque, port, size_log2);
        } else if (size_log2 == 1 && (pr->devio_flags & DEVIO_SIZE8)) {
            val = pr->read_func(pr->opaque, port, 0) & 0xff;
            val |= (pr->read_func(pr->opaque, port + 1, 0) & 0xff) << 8;
        } else {
            val = -1;
        }
    }
#ifdef DUMP_IOPORT
    if (dump_port(port1))
        printf("read port=0x%x val=0x%x s=%d\n", port1, val, 1 << size_log2);
#endif
    return val;
}

static void pc_machine_set_defaults(VirtMachineParams *p)
{
    p->accel_enable = TRUE;
}

#ifdef USE_KVM

static void sigalrm_handler(int sig)
{
}

#define CPUID_APIC (1 << 9)
#define CPUID_ACPI (1 << 22)

static void kvm_set_cpuid(PCMachine *s)
{
    struct kvm_cpuid2 *kvm_cpuid;
    int n_ent_max, i;
    struct kvm_cpuid_entry2 *ent;
    
    n_ent_max = 128;
    kvm_cpuid = mallocz(sizeof(struct kvm_cpuid2) + n_ent_max * sizeof(kvm_cpuid->entries[0]));
    
    kvm_cpuid->nent = n_ent_max;
    if (ioctl(s->kvm_fd, KVM_GET_SUPPORTED_CPUID, kvm_cpuid) < 0) {
        perror("KVM_GET_SUPPORTED_CPUID");
        exit(1);
    }

    for(i = 0; i < kvm_cpuid->nent; i++) {
        ent = &kvm_cpuid->entries[i];
        /* remove the APIC & ACPI to be in sync with the emulator */
        if (ent->function == 1 || ent->function == 0x80000001) {
            ent->edx &= ~(CPUID_APIC | CPUID_ACPI);
        }
    }
    
    if (ioctl(s->vcpu_fd, KVM_SET_CPUID2, kvm_cpuid) < 0) {
        perror("KVM_SET_CPUID2");
        exit(1);
    }
    free(kvm_cpuid);
}

/* XXX: should check overlapping mappings */
static void kvm_map_ram(PhysMemoryMap *mem_map, PhysMemoryRange *pr)
{
    PCMachine *s = mem_map->opaque;
    struct kvm_userspace_memory_region region;
    int flags;

    region.slot = pr - mem_map->phys_mem_range;
    flags = 0;
    if (pr->devram_flags & DEVRAM_FLAG_ROM)
        flags |= KVM_MEM_READONLY;
    if (pr->devram_flags & DEVRAM_FLAG_DIRTY_BITS)
        flags |= KVM_MEM_LOG_DIRTY_PAGES;
    region.flags = flags;
    region.guest_phys_addr = pr->addr;
    region.memory_size = pr->size;
#if 0
    printf("map slot %d: %08lx %08lx\n",
           region.slot, pr->addr, pr->size);
#endif
    region.userspace_addr = (uintptr_t)pr->phys_mem;
    if (ioctl(s->vm_fd, KVM_SET_USER_MEMORY_REGION, &region) < 0) {
        perror("KVM_SET_USER_MEMORY_REGION");
        exit(1);
    }
}

/* XXX: just for one region */
static PhysMemoryRange *kvm_register_ram(PhysMemoryMap *mem_map, uint64_t addr,
                                         uint64_t size, int devram_flags)
{
    PhysMemoryRange *pr;
    uint8_t *phys_mem;
    
    pr = register_ram_entry(mem_map, addr, size, devram_flags);

    phys_mem = mmap(NULL, size, PROT_READ | PROT_WRITE,
                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (!phys_mem)
        return NULL;
    pr->phys_mem = phys_mem;
    if (devram_flags & DEVRAM_FLAG_DIRTY_BITS) {
        int n_pages = size >> 12;
        pr->dirty_bits_size = ((n_pages + 63) / 64) * 8;
        pr->dirty_bits = mallocz(pr->dirty_bits_size);
    }

    if (pr->size != 0) {
        kvm_map_ram(mem_map, pr);
    }
    return pr;
}

static void kvm_set_ram_addr(PhysMemoryMap *mem_map,
                             PhysMemoryRange *pr, uint64_t addr, BOOL enabled)
{
    if (enabled) {
        if (pr->size == 0 || addr != pr->addr) {
            /* move or create the region */
            pr->size = pr->org_size;
            pr->addr = addr;
            kvm_map_ram(mem_map, pr);
        }
    } else {
        if (pr->size != 0) {
            pr->addr = 0;
            pr->size = 0;
            /* map a zero size region to disable */
            kvm_map_ram(mem_map, pr);
        }
    }
}

static const uint32_t *kvm_get_dirty_bits(PhysMemoryMap *mem_map,
                                          PhysMemoryRange *pr)
{
    PCMachine *s = mem_map->opaque;
    struct kvm_dirty_log dlog;
    
    if (pr->size == 0) {
        /* not mapped: we assume no modification was made */
        memset(pr->dirty_bits, 0, pr->dirty_bits_size);
    } else {
        dlog.slot = pr - mem_map->phys_mem_range;
        dlog.dirty_bitmap = pr->dirty_bits;
        if (ioctl(s->vm_fd, KVM_GET_DIRTY_LOG, &dlog) < 0) {
            perror("KVM_GET_DIRTY_LOG");
            exit(1);
        }
    }
    return pr->dirty_bits;
}

static void kvm_free_ram(PhysMemoryMap *mem_map, PhysMemoryRange *pr)
{
    /* XXX: do it */
    munmap(pr->phys_mem, pr->org_size);
    free(pr->dirty_bits);
}

static void kvm_pic_set_irq(void *opaque, int irq_num, int level)
{
    PCMachine *s = opaque;
    struct kvm_irq_level irq_level;
    irq_level.irq = irq_num;
    irq_level.level = level;
    if (ioctl(s->vm_fd, KVM_IRQ_LINE, &irq_level) < 0) {
        perror("KVM_IRQ_LINE");
        exit(1);
    }
}

static void kvm_init(PCMachine *s)
{
    int ret, i;
    struct sigaction act;
    struct kvm_pit_config pit_config;
    uint64_t base_addr;
    
    s->kvm_enabled = FALSE;
    s->kvm_fd = open("/dev/kvm", O_RDWR);
    if (s->kvm_fd < 0) {
        fprintf(stderr, "KVM not available\n");
        return;
    }
    ret = ioctl(s->kvm_fd, KVM_GET_API_VERSION, 0);
    if (ret < 0) {
        perror("KVM_GET_API_VERSION");
        exit(1);
    }
    if (ret != 12) {
        fprintf(stderr, "Unsupported KVM version\n");
        close(s->kvm_fd);
        s->kvm_fd = -1;
        return;
    }
    s->vm_fd = ioctl(s->kvm_fd, KVM_CREATE_VM, 0);
    if (s->vm_fd < 0) {
        perror("KVM_CREATE_VM");
        exit(1);
    }

    /* just before the BIOS */
    base_addr = 0xfffbc000;
    if (ioctl(s->vm_fd, KVM_SET_IDENTITY_MAP_ADDR, &base_addr) < 0) {
        perror("KVM_SET_IDENTITY_MAP_ADDR");
        exit(1);
    }
    
    if (ioctl(s->vm_fd, KVM_SET_TSS_ADDR, (long)(base_addr + 0x1000)) < 0) {
        perror("KVM_SET_TSS_ADDR");
        exit(1);
    }
    
    if (ioctl(s->vm_fd, KVM_CREATE_IRQCHIP, 0) < 0) {
        perror("KVM_CREATE_IRQCHIP");
        exit(1);
    }

    memset(&pit_config, 0, sizeof(pit_config));
    pit_config.flags = KVM_PIT_SPEAKER_DUMMY;
    if (ioctl(s->vm_fd, KVM_CREATE_PIT2, &pit_config)) {
        perror("KVM_CREATE_PIT2");
        exit(1);
    }
    
    s->vcpu_fd = ioctl(s->vm_fd, KVM_CREATE_VCPU, 0);
    if (s->vcpu_fd < 0) {
        perror("KVM_CREATE_VCPU");
        exit(1);
    }

    kvm_set_cpuid(s);
    
    /* map the kvm_run structure */
    s->kvm_run_size = ioctl(s->kvm_fd, KVM_GET_VCPU_MMAP_SIZE, NULL);
    if (s->kvm_run_size < 0) {
        perror("KVM_GET_VCPU_MMAP_SIZE");
        exit(1);
    }

    s->kvm_run = mmap(NULL, s->kvm_run_size, PROT_READ | PROT_WRITE,
                      MAP_SHARED, s->vcpu_fd, 0);
    if (!s->kvm_run) {
        perror("mmap kvm_run");
        exit(1);
    }

    for(i = 0; i < 16; i++) {
        irq_init(&s->pic_irq[i], kvm_pic_set_irq, s, i);
    }

    act.sa_handler = sigalrm_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGALRM, &act, NULL);

    s->kvm_enabled = TRUE;

    s->mem_map->register_ram = kvm_register_ram;
    s->mem_map->free_ram = kvm_free_ram;
    s->mem_map->get_dirty_bits = kvm_get_dirty_bits;
    s->mem_map->set_ram_addr = kvm_set_ram_addr;
    s->mem_map->opaque = s;
}

static void kvm_exit_io(PCMachine *s, struct kvm_run *run)
{
    uint8_t *ptr;
    int i;
    
    ptr = (uint8_t *)run + run->io.data_offset;
    //    printf("port: addr=%04x\n", run->io.port);
    
    for(i = 0; i < run->io.count; i++) {
        if (run->io.direction == KVM_EXIT_IO_OUT) {
            switch(run->io.size) {
            case 1:
                st_port(s, run->io.port, *(uint8_t *)ptr, 0);
                break;
            case 2:
                st_port(s, run->io.port, *(uint16_t *)ptr, 1);
                break;
            case 4:
                st_port(s, run->io.port, *(uint32_t *)ptr, 2);
                break;
            default:
                abort();
            }
        } else {
            switch(run->io.size) {
            case 1:
                *(uint8_t *)ptr = ld_port(s, run->io.port, 0);
                break;
            case 2:
                *(uint16_t *)ptr = ld_port(s, run->io.port, 1);
                break;
            case 4:
                *(uint32_t *)ptr = ld_port(s, run->io.port, 2);
                break;
            default:
                abort();
            }
        }
        ptr += run->io.size;
    }
}

static void kvm_exit_mmio(PCMachine *s, struct kvm_run *run)
{
    uint8_t *data = run->mmio.data;
    PhysMemoryRange *pr;
    uint64_t addr;
    
    pr = get_phys_mem_range(s->mem_map, run->mmio.phys_addr);
    if (run->mmio.is_write) {
        if (!pr || pr->is_ram)
            return;
        addr = run->mmio.phys_addr - pr->addr;
        switch(run->mmio.len) {
        case 1:
            if (pr->devio_flags & DEVIO_SIZE8) {
                pr->write_func(pr->opaque, addr, *(uint8_t *)data, 0);
            }
            break;
        case 2:
            if (pr->devio_flags & DEVIO_SIZE16) {
                pr->write_func(pr->opaque, addr, *(uint16_t *)data, 1);
            }
            break;
        case 4:
            if (pr->devio_flags & DEVIO_SIZE32) {
                pr->write_func(pr->opaque, addr, *(uint32_t *)data, 2);
            }
            break;
        case 8:
            if (pr->devio_flags & DEVIO_SIZE32) {
                pr->write_func(pr->opaque, addr, *(uint32_t *)data, 2);
                pr->write_func(pr->opaque, addr + 4, *(uint32_t *)(data + 4), 2);
            }
            break;
        default:
            abort();
        }
    } else {
        if (!pr || pr->is_ram)
            goto no_dev;
        addr = run->mmio.phys_addr - pr->addr;
        switch(run->mmio.len) {
        case 1:
            if (!(pr->devio_flags & DEVIO_SIZE8))
                goto no_dev;
            *(uint8_t *)data = pr->read_func(pr->opaque, addr, 0);
            break;
        case 2:
            if (!(pr->devio_flags & DEVIO_SIZE16))
                goto no_dev;
            *(uint16_t *)data = pr->read_func(pr->opaque, addr, 1);
            break;
        case 4:
            if (!(pr->devio_flags & DEVIO_SIZE32))
                goto no_dev;
            *(uint32_t *)data = pr->read_func(pr->opaque, addr, 2);
            break;
        case 8:
            if (pr->devio_flags & DEVIO_SIZE32) {
                *(uint32_t *)data =
                    pr->read_func(pr->opaque, addr, 2);
                *(uint32_t *)(data + 4) =
                    pr->read_func(pr->opaque, addr + 4, 2);
            } else {
            no_dev:
                memset(run->mmio.data, 0, run->mmio.len);
            }
            break;
        default:
            abort();
        }
            
    }
}

static void kvm_exec(PCMachine *s)
{
    struct kvm_run *run = s->kvm_run;
    struct itimerval ival;
    int ret;
    
    /* Not efficient but simple: we use a timer to interrupt the
       execution after a given time */
    ival.it_interval.tv_sec = 0;
    ival.it_interval.tv_usec = 0;
    ival.it_value.tv_sec = 0;
    ival.it_value.tv_usec = 10 * 1000; /* 10 ms max */
    setitimer(ITIMER_REAL, &ival, NULL);

    ret = ioctl(s->vcpu_fd, KVM_RUN, 0);
    if (ret < 0) {
        if (errno == EINTR || errno == EAGAIN) {
            /* timeout */
            return;
        }
        perror("KVM_RUN");
        exit(1);
    }
    //    printf("exit=%d\n", run->exit_reason);
    switch(run->exit_reason) {
    case KVM_EXIT_HLT:
        break;
    case KVM_EXIT_IO:
        kvm_exit_io(s, run);
        break;
    case KVM_EXIT_MMIO:
        kvm_exit_mmio(s, run);
        break;
    case KVM_EXIT_FAIL_ENTRY:
        fprintf(stderr, "KVM_EXIT_FAIL_ENTRY: reason=0x%" PRIx64 "\n",
                (uint64_t)run->fail_entry.hardware_entry_failure_reason);
#if 0
        {
            struct kvm_regs regs;
            if (ioctl(s->vcpu_fd, KVM_GET_REGS, &regs) < 0) {
                perror("KVM_SET_REGS");
                exit(1);
            }
            printf("RIP=%016" PRIx64 "\n", (uint64_t)regs.rip);
        }
#endif
        exit(1);
    case KVM_EXIT_INTERNAL_ERROR:
        fprintf(stderr, "KVM_EXIT_INTERNAL_ERROR: suberror=0x%x\n",
                (uint32_t)run->internal.suberror);
        exit(1);
    default:
        fprintf(stderr, "KVM: unsupported exit_reason=%d\n", run->exit_reason);
        exit(1);
    }
}
#endif

#if defined(EMSCRIPTEN)
/* with Javascript clock_gettime() is not enough precise enough to
   have a reliable TSC counter. XXX: increment the cycles during the
   power down time */
static uint64_t cpu_get_tsc(void *opaque)
{
    PCMachine *s = opaque;
    uint64_t c;
    c = x86_cpu_get_cycles(s->cpu_state);
    return c;
}
#else

#define TSC_FREQ 100000000

static uint64_t cpu_get_tsc(void *opaque)
{
    struct timespec ts;

    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint64_t)ts.tv_sec * TSC_FREQ +
        (ts.tv_nsec / (1000000000 / TSC_FREQ));
}
#endif

static void pc_flush_tlb_write_range(void *opaque, uint8_t *ram_addr,
                                     size_t ram_size)
{
    PCMachine *s = opaque;
    x86_cpu_flush_tlb_write_range_ram(s->cpu_state, ram_addr, ram_size);
}

static VirtMachine *pc_machine_init(const VirtMachineParams *p)
{
    PCMachine *s;
    int i, piix3_devfn;
    PCIBus *pci_bus;
    VIRTIOBusDef vbus_s, *vbus = &vbus_s;
    
    if (strcmp(p->machine_name, "pc") != 0) {
        vm_error("unsupported machine: %s\n", p->machine_name);
        return NULL;
    }

    assert(p->ram_size >= (1 << 20));

    s = mallocz(sizeof(*s));
    s->common.vmc = p->vmc;
    s->ram_size = p->ram_size;
    
    s->port_map = phys_mem_map_init();
    s->mem_map = phys_mem_map_init();

#ifdef USE_KVM
    if (p->accel_enable) {
        kvm_init(s);
    }
#endif

#ifdef USE_KVM
    if (!s->kvm_enabled)
#endif
    {
        s->cpu_state = x86_cpu_init(s->mem_map);
        x86_cpu_set_get_tsc(s->cpu_state, cpu_get_tsc, s);
        x86_cpu_set_port_io(s->cpu_state, ld_port, st_port, s);
        
        /* needed to handle the RAM dirty bits */
        s->mem_map->opaque = s;
        s->mem_map->flush_tlb_write_range = pc_flush_tlb_write_range;
    }

    /* set the RAM mapping and leave the VGA addresses empty */
    cpu_register_ram(s->mem_map, 0xc0000, p->ram_size - 0xc0000, 0);
    cpu_register_ram(s->mem_map, 0, 0xa0000, 0);
    
    /* devices */
    cpu_register_device(s->port_map, 0x80, 2, s, port80_read, port80_write, 
                        DEVIO_SIZE8);
    cpu_register_device(s->port_map, 0x92, 2, s, port92_read, port92_write, 
                        DEVIO_SIZE8);
    
    /* setup the bios */
    if (p->files[VM_FILE_BIOS].len > 0) {
        int bios_size, bios_size1;
        uint8_t *bios_buf, *ptr;
        uint32_t bios_addr;
        
        bios_size = p->files[VM_FILE_BIOS].len;
        bios_buf = p->files[VM_FILE_BIOS].buf;
        assert((bios_size % 65536) == 0 && bios_size != 0);
        bios_addr = -bios_size;
        /* at the top of the 4GB memory */
        cpu_register_ram(s->mem_map, bios_addr, bios_size, DEVRAM_FLAG_ROM);
        ptr = get_ram_ptr(s, bios_addr);
        memcpy(ptr, bios_buf, bios_size);
        /* in the lower 1MB memory (currently set as RAM) */
        bios_size1 = min_int(bios_size, 128 * 1024);
        ptr = get_ram_ptr(s, 0x100000 - bios_size1);
        memcpy(ptr, bios_buf + bios_size - bios_size1, bios_size1);
#ifdef DEBUG_BIOS
        cpu_register_device(s->port_map, 0x402, 2, s,
                            bios_debug_read, bios_debug_write, 
                            DEVIO_SIZE8);
#endif
    }

#ifdef USE_KVM
    if (!s->kvm_enabled)
#endif
    {
        s->pic_state = pic2_init(s->port_map, 0x20, 0xa0,
                                 0x4d0, 0x4d1,
                                 pic_set_irq_cb, s,
                                 s->pic_irq);
        x86_cpu_set_get_hard_intno(s->cpu_state, get_hard_intno_cb, s);
        s->pit_state = pit_init(s->port_map, 0x40, 0x61, &s->pic_irq[0],
                                pit_get_ticks_cb, s);
    }

    s->cmos_state = cmos_init(s->port_map, 0x70, &s->pic_irq[8],
                              p->rtc_local_time);

    /* various cmos data */
    {
        int size;
        /* memory size */
        size = min_int((s->ram_size - (1 << 20)) >> 10, 65535);
        put_le16(s->cmos_state->cmos_data + 0x30, size);
        if (s->ram_size >= (16 << 20)) {
            size = min_int((s->ram_size - (16 << 20)) >> 16, 65535);
            put_le16(s->cmos_state->cmos_data + 0x34, size);
        }
        s->cmos_state->cmos_data[0x14] = 0x06; /* mouse + FPU present */
    }
    
    s->i440fx_state = i440fx_init(&pci_bus, &piix3_devfn, s->mem_map,
                                  s->port_map, s->pic_irq);
    
    s->common.console = p->console;
    /* serial console */
    if (0) {
    s->serial_state = serial_init(s->port_map, 0x3f8, &s->pic_irq[4],
                                  serial_write_cb, s);
    }
    
    memset(vbus, 0, sizeof(*vbus));
    vbus->pci_bus = pci_bus;

    if (p->console) {
        /* virtio console */
        s->common.console_dev = virtio_console_init(vbus, p->console);
    }
    
    /* block devices */
    for(i = 0; i < p->drive_count;) {
        const VMDriveEntry *de = &p->tab_drive[i];

        if (!de->device || !strcmp(de->device, "virtio")) {
            virtio_block_init(vbus, p->tab_drive[i].block_dev);
            i++;
        } else if (!strcmp(de->device, "ide")) {
            BlockDevice *tab_bs[2];
            
            tab_bs[0] = p->tab_drive[i++].block_dev;
            tab_bs[1] = NULL;
            if (i < p->drive_count)
                tab_bs[1] = p->tab_drive[i++].block_dev;
            ide_init(s->port_map, 0x1f0, 0x3f6, &s->pic_irq[14], tab_bs);
            piix3_ide_init(pci_bus, piix3_devfn + 1);
        }
    }
    
    /* virtio filesystem */
    for(i = 0; i < p->fs_count; i++) {
        virtio_9p_init(vbus, p->tab_fs[i].fs_dev,
                       p->tab_fs[i].tag);
    }

    if (p->display_device) {
        FBDevice *fb_dev;

        fb_dev = mallocz(sizeof(*fb_dev));
        s->common.fb_dev = fb_dev;
        if (!strcmp(p->display_device, "vga")) {
            int bios_size;
            uint8_t *bios_buf;
            bios_size = p->files[VM_FILE_VGA_BIOS].len;
            bios_buf = p->files[VM_FILE_VGA_BIOS].buf;
            pci_vga_init(pci_bus, fb_dev, p->width, p->height,
                         bios_buf, bios_size);
        } else if (!strcmp(p->display_device, "simplefb")) {
            simplefb_init(s->mem_map,
                          FRAMEBUFFER_BASE_ADDR,
                          fb_dev, p->width, p->height);
        } else {
            vm_error("unsupported display device: %s\n", p->display_device);
            exit(1);
        }
    }

    if (p->input_device) {
        if (!strcmp(p->input_device, "virtio")) {
            s->keyboard_dev = virtio_input_init(vbus, VIRTIO_INPUT_TYPE_KEYBOARD);
            
            s->mouse_dev = virtio_input_init(vbus, VIRTIO_INPUT_TYPE_TABLET);
        } else if (!strcmp(p->input_device, "ps2")) {
            s->kbd_state = i8042_init(&s->ps2_kbd, &s->ps2_mouse,
                                      s->port_map,
                                      &s->pic_irq[1], &s->pic_irq[12], 0x60);
            /* vmmouse */
            cpu_register_device(s->port_map, 0x5658, 1, s,
                                vmport_read, vmport_write, 
                    DEVIO_SIZE32);
            s->vm_mouse = vmmouse_init(s->ps2_mouse);
        } else {
            vm_error("unsupported input device: %s\n", p->input_device);
            exit(1);
        }
    }
    
    /* virtio net device */
    for(i = 0; i < p->eth_count; i++) {
        virtio_net_init(vbus, p->tab_eth[i].net);
        s->common.net = p->tab_eth[i].net;
    }

    if (p->files[VM_FILE_KERNEL].buf) {
        copy_kernel(s, p->files[VM_FILE_KERNEL].buf,
                    p->files[VM_FILE_KERNEL].len,
                    p->cmdline ? p->cmdline : "");
    }

    return (VirtMachine *)s;
}

static void pc_machine_end(VirtMachine *s1)
{
    PCMachine *s = (PCMachine *)s1;
    /* XXX: free all */
    if (s->cpu_state) {
        x86_cpu_end(s->cpu_state);
    }
    phys_mem_map_end(s->mem_map);
    phys_mem_map_end(s->port_map);
    free(s);
}

static void pc_vm_send_key_event(VirtMachine *s1, BOOL is_down, uint16_t key_code)
{
    PCMachine *s = (PCMachine *)s1;
    if (s->keyboard_dev) {
        virtio_input_send_key_event(s->keyboard_dev, is_down, key_code);
    } else if (s->ps2_kbd) {
        ps2_put_keycode(s->ps2_kbd, is_down, key_code);
    }
}

static BOOL pc_vm_mouse_is_absolute(VirtMachine *s1)
{
    PCMachine *s = (PCMachine *)s1;
    if (s->mouse_dev) {
        return TRUE;
    } else if (s->vm_mouse) {
        return vmmouse_is_absolute(s->vm_mouse);
    } else {
        return FALSE;
    }
}

static void pc_vm_send_mouse_event(VirtMachine *s1, int dx, int dy, int dz,
                                   unsigned int buttons)
{
    PCMachine *s = (PCMachine *)s1;
    if (s->mouse_dev) {
        virtio_input_send_mouse_event(s->mouse_dev, dx, dy, dz, buttons);
    } else if (s->vm_mouse) {
        vmmouse_send_mouse_event(s->vm_mouse, dx, dy, dz, buttons);
    }
}

struct screen_info {
} __attribute__((packed));

/* from plex86 (BSD license) */
struct  __attribute__ ((packed)) linux_params {
    /* screen_info structure */
    uint8_t  orig_x;		/* 0x00 */
    uint8_t  orig_y;		/* 0x01 */
    uint16_t ext_mem_k;	/* 0x02 */
    uint16_t orig_video_page;	/* 0x04 */
    uint8_t  orig_video_mode;	/* 0x06 */
    uint8_t  orig_video_cols;	/* 0x07 */
    uint8_t  flags;		/* 0x08 */
    uint8_t  unused2;		/* 0x09 */
    uint16_t orig_video_ega_bx;/* 0x0a */
    uint16_t unused3;		/* 0x0c */
    uint8_t  orig_video_lines;	/* 0x0e */
    uint8_t  orig_video_isVGA;	/* 0x0f */
    uint16_t orig_video_points;/* 0x10 */
    
    /* VESA graphic mode -- linear frame buffer */
    uint16_t lfb_width;	/* 0x12 */
    uint16_t lfb_height;	/* 0x14 */
    uint16_t lfb_depth;	/* 0x16 */
    uint32_t lfb_base;		/* 0x18 */
    uint32_t lfb_size;		/* 0x1c */
    uint16_t cl_magic, cl_offset; /* 0x20 */
    uint16_t lfb_linelength;	/* 0x24 */
    uint8_t  red_size;		/* 0x26 */
    uint8_t  red_pos;		/* 0x27 */
    uint8_t  green_size;	/* 0x28 */
    uint8_t  green_pos;	/* 0x29 */
    uint8_t  blue_size;	/* 0x2a */
    uint8_t  blue_pos;		/* 0x2b */
    uint8_t  rsvd_size;	/* 0x2c */
    uint8_t  rsvd_pos;		/* 0x2d */
    uint16_t vesapm_seg;	/* 0x2e */
    uint16_t vesapm_off;	/* 0x30 */
    uint16_t pages;		/* 0x32 */
    uint16_t vesa_attributes;	/* 0x34 */
    uint32_t capabilities;     /* 0x36 */
    uint32_t ext_lfb_base;	/* 0x3a */
    uint8_t  _reserved[2];	/* 0x3e */
    
  /* 0x040 */ uint8_t   apm_bios_info[20]; // struct apm_bios_info
  /* 0x054 */ uint8_t   pad2[0x80 - 0x54];

  // Following 2 from 'struct drive_info_struct' in drivers/block/cciss.h.
  // Might be truncated?
  /* 0x080 */ uint8_t   hd0_info[16]; // hd0-disk-parameter from intvector 0x41
  /* 0x090 */ uint8_t   hd1_info[16]; // hd1-disk-parameter from intvector 0x46

  // System description table truncated to 16 bytes
  // From 'struct sys_desc_table_struct' in linux/arch/i386/kernel/setup.c.
  /* 0x0a0 */ uint16_t  sys_description_len;
  /* 0x0a2 */ uint8_t   sys_description_table[14];
                        // [0] machine id
                        // [1] machine submodel id
                        // [2] BIOS revision
                        // [3] bit1: MCA bus

  /* 0x0b0 */ uint8_t   pad3[0x1e0 - 0xb0];
  /* 0x1e0 */ uint32_t  alt_mem_k;
  /* 0x1e4 */ uint8_t   pad4[4];
  /* 0x1e8 */ uint8_t   e820map_entries;
  /* 0x1e9 */ uint8_t   eddbuf_entries; // EDD_NR
  /* 0x1ea */ uint8_t   pad5[0x1f1 - 0x1ea];
  /* 0x1f1 */ uint8_t   setup_sects; // size of setup.S, number of sectors
  /* 0x1f2 */ uint16_t  mount_root_rdonly; // MOUNT_ROOT_RDONLY (if !=0)
  /* 0x1f4 */ uint16_t  sys_size; // size of compressed kernel-part in the
                                // (b)zImage-file (in 16 byte units, rounded up)
  /* 0x1f6 */ uint16_t  swap_dev; // (unused AFAIK)
  /* 0x1f8 */ uint16_t  ramdisk_flags;
  /* 0x1fa */ uint16_t  vga_mode; // (old one)
  /* 0x1fc */ uint16_t  orig_root_dev; // (high=Major, low=minor)
  /* 0x1fe */ uint8_t   pad6[1];
  /* 0x1ff */ uint8_t   aux_device_info;
  /* 0x200 */ uint16_t  jump_setup; // Jump to start of setup code,
                                  // aka "reserved" field.
  /* 0x202 */ uint8_t   setup_signature[4]; // Signature for SETUP-header, ="HdrS"
  /* 0x206 */ uint16_t  header_format_version; // Version number of header format;
  /* 0x208 */ uint8_t   setup_S_temp0[8]; // Used by setup.S for communication with
                                        // boot loaders, look there.
  /* 0x210 */ uint8_t   loader_type;
                        // 0 for old one.
                        // else 0xTV:
                        //   T=0: LILO
                        //   T=1: Loadlin
                        //   T=2: bootsect-loader
                        //   T=3: SYSLINUX
                        //   T=4: ETHERBOOT
                        //   V=version
  /* 0x211 */ uint8_t   loadflags;
                        // bit0 = 1: kernel is loaded high (bzImage)
                        // bit7 = 1: Heap and pointer (see below) set by boot
                        //   loader.
  /* 0x212 */ uint16_t  setup_S_temp1;
  /* 0x214 */ uint32_t  kernel_start;
  /* 0x218 */ uint32_t  initrd_start;
  /* 0x21c */ uint32_t  initrd_size;
  /* 0x220 */ uint8_t   setup_S_temp2[4];
  /* 0x224 */ uint16_t  setup_S_heap_end_pointer;
  /* 0x226 */ uint16_t  pad70;
  /* 0x228 */ uint32_t  cmd_line_ptr;
  /* 0x22c */ uint8_t   pad7[0x2d0 - 0x22c];

  /* 0x2d0 : Int 15, ax=e820 memory map. */
  // (linux/include/asm-i386/e820.h, 'struct e820entry')
#define E820MAX  32
#define E820_RAM  1
#define E820_RESERVED 2
#define E820_ACPI 3 /* usable as RAM once ACPI tables have been read */
#define E820_NVS  4
  struct {
    uint64_t addr;
    uint64_t size;
    uint32_t type;
    } e820map[E820MAX];

  /* 0x550 */ uint8_t   pad8[0x600 - 0x550];

  // BIOS Enhanced Disk Drive Services.
  // (From linux/include/asm-i386/edd.h, 'struct edd_info')
  // Each 'struct edd_info is 78 bytes, times a max of 6 structs in array.
  /* 0x600 */ uint8_t   eddbuf[0x7d4 - 0x600];

  /* 0x7d4 */ uint8_t   pad9[0x800 - 0x7d4];
  /* 0x800 */ uint8_t   commandline[0x800];

  uint64_t gdt_table[4];
};

#define KERNEL_PARAMS_ADDR 0x00090000

static void copy_kernel(PCMachine *s, const uint8_t *buf, int buf_len,
                        const char *cmd_line)
{
    uint8_t *ram_ptr;
    int setup_sects, header_len, copy_len, setup_hdr_start, setup_hdr_end;
    uint32_t load_address;
    struct linux_params *params;
    FBDevice *fb_dev;
    
    if (buf_len < 1024) {
    too_small:
        fprintf(stderr, "Kernel too small\n");
        exit(1);
    }
    if (buf[0x1fe] != 0x55 || buf[0x1ff] != 0xaa) {
        fprintf(stderr, "Invalid kernel magic\n");
        exit(1);
    }
    setup_sects = buf[0x1f1];
    if (setup_sects == 0)
        setup_sects = 4;
    header_len = (setup_sects + 1) * 512;
    if (buf_len < header_len)
        goto too_small;
    if (memcmp(buf + 0x202, "HdrS", 4) != 0) {
        fprintf(stderr, "Kernel too old\n");
        exit(1);
    }
    load_address = 0x100000; /* we don't support older protocols */

    ram_ptr = get_ram_ptr(s, load_address);
    copy_len = buf_len - header_len;
    if (copy_len > (s->ram_size - load_address)) {
        fprintf(stderr, "Not enough RAM\n");
        exit(1);
    }
    memcpy(ram_ptr, buf + header_len, copy_len);

    params = (void *)get_ram_ptr(s, KERNEL_PARAMS_ADDR);
    
    memset(params, 0, sizeof(struct linux_params));

    /* copy the setup header */
    setup_hdr_start = 0x1f1;
    setup_hdr_end = 0x202 + buf[0x201];
    memcpy((uint8_t *)params + setup_hdr_start, buf + setup_hdr_start,
           setup_hdr_end - setup_hdr_start);

    strcpy((char *)params->commandline, cmd_line);

    params->mount_root_rdonly = 0;
    params->cmd_line_ptr = KERNEL_PARAMS_ADDR +
        offsetof(struct linux_params, commandline);
    params->alt_mem_k = (s->ram_size / 1024) - 1024;
    params->loader_type = 0x01;
#if 0
    if (initrd_size > 0) {
        params->initrd_start = INITRD_LOAD_ADDR;
        params->initrd_size = initrd_size;
    }
#endif
    params->orig_video_lines = 0;
    params->orig_video_cols = 0;

    fb_dev = s->common.fb_dev;
    if (fb_dev) {
        
        params->orig_video_isVGA = 0x23; /* VIDEO_TYPE_VLFB */

        params->lfb_depth = 32;
        params->red_size = 8;
        params->red_pos = 16;
        params->green_size = 8;
        params->green_pos = 8;
        params->blue_size = 8;
        params->blue_pos = 0;
        params->rsvd_size = 8;
        params->rsvd_pos = 24;

        params->lfb_width = fb_dev->width;
        params->lfb_height = fb_dev->height;
        params->lfb_linelength = fb_dev->stride;
        params->lfb_size = fb_dev->fb_size;
        params->lfb_base = FRAMEBUFFER_BASE_ADDR;
    }
    
    params->gdt_table[2] = 0x00cf9b000000ffffLL; /* CS */
    params->gdt_table[3] = 0x00cf93000000ffffLL; /* DS */
        
#ifdef USE_KVM
    if (s->kvm_enabled) {
        struct kvm_sregs sregs;
        struct kvm_segment seg;
        struct kvm_regs regs;
        
        /* init flat protected mode */

        if (ioctl(s->vcpu_fd, KVM_GET_SREGS, &sregs) < 0) {
            perror("KVM_GET_SREGS");
            exit(1);
        }

        sregs.cr0 |= (1 << 0); /* CR0_PE */
        sregs.gdt.base = KERNEL_PARAMS_ADDR +
            offsetof(struct linux_params, gdt_table);
        sregs.gdt.limit = sizeof(params->gdt_table) - 1;
        
        memset(&seg, 0, sizeof(seg));
        seg.limit = 0xffffffff;
        seg.present = 1;
        seg.db = 1;
        seg.s = 1; /* code/data */
        seg.g = 1; /* 4KB granularity */

        seg.type = 0xb; /* code */
        seg.selector = 2 << 3;
        sregs.cs = seg;

        seg.type = 0x3; /* data */
        seg.selector = 3 << 3;
        sregs.ds = seg;
        sregs.es = seg;
        sregs.ss = seg;
        sregs.fs = seg;
        sregs.gs = seg;
        
        if (ioctl(s->vcpu_fd, KVM_SET_SREGS, &sregs) < 0) {
            perror("KVM_SET_SREGS");
            exit(1);
        }
        
        memset(&regs, 0, sizeof(regs));
        regs.rip = load_address;
        regs.rsi = KERNEL_PARAMS_ADDR;
        regs.rflags = 0x2;
        if (ioctl(s->vcpu_fd, KVM_SET_REGS, &regs) < 0) {
            perror("KVM_SET_REGS");
            exit(1);
        }
    } else
#endif
    {
        int i;
        X86CPUSeg sd;
        uint32_t val;
        val = x86_cpu_get_reg(s->cpu_state, X86_CPU_REG_CR0);
        x86_cpu_set_reg(s->cpu_state, X86_CPU_REG_CR0, val | (1 << 0));
        
        sd.base = KERNEL_PARAMS_ADDR +
            offsetof(struct linux_params, gdt_table);
        sd.limit = sizeof(params->gdt_table) - 1;
        x86_cpu_set_seg(s->cpu_state, X86_CPU_SEG_GDT, &sd);
        sd.sel = 2 << 3;
        sd.base = 0;
        sd.limit = 0xffffffff;
        sd.flags = 0xc09b;
        x86_cpu_set_seg(s->cpu_state, X86_CPU_SEG_CS, &sd);
        sd.sel = 3 << 3;
        sd.flags = 0xc093;
        for(i = 0; i < 6; i++) {
            if (i != X86_CPU_SEG_CS) {
                x86_cpu_set_seg(s->cpu_state, i, &sd);
            }
        }
                        
        x86_cpu_set_reg(s->cpu_state, X86_CPU_REG_EIP, load_address);
        x86_cpu_set_reg(s->cpu_state, 6, KERNEL_PARAMS_ADDR); /* esi */
    }

    /* map PCI interrupts (no BIOS, so we must do it) */
    {
        uint8_t elcr[2];
        static const uint8_t pci_irqs[4] = { 9, 10, 11, 12 };

        i440fx_map_interrupts(s->i440fx_state, elcr, pci_irqs);
        /* XXX: KVM support */
        if (s->pic_state) {
            pic2_set_elcr(s->pic_state, elcr);
        }
    }
}

/* in ms */
static int pc_machine_get_sleep_duration(VirtMachine *s1, int delay)
{
    PCMachine *s = (PCMachine *)s1;

#ifdef USE_KVM
    if (s->kvm_enabled) {
        /* XXX: improve */
        cmos_update_irq(s->cmos_state);
        delay = 0;
    } else
#endif
    {
        cmos_update_irq(s->cmos_state);
        delay = min_int(delay, pit_update_irq(s->pit_state));
        if (!x86_cpu_get_power_down(s->cpu_state))
            delay = 0;
    }
    return delay;
}

static void pc_machine_interp(VirtMachine *s1, int max_exec_cycles)
{
    PCMachine *s = (PCMachine *)s1;
#ifdef USE_KVM
    if (s->kvm_enabled) {
        kvm_exec(s);
    } else 
#endif
    {
        x86_cpu_interp(s->cpu_state, max_exec_cycles);
    }
}

const VirtMachineClass pc_machine_class = {
    "pc",
    pc_machine_set_defaults,
    pc_machine_init,
    pc_machine_end,
    pc_machine_get_sleep_duration,
    pc_machine_interp,
    pc_vm_mouse_is_absolute,
    pc_vm_send_mouse_event,
    pc_vm_send_key_event,
};