概述在嵌入式安全领域常常需要分析各种不同形态的固件，如果需要动态执行某些代码或者对固件进行Fuzzing测试，则需要对固件代码进行仿真，常用的仿真工具一般为qemu和unicorn。unicorn适…

概述

在嵌入式安全领域常常需要分析各种不同形态的固件，如果需要动态执行某些代码或者对固件进行Fuzzing测试，则需要对固件代码进行仿真，常用的仿真工具一般为qemu和unicorn。unicorn适合模拟执行固件中的某些代码片段，而对于中断、异步执行则不支持，而大量的嵌入式固件都是以中断驱动的，对于中断的模拟则需要依赖于qemu的全系统模拟。

本文将以luaqemu为例介绍在使用qemu来模拟固件、外设时可以借鉴的技术，代码地址

https://github.com/Comsecuris/luaqemu

简单的说luaqemu通过修改部分qemu代码并在一些关键的执行点增加回调函数，使得用户可以通过lua脚本来加载固件、监控固件代码的执行，设置观察点、断点等。

示例luaqemu脚本如下

require('hw.arm.luaqemu')
 machine_cpu = 'cortex-r5'
 memory_regions = {
 region_rom = {
 name = 'mem_rom',
 start = 0x0,
 size = 0x180000
 },
 region_ram = {
 name = 'mem_ram',
 start = 0x180000,
 size = 0xC0000
 },
 }
 file_mappings = {
 main_rom = {
 name = 'rom.bin',
 start = 0x0,
 size = 0x180000
 },
 main_ram = {
 name = 'kernel.bin',
 start = 0x180000,
 size = 0xC0000
 }
 }
 cpu = {
 env = {
 thumb = true,
 },
 reset_pc = 0
 }

该脚本的作用如下

machine_cpu指定cpu的类型
利用memory_regions初始化两块内存，起始地址和内存大小分别为：(0x0, 0x180000) 和 (0x180000, 0xC0000)
file_mappings将特定的文件加载到内存中指定的位置，代码中将rom.bin文件加载到0x0地址，大小为0x180000，将kernel.bin文件加载到0x180000地址，大小为0xC0000。
cpu关键字指定cpu的属性，设置了cpu的指令类型为thumb，reset_pc设置虚拟机启动后的pc寄存器的值为0，表示虚拟机启动后执行的第一条指令。

初始化

luaqemu新增了一个luaarm的机器，代码位于

hw/arm/luaarm.c

代码通过宏和数据结构指定machine的类型和初始化函数

static void lua_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
mc->desc = "Lua ARM Meta Machine";
mc->init = lua_init;
}
static const TypeInfo lua_machine_type = {
.name = MACHINE_TYPE_NAME("luaarm"),
.parent = TYPE_MACHINE,
.class_init = lua_class_init,
};
static void lua_machine_init(void)
{
type_register_static(&lua_machine_type);
}
type_init(lua_machine_init)

可以看到lua_init为machine的入口函数

static void lua_init(MachineState *machine)
{   
// 加载 lua_script 指定的脚本，命令行参数指定
luaL_loadfile(lua_state, lua_script)
// 设置 cpu 的类型
machine->cpu_model = lua_tostring(lua_state, -1);
// 根据lua脚本来设置虚拟机的状态、固件的加载、回调函数注册
init_memory_regions();
init_luastate(machine);
init_file_mappings();
init_cpu_state();
init_vm_states();
// 执行 lua 脚本的 post_init 函数
}

该函数会根据lua脚本函数设置虚拟机的状态、固件的加载、回调函数注册等，函数的主要流程如下

首先根据命令行参数加载指定的lua脚本
设置CPU的类型，内存映射关系
加载文件到虚拟机的内存
初始化CPU的状态（寄存器）
注册一系列回调函数，比如设置断点、指令执行回调等

通过搜索lua_script关键字可以找到设置命令行参数的位置位于vl.c的main函数里面

case QEMU_OPTION_lua:
lua_script = optarg;
break;

我们也可以通过类似的方式注册需要的命令行参数

init_luastate 会把虚拟机的cpu对象保存到luastate全局变量里面

static void init_luastate(MachineState *machine)
{
ARMCPU *cpu;
ObjectClass *cpu_oc;
CPUState *cs;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, machine->cpu_model);
if (!cpu_oc) {
error_report("machine \"%s\" not found, exiting\n", machine->cpu_model);
exit(1);
}
cpu = ARM_CPU(object_new(object_class_get_name(cpu_oc)));
cs = CPU(cpu);
luastate.cpu = cpu;
luastate.cs = cs;
luastate.machine = machine;
luastate.bp_pc = 0;
luastate.bp_pc_ptr = NULL;
luastate.old_wp_ptr = NULL;
g_hash_table_foreach(breakpoints, add_cpu_breakpoints, NULL);
}

内存申请

qemu内存模型

qemu 使用 MemoryRegion 组织虚拟机的物理内存空间，MemoryRegion 表示一段逻辑内存区域，它的类型如下：

RAM：普通内存，qemu通过向主机申请虚拟内存来实现。
MMIO：MMIO内存在读写时会调用初始化mr时指定的回调函数，回调函数由MemoryRegionOps指定，在memory_region_init_io时指定
ROM：只读内存，只读内存的读操作和RAM相同，禁止写操作。
ROM device：只读设备，读操作和RAM行为相同，只读设备的允许写操作，写操作和MMIO行为相同，会触发callback。
IOMMU region：将对一段内存的访问转发到另一段内存上，这种类型的内存只用于模拟IOMMU的场景。
container：容器，管理多个MR的MR，用于将多个MR组织成一个内存区域，比如整个虚机的内存地址区域，它被抽象成一个容器，包括了所有虚拟的内存区间。
alias：主要是让不同物理地址映射到同一个 MemoryRegion ，类似于memory banking。

下面介绍一些常用内存的使用方式

申请ram

qemu使用memory_region_init_ram初始化MemoryRegion为ram类型

void memory_region_init_ram(MemoryRegion *mr,
struct Object *owner,
const char *name,
uint64_t size,
Error **errp)

使用实例

MemoryRegion *system_memory = get_system_memory();
MemoryRegion *flash = g_new(MemoryRegion, 1);
memory_region_init_ram(flash, NULL, "STM32F205.flash", FLASH_SIZE, &error_fatal);
memory_region_add_subregion(system_memory, 0, flash);

qemu通过MemoryRegion的组合来表示虚拟机的物理内存空间，qemu在启动时会创建一个system_memory的MemoryRegion，system_memory是一个全局变量可以通过get_system_memory函数获取。

static void memory_map_init(void)
{
system_memory = g_malloc(sizeof(*system_memory));
memory_region_init(system_memory, NULL, "system", UINT64_MAX);
address_space_init(&address_space_memory, system_memory, "memory");
system_io = g_malloc(sizeof(*system_io));
memory_region_init_io(system_io, NULL, &unassigned_io_ops, NULL, "io",
  65536);
address_space_init(&address_space_io, system_io, "I/O");
}

system_memory的大小为UINT64_MAX，表示了整个物理内存空间，这个只是一个初始化，如果物理地址空间中的某些区域是ram，rom或者是mmio内存就可以通过memory_region_add_subregion来定义子区域的MemoryRegion类型。

void memory_region_add_subregion(MemoryRegion *mr,
 hwaddr offset,
 MemoryRegion *subregion)
其中mr为父MemoryRegion
subregion 为子MemoryRegion
offset表示 相对于 mr 起始地址的偏移
函数的作用：mr 的 offset 处内存由 subregion 重新定义

回到本节的实例，流程如下

首先使用get_system_memory获取表示整个物理内存空间的MemoryRegion。
然后新建一个flash的MemoryRegion并使用memory_region_init_ram指定该MemoryRegion是一个RAM类型的，大小为FLASH_SIZE。
使用memory_region_add_subregion把flash挂载到system_memory起始地址偏移0处。

由于system_memory表示的是虚拟机的整个物理内存空间，执行完之后虚拟机物理地址0处的内存是RAM类型，大小为FLASH_SIZE，可以像内存使用一样直接读写。

申请rom

使用方式和申请ram的一样，不同的申请得到的内存为只读的

void memory_region_init_rom(MemoryRegion *mr,
struct Object *owner,
const char *name,
uint64_t size,
Error **errp)

使用实例

memory_region_init_rom(&s->rom, NULL, "imx6ul.rom", FSL_IMX6UL_ROM_SIZE, &error_abort);
memory_region_add_subregion(get_system_memory(), FSL_IMX6UL_ROM_ADDR, &s->rom);

执行之后虚拟机 [FSL_IMX6UL_ROM_ADDR, FSL_IMX6UL_ROM_ADDR + FSL_IMX6UL_ROM_SIZE] 这段物理地址空间为ROM内存，只读。

申请mmio

使用的函数为memory_region_init_io

void memory_region_init_io(MemoryRegion *mr,
   Object *owner,
   const MemoryRegionOps *ops,
   void *opaque,
   const char *name,
   uint64_t size)

申请之后，对mr内存区域的读写会调用ops指定回调函数进行处理，这种类型的内存是模拟外设时常用的内存类型，因为在ARM芯片中外设的寄存器空间会挂载在系统内存总线上，所以可以通过访问内存来访问外设的寄存器空间，从而控制外设的行为。

使用实例

static uint64_t demo_read(void *opaque, hwaddr offset,
   unsigned size)
{
return data[offset];
}
static void demo_write(void *opaque, hwaddr offset,
uint64_t value, unsigned size)
{
// 进行具体的写操作
return;
}
static const MemoryRegionOps demo_ops = {
.read = demo_read,
.write = demo_write,
.endianness = DEVICE_NATIVE_ENDIAN,
};
memory_region_init_io(&demo_mr, NULL, &demo_ops, NULL, "demo-mmio",  0x1000);
memory_region_add_subregion(system_mem, 0x110000, &demo_mr);

执行完后虚拟机物理内存 [0x110000, 0x110000+0x1000] 这块区域为 mmio内存，当对这块内存进行读写操作时会调用demo_ops中指定的回调函数，比如读内存时调用demo_read，写内存时调用demo_write。

以写内存为例

static void demo_write(void *opaque, hwaddr offset,
uint64_t value, unsigned size)
{
// 进行具体的写操作
return;
}

offset为虚拟机写内存的地址相对MemoryRegion起始地址的偏移，比如现在写的地址是 0x110012，写的数据大小为2个字节，值为 0xaabb。

那么进入demo_write时的参数信息如下

offset: 0x110012-0x110000 --> 0x12
value: 0xaabb
size: 2

申请alias内存

申请函数

void memory_region_init_alias(MemoryRegion *mr,
  Object *owner,
  const char *name,
  MemoryRegion *orig,
  hwaddr offset,
  uint64_t size)

使用实例

memory_region_init_ram(flash, NULL, "flash", FLASH_SIZE, &error_fatal);
memory_region_init_alias(flash_alias, NULL, "flash.alias", flash, 0, FLASH_SIZE);
memory_region_add_subregion(system_memory, 0x08000000, flash);
memory_region_add_subregion(system_memory, 0, flash_alias);

执行完后 0x08000000 和 0 地址的内存是同一块，对 0x08000000 写数据，0地址也可以读到修改后的数据。

luaqemu申请内存的实现

lua脚本通过memory_regions定义内存申请

memory_regions = {
region_rom = {
name = 'mem_rom',
start = 0x0,
size = 0x180000
},
region_ram = {
name = 'mem_ram',
start = 0x180000,
size = 0xC0000
},
}

static void init_memory_regions(void)
{
MemoryRegion *sysmem = get_system_memory();
lua_get_global("memory_regions", THROW_ERROR);
// 遍历 memory_regions
while (lua_next(lua_state, -2)) { 
add_memory_region(sysmem);
lua_pop(lua_state, 1);
}
}

遍历memory_regions然后对其中的每一项使用 add_memory_region 处理每一个内存映射

static void add_memory_region(MemoryRegion *sm)
{
region_start = lua_get_unsigned("start", THROW_ERROR);
region_size  = lua_get_unsigned("size", THROW_ERROR);
region_name  = lua_get_string("name", THROW_ERROR);
memory_region = g_new(MemoryRegion, 1);
memory_region_allocate_system_memory(memory_region, NULL, region_name, region_size);
memory_region_add_subregion(sm, region_start, memory_region);
}

主要逻辑就是根据lua脚本的memory_region定义，使用memory_region_allocate_system_memory分配内存，然后使用memory_region_add_subregion挂载到system_memory中。

文件加载

lua脚本使用file_mappings定义文件加载的路径、地址和大小

 file_mappings = {
 main_rom = {
 name = 'examples/bcm4358/bcm4358.rom.bin',
 start = 0x0,
 size = 0x180000
 },
 main_ram = {
 name = 'kernel',
 start = 0x180000,
 size = 0xC0000
 }
 }

处理文件加载的逻辑位于init_file_mappings函数

static void init_file_mappings(void)
{
lua_get_global("file_mappings", THROW_ERROR);
while (lua_next(lua_state, -2)) {
add_file();  // 具体处理
lua_pop(lua_state, 1);
}
}

遍历file_mappings每一项，然后调用add_file处理每一个文件映射

static void add_file(void)
{
mapping_fn= lua_get_string("name", THROW_ERROR);
mapping_type  = lua_get_string("type", NOTHROW_ERROR); 
if (!strcasecmp(mapping_fn, "kernel")) {
mapping_fn = luastate.machine->kernel_filename;
}
if (mapping_type && !strcasecmp(mapping_type, "elf")) {
load_arm_elf(mapping_fn);
} else {
load_flat_file(mapping_fn, mapping_start, mapping_size);
}
}

主要是分两种情况进行处理，如果name为kernel，就调用load_arm_elf加载elf文件到内存，否则就使用load_flat_file把文件直接加载到内存的指定位置。

static void load_flat_file(const char *file_path, hwaddr start, uint64_t size)
{
char *fn = NULL;
if (NULL == (fn = qemu_find_file(QEMU_FILE_TYPE_BIOS, file_path))) {
error_report("Couldn't find rom image '%s'.", file_path);
exit(4);
}
if (0 > load_image_targphys(fn, start, size)) {
error_report("Couldn't map file to memory\n");
exit(5);
}
g_free(fn);
}

load_flat_file主要就是先qemu_find_file找到文件，然后使用load_image_targphys加载到指定的位置。

设置CPU状态和执行回调

init_cpu_state为处理函数

static const keyword_table_t kwt[] =
{
{"reset_pc", init_reset_addr},
{"env", init_cpu_env},
{"callbacks", init_cpu_callbacks},
\{\{0, 0\}\}
};
static int handle_keyword(int type, const char *key)
{
unsigned int n = sizeof(kwt) / sizeof(*kwt);
int i = 0;
for (;i < n; i++) {
if (!strcmp(kwt[i].keyword, key)) {
kwt[i].fptr(type);
return 0;
}
}
error_report("keyword '%s' not known", key);
return -1;
}
static void init_cpu_state(void)
{
int m_type = 0;
const char *m_name = NULL;
lua_get_global("cpu", NOTHROW_ERROR);
while (lua_next(lua_state, -2)) {
m_name = lua_tostring(lua_state, -2);
m_type = lua_type(lua_state, -1);
handle_keyword(m_type, m_name);
lua_pop(lua_state, 1);
}
}

主要就是根据关键字来调用对应的处理函数

init_reset_addr

用于设置系统启动后的PC值

static void init_reset_addr(int type)
{
double d = 0;
uint64_t addr;
ARMCPU *cpu = ARM_CPU(luastate.cs);
if (type != LUA_TNUMBER) {
return;
}
d = lua_tonumber(lua_state, -1);
lua_number2unsigned(addr, d);
cpu->rvbar = addr;
return;
}

主要就是从lua脚本中提取reset_pc的值，暂时保存在cpu->rvbar，后面会在init_cpu_env设置pc。

static void init_cpu_env(int type)
{
........
if (cpu->rvbar) {
cpu_set_pc(luastate.cs, cpu->rvbar); // 设置 pc寄存器
}

init_cpu_env

函数首先根据cpu->rvbar设置cpu的pc，然后会设置是否使用thumb指令集，后面会设置miss_max用于检测死循环，最后调用init_cpu_env_registers设置其他的回调函数。

static void init_cpu_env(int type)
{
if (cpu->rvbar) {
cpu_set_pc(luastate.cs, cpu->rvbar);
}
luastate.cpu->env.thumb   = lua_get_boolean("thumb", 0);
luastate.cs->crs.miss_max = lua_get_unsigned("stuck_max", 0);
init_cpu_env_registers();
}

miss_max固件代码死循环检测

在嵌入式固件中，在执行过程中如果发生了异常（比如发现某个硬件设备工作不正常），会进入死循环

Infinite_Loop:
b   Infinite_Loop

最开始仿真固件时，就会由于某些硬件设备没有仿真正确，从而让固件代码进入了死循环，luaqemu实现了一种方式可以快速的检测发生死循环的位置.

首先在 init_cpu_env 中设置 miss_max，表示同一个状态进入次数的最大值，状态通过arm_cpu_state_hash计算得到

uint64_t arm_cpu_state_hash(CPUState *cs, int flags)
{
ARMCPU *cpu = ARM_CPU(cs);
CPUARMState *env = &cpu->env;
int max_regs = !is_a64(env) ? sizeof(env->regs) / sizeof(env->regs[0]) : sizeof(env->xregs) / sizeof(env->xregs[0]);
uint64_t hash = !is_a64(env) ? env->regs[15] : env->pc;
int i = 0;
if (!is_a64(env)) {
for (; i < max_regs; i++) {
hash += env->regs[i];
}
} else {
for (; i < max_regs; i++) {
hash += env->xregs[i];
}
}
return hash;
}

该函数其实就是把所有cpu寄存器的值加在一起作为hash，用于标识每个状态。

然后在cpu_tb_exec中每个tb执行前会去计算当前状态的执行次数

static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb)
{
if (cpu->crs.miss_max != 0) {
record_cpu_state(cpu, 0);
}

record_cpu_state的逻辑相对简单，根据当前cpu的寄存器状态计算hash(arm_cpu_state_hash)，然后更新对应hash的执行次数，如果次数达到阈值（miss_count），就调用回调函数

void record_cpu_state(CPUState *cpu, int flags)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
uint64_t hash = 0;
if (cc->cpu_state_hash) {
hash = cc->cpu_state_hash(cpu, flags);
if (g_hash_table_contains(cpu->crs.cpu_states, GUINT_TO_POINTER(hash))) {
cpu->crs.miss_count++;
if (cpu->crs.miss_count >= cpu->crs.miss_max && cpu->crs.state_cb != NULL) {
cpu->crs.state_cb(cpu);
}
} else {
cpu->crs.ns++;
if (cpu->crs.ns >= cpu->crs.miss_max) {
g_hash_table_remove_all(cpu->crs.cpu_states);
cpu->crs.miss_count = 0;
}
g_hash_table_insert(cpu->crs.cpu_states, GUINT_TO_POINTER(hash), GUINT_TO_POINTER(hash));
}
}
}

回调函数定义

static void set_cpu_stuck_state_cb(void)
{
printf("Found stuck state callback. Make sure to set \"stuck_max\" in env block.\n");
luastate.cs->crs.state_cb = cpu_stuck_callback;
}

cpu_stuck_callback就是调用lua脚本里面指定的回调函数

lua脚本示例

cpu = {
env = {
stuck_max = 200000,
stuck_cb = lua_stuck_cb,
... }
}

此外还有一个比较关键的点，由于qemu在执行时会把有跳转关系的tb链接到一起，所以如果程序一直死循环，则正常情况下cpu_tb_exec不会被执行多次，因为如果tb链接到一起后就不会进入cpu_tb_exec了。

luaqemu的做法是在tb_find里面当需要检测死循环时禁用tb链接。

/* See if we can patch the calling TB. */
if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN) && !cpu->crs.miss_max) {
if (!tb->invalid) {
tb_add_jump(last_tb, tb_exit, tb);
}
}

设置CPU寄存器初始值

/* target/arm/cpu.h */
static void init_cpu_env_registers(void)
{
int reg_i, reg_v = 0;
char reg_s[4] = {0};
lua_get_field("regs", 0);
for (reg_i = 0; reg_i < sizeof(luastate.cpu->env.regs) / sizeof(*(luastate.cpu->env.regs)); reg_i++) {
snprintf(reg_s, sizeof(reg_s), "r%d", reg_i);
lua_pushstring(lua_state, reg_s);
lua_gettable(lua_state, -2); /* get table[name] */
if (lua_isnil(lua_state, -1)) {
lua_pop(lua_state, 1);
continue;
} else {
reg_v = lua_tointeger(lua_state, -1);
debug_print("'%s' -> %x\n", reg_s, reg_v);
luastate.cpu->env.regs[reg_i] = reg_v;
}

关键逻辑就是根据regs的值，设置对应寄存器。

init_cpu_callbacks

该函数主要处理针对cpu事件的回调函数，比如指令执行、基本块执行等

static const cb_keyword_table_t cb_kwt[] =
{
{"stuck_state_cb", &luastate.stuck_state_cb, set_cpu_stuck_state_cb},
{"exec_insn_cb",   &luastate.exec_insn_cb, NULL},
{"exec_block_cb",  &luastate.exec_block_cb, NULL},
{"post_exec_block_cb", &luastate.post_exec_block_cb, NULL},
\{\{0, 0, 0\}\}
};

其中stuck_state_cb在上一节中已经说过

指令执行回调

luaqemu在gen_intermediate_code翻译指令的位置插入了lua_cpu_exec_insn_callback回调函数

#ifdef CONFIG_LUAJIT
uint64_t insn_bytes;
if (dc->thumb) {
insn_bytes = arm_lduw_code(env, dc->pc, dc->sctlr_b);
if (insn_bytes >> 12 == 15 ||
(insn_bytes >> 12 == 14 && (insn_bytes & (1 << 11)))) { // thumb2, see disas_thumb2_insn use
insn_bytes = arm_ldl_code(env, dc->pc, dc->sctlr_b);
}
} else {
insn_bytes = arm_ldl_code(env, dc->pc, dc->sctlr_b);
}
lua_cpu_exec_insn_callback(dc->pc, insn_bytes);
#endif

lua_cpu_exec_insn_callback 其实就是调用lua侧的函数

基本块执行回调

在cpu_tb_exec中基本块执行前调用lua_cpu_post_exec_block_callback，基本块执行后调用lua_cpu_post_exec_block_callback。

lua_cpu_post_exec_block_callback和lua_cpu_post_exec_block_callback最后都是调用lua侧的函数

/* Execute a TB, and fix up the CPU state afterwards if necessary */
static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb)
{
#ifdef CONFIG_LUAJIT
lua_cpu_exec_block_callback(itb->pc);
#endif
ret = tcg_qemu_tb_exec(env, tb_ptr);
#ifdef CONFIG_LUAJIT
lua_cpu_post_exec_block_callback(itb->pc);
#endif

设置执行断点

处理函数为init_vm_states

static void init_vm_states(void)
{
qemu_add_vm_change_state_handler(lua_vm_state_change, NULL);
lua_get_global("breakpoints", NOTHROW_ERROR);
while (lua_next(lua_state, -2)) {
util_breakpoint_insert(lua_tointeger(lua_state, -2), bp_func);
lua_pop(lua_state, 1);
}
}

主要逻辑就是调用qemu_add_vm_change_state_handler注册一个回调函数，当虚拟机状态变化时（比如命中断点、观察点等）调用对应函数。

然后处理breakpoints，用util_breakpoint_insert给地址插入断点，当断点命中执行 bp_func

static void util_breakpoint_insert(uint64_t addr, int bp_func)
{
if(luastate.cs) {
cpu_breakpoint_insert(luastate.cs, addr, BP_LUA, NULL);
}
g_hash_table_insert(breakpoints, GUINT_TO_POINTER(addr), GINT_TO_POINTER(bp_func));
}

主要就是调用cpu_breakpoint_insert插入断点，然后把断点的地址和回调函数保存到全局哈希表里面。

下面看一下断点处理流程

static void lua_vm_state_change(void *opaque, int running, RunState state)
{
   // 获取当前pc值
uint64_t old_pc = lua_current_pc();
switch (state) {
case RUN_STATE_DEBUG:
handle_vm_state_breakpoint(old_pc);
break;

在init_vm_states处注册了lua_vm_state_change回调函数，当命中断点、命中watchpoint、单步执行时会触发RUN_STATE_DEBUG事件，断点就是在这里处理，最后会进入handle_vm_state_breakpoint处理断点事件

static inline void handle_vm_state_breakpoint(uint64_t pc)
{
int bp_func;
bp_func = GPOINTER_TO_INT(g_hash_table_lookup(breakpoints, GUINT_TO_POINTER(pc)));
if (bp_func) {
trigger_breakpoint(bp_func);
if (pc == lua_current_pc()) {
cpu_breakpoint_remove(luastate.cs, pc, BP_LUA);
luastate.bp_pc = pc;
luastate.bp_pc_ptr = &luastate.bp_pc;
cpu_single_step(luastate.cs, 1);
}
tb_flush(luastate.cs);
} else {
if (!luastate.bp_pc_ptr) {
return;
}
cpu_single_step(luastate.cs, 0);
cpu_breakpoint_insert(luastate.cs, luastate.bp_pc, BP_LUA, NULL);
vm_start(); 
luastate.bp_pc_ptr = NULL;
}
}

下面简单介绍下断点的处理流程

断点触发时进入handle_vm_state_breakpoint，然后根据pc搜索回调函数，然后trigger_breakpoint调用回调函数。
如果回调函数里面没有修改cpu的pc指针，则会调用cpu_breakpoint_remove临时删除该断点，并设置luastate.bp_pc和luastate.bp_pc_ptr为此时的pc，即触发断点的pc。
然后cpu_single_step启用cpu的单步模式，下次执行一条指令后，会再次触发断点事件，进入该函数，此时bp_func为NULL。
然后会进入else分支，首先调用cpu_single_step关闭单步执行模式，然后调用cpu_breakpoint_insert重新把断点插到之前删除的位置。

至此luaqemu的初始化工作完成，下面分析luaqemu提供给lua脚本的一些api的实现

Luaqemu API实现分析

断点相关

设置断点

void lua_breakpoint_insert(uint64_t addr, void (*func)(void))
{
int bp_func = luaL_ref(lua_state, LUA_REGISTRYINDEX);
util_breakpoint_insert(addr, bp_func);
}

删除断点

void lua_breakpoint_remove(uint64_t addr)
{
util_breakpoint_remove(addr);
}
static void util_breakpoint_remove(uint64_t addr)
{
int bp_fun = GPOINTER_TO_INT(g_hash_table_lookup(breakpoints, GUINT_TO_POINTER(addr)));
cpu_breakpoint_remove(luastate.cs, addr, BP_LUA);
g_hash_table_remove(breakpoints, GUINT_TO_POINTER(addr));
}

首先调用cpu_breakpoint_remove把断点撤销，然后从哈希表中删除断点。

watchpoint

新增

lua_watchpoint_insert调用util_watchpoint_insert进行具体的观察点设置

void lua_watchpoint_insert(uint64_t addr, uint64_t size, int flags, watchpoint_cb func)
{
  util_watchpoint_insert(addr, size, flags, func);
}
static void util_watchpoint_insert(uint64_t addr, uint64_t size, int flags, watchpoint_cb cb)
{
watchpoint_t *wp;
flags |= BP_STOP_BEFORE_ACCESS;
wp = g_malloc0(sizeof(*wp));
wp->addr = addr;
wp->len = size;
wp->flags = flags;
wp->fptr = cb;
cpu_watchpoint_insert(luastate.cs, addr, size, flags, NULL);
if (NULL == (watchpoints = g_list_append(watchpoints, wp))) {
error_report("%s error adding watchpoint\n", __func__);
g_free(wp);
}
}

util_watchpoint_insert会调用cpu_watchpoint_insert设置观察点，最后把观察点的信息设置到watchpoints列表中

watchpoint在lua_vm_state_change中进行处理，命中观察点时check_watchpoint函数会触发RUN_STATE_DEBUG事件

static inline void handle_vm_state_watchpoint(CPUWatchpoint *wpt, watchpoint_t *owp)
{
GList *iterator;
watchpoint_t *wp;
if (luastate.old_wp_ptr && owp && luastate.old_wp_ptr == owp) {
cpu_single_step(luastate.cs, 0);
cpu_watchpoint_insert(luastate.cs, owp->addr, owp->len, owp->flags, NULL);
vm_start(); /* this is expensive */
return;
}
for(iterator = watchpoints; iterator; iterator = iterator->next) {
wp = iterator->data;
if (wp->addr == wpt->vaddr && wp->len == wpt->len && (wp->flags & wpt->flags)) {
watchpoint_args_t arg;
arg.len = wpt->len;
arg.flags = wpt->flags;
arg.addr = wpt->vaddr;
wp->fptr(&arg);
cpu_watchpoint_remove(luastate.cs, wp->addr, wp->len, wp->flags);
luastate.old_wp_ptr = wp;
cpu_single_step(luastate.cs, 1);
// TODO: introduce flag potentially to control this behavior
tb_flush(luastate.cs);
return;
}
}
}
static void lua_vm_state_change(void *opaque, int running, RunState state)
{
switch (state) {
case RUN_STATE_DEBUG:
if (luastate.old_wp_ptr) {
handle_vm_state_watchpoint(NULL, luastate.old_wp_ptr);
luastate.old_wp_ptr = NULL;
return;
}
if (luastate.cs->watchpoint_hit) {
handle_vm_state_watchpoint(luastate.cs->watchpoint_hit, NULL);
luastate.cs->watchpoint_hit = NULL;
} 
break;

流程如下：

第一次进入old_wp_ptr为空，watchpoint_hit为命中的观察点结构
handle_vm_state_watchpoint 函数会遍历观察点列表，找到回调函数进行调用，然后调用cpu_watchpoint_remove临时删除观察点
cpu_single_step启用单步模式，让单步执行一条指令
再次进入lua_vm_state_change，此时luastate.old_wp_ptr为上次触发观察点的结构
此时关闭单步模式，然后重新把观察点插入

删除

从全局watchpoints列表中删除并调用cpu_watchpoint_remove撤销观察点。

void lua_watchpoint_remove(uint64_t addr, uint64_t size, int flags)
{
  util_watchpoint_remove(addr, size, flags);
}
static void util_watchpoint_remove(uint64_t addr, uint64_t size, int flags)
{
GList *iterator;
watchpoint_t *wp;
for(iterator = watchpoints; iterator; iterator = iterator->next) {
wp = iterator->data;
if (wp->addr == addr && wp->len == size && wp->flags == flags) {
watchpoints = g_list_delete_link(watchpoints, iterator);
cpu_watchpoint_remove(luastate.cs, wp->addr, wp->len, wp->flags);
g_free(wp);
return;
}
}
error_report("%s could not find matching watchpoint\n", __func__);
}

执行相关

lua_continue让虚拟机继续运行

void lua_continue(void)
{
vm_start();
}

寄存器操作

lua_set_pc 设置pc寄存器的值

void lua_set_pc(uint64_t addr)
{
if (!is_a64(&luastate.cpu->env)) {
luastate.cpu->env.regs[15] = addr;
} else {
luastate.cpu->env.pc = addr;
}
}

lua_get_register 获取寄存器的值，就是根据索引去cpu->env结构里面取

uint64_t lua_get_register(uint8_t reg)
{
if (!is_a64(&luastate.cpu->env)) {
if (reg >= sizeof(luastate.cpu->env.regs) / sizeof(*(luastate.cpu->env.regs))) {
error_report("%s '%d' exceeds cpu registers", __func__, reg);
return 0;
}
return luastate.cpu->env.regs[reg];
} else {
if (reg >= sizeof(luastate.cpu->env.xregs) / sizeof(*(luastate.cpu->env.xregs))) {
error_report("%s '%d' exceeds cpu registers", __func__, reg);
return 0;
}
return luastate.cpu->env.xregs[reg];
}
}

lua_set_register 设置寄存器的值，实现类似。

读写虚拟机内存

API列表

uint8_t lua_read_byte(uint64_t);
uint16_t lua_read_word(uint64_t);
uint32_t lua_read_dword(uint64_t);
uint64_t lua_read_qword(uint64_t);
void lua_read_memory(uint8_t *, uint64_t, size_t);
void lua_write_byte(uint64_t, uint8_t);
void lua_write_word(uint64_t, uint16_t);
void lua_write_dword(uint64_t, uint32_t);
void lua_write_qword(uint64_t, uint64_t);
void lua_write_memory(uint64_t, uint8_t *, size_t);

以lua_write_memory为例，这个是往某个地址写一段内存

static inline int lua_memory_rw(target_ulong addr, uint8_t *buf, int len, bool is_write)
{
CPUClass *cc = CPU_GET_CLASS(luastate.cs);
if (cc->memory_rw_debug) {
return cc->memory_rw_debug(luastate.cs, addr, buf, len, is_write);
}
return cpu_memory_rw_debug(luastate.cs, addr, buf, len, is_write);
}
void lua_write_memory(uint64_t addr, uint8_t *src, size_t len)
{
lua_memory_rw(addr, src, len, 1);
}
void lua_read_memory(uint8_t *dest, uint64_t addr, size_t size)
{
lua_memory_rw(addr, dest, size, 0);
}

主要就是调用 cpu_memory_rw_debug 进行内存的写

MMIO内存处理

注册

void lua_trapped_physregion_add(uint64_t addr, uint64_t size, TprReadCb readCb, TprWriteCb writeCb)
{
util_trapped_physregion_add(addr, size, readCb, writeCb);
}
static void util_trapped_physregion_add(uint64_t addr, uint64_t size, TprReadCb readCb, TprWriteCb writeCb)
{
MemoryRegion *sysmem = get_system_memory();
tpr = g_malloc0(sizeof(TrappedPhysRegion));
tpr->readCb = readCb;
tpr->writeCb = writeCb;
tpr->ops.read = trapped_physregion_read;
tpr->ops.write = trapped_physregion_write;
tpr->ops.endianness = DEVICE_NATIVE_ENDIAN;
snprintf(tpr->name, TPR_NAME_SIZE, "TPR_%" PRIx64 "-%" PRIx64 , addr, (addr+size));
memory_region_init_io(&tpr->region, NULL, &tpr->ops, tpr, tpr->name, size);
memory_region_add_subregion(sysmem, addr, &tpr->region);
if (NULL == (trapped_physregions = g_list_append(trapped_physregions, tpr))) {
memory_region_del_subregion(sysmem, &tpr->region);
g_free(tpr);
}
}

核心点就是调用memory_region_init_io注册mmio内存，使得对该内存的读写会调用对应的回调函数，并把tpr作为第一个参数传入。

当对内存读写时会调用 trapped_physregion_read 和 trapped_physregion_write

/* function stolen from memory.c */
static hwaddr memory_region_to_absolute_addr(MemoryRegion *mr, hwaddr offset)
{
MemoryRegion *root;
hwaddr abs_addr = offset;
abs_addr += mr->addr;
for (root = mr; root->container; ) {
root = root->container;
abs_addr += root->addr;
}
return abs_addr;
}
uint64_t trapped_physregion_read(void *opaque, hwaddr addr, unsigned size)
{
TrappedPhysRegion *tpr = opaque;
TprReadCbArgs cbArgs;
hwaddr addr2;
addr2 = memory_region_to_absolute_addr(&tpr->region, addr);
cbArgs.opaque = opaque;
cbArgs.addr = addr2;
cbArgs.size = size;
tpr->readCb(&cbArgs);
return 0;
}
void trapped_physregion_write(void *opaque, hwaddr addr, uint64_t data, unsigned size)
{
TrappedPhysRegion *tpr = opaque;
TprWriteCbArgs cbArgs;
hwaddr addr2;
addr2 = memory_region_to_absolute_addr(&tpr->region, addr);
cbArgs.opaque = opaque;
cbArgs.addr = addr2;
cbArgs.data = data;
cbArgs.size = size;
tpr->writeCb(&cbArgs);
}

核心逻辑就是首先获取访问内存的地址，然后调用TrappedPhysRegion里面的回调函数。

删除

找到对应的region，然后调用memory_region_del_subregion删掉。

void lua_trapped_physregion_remove(uint64_t addr, uint64_t size)
{
util_trapped_physregion_remove(addr, size);
}
static void util_trapped_physregion_remove(uint64_t addr, uint64_t size)
{
GList *iterator;
TrappedPhysRegion *tpr;
MemoryRegion *sysmem = get_system_memory();
for(iterator = trapped_physregions; iterator; iterator = iterator->next) {
tpr = iterator->data;
if (tpr->region.addr == addr && tpr->region.size == size) {
trapped_physregions = g_list_delete_link(trapped_physregions, iterator);
memory_region_del_subregion(sysmem, &tpr->region);
g_free(tpr);
return;
}
}
}

总结

本文分析了luaqemu的实现，luaqemu支持监控基本块、指令级别的监控，支持观察点、断点的设置，支持mmio内存的申请，而且提供了友好的用户接口，可以简单的对虚拟机内存进行读写，唯一不足的是没有中断相关的API。

下篇文章介绍如何使用QEMU模拟设备中断。

参考链接

https://blog.csdn.net/huang987246510/article/details/104012839
https://comsecuris.com/blog/posts/luaqemu_bcm_wifi/

ordar

QEMU固件模拟技术分析-luaqemu实现分析

概述

初始化

内存申请

qemu内存模型

申请ram

申请rom

申请mmio

申请alias内存

luaqemu申请内存的实现

文件加载

设置CPU状态和执行回调

init_reset_addr

init_cpu_env

miss_max固件代码死循环检测

设置CPU寄存器初始值

init_cpu_callbacks

指令执行回调

基本块执行回调

设置执行断点

Luaqemu API实现分析

断点相关

watchpoint

新增

删除

执行相关

寄存器操作

读写虚拟机内存

MMIO内存处理

注册

删除

总结

参考链接