Archipelago » qemu

void qemu_ram_free(ram_addr_t addr);

/* This should only be used for ram local to a device.  */

void *qemu_get_ram_ptr(ram_addr_t addr);

int cpu_register_io_memory(int io_index,

                           CPUReadMemoryFunc **mem_read,

                           CPUWriteMemoryFunc **mem_write,

static inline target_ulong get_phys_addr_code(CPUState *env1, target_ulong addr)

{

    int mmu_idx, page_index, pd;

    page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);

    mmu_idx = cpu_mmu_index(env1);

        cpu_abort(env1, "Trying to execute code outside RAM or ROM at 0x" TARGET_FMT_lx "\n", addr);

#endif

    }

}

/* Deterministic execution requires that IO only be performed on the last

    }

}

void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,

                                     int dirty_flags)

{

    /* we modify the TLB cache so that the dirty bit will be set again

       when accessing the range */

    for(env = first_cpu; env != NULL; env = env->next_cpu) {

        for(i = 0; i < CPU_TLB_SIZE; i++)

            tlb_reset_dirty_range(&env->tlb_table[0][i], start1, length);

static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)

{

    ram_addr_t ram_addr;

    if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {

        if (!cpu_physical_memory_is_dirty(ram_addr)) {

            tlb_entry->addr_write |= TLB_NOTDIRTY;

        }

        /* IO memory case (romd handled later) */

        address |= TLB_MMIO;

    }

    if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {

        /* Normal RAM.  */

        iotlb = pd & TARGET_PAGE_MASK;

}

/* Return a host pointer to ram allocated with qemu_ram_alloc.

void *qemu_get_ram_ptr(ram_addr_t addr)

{

    return phys_ram_base + addr;

}

static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)

{

#ifdef DEBUG_UNASSIGNED

        dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];

#endif

    }

#ifdef USE_KQEMU

    if (cpu_single_env->kqemu_enabled &&

        (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)

        dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];

#endif

    }

#ifdef USE_KQEMU

    if (cpu_single_env->kqemu_enabled &&

        (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)

        dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];

#endif

    }

#ifdef USE_KQEMU

    if (cpu_single_env->kqemu_enabled &&

        (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)

                unsigned long addr1;

                addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);

                /* RAM case */

                memcpy(ptr, buf, l);

                if (!cpu_physical_memory_is_dirty(addr1)) {

                    /* invalidate code */

                }

            } else {

                /* RAM case */

                    (addr & ~TARGET_PAGE_MASK);

                memcpy(buf, ptr, l);

            }

            unsigned long addr1;

            addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);

            /* ROM/RAM case */

            memcpy(ptr, buf, l);

        }

        len -= l;

            ptr = bounce.buffer;

        } else {

            addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);

        }

        if (!done) {

            ret = ptr;

{

    if (buffer != bounce.buffer) {

        if (is_write) {

            while (access_len) {

                unsigned l;

                l = TARGET_PAGE_SIZE;

        val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);

    } else {

        /* RAM case */

            (addr & ~TARGET_PAGE_MASK);

        val = ldl_p(ptr);

    }

#endif

    } else {

        /* RAM case */

            (addr & ~TARGET_PAGE_MASK);

        val = ldq_p(ptr);

    }

        io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);

    } else {

        unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);

        stl_p(ptr, val);

        if (unlikely(in_migration)) {

        io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);

#endif

    } else {

            (addr & ~TARGET_PAGE_MASK);

        stq_p(ptr, val);

    }

        unsigned long addr1;

        addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);

        /* RAM case */

        stl_p(ptr, val);

        if (!cpu_physical_memory_is_dirty(addr1)) {

            /* invalidate code */

    mem.slot = slot->slot;

    mem.guest_phys_addr = slot->start_addr;

    mem.memory_size = slot->memory_size;

    mem.flags = slot->flags;

    return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);

    /* initially, KVM allocated its own memory and we had to jump through

     * hooks to make phys_ram_base point to this.  Modern versions of KVM

     * unmodified.  Make sure we have a sufficiently modern version of KVM.

     */

    ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);

    if (qemu_get_be32(f) != phys_ram_size)

        return -EINVAL;

    for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {

        if (ret)

            return ret;

    }

    while (addr < phys_ram_size) {

        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {

            cpu_physical_memory_reset_dirty(current_addr,

                                            current_addr + TARGET_PAGE_SIZE,

                                            MIGRATION_DIRTY_FLAG);

                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);

            } else {

                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);

            }

            found = 1;

            goto error;

        }

        if (buf[0] == 0) {

                fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);

                goto error;

            }

        if (flags & RAM_SAVE_FLAG_COMPRESS) {

            uint8_t ch = qemu_get_byte(f);

        } else if (flags & RAM_SAVE_FLAG_PAGE)

    } while (!(flags & RAM_SAVE_FLAG_EOS));

    return 0;