QEMU 的簡介請見 QEMU internals。

• Introduction to QEMU
• Understand Qemu
• Qemu-devel] Question about intermediate code generation in qemu (tcg)
• Memory Simulation in QEMU
• [Qemu-devel] TCG flow vs dyngen
• Re: [Qemu-devel] TCG flow vs dyngen
  • Re: [Qemu-devel] TCG flow vs dyngen

QEMU 中的 target 有兩種意義，

1. 描述被模擬的硬體
2. 對 TCG 而言，target 描述產生何種宿主硬體代碼

• http://vm-kernel.org/blog/ 不要用 IE 開。
• QEMU开发中的小技巧
• qemu internal part 1: the code path of memory load emulation
• qemu internal part 2: softmmu
• qemu internal part 3: memory watchpoint
• vmkernelnewbies
• QEMU Internals: vhost architecture
• http://hi.baidu.com/yiki2/blog/item/3e965a809e86bc9cf703a67c.html
• http://blog.csdn.net/ustc_dylan/article/details/6807731
• QEMU Source Code Notes

QEMU 0.9 版以前使用 dyngen，對於 dyngen 的描述可以參考以下文件。QEMU 0.10 以後改採 TCG。可以從下載 QEMU Source Archive 源碼。

• QEMU, a Fast and Portable Dynamic Translator
• Porting QEMU to Plan 9: QEMU Internals and Port Strategy
• QEMU JIT Code Generator & System Emulation

請先閱讀 Documentation/GettingStartedDevelopers。

• QEMU does not have a high level design description document - only the source code tells the full story
• HACKING 、CODING_STYLE 和 tcg/README。
• QEMU 使用宏展開。編譯時加上 –extra-cflags="-save-temps" 可以得到宏展開之後的檔案 *.i。
• 有些註解是 QEMU 0.9 以前的殘留。
• qemu patchlist 保留早期 QEMU 的 log。

簡單的 patch 請送到 ，請見 Contribute/TrivialPatches。

• target-ARCH/
  • 定義被模擬硬體，反匯編
• OS-user/
  • 作業系統相關
• tcg/
  • 定義如何生成宿主平台指令

QEMU 1.0 將有變動。請見 HACKING、docs/memory.txt 或 Planning/1.0。

請見 memory.[ch]。

• target_phys_addr_t (targphys.h) 代表客戶機物理地址空間。如果客戶機是 x86 開啟 PAE 的話，target_phys_addr_t 為 64 bit。
• target_ulong 代表客戶機暫存器大小和虛擬地址空間。如果客戶機是 x86 開啟 PAE 的話，target_ulong 為 32 bit。
• ram_addr_t (cpu-common.h) 代表宿主機虛擬地址空間。如果宿主機是 x86 的話，ram_addr_t 為 32 bit。
• tb_page_addr_t (exec-all.h) 在 system mode 中被 typedef 成 ram_addr_t; 在 process mode 中被 typedef 成 abi_ulong，abi_ulong 又被 typedef 成 target_ulong。

以宿主機作業系統的角度來看，QEMU 就是一般的使用者進程。QEMU 會在自己的虛擬位址空間分配內存給客戶機作業系統。以客戶機作業系統的角度來看，該塊內存即是客戶機作業系統的物理內存。該物理內存分成一般使用的內存和內存映射 IO。透過 cpu_register_physical_memory_offset (exec.c) 註冊。hw/* 會依序呼叫 cpu_register_io_memory 註冊 IO 模擬的函式和 cpu_register_physical_memory。因為 QEMU 看不到宿主機物理內存，所以註解中所提到的 physical 代表的是 guest physical。

QEMU 分配給客戶機的內存是以 RAMBlock 和 RAMList 來管理。內存主要分為底下幾類 (cpu-common.h):

• IO_MEM_RAM: 一般內存。
• IO_MEM_ROM: ROM。
• IO_MEM_UNASSIGNED: 初始未指定。
• IO_MEM_ROMD: 讀的時候視作為 ROM，寫的時候視作為裝置。

1. 透過 qemu_ram_alloc (exec.c) 申請空間。

   ram_addr_t qemu_ram_alloc(DeviceState *dev, const char *name, ram_addr_t size)
   {
       RAMBlock *new_block, *block;
    
       // RAMBlock 會被賦予一個字串名稱。
       pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
    
       // 檢視 RAMList 中是否已有具有相同名稱的 RAMBlock。
       QLIST_FOREACH(block, &ram_list.blocks, next) {
       }
    
       if (mem_path) {
       } else {
           // 指向宿主的虛擬內存位址。
           new_block->host = qemu_vmalloc(size);
       }
    
       new_block->offset = find_ram_offset(size); // 該 RAMBlock 在 RAMList 的偏移量。
       new_block->length = size; // 該 RAMBlock 的大小。
    
       QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next); // 將新增的 RAMBlock 加入 RAMList。
    
       ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
                                          last_ram_offset() >> TARGET_PAGE_BITS);
       memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
              0xff, size >> TARGET_PAGE_BITS);
    
       return new_block->offset; // 回傳該 RAMBlock 在 RAMList 的偏移量。

2. 透過 cpu_register_physical_memory → cpu_register_physical_memory_offset 註冊該 RAMBlock 的資訊 (跟 QEMU 註冊客戶機物理內存)。target_phys_addr_t 代表客戶機物理內存空間; ram_addr_t 代表宿主機虛擬內存空間。

   void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
                                            ram_addr_t size,
                                            ram_addr_t phys_offset,
                                            ram_addr_t region_offset)
   {
       PhysPageDesc *p;
    
       for(addr = start_addr; addr != end_addr; addr += TARGET_PAGE_SIZE) {
           p = phys_page_find(addr >> TARGET_PAGE_BITS); // 用客戶機物理位址 start_addr 查找 l1_phys_map
           if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
               // 1_phys_map 中已存在該客戶機物理位址的項目。
           } else {
             // 針對該客戶機物理位址在 1_phys_map 中配置 PhysPageDesc 並更新相應的欄位。
               p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
          }
       }
   }

3. 使用 MMIO 的裝置會先呼叫 cpu_register_io_memory 註冊 IO 模擬函式。cpu_register_io_memory 返回 io_mem_write/io_mem_read 的索引。該索引被當作 phys_offset 傳給 cpu_register_physical_memory。

   static void cirrus_init_common(CirrusVGAState * s, int device_id, int is_pci)
   {
       s->vga.vga_io_memory = cpu_register_io_memory(cirrus_vga_mem_read,
                                                     cirrus_vga_mem_write, s);
       cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
                                    s->vga.vga_io_memory);
   }

PhysPageDesc 用來描述客戶機物理頁面和宿主機虛擬頁面的對映。有一個二級頁表 l1_phys_map 存放 PhysPageDesc。phys_page_find_alloc 用客戶機物理位址查詢 l1_phys_map 取得 PhysPageDesc，視情況配置新的 PhysPageDesc。

• cpu_register_physical_memory_offset → phys_page_find → phys_page_find_alloc。

  static PhysPageDesc *phys_page_find_alloc(target_phys_addr_t index, int alloc)
  {
      // 取得一級頁表項
      lp = l1_phys_map + ((index >> P_L1_SHIFT) & (P_L1_SIZE - 1));
   
      // 視 alloc 是否要分配二級頁表項
      for (i = P_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
      }
   
      pd = *lp;
      if (pd == NULL) {
          for (i = 0; i < L2_SIZE; i++) {
              pd[i].phys_offset = IO_MEM_UNASSIGNED;
              pd[i].region_offset = (index + i) << TARGET_PAGE_BITS;
          }
      }
  }

PageDesc 維護 TB 和虛擬頁面/客戶機物理頁面之間的關係 (視 process/system mode 而定)。同樣有一個二級頁表 l1_map 存放 PageDesc。page_find_alloc 查詢 l1_map 取得 PageDesc，視情況配置新的 PageDesc。

• tb_find_slow → tb_gen_code → tb_link_page → tb_alloc_page → page_find_alloc。

  static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
  {
      // ALLOC 在 process mode 使用 mmap; 在 system mode 使用 qemu_mallocz。
   
      /* Level 1.  Always allocated.  */
      lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
   
      /* Level 2..N-1.  */
      for (i = V_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
      }
  }

QEMU 基本上是以 page 為單位將該 page 所屬 TB 清掉。

• stl_mmu (softmmu_template.h) → io_writel (softmmu_template.h) → notdirty_mem_writel (exec.c) → notdirty_mem_writel → tb_invalidate_phys_page_fast (exec.c) → tb_invalidate_phys_page_range (exec.c) → tb_phys_invalidate (exec.c) 會將屬於某虛擬頁面/客戶機物理頁面的 TB 清掉。

  void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end, ...)
  {
      p = page_find(start >> TARGET_PAGE_BITS);
   
      /* we remove all the TBs in the range [start, end[ */
      tb = p->first_tb;
      while (tb != NULL) {
      }
  }

• tb_invalidate_phys_page (exec.c) → tb_phys_invalidate (exec.c)。tb_invalidate_phys_page 僅在 process mode 有定義，用來處理 SMC。

  #if !defined(CONFIG_SOFTMMU)
  static void tb_invalidate_phys_page(tb_page_addr_t addr,
                                      unsigned long pc, void *puc)
  {
      addr &= TARGET_PAGE_MASK;
      p = page_find(addr >> TARGET_PAGE_BITS);
      // 取得該 page 的第一個 tb。
       // tb 末兩位如果是 01 (1)，代表 tb 對應的 guest bianry 跨 page。
       tb = p->first_tb;
   
      while (tb != NULL) {
          n = (long)tb & 3; // 取得 block chaing 的方向
           tb = (TranslationBlock *)((long)tb & ~3); // 去掉末兩位的編碼，還原回真正的 tb
          tb_phys_invalidate(tb, addr);
          tb = tb->page_next[n]; // 取得 tb 所屬 page (或下一個 page) 的下一個 tb
      }
      p->first_tb = NULL;
   
  }

• 最終會呼叫到 tb_phys_invalidate。

  void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
  {
      // 將該 tb 從 tb_phys_hash 中移除
       phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK); // virtual addr 中 page offset 的部分和 physical addr 一樣
       h = tb_phys_hash_func(phys_pc);
      tb_remove(&tb_phys_hash[h], tb,
                offsetof(TranslationBlock, phys_hash_next));
   
      // 將 tb 從相應的 PageDesc 中移除
      if (tb->page_addr[0] != page_addr) {
          p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
          tb_page_remove(&p->first_tb, tb);
          invalidate_page_bitmap(p);
      }
      if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
          p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
          tb_page_remove(&p->first_tb, tb);
          invalidate_page_bitmap(p);
      }
   
      tb_invalidated_flag = 1;
   
      // 將 tb 從 tb_jmp_cache 移除
       h = tb_jmp_cache_hash_func(tb->pc);
      // 因為每一個 env 都有一份自己的 tb_jmp_cache，全部清除。
      for(env = first_cpu; env != NULL; env = env->next_cpu) {
          if (env->tb_jmp_cache[h] == tb)
              env->tb_jmp_cache[h] = NULL;
      }
   
      // 處理 tb1 (tb -> tb1) 
      tb_jmp_remove(tb, 0);
      tb_jmp_remove(tb, 1);
   
      // 處理 tb1 (tb1 -> tb)
      tb1 = tb->jmp_first;
      for(;;) {
          n1 = (long)tb1 & 3;
          if (n1 == 2) // tb1 末兩位如果為 10 (2)，代表 tb1 沒有跳至其它 tb
              break;
          tb1 = (TranslationBlock *)((long)tb1 & ~3); // 還原回原本的 tb1
          tb2 = tb1->jmp_next[n1]; // 處理 tb2 (tb1 -> tb2)
          tb_reset_jump(tb1, n1); // 將 tb1 至其它的 tb 的 block chaining 打斷 (code cache)
          tb1->jmp_next[n1] = NULL;
          tb1 = tb2;
      }
      tb->jmp_first = (TranslationBlock *)((long)tb | 2); // 將 jmp_first 再次指向自己
  }

  • tb_jmp_remove 將該 tb 移出 circular lists‎。

    static inline void tb_jmp_remove(TranslationBlock *tb, int n)
    {
        ptb = &tb->jmp_next[n]; // n (0 或 1) 指示 tb 下一個 block chaining 的方向
         tb1 = *ptb; // 處理 tb1 (tb -> tb1)
        if (tb1) {
            /* find tb(n) in circular list */
            for(;;) {
                tb1 = *ptb;
                n1 = (long)tb1 & 3; // 取出 tb1 末兩位
                  tb1 = (TranslationBlock *)((long)tb1 & ~3); 還原回原本的 tb1
                if (n1 == n && tb1 == tb) // 代表 tb 沒有跳至其它 tb
                    break;
                if (n1 == 2) {
                    ptb = &tb1->jmp_first; // 代表沒有其它 tb 跳至 tb1
                } else {
                    ptb = &tb1->jmp_next[n1]; // 處理 tb2 (tb1 -> tb2)
                }
            }
            /* now we can suppress tb(n) from the list */
            *ptb = tb->jmp_next[n];
     
            tb->jmp_next[n] = NULL;
        }
    }

  • cpu_exec (cpu-exec.c) 會用到 tb_invalidated_flag。

    if (tb_invalidated_flag) {
        /* as some TB could have been invalidated because
           of memory exceptions while generating the code, we
           must recompute the hash index here */
        next_tb = 0;
        tb_invalidated_flag = 0;
    }

• qemu internal part 2: softm mu
• QEMU分页机制分析

請見 memory.[ch] 和 doc/memory.txt。

• target_phys_addr_t (targphys.h) 代表客戶機物理地址空間。如果客戶機是 x86 開啟 PAE 的話，target_phys_addr_t 為 64 bit。
• target_ulong 代表客戶機暫存器大小和虛擬地址空間。如果客戶機是 x86 開啟 PAE 的話，target_ulong 為 32 bit。
• ram_addr_t (cpu-common.h) 代表宿主機虛擬地址空間。如果宿主機是 x86 的話，ram_addr_t 為 32 bit。
• tb_page_addr_t (exec-all.h) 在 system mode 中被 typedef 成 ram_addr_t; 在 process mode 中被 typedef 成 abi_ulong，abi_ulong 又被 typedef 成 target_ulong。

• MemoryRegion (memory.h)。

  struct MemoryRegion {
      /* All fields are private - violators will be prosecuted */
      const MemoryRegionOps *ops;
      void *opaque;
      MemoryRegion *parent;
      Int128 size;
      target_phys_addr_t addr;
      void (*destructor)(MemoryRegion *mr);
      ram_addr_t ram_addr;
      bool subpage;
      bool terminates;
      bool readable;
      bool ram;
      bool readonly; /* For RAM regions */
      bool enabled;
      bool rom_device;
      bool warning_printed; /* For reservations */
      MemoryRegion *alias;
      target_phys_addr_t alias_offset;
      unsigned priority;
      bool may_overlap;
      QTAILQ_HEAD(subregions, MemoryRegion) subregions;
      QTAILQ_ENTRY(MemoryRegion) subregions_link;
      QTAILQ_HEAD(coalesced_ranges, CoalescedMemoryRange) coalesced;
      const char *name;
      uint8_t dirty_log_mask;
      unsigned ioeventfd_nb;
      MemoryRegionIoeventfd *ioeventfds;
  };

以 QEMU 1.0 版以前，qemu (i386-softmmu) 為例，主要流程如下:

main (vl.c) → init_clocks (qemu-timer.c) → module_call_init(MODULE_INIT_MACHINE) (module.c) → cpu_exec_init_all (初始 dynamic translator) (exec.c) → module_call_init(MODULE_INIT_DEVICE) (module.c) → machine→init (初始 machine) (vl.c) → main_loop (vl.c)

• main_loop (vl.c) → qemu_main_loop_start (cpus.c) → cpu_exec_all (cpus.c) → main_loop_wait (vl.c)
  • cpu_exec_all (cpus.c) → qemu_clock_enable (qemu-timer.c) → qemu_alarm_pending (qemu-timer.c) → any_cpu_has_work (cpus.c)
  • cpu_exec_all (cpus.c) → qemu_cpu_exec (cpus.c) → cpu_x86_exec (cpu-exec.c) → tb_find_fast (cpu-exec.c) → tb_find_slow (cpu-exec.c)
    • tb_find_slow (cpu-exec.c) → get_page_addr_code (exec-all.h)
    • tb_find_slow (cpu-exec.c) → tb_gen_code (exec.c) → cpu_gen_code (translate-all.c) → gen_intermediate_code (target-i386/translate.c) → tcg_gen_code (tcg/tcg.c) → tcg_gen_code_common (tcg/tcg.c)
• main_loop_wait (vl.c) 處理事件。

check exception -> check interrupt (setjmp) -> tb_find_fast -> tb_exec -> check exception (check interrupt)
main_loop_wait -> select (alarm)

QEMU 會設置定時器 (qemu_signal_init)，定時發出 SINGALARM 將 QEMU 從 code cache 拉出，去檢查 exception 或 interrupt。

1. 進入點為 main.c (vl.c)。初始化環境。

   int main(int argc, char **argv, char **envp)
   {
       // QEMU 內部維護三個 clock，分別為: rt_clock，vm_clock 和 host_clock。
       // 之後會根據命令行參數將 rtc_clock 設為前述三者之一。
       init_clocks(); 
    
       // module_call_init -> pc_machine_init -> qemu_register_machine
       // 會有預設 QEMUMachine，之後處理命令行參數時可被替換。
       module_call_init(MODULE_INIT_MACHINE);
    
       /* 處理命令行參數，並初始化環境 */
    
       // 初始 QEMU 會用到的鎖以及使用的 signal number
       if (qemu_init_main_loop()) {
           fprintf(stderr, "qemu_init_main_loop failed\n");
           exit(1);
       }
    
       // alarm_timers 數組存放各種 timer 相對應的啟動/終止函式指針，以及其它資料。
       // init_timer_alarm 依序呼叫 alarm_timers 數組中各個 timer 的啟動函式。
       // dynticks_start_timer 會註冊 SIGALRM 相對應的信號句柄。
       if (init_timer_alarm() < 0) {
           fprintf(stderr, "could not initialize alarm timer\n");
           exit(1);
       }
    
       /* init the dynamic translator */
       cpu_exec_init_all(tb_size * 1024 * 1024);
    
       // drive_init_func 最後會呼叫到 paio_init 註冊 SIGUSR2 的信號句柄。
       if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, &machine->use_scsi, 1) != 0)
           exit(1);
    
       // 初始化設備
       module_call_init(MODULE_INIT_DEVICE);
    
       // 建立 QEMUMachine (hw/pc_piix.c) 並呼叫 machine->init (pc_init_pci) 初始化。
       machine->init(ram_size, boot_devices,
                     kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
    
       /* 初始化剩下的設備以及輸出設備 */
    
       main_loop(); // 主要執行迴圈
       quit_timers();
       net_cleanup();
    
       return 0;
   }

   • dynticks_start_timer 所註冊的 SIGALRM 的信號句柄是 host_alarm_handler。當宿主機作業系統發出 SIGALRM 時，host_alarm_handler 視情況會呼叫 qemu_notify_event。qemu_notify_event 用 cpu_exit 將 QEMU 從當前 code cache 中拉出來檢查 IO。關於 clock 請見 [Qemu-devel] Question on kvm_clock working ...。
   • cpu_exec_init_all 的代碼如下:

     /* Must be called before using the QEMU cpus. 'tb_size' is the size
        (in bytes) allocated to the translation buffer. Zero means default
        size. */
     void cpu_exec_init_all(unsigned long tb_size)
     {
         cpu_gen_init();
         code_gen_alloc(tb_size);
         code_gen_ptr = code_gen_buffer;
         page_init();
     #if !defined(CONFIG_USER_ONLY)
         io_mem_init(); // 註冊 MMIO 回掉函式
     #endif
     #if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)
         /* There's no guest base to take into account, so go ahead and
            initialize the prologue now.  */
         tcg_prologue_init(&tcg_ctx);
     #endif
     }

   • pc_init_pci (hw/pc_piix.c) 呼叫 pc_init1 (hw/pc_piix.c) 進行 PC 機器的初始化。

     /* PC hardware initialisation */
     static void pc_init1(ram_addr_t ram_size, ...)
     {
         // 呼叫 pc_new_cpu (hw/pc.c) -> cpu_init/cpu_x86_init (target-i386/helper.c) 初始化 CPU。
         pc_cpus_init(cpu_model);
      
         // 配置客戶機內存，載入 BIOS。
         // 這部分在 QEMU 1.0 會用 memory API 改寫。
         // http://lists.gnu.org/archive/html/qemu-devel/2011-07/msg02716.html
         pc_memory_init(ram_size, kernel_filename, kernel_cmdline, initrd_filename,
                        &below_4g_mem_size, &above_4g_mem_size);
      
         // 呼叫 qemu_allocate_irqs (hw/irq.c) 設置中斷處理常式。
         cpu_irq = pc_allocate_cpu_irq();
      
         pc_vga_init(pci_enabled? pci_bus: NULL);
      
         /* init basic PC hardware */
         pc_basic_device_init(isa_irq, &floppy_controller, &rtc_state);
      
         pc_vga_init(pci_enabled? pci_bus: NULL);
      
         /* init basic PC hardware */
         pc_basic_device_init(isa_irq, &floppy_controller, &rtc_state);
     }

     • 第一部分 qemu oldworld mac(heathrow)的初始化
     • Features/RamAPI

       void pc_memory_init(ram_addr_t ram_size, ...)
       {
           // 透過 qemu_ram_alloc 跟 QEMU 申請內存空間。QEMU 以 RAMBlock 為單位分配內存，並以 RAMList 管理所有 RAMBlock。
           // QEMU 依命令行參數的不同，會從檔案或是跟宿主機作業系統申請 (posix_memalign) 配置空間。
           // 回傳的是 RAMBlock 在 RAMList 的偏移量。
           ram_addr = qemu_ram_alloc(NULL, "pc.ram",
                                     below_4g_mem_size + above_4g_mem_size);
           // 所有類型的 RAM (一般內存、內存映射 IO) 皆要透過 cpu_register_physical_memory 跟 QEMU 註冊。
           // 將該資訊記錄在 PhysPageDesc。
           cpu_register_physical_memory(0, 0xa0000, ram_addr);
           cpu_register_physical_memory(0x100000,
                        below_4g_mem_size - 0x100000,
                        ram_addr + 0x100000);
       }

2. main_loop (vl.c) 是主要的執行迴圈。

   static void main_loop(void)
   {
       // 若是沒有開啟 IO 執行緒的話，無作用。
       qemu_main_loop_start();
    
       // 主要執行的無窮迴圈。
       for (;;) {
           do {
               bool nonblocking = false;
    
   #ifndef CONFIG_IOTHREAD
               nonblocking = cpu_exec_all(); // 翻譯並執行客戶端代碼
   #endif
               main_loop_wait(nonblocking); // 處理 IO
           } while (vm_can_run()); // 如果此虛擬機沒有收到關機或是重開機等諸如此類的請求，則繼續執行。
    
          /* 檢查系統是否收到關機或是重開機的要求。若是關機，則跳離此無窮迴圈 */
       }
       bdrv_close_all(); // 關閉所有設備
       pause_all_vcpus(); // 暫無作用
   }

3. 翻譯並執行客戶端代碼是由 cpu_exec_all (cpus.c) 負責。

   bool cpu_exec_all(void)
   {
       // 依序檢視虛擬處理器
       for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
           CPUState *env = next_cpu;
    
           qemu_clock_enable(vm_clock,
                             (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
    
           if (qemu_alarm_pending())
               break;
           if (cpu_can_run(env)) {
               // qemu_cpu_exec 以 process mode 的路徑執行。
               // cpu_x86_exec (cpu-exec.c) → tb_find_fast (cpu-exec.c) → tb_find_slow (cpu-exec.c)
               // cpu_exec 執行完後會返回 exception_index 狀態，狀態定義在 cpu-defs.h。 
               if (qemu_cpu_exec(env) == EXCP_DEBUG) {
                   break;
               }
           } else if (env->stop) {
               break;
           }
       }
       exit_request = 0;
       return any_cpu_has_work();
   }

   • qemu_cpu_exec 基本上只額外多做計數。
4. 處理 IO 是由 main_loop_wait (vl.c) 負責。How to use the select(), an I/O Multiplexer

   void main_loop_wait(int nonblocking)
   {
       nfds = -1;
       FD_ZERO(&rfds);
       FD_ZERO(&wfds);
       FD_ZERO(&xfds);
       QLIST_FOREACH(ioh, &io_handlers, next) {
         // 將欲處理的設備加入上述的 file set
       }
    
       // 根據 nonblocking 與否計算 select 等待時間    
       tv.tv_sec = timeout / 1000;
       tv.tv_usec = (timeout % 1000) * 1000;
    
       // 將設備以 file descriptor 來處理
       qemu_mutex_unlock_iothread();
       // 用 select 由設備描述符中選擇一個能立即處理的設備
       // select 參數代表的意義分別是: 欲處理的設備個數，要處理的輸入設備的檔案描述詞的集合，要處理的輸出設備的檔案描述詞的集合，
       // 有突發狀態發生的設備的檔案描述詞的集合和要求 select 等待的時間。
       ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
       qemu_mutex_lock_iothread();
       if (ret > 0) {
           IOHandlerRecord *pioh;
    
           QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) {
             /* 處理設備 */  
           }
       }
    
       qemu_run_all_timers();
    
       /* Check bottom-halves last in case any of the earlier events triggered
          them.  */
       qemu_bh_poll();
   }

• QEMU Internals: Overall architecture and threading model
  • QEMU 1.0 之前，預設編譯為 non-iothread。不論 guest OS 是否為 SMP，只有一個 QEMU thread 負責執行 guest code 和 IO 處理。如果開啟 IO thread，每一個 guest CPU 有一個 QEMU thread 對映，加上一個處理 IO 的 thread。因為 TCG 為 non thread safe，以上兩種模式同時都只有一個 thread 在執行。
• [Qemu-devel] Doubts on SMP, VCPU and CONFIG_IOTHREAD

QEMU 1.0 開啟 IO thread，無法關閉。仍舊以 qemu-system-i386 為例:

模擬虛擬 CPU 和虛擬外設分為不同的執行緒。開機時至少會看到兩個執行緒，主執行緒處理 IO，另一個則是模擬虛擬 CPU 的執行緒。模擬客戶機 CPU 的流程如下:

1. cpu_init/cpu_x86_init (target-i386/helper.c) 在初始化虛擬 CPU 時，會呼叫 qemu_init_vcpu

   CPUX86State *cpu_x86_init(const char *cpu_model)
   {
       CPUX86State *env;
       static int inited;
    
       env = g_malloc0(sizeof(CPUX86State));
       cpu_exec_init(env);
       env->cpu_model_str = cpu_model;
    
       /* init various static tables used in TCG mode */
       if (tcg_enabled() && !inited) {
           inited = 1;
           optimize_flags_init();
   #ifndef CONFIG_USER_ONLY
           prev_debug_excp_handler =
               cpu_set_debug_excp_handler(breakpoint_handler);
   #endif
       }
       if (cpu_x86_register(env, cpu_model) < 0) {
           cpu_x86_close(env);
           return NULL;
       }
       env->cpuid_apic_id = env->cpu_index;
       mce_init(env);
    
       qemu_init_vcpu(env);
    
       return env;
   }

2. qemu_init_vcpu (cpus.c)

   void qemu_init_vcpu(void *_env)
   {
       CPUState *env = _env;
    
       env->nr_cores = smp_cores;
       env->nr_threads = smp_threads;
       env->stopped = 1;
       if (kvm_enabled()) {
           qemu_kvm_start_vcpu(env);
       } else {
           qemu_tcg_init_vcpu(env);
       }
   }

3. qemu_tcg_init_vcpu (cpus.c)

   static void qemu_tcg_init_vcpu(void *_env)
   {
       CPUState *env = _env;
    
       /* share a single thread for all cpus with TCG */
       if (!tcg_cpu_thread) {
           env->thread = g_malloc0(sizeof(QemuThread));
           env->halt_cond = g_malloc0(sizeof(QemuCond));
           qemu_cond_init(env->halt_cond);
           tcg_halt_cond = env->halt_cond;
           qemu_thread_create(env->thread, qemu_tcg_cpu_thread_fn, env,
                              QEMU_THREAD_JOINABLE);
   #ifdef _WIN32
           env->hThread = qemu_thread_get_handle(env->thread);
   #endif
           while (env->created == 0) {
               qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
           }
           tcg_cpu_thread = env->thread;
       } else {
           env->thread = tcg_cpu_thread;
           env->halt_cond = tcg_halt_cond;
       }
   }

4. qemu_tcg_cpu_thread_fn (cpus.c)

   static void *qemu_tcg_cpu_thread_fn(void *arg)
   {
       CPUState *env = arg;
    
       qemu_tcg_init_cpu_signals();
       qemu_thread_get_self(env->thread);
    
       /* signal CPU creation */
       qemu_mutex_lock(&qemu_global_mutex);
       for (env = first_cpu; env != NULL; env = env->next_cpu) {
           env->thread_id = qemu_get_thread_id();
           env->created = 1;
       }
       qemu_cond_signal(&qemu_cpu_cond);
    
       /* wait for initial kick-off after machine start */
       while (first_cpu->stopped) {
           qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
       }
    
       while (1) {
           tcg_exec_all();
           if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
               qemu_notify_event();
           }
           qemu_tcg_wait_io_event();
       }
    
       return NULL;
   }

5. tcg_exec_all (cpus.c) 執行所有的虛擬 CPU。

   static void tcg_exec_all(void)
   {
       int r;
    
       /* Account partial waits to the vm_clock.  */
       qemu_clock_warp(vm_clock);
    
       if (next_cpu == NULL) {
           next_cpu = first_cpu;
       }
       for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
           CPUState *env = next_cpu;
    
           qemu_clock_enable(vm_clock,
                             (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
    
           if (cpu_can_run(env)) {
               r = tcg_cpu_exec(env);
               if (r == EXCP_DEBUG) {
                   cpu_handle_guest_debug(env);
                   break;
               }
           } else if (env->stop || env->stopped) {
               break;
           }
       }
       exit_request = 0;
   }

   • qemu_tcg_cpu_thread_fn (cpus.c) → tcg_exec_all (cpus.c) → tcg_cpu_exec (cpus.c) → cpu_x86_exec (cpu-exec.c)

目前 QEMU 本身即為 IO thread 執行 main_loop_wait，當遇到 block IO 時，會 fork 出 posix-aio-compat.c worker thread 去處理。

1. main (vl.c)

       cpu_exec_init_all();
    
       /* open the virtual block devices */
       if (snapshot)
           qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot, NULL, 0);
       if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func, &machine->use_scsi, 1) != 0)
           exit(1);
    
       qemu_init_cpu_loop();
       // qemu_init_main_loop 呼叫 main_loop_init (main-loop.c)
       if (qemu_init_main_loop()) {
           fprintf(stderr, "qemu_init_main_loop failed\n");
           exit(1);
       }

   • qemu_init_cpu_loop (cpus.c)

     void qemu_init_cpu_loop(void)
     {
         qemu_init_sigbus();
         qemu_cond_init(&qemu_cpu_cond);
         qemu_cond_init(&qemu_pause_cond);
         qemu_cond_init(&qemu_work_cond);
         qemu_cond_init(&qemu_io_proceeded_cond);
         qemu_mutex_init(&qemu_global_mutex);
      
         qemu_thread_get_self(&io_thread);
     }

   • main_loop_init (main-loop.c)

     int main_loop_init(void)
     {
         int ret;
      
         qemu_mutex_lock_iothread();
         ret = qemu_signal_init();
         if (ret) {
             return ret;
         }
      
         /* Note eventfd must be drained before signalfd handlers run */
         ret = qemu_event_init();
         if (ret) {
             return ret;
         }
      
         return 0;
     }

2. main_loop (vl.c) 是主要的執行迴圈，IO thread。

   static void main_loop(void)
   {
       bool nonblocking;
       int last_io = 0;
    
       do {
           nonblocking = !kvm_enabled() && last_io > 0;
    
           last_io = main_loop_wait(nonblocking);
    
       } while (!main_loop_should_exit());
   }

3. main_loop_wait (main-loop.c)

   int main_loop_wait(int nonblocking)
   {
       fd_set rfds, wfds, xfds;
       int ret, nfds;
       struct timeval tv;
       int timeout;
    
       if (nonblocking) {
           timeout = 0;
       } else {
           timeout = qemu_calculate_timeout();
           qemu_bh_update_timeout(&timeout);
       }
    
       os_host_main_loop_wait(&timeout);
    
       tv.tv_sec = timeout / 1000;
       tv.tv_usec = (timeout % 1000) * 1000;
    
       /* poll any events */
       /* XXX: separate device handlers from system ones */
       nfds = -1;
       FD_ZERO(&rfds);
       FD_ZERO(&wfds);
       FD_ZERO(&xfds);
    
   #ifdef CONFIG_SLIRP
       slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
   #endif
       qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
       glib_select_fill(&nfds, &rfds, &wfds, &xfds, &tv);
    
       if (timeout > 0) {
           qemu_mutex_unlock_iothread();
       }
    
       ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
    
       if (timeout > 0) {
           qemu_mutex_lock_iothread();
       }
    
       glib_select_poll(&rfds, &wfds, &xfds, (ret < 0));
       qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
   #ifdef CONFIG_SLIRP
       slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
   #endif
    
       qemu_run_all_timers();
    
       /* Check bottom-halves last in case any of the earlier events triggered
          them.  */
       qemu_bh_poll();
    
       return ret;
   }

main (vl.c) → qemu_opts_foreach (qemu-option.c) → qemu_aio_wait (aio.c) → qemu_bh_poll (async.c) → spawn_thread_bh_fn (posix-aio-compat.c) → do_spawn_thread (posix-aio-compat.c)

aio_thread (posix-aio-compat.c) → cond_timedwait (posix-aio-compat.c)

• [Qemu-devel] spawning and killing threads in qemu
• Re: [Qemu-devel] spawning and killing threads in qemu

• Linux 驅動程式的中斷處理, #3: Bottom Half 的觀念
• Bottom Half Handling
• 10.4. Top and Bottom Halves
• QEMU Internals: Big picture overview
• [Qemu-devel] [PATCH] main: force enabling of I/O thread

底下腳本可以觀察 QEMU 本身。

$ vi command.gdb
set breakpoint pending on
file qemu
handle SIGUSR2 noprint nostop
break main_loop
run linux-0.2.img -vnc 0.0.0.0:1
$ gdb -x command.gdb

• QEMU开发中的小技巧
• debug_dma
• Qemu对x86静态内存布局的模拟
• Qemu对x86复位状态的模拟
  • $BUILD/pc-bios/bios.bin

虛擬機重啟 (reboot) 的時候，會重置 virtual cpu 的 reset vector，這樣 virtual cpu 才會跳至開機預設的位址執行。請在 cpu_reset 下斷點，並 reboot 虛擬機 ¹⁾。

(gdb) bt
#0  cpu_reset (env=0x1251290) at /nfs_home/chenwj/work/svn/qemu-1.0/target-i386/helper.c:37
#1  0x0000000000638753 in pc_cpu_reset (opaque=0x1251290) at /nfs_home/chenwj/work/svn/qemu-1.0/hw/pc.c:928
#2  0x00000000004fe916 in qemu_system_reset (report=true) at /nfs_home/chenwj/work/svn/qemu-1.0/vl.c:1381
#3  0x00000000004feb71 in main_loop_should_exit () at /nfs_home/chenwj/work/svn/qemu-1.0/vl.c:1452
#4  0x00000000004fec48 in main_loop () at /nfs_home/chenwj/work/svn/qemu-1.0/vl.c:1485
#5  0x0000000000503864 in main (argc=4, argv=0x7fffffffe218, envp=0x7fffffffe240) at /nfs_home/chenwj/work/svn/qemu-1.0/vl.c:3485
(gdb)

1. 當有 reboot (reset) 的需要時，會呼叫 qemu_system_reset_request (vl.c) 拉起 reset_requested。

   void qemu_system_reset_request(void)
   {
       if (no_reboot) {
           shutdown_requested = 1;
       } else {
           reset_requested = 1;
       }
       cpu_stop_current();
       qemu_notify_event();
   }

   • 以 i386 為例，大約有以下幾處會呼叫 qemu_system_reset_request。前兩者都是當出現 Triple fault 的時候重啟系統，後者是拉起 port 92。
     1. target-i386/op_helper.c
     2. target-i386/helper.c
     3. hw/pc.c
2. 在 main_loop (vl.c) 中會呼叫 main_loop_should_exit 判斷是否需要跳離主迴圈。

   static void main_loop(void)
   {
       bool nonblocking;
       int last_io = 0;
    
       do {
           nonblocking = !kvm_enabled() && last_io > 0;
    
           last_io = main_loop_wait(nonblocking);
    
       } while (!main_loop_should_exit());
   }

3. main_loop_should_exit

   static bool main_loop_should_exit(void)
   {
       RunState r;
       if (qemu_debug_requested()) {
           vm_stop(RUN_STATE_DEBUG);
       }
       if (qemu_shutdown_requested()) {
           qemu_kill_report();
           monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
           if (no_shutdown) {
               vm_stop(RUN_STATE_SHUTDOWN);
           } else {
               return true;
           }
       }
       if (qemu_reset_requested()) { // 返回 reset_requested
           pause_all_vcpus();
           cpu_synchronize_all_states();
           qemu_system_reset(VMRESET_REPORT); // 重啟系統
           resume_all_vcpus();
           if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
               runstate_check(RUN_STATE_SHUTDOWN)) {
               runstate_set(RUN_STATE_PAUSED);
           }
       }
       if (qemu_powerdown_requested()) {
           monitor_protocol_event(QEVENT_POWERDOWN, NULL);
           qemu_irq_raise(qemu_system_powerdown);
       }
       if (qemu_vmstop_requested(&r)) {
           vm_stop(r);
       }
       return false;
   }

4. void qemu_system_reset(bool report)
   {
       QEMUResetEntry *re, *nre;
    
       /* reset all devices */
       // 從 reset_handlers 抓出 device 重啟。之前就會用 qemu_register_reset 註冊各個裝置的 reset 回掉函式。
       QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
           re->func(re->opaque);
       }
       if (report) {
           monitor_protocol_event(QEVENT_RESET, NULL);
       }
       cpu_synchronize_all_post_reset();
   }

5. pc_cpu_reset 呼叫 cpu_reset (target-i386/helper.c)。

   static void pc_cpu_reset(void *opaque)
   {
       CPUState *env = opaque;
    
       cpu_reset(env);
       env->halted = !cpu_is_bsp(env);
   }

6. cpu_reset (target-i386/helper.c) 開機或是重啟時會將 CPU 狀態重置。

   void cpu_reset(CPUX86State *env)
   {
       int i;
    
       if (qemu_loglevel_mask(CPU_LOG_RESET)) {
           qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
           log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
       }
    
       memset(env, 0, offsetof(CPUX86State, breakpoints));
    
       tlb_flush(env, 1);
    
       env->old_exception = -1;
    
       /* init to reset state */
    
   #ifdef CONFIG_SOFTMMU
       env->hflags |= HF_SOFTMMU_MASK;
   #endif
       env->hflags2 |= HF2_GIF_MASK;
    
       cpu_x86_update_cr0(env, 0x60000010);
       env->a20_mask = ~0x0;
       env->smbase = 0x30000;
    
       env->idt.limit = 0xffff;
       env->gdt.limit = 0xffff;
       env->ldt.limit = 0xffff;
       env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);
       env->tr.limit = 0xffff;
       env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);
    
       cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
                              DESC_R_MASK | DESC_A_MASK);
       cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
                              DESC_A_MASK);
       cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
                              DESC_A_MASK);
       cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
                              DESC_A_MASK);
       cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
                              DESC_A_MASK);
       cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,
                              DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
                              DESC_A_MASK);
    
       env->eip = 0xfff0;
       env->regs[R_EDX] = env->cpuid_version;
    
       env->eflags = 0x2;
    
       /* FPU init */
       for(i = 0;i < 8; i++)
           env->fptags[i] = 1;
       env->fpuc = 0x37f;
    
       env->mxcsr = 0x1f80;
    
       env->pat = 0x0007040600070406ULL;
       env->msr_ia32_misc_enable = MSR_IA32_MISC_ENABLE_DEFAULT;
    
       memset(env->dr, 0, sizeof(env->dr));
       env->dr[6] = DR6_FIXED_1;
       env->dr[7] = DR7_FIXED_1;
       cpu_breakpoint_remove_all(env, BP_CPU);
       cpu_watchpoint_remove_all(env, BP_CPU);
   }

   • 再论 real mode
   • 當感覺已麻木，告訴 Linux 說 reboot
   • Magic numbers of the Linux reboot() system call
   • INIt-SIPI-SIPI

• target_phys_addr_t (targphys.h) 代表客戶機物理地址空間。如果客戶機是 x86 開啟 PAE 的話，target_phys_addr_t 為 64 bit。
• target_ulong 代表客戶機暫存器大小和虛擬地址空間。如果客戶機是 x86 開啟 PAE 的話，target_ulong 為 32 bit。
• ram_addr_t (cpu-common.h) 代表宿主機虛擬地址空間。如果宿主機是 x86 的話，ram_addr_t 為 32 bit。
• tb_page_addr_t (exec-all.h) 在 system mode 中被 typedef 成 ram_addr_t; 在 process mode 中被 typedef 成 abi_ulong，abi_ulong 又被 typedef 成 target_ulong。

guest virtual addr (GVA) → guest physical addr (GPA) → host virtual addr (HVA)

1. GVA → GPA 由客戶機作業系統負責; GPA → HVA 由 QEMU 負責。HVA → HPA 由宿主機作業系統負責
   • CPUTLBEntry
     • GVA → HVA。存放 GVA 相對於 HVA 的偏移量。轉換 GVA 到 HVA 的過程中，會先搜尋 TLB。如果命中，則將 GVA 加上該偏移量得到 HVA。若否，則需搜尋 l1_phys_map 並將 PhysPageDesc 填入 TLB。
   1. guest virtual addr → guest physical addr
   2. 搜尋 l1_phys_map 得到 PhysPageDesc。
   3. 將 phys_ram_base 加上 PhysPageDesc.phys_offset，得到 host virtual addr (physical addr → host virtual addr)

  typedef struct CPUTLBEntry {
    // 以下存放 GVA，同時也代表該頁面的權限。tlb_set_page (exec.c) 填入新的 TLB 項目時會做設置。
    target_ulong addr_read; // 可讀
    target_ulong addr_write; // 可寫
    target_ulong addr_code; // 可執行
    // HVA 相對於 GVA 的偏移量。
    unsigned long addend;
} CPUTLBEntry;

• Bitwise Operation

1. tb_find_slow 是利用 guest pc (GVA) 對映的 guest physical address (GPA) 查找該 guest pc 的 TB。

   static TranslationBlock *tb_find_slow(target_ulong pc, ...)
   {
       /* find translated block using physical mappings */
       phys_pc = get_page_addr_code(env, pc);
    
       phys_page1 = phys_pc & TARGET_PAGE_MASK;
       phys_page2 = -1;
       // 用虛擬位址 pc 對映的物理位址 phys_pc 查找 tb_phys_hash。  
        h = tb_phys_hash_func(phys_pc);
       ptb1 = &tb_phys_hash[h];
       for(;;) {
           tb = *ptb1;
           if (!tb)
               goto not_found;
           if (tb->pc == pc &&
               tb->page_addr[0] == phys_page1 && // 該 TB 所屬物理頁面 (guest code) 是否與 pc 所屬物理頁面相同?
               tb->cs_base == cs_base &&
               tb->flags == flags) {
               /* check next page if needed */
               if (tb->page_addr[1] != -1) { // 該 TB 有跨物理頁面
                   virt_page2 = (pc & TARGET_PAGE_MASK) +
                       TARGET_PAGE_SIZE;
                   phys_page2 = get_page_addr_code(env, virt_page2);
                   if (tb->page_addr[1] == phys_page2) // 該 TB 所屬的第二個物理頁面是否與 pc 所屬的第二個物理頁面相同?
                       goto found;
               } else {
                   goto found;
               }
           }
           ptb1 = &tb->phys_hash_next; // 當 phys_pc 雜湊到同一個 tb_phys_hash 項目時。
       }
    not_found:
      /* if no translated code available, then translate it now */
       tb = tb_gen_code(env, pc, cs_base, flags, 0);
    
    found:
       /* we add the TB in the virtual pc hash table */
       env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)] = tb;
       return tb;
   }

2. get_page_addr_code (exec.c) 先查找 TLB。process mode 情況有所不同，此時沒有所謂的 GPA，直接返回 addr。注意! get_page_addr_code 是被 tb_find_slow (cpu-exec.c) 或是 tb_gen_code (exec.c) 這兩個函式呼叫，get_page_addr_code 中的 code 代表存取的地址是一段 code。因此，皆是呼叫到 ld*_code 或是 ldb_cmmu。強烈建議查看 i386-softmmu/exec.i。

   static inline tb_page_addr_t get_page_addr_code(CPUState *env1, target_ulong addr)
   {
       page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1); // 計算 GVA 對映的 TLB 索引
        mmu_idx = cpu_mmu_index(env1);
       // TLB 不命中
       if (unlikely(env1->tlb_table[mmu_idx][page_index].addr_code !=
                    (addr & TARGET_PAGE_MASK))) {
           ldub_code(addr);
       }
       // TLB 命中。檢查欲執行的位址屬於 RAM 之後，計算 GVA 對映的 HVA。
       p = (void *)(unsigned long)addr
           + env1->tlb_table[mmu_idx][page_index].addend;
       // 返回 HVA 在 RAM 中的偏移量。 
       return qemu_ram_addr_from_host(p);
   }

3. TLB 不命中。ldub_code (softmmu_header.h) 是個透過宏展開的函式。

   static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
   {
       if (unlikely(env->tlb_table[mmu_idx][page_index].ADDR_READ !=
                    (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
           // ADDR_READ 會視情況被替換成 addr_code 或是 addr_read。這裡因為存取的是 code，
            // ADDR_READ 被替換成 addr_code。 
            res = glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
       } else {
           physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
           res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)physaddr);
       }
       return res;
   }

4. ldb_cmmu (softmmu_template.h)，其中的 cmmu 代表存取的是 code。如果是 mmu，代表存取的是 data。

   /* handle all cases except unaligned access which span two pages */
   DATA_TYPE REGPARM glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
                                                         int mmu_idx)
   {
    // 先查找 TLB
    redo:
       // ADDR_READ 會被替換成 addr_code。
       tlb_addr = env->tlb_table[mmu_idx][index].ADDR_READ;
       if ((addr & TARGET_PAGE_MASK) == (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
           // TLB 命中
           if (tlb_addr & ~TARGET_PAGE_MASK) {
               /* IO access */
               // iotlb 緩存 IO 模擬函式
               ioaddr = env->iotlb[mmu_idx][index];
           } else if (((addr & ~TARGET_PAGE_MASK) + DATA_SIZE - 1) >= TARGET_PAGE_SIZE) {
           do_unaligned_access:
               /* slow unaligned access (it spans two pages) */
               // 這裡會呼叫 slow_ldb_cmmu 做跨頁存取。
          } else {
               /* unaligned/aligned access in the same page */
               addend = env->tlb_table[mmu_idx][index].addend;
               res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)(long)(addr+addend));
          }
       } else {
           /* the page is not in the TLB : fill it */
           // GETPC 包裝 __builtin_return_address，請見 http://gcc.gnu.org/onlinedocs/gcc/Return-Address.html。
            // 其用途是取得此函式的 return address，藉此可得知從哪個 caller 呼叫到此函式。
            // 在 exec.c 的最後已將 GETPC 定為 NULL。
            retaddr = GETPC();
    
           // 不同 ISA 分別定義不同的 tlb_fill
           tlb_fill(addr, READ_ACCESS_TYPE, mmu_idx, retaddr);
           goto redo;
       }
       return res;
   }

   • 在 exec.c 的最後定義如下的宏，並 include softmmu_template.h 將其中的宏展開。請見 exec.i。

     #define MMUSUFFIX _cmmu // load code
     #define GETPC() NULL // tb_find_slow -> get_page_addr_code -> ldub_code -> __ldb_cmmu
     #define env cpu_single_env
     #define SOFTMMU_CODE_ACCESS
      
     #define SHIFT 0
     #include "softmmu_template.h"
      
     #define SHIFT 1
     #include "softmmu_template.h"
      
     #define SHIFT 2
     #include "softmmu_template.h"
      
     #define SHIFT 3
     #include "softmmu_template.h"
      
     #undef env

     請見 [Qemu-devel] When the tlb_fill will be called from generated code?。

5. tlb_fill (target-i386/op_helper.c)。查找頁表，如果頁存在，將該頁帶進 TLB; 如果頁不存在，發出頁缺失中斷。

   /* try to fill the TLB and return an exception if error. If retaddr is
      NULL, it means that the function was called in C code (i.e. not
      from generated code or from helper.c) */
   void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
   {
       ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
       if (ret) { // 出包了! 
           if (retaddr) { // tlb_fill 由 code cache 或是 helper.c 被呼叫。
               /* now we have a real cpu fault */
               pc = (unsigned long)retaddr;
               tb = tb_find_pc(pc);
               if (tb) {
                   /* the PC is inside the translated code. It means that we have
                      a virtual CPU fault */
                   cpu_restore_state(tb, env, pc, NULL);
               }
           }
           // tlb_fill 以一般的方式 (get_page_addr_code) 被呼叫，並非從 code cache 或是 helper function 被呼叫。
            // 發出 guest page fault exception，guest OS 開始 page fault 處理。
            raise_exception_err(env->exception_index, env->error_code);
       }
       // 頁面已在內存。
       env = saved_env;
   }

   • retaddr 非 NULL 代表 tlb_fill 並非從 get_page_addr_code 呼叫。例如，target-i386/op_helper.c 或是 code cache。請見 op_helper.i。

     uint8_t __ldb_mmu(target_ulong addr, int mmu_idx)
     {
             retaddr = ((void *)((unsigned long)__builtin_return_address(0) - 1));
      
             tlb_fill(addr, 0, mmu_idx, retaddr);
             goto redo;
     }

6. cpu_x86_handle_mmu_fault (target-i386/helper.c) 查找頁表。如果該頁已在內存，呼叫 tlb_set_page 將該頁寫入 TLB。

   /* return value:
      -1 = cannot handle fault
      0  = nothing more to do // 頁面已在內存，填入適當 TLB 項目即可。 
      1  = generate PF fault  // 頁面不在內存，產生頁缺失。
   */
   int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr, ...)
   {
    do_mapping:
       tlb_set_page(env, vaddr, paddr, prot, mmu_idx, page_size);
       return 0;
    do_fault:
       return 1;
   }

7. tlb_set_page (exec.c) 填入 TLB 項。

   void tlb_set_page(CPUState *env, target_ulong vaddr, ...)
   {
       CPUTLBEntry *te;
    
       // 回傳 host virtual address
       addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
       // 更新 TLB 項目
        te = &env->tlb_table[mmu_idx][index];
       te->addend = addend - vaddr; // host virtual address 與 guest virtual address 的偏移量。
   }

• Introduction to QEMU
• Understand Qemu
• Memory Simulation in QEMU
• qemu internal part 2: softmmu

請見 [Qemu-devel] When the tlb_fill will be called from generated code?。共有底下檔案:

• softmmu-semi.h
• softmmu_defs.h: 宣告 \_\_{ld,st}* 函式原型。
• softmmu_exec.h: 利用 softmmu_header.h 生成 {ld,st}_{user,kernel,etc} 函式。{ld,st}_{user,kernel,etc} 函式又會呼叫到 \_\_{ld,st}* 函式。
• softmmu_header.h: 生成 {ld,st}* 函式。{ld,st}* 函式又會呼叫到 \_\_{ld,st}* 函式。
• softmmu_template.h: 生成 \_\_{ld,st}* 函式。

底下檔案定義相關函式原型。

• softmmu_defs.h: 宣告給 TCG IR qemu_ld/qemu_st 使用的 \_\_{ld,st}* 函式原型。被 softmmu_exec.h, tcg/xxx/tcg-target.c 和 exec-all.h 所 #include。

底下檔案生成相關函式體。

• softmmu_template.h: exec.c 和 target-*/op_helper.c 使用 softmmu_template.h 生成 \_\_{ld,st}* 函式。tcg_out_qemu_ld (tcg/xxx/tcg-target.c) 在為 qemu_ld/qemu_st 產生 host binary 時，會呼叫到 softmmu_template.h 生成 \_\_{ld,st}* 函式。
  1. tcg_out_qemu_ld (tcg/i386/tcg-target.c)。

     #include "../../softmmu_defs.h"
     // softmmu_defs.h
     // uint8_t REGPARM __ldb_mmu(target_ulong addr, int mmu_idx);
     // void REGPARM __stb_mmu(target_ulong addr, uint8_t val, int mmu_idx);
      
     // 內存讀指令。會將該指令指定的虛擬位址透過 software MMU 轉換成物理位址。
     // softmmu_template.h 會透過宏展開定義相對應的函式。  
     static void *qemu_ld_helpers[4] = {
         __ldb_mmu, // load byte
         __ldw_mmu, // load word 
         __ldl_mmu, // load long word
         __ldq_mmu, // load quad word
     };
      
     /* XXX: qemu_ld and qemu_st could be modified to clobber only EDX and
        EAX. It will be useful once fixed registers globals are less
        common. */
     static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args,
                                 int opc)
     {
         /* 略 */
      
         tcg_out_calli(s, (tcg_target_long)qemu_ld_helpers[s_bits]); // 呼叫上述函式。
      
         /* 略 */
     }

  2. switch_tss (target-i386/op_helper.c)

     // #define MMU_MODE0_SUFFIX _kernel
     // #define MMU_MODE1_SUFFIX _user
     #include "cpu.h"
      
     // softmmu_exec.h 生成 {ld,st}*_{kernel,user,etc} 函式。
     // #define ACCESS_TYPE 0
     // #define MEMSUFFIX MMU_MODE0_SUFFIX
     // #define DATA_SIZE 1
     // #include "softmmu_header.h"
     #if !defined(CONFIG_USER_ONLY)
     #include "softmmu_exec.h"
     #endif /* !defined(CONFIG_USER_ONLY) */
      
      
     #define MMUSUFFIX _mmu
      
     #define SHIFT 0
     #include "softmmu_template.h"
      
     // softmmu_template.h
     // SUFFIX 代表資料大小，可以是 b (byte, 8)、w (word, 16)、l (long word, 32) 或 q (quadruple word，64)
     // MMUSUFFIX 代表存取代碼或是資料，可以是 _cmmu 或 _mmu。
     DATA_TYPE REGPARM glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
                                                           int mmu_idx)
     {
     }
      
     // target-i386/op_helper.i
     uint8_t __ldb_mmu(target_ulong addr, int mmu_idx)
     {
     }
      
     # 1 "/tmp/chenwj/qemu/softmmu_exec.h" 1
     # 27 "/tmp/chenwj/qemu/softmmu_exec.h"
     # 1 "/tmp/chenwj/qemu/softmmu_header.h" 1
     # 83 "/tmp/chenwj/qemu/softmmu_header.h"
     // 存取內核態資料
     static __attribute__ (( always_inline )) __inline__ uint32_t ldub_kernel(target_ulong ptr)
     {
         if (__builtin_expect(!!(env->tlb_table[mmu_idx][page_index].addr_read != (addr & (~((1 << 12) - 1) | (1 - 1)))), 0)
                                                                    ) {
             res = __ldb_mmu(addr, mmu_idx); // softmmu_defs.h 定義函式原型，其函式體由 softmmu_template.h 實現。 
         } else {
             physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
             // softmmu_exec.h 定義函式原型，其函式體由 softmmu_header.h 實現。
             res = ldub_p((uint8_t *)(long)(((uint8_t *)physaddr)));
         }
     }
      
     static void switch_tss(int tss_selector, ...)
     {
         /* 略 */
      
         v1 = ldub_kernel(env->tr.base);
         v2 = ldub_kernel(env->tr.base + old_tss_limit_max);
      
         /* 略 */   
     }

• softmmu_exec.h: target-*/op_helper.c #include softmmu_exec.h，softmmu_exec.h 再利用 softmmu_header.h 生成 {ld,st}*_{kernel,user,etc} 函式。
  • softmmu_exec.h #include softmmu_defs.h，softmmu_defs.h 定義函式原型 \_\_{ld,st}，其函式體由 softmmu_template.h 實現。softmmu_exec.h 也 #include softmmu_header.h，softmmu_header.h 定義巨集生成 {ld,st}*_{kernel,user,etc} 函式。

    // softmmu_defs.h
    uint8_t REGPARM __ldb_mmu(target_ulong addr, int mmu_idx);
    void REGPARM __stb_mmu(target_ulong addr, uint8_t val, int mmu_idx);
     
    // softmmu_template.h
    DATA_TYPE REGPARM glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
                                                          int mmu_idx)
    {
    }
     
    // softmmu_header.h
    static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
    {
            /* 略 */
     
            res = glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
     
            /* 略 */
    }

  • helper_fldt (target-i386/op_helper.c)

    #if !defined(CONFIG_USER_ONLY)
    #include "softmmu_exec.h"
    #endif /* !defined(CONFIG_USER_ONLY) */
     
    static inline floatx80 helper_fldt(target_ulong ptr)
    {
        CPU_LDoubleU temp;
     
        temp.l.lower = ldq(ptr);     // #define ldub(p) ldub_data(p) in softmmu_exec.h
        temp.l.upper = lduw(ptr + 8);
        return temp.d;
    }

• softmmu_header.h: 定義巨集。被 softmmu_exec.h 和 exec-all.h #include 進而展開巨集，根據 MMU mode 和 data size 定義 inli ne ld/st 函式。
  • softmmu_exec.h: 被 target-xxx/op_helper.c 所 #include。根據 MMU mode (user/kernel) 和 data size 生成 inline ld/st 函式。

    // target-xxx/cpu.h 自行定義 MMU_MODE?_SUFFIX。
    // 以 i386 為例: _kernel，_user。
    #define MEMSUFFIX MMU_MODE1_SUFFIX

    // target-i386/op_helper.c
    #include "cpu.h"
    #include "softmmu_exec.h"
     
    // softmmu_exec.h
    #include "softmmu_defs.h"
     
    #define ACCESS_TYPE 0
    #define MEMSUFFIX MMU_MODE0_SUFFIX
    #define DATA_SIZE 1
    #include "softmmu_header.h"
     
    // softmmu_header.h
    // op_helper.i -> ldub_kernel
    // ld/st 最後會呼叫到 __ld/__st
    // kernel mode: env->tlb_table[0]
    // user mode: env->tlb_table[1]
    // data: env->tlb_table[(cpu_mmu_index(env))]
    static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
    {
    }

1. exec-all.h。定義給 code cache 使用的 softmmu 函式。

   #include "softmmu_defs.h"
    
   // uint64_t REGPARM __ldq_mmu(target_ulong addr, int mmu_idx);
   // void REGPARM __stq_mmu(target_ulong addr, uint64_t val, int mmu_idx);
   //
   // uint8_t REGPARM __ldb_cmmu(target_ulong addr, int mmu_idx);
   // void REGPARM __stb_cmmu(target_ulong addr, uint8_t val, int mmu_idx);
    
   #define ACCESS_TYPE (NB_MMU_MODES + 1)
   #define MEMSUFFIX _code
   #define env cpu_single_env
    
   #define DATA_SIZE 1
   #include "softmmu_header.h"
    
   // softmmu_header.h
   #elif ACCESS_TYPE == (NB_MMU_MODES + 1)
    
   #define CPU_MMU_INDEX (cpu_mmu_index(env))
   #define MMUSUFFIX _cmmu
    
   #else
    
   // 生成 ldub_cmmu -> __ldb_cmmu
   // env->tlb_table[(cpu_mmu_index(env))]

• cpu-exec.i: {ld, st}{sb, ub}_{kernel, user, data, p} p: 直接讀。

QEMU softmmu 有幾處可以加速²⁾³⁾⁴⁾。

• [Qemu-devel] [RFC][PATCH 0/4] tcg: enhance code generation quality for qemu_ld/st IRs

以 x86 為例，有幾種情況會呼叫 tlb_flush。

1. cpu_x86_update_crN。在 target-i386/translate.c 中，遇到 mov reg, crN 或是 mov crN, reg 會呼叫 helper_write_crN (target-i386/op_helper.c)，helper_write_crN 再視情況呼叫 cpu_x86_update_crN (target-i386/helper.c)。Control register
2. cpu_register_physical_memory_log
3. cpu_reset
4. cpu_x86_set_a20

1. tlb_flush (exec.c)。

   void tlb_flush(CPUState *env, int flush_global)
   {
       int i;
    
       /* must reset current TB so that interrupts cannot modify the
          links while we are modifying them */
       env->current_tb = NULL;
    
       for(i = 0; i < CPU_TLB_SIZE; i++) {
           int mmu_idx;
           for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
               env->tlb_table[mmu_idx][i] = s_cputlb_empty_entry;
           }
       }
    
       // 此時 softmmu (tlb) 失效，GVA -> HVA 的對映不再合法，所以要清空以 GVA (guest pc) 當索引的 tb_jmp_cache。 
       memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
    
       env->tlb_flush_addr = -1;
       env->tlb_flush_mask = 0;
       tlb_flush_count++;
   }

2. 這時 QEMU 被迫以 tb_find_slow 改以 GPA 查找是否有以翻譯過的 TranslationBlock，同時會進行額外檢查。注意! 這時候有可能會重翻!

   static TranslationBlock *tb_find_slow(CPUState *env, ...)
   {
       for(;;) {
           tb = *ptb1;
           if (!tb)
               goto not_found;
           if (tb->pc == pc &&
               tb->page_addr[0] == phys_page1 &&
               tb->cs_base == cs_base &&
               tb->flags == flags) {
               /* check next page if needed */
               if (tb->page_addr[1] != -1) {
                   tb_page_addr_t phys_page2;
    
                   virt_page2 = (pc & TARGET_PAGE_MASK) +
                       TARGET_PAGE_SIZE;
                   phys_page2 = get_page_addr_code(env, virt_page2);
                   if (tb->page_addr[1] == phys_page2)
                       goto found;
               } else {
                   goto found;
               }
           }
           ptb1 = &tb->phys_hash_next;
       }
   }

• [Qemu-devel] throwing away translated code on CPU reset
• [Qemu-devel] Question about tlb_flush
  • [Qemu-devel] [PATCH] exec.c: Clarify comment about tlb_flush() flush_global parameter

可參考底下文件，

• 程序員的自我修養 第 171 頁。
• qemu用户态仿真代码分析
• qemu中ELF文件的加载

1. main (linux-user/main.c) 為進入點。

   int main(int argc, char **argv, char **envp)
   {
       // 初始化 TCG
       cpu_exec_init_all(0);
    
       // 初始化 CPUState
       env = cpu_init(cpu_model);
    
       // 傳遞環境變數和命令行參數給 guest program   
       target_environ = envlist_to_environ(envlist, NULL);
    
       // 初始化 TaskState 数据结构
       init_task_state(ts);
       /* build Task State */
       ts->info = info;
       ts->bprm = &bprm;
       env->opaque = ts; // 後續透過 env->opaque 取得 TaskState
       task_settid(ts);
    
       // 載入 guest program。此時 regs 存放程序進入點，之後將此進入點賦值給 virtual CPU。
       // 這樣 virtual CPU 就知道從哪裡開始執行。
       ret = loader_exec(filename, target_argv, target_environ, regs,
           info, &bprm);
    
       target_set_brk(info->brk); // 設置 guest process 的 brk 指針。
       syscall_init();
       signal_init();
    
       tcg_prologue_init(&tcg_ctx);
    
       // 設置 CPU
   #if defined(TARGET_I386)
       cpu_x86_set_cpl(env, 3); // 將 x86 virtual CPU 特權級設為 ring 3。
    
       env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
       env->hflags |= HF_PE_MASK;
       if (env->cpuid_features & CPUID_SSE) {
           env->cr[4] |= CR4_OSFXSR_MASK;
           env->hflags |= HF_OSFXSR_MASK;
       }
    
       /* flags setup : we activate the IRQs by default as in user mode */
       env->eflags |= IF_MASK;
    
       /* linux register setup */
   #ifndef TARGET_ABI32
       env->regs[R_EAX] = regs->rax;
       env->regs[R_EBX] = regs->rbx;
       env->regs[R_ECX] = regs->rcx;
       env->regs[R_EDX] = regs->rdx;
       env->regs[R_ESI] = regs->rsi;
       env->regs[R_EDI] = regs->rdi;
       env->regs[R_EBP] = regs->rbp;
       env->regs[R_ESP] = regs->rsp;
       env->eip = regs->rip;
   #else
       env->regs[R_EAX] = regs->eax;
       env->regs[R_EBX] = regs->ebx;
       env->regs[R_ECX] = regs->ecx;
       env->regs[R_EDX] = regs->edx;
       env->regs[R_ESI] = regs->esi;
       env->regs[R_EDI] = regs->edi;
       env->regs[R_EBP] = regs->ebp;
       env->regs[R_ESP] = regs->esp;
       env->eip = regs->eip; // 前面已將 guest binary 進入點存進 regs。
   #endif
    
       // 設置中斷
       /* linux interrupt setup */
   #ifndef TARGET_ABI32
       env->idt.limit = 511;
   #else
       env->idt.limit = 255;
   #endif
       env->idt.base = target_mmap(0, sizeof(uint64_t) * (env->idt.limit + 1),
                                   PROT_READ|PROT_WRITE,
                                   MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
       idt_table = g2h(env->idt.base); // 取得 guest idt (中斷描述符表) 在 host 的位址。
       set_idt(0, 0); // 設定
       set_idt(1, 0);
    
       // 開始 guest binary -> TCG IR -> host binary，並執行 host binary。 
       cpu_loop(env);
   }

   • cpu_exec_init_all 初始化 TCG。

     void cpu_exec_init_all(unsigned long tb_size)
     {
         // 呼叫 tcg_context_init (tcg/tcg.c) 初始化 TCG。tcg_context_init
         // 再呼叫 tcg_target_init (tcg/i386/tcg-target.c) 針對宿主機做相應的設置。
         cpu_gen_init();
         code_gen_alloc(tb_size); // 使用 mmap 將 code_gen_prologue 和 code_gen_buffer 設為可讀、可寫和可執行。
         code_gen_ptr = code_gen_buffer;
         page_init(); // 扫描 /proc/self/maps。針對每個頁調用 page_set_flags。
     }

   • page_init (exec.c)。

     static void page_init(void)
     {
             last_brk = (unsigned long)sbrk(0); // 取得目前 QEMU brk 指針，brk 指向堆 (heap) 的頂端，代表程序資料段的結尾。
      
             f = fopen("/compat/linux/proc/self/maps", "r"); // 取得 QEMU 虛擬內存的映象。
             if (f) {
                 mmap_lock();
      
                 do {
                     // 掃描 maps 的內容，透過 h2g (cpu-all.h) 將 host addr 轉換成 guest addr，透過減去 guest addr base。
                        // 並檢查 guest addr 是否落在 guest addr space。
      
                         // page_set_flags 檢視該頁面是否被寫入。若被寫入，則清空所有與該頁面有關的 TB。這裡只是要建該頁面的 PageDesc。
                         page_set_flags(startaddr, endaddr, PAGE_RESERVED); 
                 } while (!feof(f));
            }
     }

2. cpu_init 依據不同的 guest CPU 型號進行初始化。如 x86，則呼叫 cpu_x86_init (target-i386/helper.c)。
3. init_task_state (linux-user/main.c) 每個 guest process 都有一個 TaskState。

   void init_task_state(TaskState *ts)
   {
       int i;
    
       ts->used = 1;
       ts->first_free = ts->sigqueue_table;
       for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
           ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
       }
       ts->sigqueue_table[i].next = NULL;
   }

4. loader_exec (linux-user/linuxload.c) 載入 guest program。檢查其執行檔格式和權限。
   • linux_binprm
   • image_info

     // ret = loader_exec(filename, target_argv, target_environ, regs,
     //   info, &bprm);
     int loader_exec(const char * filename, char ** argv, char ** envp,
                  struct target_pt_regs * regs, struct image_info *infop,
                  struct linux_binprm *bprm)
     {
         retval = open(filename, O_RDONLY);
      
         retval = prepare_binprm(bprm);
      
         if(retval>=0) {
             if (bprm->buf[0] == 0x7f
                     && bprm->buf[1] == 'E'
                     && bprm->buf[2] == 'L'
                     && bprm->buf[3] == 'F') {
                 retval = load_elf_binary(bprm, regs, infop);
             }
         }
      
         if(retval>=0) {
             /* success.  Initialize important registers */
             // do_init_thread (linux-user/elfload.c) 呼叫 init_thread (linux-user/elfload.c) 根據不同架構
             // 初始化 CPU 暫存器。以 x86_64 為例，
             // 
            // regs->rax = 0;
            // regs->rsp = infop->start_stack;
            // regs->rip = infop->entry;
             do_init_thread(regs, infop);
             return retval;
         }
     }

   • load_elf_binary (linux-user/elfload.c) 將 guest binary 載入成為 image。
     • ELF 之 Program Loading 教學文件, #3: Segment Type 與 Kernel Space Loader
     • Dynamic Linking

       int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
                           struct image_info * info)
       {
           // 將 guest binary 載入成為 image。
           load_elf_image(bprm->filename, bprm->fd, info,
                          &elf_interpreter, bprm->buf);
        
           // 如果該 guest binary 為動態連結，載入 dynamic linker。透過檢查 guest binary 的 program header 是否帶有 PT_INTERP。
           if (elf_interpreter) {
               load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
           }
        
           bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
                                       info, (elf_interpreter ? &interp_info : NULL));
           info->start_stack = bprm->p;
        
           // 將進入點設為 dynamic linker。 
           if (elf_interpreter) {
               info->load_bias = interp_info.load_bias;
               info->entry = interp_info.entry;
               free(elf_interpreter);
           }
       }

   • create_elf_tables (linux-user/elfload.c)

     static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
                                        struct elfhdr *exec,
                                        struct image_info *info,
                                        struct image_info *interp_info)
     {
         info->saved_auxv = sp;
      
         sp = loader_build_argptr(envc, argc, sp, p, 0);
         return sp;
     }

   • loader_build_argptr (linux-user/linuxload.c) 在 guest (target) 的棧上放置環境變數和命令行參數。put_user_ual (linux-user/qemu.h) 用來將資料搬移至 guest 內存。

     /* Construct the envp and argv tables on the target stack.  */
     abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp, ...)
     {
         TaskState *ts = (TaskState *)thread_env->opaque;
      
         sp -= (envc + 1) * n; // 調整棧指針給予環境變數空間。
         envp = sp;
         sp -= (argc + 1) * n; // 調整棧指針給予命令行參數空間。
         argv = sp;
      
         // 將命令行參數寫至 guest 棧上。
          while (argc-- > 0) {
             /* FIXME - handle put_user() failures */
             put_user_ual(stringp, argv);
             argv += n;
             stringp += target_strlen(stringp) + 1;
         }
      
         // 將環境變數寫至 guest 棧上。
         while (envc-- > 0) {
             /* FIXME - handle put_user() failures */
             put_user_ual(stringp, envp);
             envp += n;
             stringp += target_strlen(stringp) + 1;
         }
      
     }

5. syscall_init (linux-user/syscall.c) IOCTLEntry

6. signal_init (linux-user/signal.c) 會處理 guest 跟 host 之間 signal 如何對映和處理。

   // linux-user/syscall_defs.h 定義 TARGET_XXX
   static uint8_t host_to_target_signal_table[_NSIG] = {
       [SIGHUP] = TARGET_SIGHUP,
   }
    
   static uint8_t target_to_host_signal_table[_NSIG];
    
   void signal_init(void)
   {
       /* generate signal conversion tables */
       for(i = 1; i < _NSIG; i++) {
           if (host_to_target_signal_table[i] == 0)
               host_to_target_signal_table[i] = i;
       }
       for(i = 1; i < _NSIG; i++) {
           j = host_to_target_signal_table[i];
           target_to_host_signal_table[j] = i;
       }
    
       /* set all host signal handlers. ALL signals are blocked during
          the handlers to serialize them. */
       memset(sigact_table, 0, sizeof(sigact_table));
    
       sigfillset(&act.sa_mask);
       act.sa_flags = SA_SIGINFO;
       act.sa_sigaction = host_signal_handler;
       for(i = 1; i <= TARGET_NSIG; i++) {
           host_sig = target_to_host_signal(i);
           sigaction(host_sig, NULL, &oact);
           if (oact.sa_sigaction == (void *)SIG_IGN) {
               sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
           } else if (oact.sa_sigaction == (void *)SIG_DFL) {
               sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
           }
           /* If there's already a handler installed then something has
              gone horribly wrong, so don't even try to handle that case.  */
           /* Install some handlers for our own use.  We need at least
              SIGSEGV and SIGBUS, to detect exceptions.  We can not just
              trap all signals because it affects syscall interrupt
              behavior.  But do trap all default-fatal signals.  */
           if (fatal_signal (i))
               sigaction(host_sig, &act, NULL);
       }
   }

7. 設定 virtual CPU 暫存器、中斷描述符表、全域描述符表和段描述符。

   static uint64_t *idt_table;
    
   static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
                        uint32_t addr, unsigned int sel)
   {
       uint32_t *p, e1, e2;
       e1 = (addr & 0xffff) | (sel << 16);
       e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
       p = ptr;
       p[0] = tswap32(e1);
       p[1] = tswap32(e2);
   }
    
   static void set_idt(int n, unsigned int dpl)
   {
       set_gate(idt_table + n, 0, dpl, 0, 0);
   }

8. cpu_loop (linux-user/main.c) 為主要執行迴圈，呼叫 cpu_x86_exec 進行 guest binary → TCG → host binary 並執行的流程。cpu_x86_exec/cpu_exec (cpu-exec.c) 會返回例外號，cpu_loop 視例外號的不同做相對應的處理，之後處理訊號。不同架構定義不同的 cpu_loop。以 x86 為例，

   void cpu_loop(CPUX86State *env)
   {
       int trapnr;
       abi_ulong pc;
       target_siginfo_t info;
    
       for(;;) {
           trapnr = cpu_x86_exec(env);
           switch(trapnr) {
           case 0x80:
               /* linux syscall from int $0x80 */
               env->regs[R_EAX] = do_syscall(env,
                                             env->regs[R_EAX],
                                             env->regs[R_EBX],
                                             env->regs[R_ECX],
                                             env->regs[R_EDX],
                                             env->regs[R_ESI],
                                             env->regs[R_EDI],
                                             env->regs[R_EBP],
                                             0, 0);
               break;
    
           /* different cases */
           default:
               pc = env->segs[R_CS].base + env->eip;
               fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
                       (long)pc, trapnr);
               abort();
           }
           process_pending_signals(env); // linux-user/signal.c
       }
   }

• Qemu-mipsel-linux-user initial trace analysis
• Linux: where are environment variables stored?
• Virtual Memory - looking "Under the Hood"
• 深入淺出Hello World
• [Qemu-devel] Fwd: envlist_setenv...

QEMU user mode 在處理系統呼叫時，不像 system mode 需要翻譯 system call handler。

1. cpu_loop (linux-user/main.c)。

   void cpu_loop(CPUX86State *env)
   {
       int trapnr;
       abi_ulong pc;
       target_siginfo_t info;
    
       for(;;) {
           trapnr = cpu_x86_exec(env);
           switch(trapnr) {
           case 0x80:
               /* linux syscall from int $0x80 */
               env->regs[R_EAX] = do_syscall(env,
                                             env->regs[R_EAX],
                                             env->regs[R_EBX],
                                             env->regs[R_ECX],
                                             env->regs[R_EDX],
                                             env->regs[R_ESI],
                                             env->regs[R_EDI],
                                             env->regs[R_EBP],
                                             0, 0);
               break;
    
            ... 略 ...
        }
    
        ... 略 ...
    
   }

2. do_syscall (linux-user/syscall.c) 將客戶 system call 做些包裝之後，轉交給宿主 system call。

   abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
                       abi_long arg2, abi_long arg3, abi_long arg4,
                       abi_long arg5, abi_long arg6, abi_long arg7,
                       abi_long arg8)
   {
       switch(num) {
    
       ... 略 ...
    
       case TARGET_NR_open:
           if (!(p = lock_user_string(arg1)))
               goto efault;
           ret = get_errno(do_open(cpu_env, p,
                                   target_to_host_bitmask(arg2, fcntl_flags_tbl),
                                   arg3));
           unlock_user(p, arg1, 0);
           break;
    
       ... 略 ...
    
       }
    
       ... 略 ...
   }

3. do_open (linux-user/syscall.c)。

   static int do_open(void *cpu_env, const char *pathname, int flags, mode_t mode)
   {
       // 前置處理。
    
       // 呼叫 host system call。
       return get_errno(open(path(pathname), flags, mode));
   }

以 x86 為例，

• cpu-defs.h 定義例外號。

  #define EXCP_INTERRUPT  0x10000 /* async interruption */
  #define EXCP_HLT        0x10001 /* hlt instruction reached */
  #define EXCP_DEBUG      0x10002 /* cpu stopped after a breakpoint or singlestep */
  #define EXCP_HALTED     0x10003 /* cpu is halted (waiting for external event) */

• 有些函式前面會加上 QEMU_NORETURN (compiler.h)，這代表該函式不會返回。

  #define QEMU_NORETURN __attribute__ ((__noreturn__))

1. cpu_exec (cpu-exec.c)

   int cpu_exec(CPUState *env)
   {
       if (env->halted) { // system mode 才會拉起 env->halted。
           if (!cpu_has_work(env)) {
               return EXCP_HALTED;
           }
    
           env->halted = 0;
       }
    
       cpu_single_env = env; // 保存當前 env。待 lonjmp 時，可以用 cpu_single_env 回復 env。
    
       if (unlikely(exit_request)) {
           env->exit_request = 1;
       }
    
   // 不同架構會有不同前置處理。
   #if defined(TARGET_I386)
       CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
       DF = 1 - (2 * ((env->eflags >> 10) & 1));
       CC_OP = CC_OP_EFLAGS;
       env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
   #else
   #error unsupported target CPU
   #endif
       // cpu_exec 返回值即為 env->exception_index。以 process mode 為例，cpu_loop 在呼叫 cpu_exec 之後，會檢視其返回值並做相應處理。 
       env->exception_index = -1;
    
       // 進行翻譯並執行的迴圈。
       /* prepare setjmp context for exception handling */
       for(;;) {
           if (setjmp(env->jmp_env) == 0) { // 正常流程。
    
               next_tb = 0; /* force lookup of first TB */
               for(;;) {
    
               } /* for(;;) */
           } else {
               /* Reload env after longjmp - the compiler may have smashed all
                * local variables as longjmp is marked 'noreturn'. */
               env = cpu_single_env;
           }
       } /* for(;;) */
   }

   • QEMU 支持 precise exception。當例外發生時，執行流程會將舊的 env (cpu_single_env) 存回 env。
2. 外層迴圈。cpu_exec 利用 setjmp/longjmp 處理例外。cpu_loop_exit (cpu-exec.c) 和 cpu_resume_from_signal (cpu-exec.c) 會呼叫 longjmp 回到 setjmp 設定的例外處理分支。⁵⁾

       for(;;) {
           if (setjmp(env->jmp_env) == 0) {
               /* if an exception is pending, we execute it here */
               if (env->exception_index >= 0) { // exception_index 非 -1 代表有事要處理。
                   if (env->exception_index >= EXCP_INTERRUPT) { // 來自 cpu_exec 以外的例外。
                       /* exit request from the cpu execution loop */
                       ret = env->exception_index;
                       if (ret == EXCP_DEBUG) {
                           cpu_handle_debug_exception(env);
                       }
                       break;
                   } else {
    
   #if defined(CONFIG_USER_ONLY) 
                       /* if user mode only, we simulate a fake exception
                          which will be handled outside the cpu execution
                          loop */
   #if defined(TARGET_I386)
                       do_interrupt(env);
   #endif
                       ret = env->exception_index;
                       break;
   #else
                   }
               }
    
           } else {
               /* Reload env after longjmp - the compiler may have smashed all
                * local variables as longjmp is marked 'noreturn'. */
               env = cpu_single_env;
           }
       } /* for(;;) */
    
       /* 回復 env 中的欄位，清空 cpu_single_env，返回 cpu_loop 處理例外 */
   }

   • cpu_loop_exit (cpu-exec.c)

     void cpu_loop_exit(CPUState *env)
     {
         env->current_tb = NULL;
         longjmp(env->jmp_env, 1);
     }

   • cpu_resume_from_signal (cpu-exec.c)

     /* exit the current TB from a signal handler. The host registers are
        restored in a state compatible with the CPU emulator
      */
     #if defined(CONFIG_SOFTMMU)
     void cpu_resume_from_signal(CPUState *env, void *puc)
     {
         /* XXX: restore cpu registers saved in host registers */
      
         env->exception_index = -1;
         longjmp(env->jmp_env, 1);
     }
     #endif

3. user mode 和 system mode 有不同處置。

   void do_interrupt(CPUState *env1)
   {
       CPUState *saved_env;
    
       saved_env = env;
       env = env1;
   #if defined(CONFIG_USER_ONLY)
       /* if user mode only, we simulate a fake exception
          which will be handled outside the cpu execution
          loop */
       do_interrupt_user(env->exception_index,
                         env->exception_is_int,
                         env->error_code,
                         env->exception_next_eip);
       /* successfully delivered */
       env->old_exception = -1;
   #else
       /* simulate a real cpu exception. On i386, it can
          trigger new exceptions, but we do not handle
          double or triple faults yet. */
       do_interrupt_all(env->exception_index,
                        env->exception_is_int,
                        env->error_code,
                        env->exception_next_eip, 0);
       /* successfully delivered */
       env->old_exception = -1;
   #endif
       env = saved_env;
   }

   • user mode。
     • General protection fault

       #if defined(CONFIG_USER_ONLY)
       /* fake user mode interrupt */
       static void do_interrupt_user(int intno, int is_int, int error_code,
                                     target_ulong next_eip)
       {
           SegmentCache *dt;
           target_ulong ptr;
           int dpl, cpl, shift;
           uint32_t e2;
        
           dt = &env->idt; // 取出中斷描述符表
           if (env->hflags & HF_LMA_MASK) {
               shift = 4;
           } else {
               shift = 3;
           }
           ptr = dt->base + (intno << shift); // 取出中斷處理常式
           e2 = ldl_kernel(ptr + 4);
        
           dpl = (e2 >> DESC_DPL_SHIFT) & 3;
           cpl = env->hflags & HF_CPL_MASK;
           /* check privilege if software int */
           if (is_int && dpl < cpl)
               raise_exception_err(EXCP0D_GPF, (intno << shift) + 2); // target-i386/cpu.h
        
           /* Since we emulate only user space, we cannot do more than
              exiting the emulation with the suitable exception and error
              code */
           if (is_int)
               EIP = next_eip; // target-i386/cpu.h:#define EIP (env->eip)
       }
        
       #else

     • raise_exception_err (target-i386/op_helper.c) 轉呼叫 raise_interrupt (target-i386/op_helper.c)。

       static void QEMU_NORETURN raise_exception_err(int exception_index,
                                                     int error_code)
       {
           raise_interrupt(exception_index, 0, error_code, 0);
       }

     • raise_interrupt (target-i386/op_helper.c) 最後呼叫 cpu_loop_exit (cpu-exec.c) longjmp 回外層迴圈 else 分支。

       /*
        * Signal an interruption. It is executed in the main CPU loop.
        * is_int is TRUE if coming from the int instruction. next_eip is the
        * EIP value AFTER the interrupt instruction. It is only relevant if
        * is_int is TRUE.
        */
       static void QEMU_NORETURN raise_interrupt(int intno, int is_int, int error_code,
                                                 int next_eip_addend)
       {
           if (!is_int) {
               helper_svm_check_intercept_param(SVM_EXIT_EXCP_BASE + intno, error_code);
               intno = check_exception(intno, &error_code);
           } else {
               helper_svm_check_intercept_param(SVM_EXIT_SWINT, 0);
           }
        
           env->exception_index = intno;
           env->error_code = error_code;
           env->exception_is_int = is_int;
           env->exception_next_eip = env->eip + next_eip_addend;
           cpu_loop_exit(env);
       }

   • system mode。
     • do_interrupt_all (target-i386/op_helper.c)。

       static void do_interrupt_all(int intno, int is_int, int error_code,
                                    target_ulong next_eip, int is_hw)
       {
           ... 略 ...
        
           // 檢查當前處於何種模式，交由相對應的函式處理。如果客戶機是 64 bit，還有 do_interrupt_64。
           if (env->cr[0] & CR0_PE_MASK) {
               if (env->hflags & HF_SVMI_MASK)
                   handle_even_inj(intno, is_int, error_code, is_hw, 0);
               {
                   do_interrupt_protected(intno, is_int, error_code, next_eip, is_hw);
               }
           } else {
               do_interrupt_real(intno, is_int, error_code, next_eip);
           }
        
           ... 略 ...
       }

     • 內核態與用戶態分別有內核棧和用戶棧。
     • do_interrupt_real。

       static void do_interrupt_real(int intno, int is_int, int error_code,
                                     unsigned int next_eip)
       {
           ... 略 ...
        
           // 取得內核棧棧頂。
           ssp = env->segs[R_SS].base;
        
           esp = ESP; // #define ESP (env->regs[R_ESP]) (target-i386/cpu.h)
           ssp = env->segs[R_SS].base;
        
           // 將用戶態資訊放至內核棧。
           /* XXX: use SS segment size ? */
           PUSHW(ssp, esp, 0xffff, compute_eflags());
           PUSHW(ssp, esp, 0xffff, old_cs);
           PUSHW(ssp, esp, 0xffff, old_eip);
        
           // 將 env->eip 指向中斷向量。返回 cpu_exec 後便會翻譯中斷向量並執行。
           /* update processor state */
           ESP = (ESP & ~0xffff) | (esp & 0xffff);
           env->eip = offset;
           env->segs[R_CS].selector = selector;
           env->segs[R_CS].base = (selector << 4);
           env->eflags &= ~(IF_MASK | TF_MASK | AC_MASK | RF_MASK);
       }

     • helper_iret_real。當中斷向量執行完畢後，會執行 iret 返回用戶態。

       void helper_iret_real(int shift)
       {
           ... 略 ...
        
           // 將用戶態資訊從內核棧取出。
           if (shift == 1) {
               /* 32 bits */
               POPL(ssp, sp, sp_mask, new_eip);
               POPL(ssp, sp, sp_mask, new_cs);
               new_cs &= 0xffff;
               POPL(ssp, sp, sp_mask, new_eflags);
           } else {
               /* 16 bits */
               POPW(ssp, sp, sp_mask, new_eip);
               POPW(ssp, sp, sp_mask, new_cs);
               POPW(ssp, sp, sp_mask, new_eflags);
           }
           ESP = (ESP & ~sp_mask) | (sp & sp_mask);
           env->segs[R_CS].selector = new_cs;
           env->segs[R_CS].base = (new_cs << 4);
           env->eip = new_eip; // 返回用戶態後，欲執行的 pc。
           if (env->eflags & VM_MASK)
               eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | RF_MASK | NT_MASK;
           else
               eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | IOPL_MASK | RF_MASK | NT_MASK;
           if (shift == 0)
               eflags_mask &= 0xffff;
           load_eflags(new_eflags, eflags_mask);
           env->hflags2 &= ~HF2_NMI_MASK;
       }

4. 內層迴圈。

               next_tb = 0; /* force lookup of first TB */
               for(;;) {
                   interrupt_request = env->interrupt_request;
                   // 檢視 interrupt_request 是何種中斷，並將 interrupt_request 復位。
                      // 設置 env->exception_index，再跳至 cpu_loop_exit。
                      // cpu_loop_exit 再 longjmp 到外層迴圈 setjmp 的點，跳到處理中斷的分支。
                     if (unlikely(interrupt_request)) {
                   }
    
                   // 檢視 env->exit_request。
                   if (unlikely(env->exit_request)) {
                       env->exit_request = 0;
                       env->exception_index = EXCP_INTERRUPT;
                       cpu_loop_exit(env);
                   }
    
                   tb = tb_find_fast(env);
    
                   env->current_tb = tb;
                   barrier();
                   // 若無 exit_request，跳入 code cache 開始執行。
                   if (likely(!env->exit_request)) {
                   }
                   env->current_tb = NULL;
                   /* reset soft MMU for next block (it can currently
                      only be set by a memory fault) */
               } /* for(;;) */

• QEMU - cpu-interrupt

• [Qemu-devel] How QEMU handle precise exception?⁶⁾

Precise exception 要求當某一條 guest 指令發生例外，例如溢位或是頁缺失，此條指令之前的運算必須完成，此條指令之後的運算必須捨棄。當 QEMU 在 code cache 中執行翻譯過後的指令，其中發生例外時，QEMU 必須要能維護例外發生之前 guest 的暫存器和內存內容，並能反查出發生例外的 basic block 相對映開頭的 guest pc。從那個 guest pc 重新開始翻譯直到發生例外的位址，並把這個 guest pc 存回 CPUState，這是因為 QEMU 不會執行完一條 guest 指令就更新 guest pc。

1. 暫存器: 在有可能發生例外的運算之前，如: guest load/store 或是呼叫 helper function，QEMU 會把 dirty CPUState 寫回內存。
2. 內存: QEMU 不會將原本指令亂序。

QEMU 會用到底下定義在 translate-all.c 資料結構:

target_ulong gen_opc_pc[OPC_BUF_SIZE]; // 紀錄 guest pc。
uint16_t gen_opc_icount[OPC_BUF_SIZE];
uint8_t gen_opc_instr_start[OPC_BUF_SIZE]; // 當作標記之用。  

針對 x86，又在 target-i386/translate.c 定義以下資料結構:

static uint8_t gen_opc_cc_op[OPC_BUF_SIZE]; // 紀錄 condition code。

QEMU 會以 retaddr 判斷在哪裡發生例外，這用到 GCC Getting the Return or Frame Address of a Function 擴展。注意! QEMU 在兩個地方定義 GETPC，分別位於 exec-all.h 和 exec.c。

1. exec-all.h。定義給 code cache 使用的 softmmu 函式。

   // __builtin_return_address 返回當前函式 (參數 0) 的返回位址。
   #else
   # define GETPC() ((void *)((unsigned long)__builtin_return_address(0) - 1))
   #endif
    
   #include "softmmu_defs.h"
    
   #define ACCESS_TYPE (NB_MMU_MODES + 1)
   #define MEMSUFFIX _code
   #define env cpu_single_env
    
   #define DATA_SIZE 1
   #include "softmmu_header.h"
    
   #define DATA_SIZE 2
   #include "softmmu_header.h"
    
   #define DATA_SIZE 4
   #include "softmmu_header.h"
    
   #define DATA_SIZE 8
   #include "softmmu_header.h"
    
   #undef ACCESS_TYPE
   #undef MEMSUFFIX
   #undef env
    
   #endif

2. exec.c。定義給一般 C 函式使用的 softmmu 函式。

   #define MMUSUFFIX _cmmu
   #undef GETPC
   #define GETPC() NULL
   #define env cpu_single_env
   #define SOFTMMU_CODE_ACCESS
    
   #define SHIFT 0
   #include "softmmu_template.h"
    
   #define SHIFT 1
   #include "softmmu_template.h"
    
   #define SHIFT 2
   #include "softmmu_template.h"
    
   #define SHIFT 3
   #include "softmmu_template.h"
    
   #undef env
    
   #endif
    
   static inline void svm_load_seg(target_phys_addr_t addr, SegmentCache *sc)
   {
       unsigned int flags;
    
       sc->selector = lduw_phys(addr + offsetof(struct vmcb_seg, selector));
       sc->base = ldq_phys(addr + offsetof(struct vmcb_seg, base));
       sc->limit = ldl_phys(addr + offsetof(struct vmcb_seg, limit));
       flags = lduw_phys(addr + offsetof(struct vmcb_seg, attrib));
       sc->flags = ((flags & 0xff) << 8) | ((flags & 0x0f00) << 12);
   }

1. tlb_fill。env 是 dyngen-exec.h 中定義的全域變數，是一個指向 CPUState 的指針，該指針存放在宿主機特定的暫存器 ⁷⁾。

   #if !defined(CONFIG_USER_ONLY)
   /* try to fill the TLB and return an exception if error. If retaddr is
      NULL, it means that the function was called in C code (i.e. not
      from generated code or from helper.c) */
   /* XXX: fix it to restore all registers */
   void tlb_fill(CPUState *env1, target_ulong addr, int is_write, int mmu_idx,
                 void *retaddr)
   {
       TranslationBlock *tb;
       int ret;
       unsigned long pc;
       CPUX86State *saved_env;
    
       saved_env = env;  // 備份 global env。
       env = env1;       // 將當前 env (env1) 賦值與 global env。
    
       ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx);
       if (ret) {
           if (retaddr) {
               /* now we have a real cpu fault */
               pc = (unsigned long)retaddr;
               tb = tb_find_pc(pc);
               if (tb) {
                   /* the PC is inside the translated code. It means that we have
                      a virtual CPU fault */
                   cpu_restore_state(tb, env, pc);
               }
           }
           raise_exception_err(env->exception_index, env->error_code);
       }
       env = saved_env;
   }
   #endif

   • tb_find_slow → get_page_addr_code → ldub_code → \_\_ldb_cmmu → tlb_fill。此時，retaddr 為 NULL，代表是從一般 C 函式呼叫到 tlb_fill。
   • code cache → \_\_ldl_mmu → tlb_fill。此時，retaddr 不為 NULL，代表是從 code cache 呼叫到 tlb_fill，guest binary 通常在做 guest memory operation。
2. 透過 tb_find_pc 以發生例外 host binary (retaddr) 位址反查 TranslationBlock。

   /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
      tb[1].tc_ptr. Return NULL if not found */
   TranslationBlock *tb_find_pc(unsigned long tc_ptr)
   {
       int m_min, m_max, m;
       unsigned long v;
       TranslationBlock *tb;
    
       if (nb_tbs <= 0)
           return NULL;
       // code_gen_buffer 是 code cache 起始位址，code_gen_ptr 是 code cache 目前生成 host binary 會放的位址。
       if (tc_ptr < (unsigned long)code_gen_buffer ||
           tc_ptr >= (unsigned long)code_gen_ptr)
           return NULL;
       /* binary search (cf Knuth) */
       m_min = 0;
       m_max = nb_tbs - 1;
       while (m_min <= m_max) {
           m = (m_min + m_max) >> 1;
           tb = &tbs[m];
           v = (unsigned long)tb->tc_ptr;
           // 例外發生所在的 host 位址和該 TranslationBlock 在 code cache 的位址一致。
           if (v == tc_ptr)
               return tb;
           else if (tc_ptr < v) {
               m_max = m - 1;
           } else {
               m_min = m + 1;
           }
       }
       return &tbs[m_max]; // 返回發生例外的 TranslationBlock。
   }

3. cpu_restore_state (translate-all.c) 重翻該 TranslationBlock (guest binary → TCG IR → host binary)，同時附帶上 guest pc 資訊。searched_pc 為發生例外的 host binary 位址。

   /* The cpu state corresponding to 'searched_pc' is restored.
    */
   int cpu_restore_state(TranslationBlock *tb,
                         CPUState *env, unsigned long searched_pc)
   {
       TCGContext *s = &tcg_ctx;
       int j;
       unsigned long tc_ptr;
    
       tcg_func_start(s); // 初始 gen_opc_ptr 和 gen_opparam_ptr
    
       // 轉呼叫 gen_intermediate_code_internal，要求在生成 TCG IR 的同時，為其生成相關的 pc 資訊。
       gen_intermediate_code_pc(env, tb);
    
       if (use_icount) {
           /* Reset the cycle counter to the start of the block.  */
           env->icount_decr.u16.low += tb->icount;
           /* Clear the IO flag.  */
           env->can_do_io = 0;
       }
    
       /* find opc index corresponding to search_pc */
       // tc_ptr 指向 host binary 在 code cache 的起始位址。
       // 如果 searched_pc 小於 tc_ptr，代表此 tb 並非是負責人。
       tc_ptr = (unsigned long)tb->tc_ptr;
       if (searched_pc < tc_ptr)
           return -1;
    
       s->tb_next_offset = tb->tb_next_offset;
   #ifdef USE_DIRECT_JUMP
       s->tb_jmp_offset = tb->tb_jmp_offset;
       s->tb_next = NULL;
   #else
       s->tb_jmp_offset = NULL;
       s->tb_next = tb->tb_next;
   #endif
       // 轉呼叫 tcg_gen_code_common (tcg/tcg.c)
       j = tcg_gen_code_search_pc(s, (uint8_t *)tc_ptr, searched_pc - tc_ptr);
       if (j < 0)
           return -1;
       /* now find start of instruction before */
       while (gen_opc_instr_start[j] == 0)
           j--;
       env->icount_decr.u16.low -= gen_opc_icount[j];
    
       // 此時，用 j 索引 gen_opc_pc 可以得到對應的 guest pc。
       restore_state_to_opc(env, tb, j);
    
       return 0;
   }

   1. gen_intermediate_code_pc (target-i386/translate.c) 轉呼叫 gen_intermediate_code_internal，search_pc 為真。將 guest binary 翻成 TCG IR 的同時，紀錄下 guest pc。

      static inline void gen_intermediate_code_internal(CPUState *env,
                                                        TranslationBlock *tb,
                                                        int search_pc)
      {
          for(;;) {
              if (search_pc) {
                  // gen_opc_ptr 為 TCG opcode buffer 目前位址，gen_opc_buf 為 TCG opcode buffer。
                  j = gen_opc_ptr - gen_opc_buf;
                  if (lj < j) {
                      lj++;
                      while (lj < j)
                          gen_opc_instr_start[lj++] = 0; // 不到 j 的部分填零。
                  }
                  gen_opc_pc[lj] = pc_ptr; // 紀錄 guest pc。
                  gen_opc_cc_op[lj] = dc->cc_op; // 紀錄 condition code。
                  gen_opc_instr_start[lj] = 1; // 填 1 作為標記。
                  gen_opc_icount[lj] = num_insns;
              }
          }
          if (tb->cflags & CF_LAST_IO)
              gen_io_end();
          gen_icount_end(tb, num_insns);
          *gen_opc_ptr = INDEX_op_end;
          /* we don't forget to fill the last values */
          if (search_pc) {
              j = gen_opc_ptr - gen_opc_buf;
              lj++;
              while (lj <= j)
                  gen_opc_instr_start[lj++] = 0;
          }
      }

   2. tcg_gen_code_search_pc (tcg/tcg.c) 轉呼叫 tcg_gen_code_common (tcg/tcg.c) 將 TCG IR 翻成 host binary。search_pc 應該改叫 offset。

      /* Return the index of the micro operation such as the pc after is <
         offset bytes from the start of the TB.  The contents of gen_code_buf must
         not be changed, though writing the same values is ok.
         Return -1 if not found. */
      static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
                                            long search_pc)
      {
          for(;;) {
              switch(opc) {
              case INDEX_op_nopn:
                  args += args[0];
                  goto next;
              case INDEX_op_call:
                  dead_args = s->op_dead_args[op_index];
                  args += tcg_reg_alloc_call(s, def, opc, args, dead_args);
                  goto next;
              }
              args += def->nb_args;
          next:
              // 如果 offset (search_pc) 落在目前 code cache 起始位址和 code cache 目前存放 host binary 的位址之間，
              // 返回 TCG op index。 
              if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) {
                  return op_index;
              }
              op_index++;
          }
      }

   3. restore_state_to_opc (target-i386/translate.c)

      void restore_state_to_opc(CPUState *env, TranslationBlock *tb, int pc_pos)
      {
          int cc_op;
       
          env->eip = gen_opc_pc[pc_pos] - tb->cs_base;
          cc_op = gen_opc_cc_op[pc_pos];
          if (cc_op != CC_OP_DYNAMIC)
              env->cc_op = cc_op;
      }

4. raise_exception_err (target-i386/op_helper.c)

   static void QEMU_NORETURN raise_exception_err(int exception_index,
                                                 int error_code)
   {
       raise_interrupt(exception_index, 0, error_code, 0);
   }

5. raise_interrupt (target-i386/op_helper.c)

   /*
    * Signal an interruption. It is executed in the main CPU loop.
    * is_int is TRUE if coming from the int instruction. next_eip is the
    * EIP value AFTER the interrupt instruction. It is only relevant if
    * is_int is TRUE.
    */
   static void QEMU_NORETURN raise_interrupt(int intno, int is_int, int error_code,
                                             int next_eip_addend)
   {
       if (!is_int) {
           // 走這裡。
           helper_svm_check_intercept_param(SVM_EXIT_EXCP_BASE + intno, error_code);
           intno = check_exception(intno, &error_code);
       } else {
           helper_svm_check_intercept_param(SVM_EXIT_SWINT, 0);
       }
    
       env->exception_index = intno;
       env->error_code = error_code;
       env->exception_is_int = is_int;
       env->exception_next_eip = env->eip + next_eip_addend;
       cpu_loop_exit(env);
   }

   • 這裡操作的 env 是 global env，在 tlb_fill 已經同步成當前 env。
6. helper_svm_check_intercept_param (target-i386/op_helper.c)
7. cpu_loop_exit (cpu-exec.c)

   void cpu_loop_exit(CPUState *env)
   {
       env->current_tb = NULL;
       longjmp(env->jmp_env, 1);
   }

以 linux-0.11 為例，

(gdb) b gen_intermediate_code_internal if tb->pc == 0xe4c0
(gdb) r -m 1024M -boot a -fda linux-0.11/Image -hda rootfs/hdc-0.11-new.img -vnc 0.0.0.0:1

1. Breakpoint 1, gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe75b9e60, search_pc=0) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
   7731    {
   (gdb) bt
   #0  gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe75b9e60, search_pc=0) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
   #1  0x0000000000535551 in gen_intermediate_code (env=0x110e5d0, tb=0x7fffe75b9e60) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7907
   #2  0x000000000050fdee in cpu_x86_gen_code (env=0x110e5d0, tb=0x7fffe75b9e60, gen_code_size_ptr=0x7fffffffdd30)
       at /tmp/chenwj/qemu-0.13.0/translate-all.c:73
   #3  0x000000000050871f in tb_gen_code (env=0x110e5d0, pc=58560, cs_base=0, flags=2740, cflags=0) at /tmp/chenwj/qemu-0.13.0/exec.c:962
   #4  0x0000000000510a7a in tb_find_slow (pc=58560, cs_base=0, flags=2740) at /tmp/chenwj/qemu-0.13.0/cpu-exec.c:167

2. 下 ls。0x4011809f 位在 code cache 之內。

   Breakpoint 1, gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe75b9e60, search_pc=1) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
   7731    {
   (gdb) bt
   #0  gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe75b9e60, search_pc=1) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
   #1  0x000000000053559e in gen_intermediate_code_pc (env=0x110e5d0, tb=0x7fffe75b9e60) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7912
   #2  0x000000000050ff4d in cpu_restore_state (tb=0x7fffe75b9e60, env=0x110e5d0, searched_pc=1074888863, puc=0x0)
       at /tmp/chenwj/qemu-0.13.0/translate-all.c:130
   #3  0x000000000054effd in tlb_fill (addr=268513280, is_write=1, mmu_idx=0, retaddr=0x4011809f) at /tmp/chenwj/qemu-0.13.0/target-i386/op_helper.c:4836
   #4  0x000000000054d4f0 in __stb_mmu (addr=268513280, val=150 '\226', mmu_idx=0) at /tmp/chenwj/qemu-0.13.0/softmmu_template.h:272
   #5  0x00000000401180a0 in ?? ()

   • ----------------
     IN:
     0x0000e4c0:  sub    $0x4,%esp
     0x0000e4c3:  mov    0x8(%esp),%eax
     0x0000e4c7:  mov    %al,(%esp)
     0x0000e4ca:  movzbl (%esp),%eax
     0x0000e4ce:  mov    0xc(%esp),%edx
     0x0000e4d2:  mov    %al,%fs:(%edx)  <---
     0x0000e4d5:  add    $0x4,%esp
     0x0000e4d8:  ret
     
      ---- 0xe4d2
      mov_i32 tmp2,edx
      ld_i32 tmp4,env,$0x84
      add_i32 tmp2,tmp2,tmp4
      mov_i32 tmp0,eax
      qemu_st8 tmp0,tmp2,$0x0            <---
     
     RESTORE:
     0x0000: 0000e4c0
     0x0007: 0000e4c3
     0x000d: 0000e4c7
     0x0011: 0000e4ca
     0x0015: 0000e4ce
     0x001b: 0000e4d2
     // spc 是觸發例外的 host binary 位址，等同 retaddr。
     // eip 是觸發例外的 guest binary 位址。
     spc=0x401255bf pc_pos=0x1b eip=0000e4d2 cs_base=0
     Servicing hardware INT=0x20

   • 0x40125577:  mov    %eax,%ebp              // 保存 CPUState
     0x40125579:  mov    %ebp,%ebx
     0x4012557b:  mov    0x84(%r14),%r12d
     0x40125582:  add    %r12d,%ebx
     0x40125585:  mov    (%r14),%r12d
     0x40125588:  mov    %ebp,0x8(%r14)
     0x4012558c:  mov    %ebx,%esi              // 查詢 TLB
     0x4012558e:  mov    %ebx,%edi
     0x40125590:  shr    $0x7,%esi
     0x40125593:  and    $0xfffff000,%edi
     0x40125599:  and    $0x1fe0,%esi
     0x4012559f:  lea    0x34c(%r14,%rsi,1),%rsi
     0x401255a7:  cmp    (%rsi),%edi
     0x401255a9:  mov    %ebx,%edi
     0x401255ab:  jne    0x401255b6             // TLB 不命中，跳至 0x401255b6。
     0x401255ad:  add    0xc(%rsi),%rdi
     0x401255b1:  mov    %r12b,(%rdi)
     0x401255b4:  jmp    0x401255c0             
     0x401255b6:  mov    %r12d,%esi             // 不命中，呼叫 __stb_mmu
     0x401255b9:  xor    %edx,%edx              
     0x401255bb:  callq  0x54d38a               // 執行 __stb_mmu 的時候，發生頁缺失例外。
     0x401255c0:  mov    0x10(%r14),%ebp

• 執行 \_\_stb_mmu 的時候，會呼叫 tlb_fill。tlb_fill 呼叫 cpu_x86_handle_mmu_fault 查找客戶機頁表，若該頁存在，將其頁表項填入 tlb; 否則觸發頁缺失例外。

數個 tb 可能會相對應 (不同進程的) guest pc。

Breakpoint 1, gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe75d2eb0, search_pc=0) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
7731    {
Breakpoint 1, gen_intermediate_code_internal (env=0x110e5d0, tb=0x7fffe76232c0, search_pc=0) at /tmp/chenwj/qemu-0.13.0/target-i386/translate.c:7731
7731    {

• Bochs
• Virtual Machine

請閱讀以下文章:

• KVM虚拟机代码揭秘——QEMU代码结构分析
• Qemu Detailed Study
• Qemu Detailed Study (中譯)
• QEMU Internal – Tiny Code Generator (TCG) 1/2
• QEMU Internal – Tiny Code Generator (TCG) 2/2

TCG 是 dynamic binary tranlation。QEMU 1.0 預計會加入 TCI (tiny code interpreter)。請見 [Qemu-devel] [PATCH 0/8] tcg/interpreter: Add TCG + interpreter for bytecode (virtual machine)。在上下文有提到 TCG 的話，其所指的 target 必定是指 QEMU 運行其上的 host。⁸⁾

底下是 TCG 動態翻譯流程中會使用到的緩衝區:

1. gen_opc_buf 和 gen_opparam_buf (translate-all.c) 是 TCG IR 所在位置。

   uint16_t gen_opc_buf[OPC_BUF_SIZE]; // 放置 TCG opcode。
   TCGArg gen_opparam_buf[OPPARAM_BUF_SIZE]; // 放置 TCG opcode 會用到的 operand。

2. 如果使用靜態配置的緩衝區，static_code_gen_buffer (exec.c) 是 translation block code cache (host binary) 所在位置。

   #ifdef USE_STATIC_CODE_GEN_BUFFER
   static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE]
                  __attribute__((aligned (CODE_GEN_ALIGN)));
   #endif

3. 在跳入/出 code cache 執行之前/後，要執行 prologue/epilogue。

   // 根據不同平台，code_gen_section 用不同的 __attribute__ 修飾 code_gen_prologue。
   uint8_t code_gen_prologue[1024] code_gen_section;

以 qemu-i386 為例，主要流程如下:

main (linux-user/main.c) → cpu_exec_init_all (exec.c) → cpu_init/cpu_x86_init (target-i386/helper.c) → tcg_prologue_init (tcg/tcg.c) → cpu_loop (linux-user/main.c)

• tcg_prologue_init (tcg/tcg.c) → tcg_target_qemu_prologue (tcg/i386/tcg-target.c)
  • 進 translation block code cache 之前和之後，需要執行 prologue 和 epilogue。請參考 Calling convention 和 Which x86 registers to save in C functions?。

    void tcg_prologue_init(TCGContext *s)
    {
        /* init global prologue and epilogue */
        s->code_buf = code_gen_prologue;
        s->code_ptr = s->code_buf;
        tcg_target_qemu_prologue(s);
        flush_icache_range((unsigned long)s->code_buf,
                           (unsigned long)s->code_ptr);
    }
     
    static void tcg_target_qemu_prologue(TCGContext *s)
    {
        // QEMU -> prologue -> code cache。prologue -> code cache 被當作一個函式。
        // 寫入 host binary。
        tcg_out_push(s, tcg_target_callee_save_regs[i]); // 將 callee saved 的暫存器入棧
     
        tcg_out_addi(s, TCG_REG_ESP, -stack_addend); // 調整棧指針，加大棧
     
        // OPC_GRP5 (0xff) 為 call，EXT5_JMPN_Ev 是其 opcode extension。
       // tcg_target_call_iarg_regs 是函式呼叫負責傳遞參數的暫存器。
        tcg_out_modrm(s, OPC_GRP5, EXT5_JMPN_Ev, tcg_target_call_iarg_regs[0]); // 跳至 code cache 執行
     
       // 此時，s->code_ptr 指向 code_gen_prologue 中 prologue 和 jmp to code cache 之後的位址。
       // tb_ret_addr 是紀錄 code cache 跳回 code_gen_prologue 的哪個地方。
       tb_ret_addr = s->code_ptr;
     
       tcg_out_addi(s, TCG_REG_ESP, stack_addend); // 調整棧指針，縮小棧
     
       tcg_out_pop(s, tcg_target_callee_save_regs[i]); // 回復 callee saved 的暫存器
     
        tcg_out_opc(s, OPC_RET, 0, 0, 0); // 返回 QEMU
    }

• cpu_loop (linux-user/main.c) → cpu_x86_exec/cpu_exec (cpu-exec.c) → tb_find_fast (cpu-exec.c)
  • tb_find_fast (cpu-exec.c) → tb_find_slow (cpu-exec.c) → tb_gen_code (exec.c) → cpu_gen_code (translate-all.c) → gen_intermediate_code (target-i386/translate.c) → tcg_gen_code (tcg/tcg.c) → tcg_gen_code_common (tcg/tcg.c)
  • tcg_gen_code_common (tcg/tcg.c) → tcg_reg_alloc_op (tcg/tcg.c) → tcg_out_op (tcg/i386/tcg-target.c)

1. cpu_exec (cpu-exec.c) 為主要執行迴圈。cpu_exec_nocache 是在 system mode 啟用 icount 的時候才會被用到

   next_tb = 0; /* force lookup of first TB */
   for(;;) {
       // 處理中斷。這裡會檢視是何種中斷，並將 interrupt_request 復位。設置 exception_index，再跳至 cpu_loop_exit。
        // cpu_loop_exit 再 longjmp 到外層迴圈 setjmp 的點，跳到處理中斷的分支。
        if (unlikely(interrupt_request)) {
           if (interrupt_request & CPU_INTERRUPT_DEBUG) {
               env->interrupt_request &= ~CPU_INTERRUPT_DEBUG;
               env->exception_index = EXCP_DEBUG;
               cpu_loop_exit();
           }
       }
    
       tb_find_fast(); // 查詢 TB 是否已存在 code cache。若無，則呼叫 tb_find_slow
    
       // 執行 TB，也就是 tc_ptr 所指到的位址。注意，產生 TCG IR 的過程中，在 block 的最後會是
       // exit_tb addr，此 addr 是正在執行的這個 block 起始位址，同時也是 tcg_qemu_tb_exec 的回傳值。
        // 該位址後兩位會被填入 0、1 或 2 以指示 block chaining 的方向。 
       next_tb = tcg_qemu_tb_exec(tc_ptr);  
   }

   • tb_find_fast 會以 pc (虛擬位址)試圖尋找已翻譯過的 translation block。

     tb = env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)];

     如果失敗，則呼叫 tb_find_slow 以 pc (cs + eip) 對映的物理位址尋找 TB。如果成功，則將該 TB 寫入 tb_jmp_cache; 若否，則進行翻譯。

     not_found:
       /* if no translated code available, then translate it now */
       tb = tb_gen_code(env, pc, cs_base, flags, 0);
      
     found:
       /* we add the TB in the virtual pc hash table */
       env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)] = tb;
       return tb;

2. tb_gen_code 配置內存給 TB，再交由 cpu_gen_code。

   // 注意! 這裡會將虛擬位址轉成物理位址。phys_pc 將交給之後的 tb_link_page 使用。
   // get_page_addr_code 在 process mode 直接返回 pc; system mode 則透過查找
   // env 的 tlb_table 返回 GPA 在客戶機內存中的偏移量。
   phys_pc = get_page_addr_code(env, pc);
   tb = tb_alloc(pc);
   if (!tb) {
     // 清空 code cache
   }
    
   // 初始 tb
    
   cpu_gen_code(env, tb, &code_gen_size); // 開始 guest binary -> TCG IR -> host binary 的翻譯。
    
   // 將 tb 加入 tb_phys_hash 和二級頁表 l1_map。
   // phys_pc 和 phys_page2 分別代表 tb (guest pc) 對映的物理位址和所屬的第二個頁面 (如果 tb 代表的 guest binary 跨頁面的話)。
   tb_link_page(tb, phys_pc, phys_page2);
   return tb; 

   • cpu_gen_code 負責 guest binary → TCG IR → host binary 的翻譯。

     tcg_func_start(s); // 初始 gen_opc_ptr 和 gen_opparam_ptr  
      
     gen_intermediate_code(env, tb); // 呼叫 gen_intermediate_code_internal 產生 TCG IR
      
     gen_code_size = tcg_gen_code(s, gen_code_buf); // TCG IR -> host binary

     • tcg_func_start (tcg/tcg.c)

       void tcg_func_start(TCGContext *s)
       {
           int i;
           tcg_pool_reset(s);
           s->nb_temps = s->nb_globals;
           for(i = 0; i < (TCG_TYPE_COUNT * 2); i++)
               s->first_free_temp[i] = -1;
           s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS);
           s->nb_labels = 0;
           s->current_frame_offset = s->frame_start;
        
           gen_opc_ptr = gen_opc_buf;
           gen_opparam_ptr = gen_opparam_buf;
       }

   • gen_intermediate_code_internal (target-*/translate.c) 初始化並呼叫 disas_insn 反組譯 guest binary 成 TCG IR。
     • disas_insn 呼叫 tcg_gen_xxx (tcg/tcg-op.h) 產生 TCG IR。分別將 opcode 寫入 gen_opc_ptr 指向的緩衝區 (translate-all.c 裡的 gen_opc_buf); operand 寫入 gen_opparam_ptr 指向的緩衝區 (translate-all.c 裡的 gen_opparam_buf )。
   • tcg_gen_code (tcg/tcg.c) 呼叫 tcg_gen_code_common (tcg/tcg.c) 將 TCG IR 轉成 host binary。

     tcg_reg_alloc_start(s);
      
     s->code_buf = gen_code_buf;
     s->code_ptr = gen_code_buf; // host binary 會寫入 TCGContext s 的 code_ptr 所指向的緩衝區。  

   • tb_link_page (exec.c) 把新的 TB 加進 tb_phys_hash 和 l1_map 二級頁表。tb_find_slow 會用 pc 對映的物理位址的哈希值索引 tb_phys_hash (存放 TranslationBlock *) 取得下一個 TB。

     /* add in the physical hash table */
     h = tb_phys_hash_func(phys_pc);
     ptb = &tb_phys_hash[h]; 
     tb->phys_hash_next = *ptb; // 如果兩個以上的 TB 其 phys_pc 的哈希值相同，則做 chaining。
     *ptb = tb; // 新加入的 TB 放至 chaining 的開頭。  
      
     /* add in the page list */
     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
     if (phys_page2 != -1) // TB 對應的 guest binary 跨頁
         tb_alloc_page(tb, 1, phys_page2);
     else
         tb->page_addr[1] = -1;
      
     // jmp_first 代表跳至此 TB 的其它 TB 中的頭一個。jmp_first 初值為自己，末兩位為 10 (2)。
     // 將來做 block chaining 時，jmp_first 指向跳至此 TB 的其它 TB 中的頭一個 tb1，末兩位為 00
     // 或 01，這代表從 tb1 的哪一個分支跳至此 TB。
     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
     // jmp_next[n] 代表此 TB 條件分支的目標 TB。
     // 注意! 如果目標 TB，tb1，孤身一人，jmp_next 就真的指向 tb1。
     // 如果其它 TB，tb2，跳至 tb1，則賦值給 tb->jmp_next 的是 tb1 的 jmp_first，也就是 tb1 (末兩位編碼 tb2 跳至 tb1 的方向)。
     tb->jmp_next[0] = NULL;
     tb->jmp_next[1] = NULL;
      
     // tb_next_offset 代表此 TB 在 code cache 中分支跳轉要被 patch 的位址 (相對於其 code cache 的偏移量)，
     // 為了 direct block chaining 之用。
     if (tb->tb_next_offset[0] != 0xffff)
         tb_reset_jump(tb, 0);
     if (tb->tb_next_offset[1] != 0xffff)
         tb_reset_jump(tb, 1);

     • tb_alloc_page 建立新的 PageDesc。(exec.c)。

       static inline void tb_alloc_page(TranslationBlock *tb,
                                        unsigned int n, tb_page_addr_t page_addr)
       {
         // 代表 tb (guest binary) 所屬頁面。
         tb->page_addr[n] = page_addr;
         // 在 l1_map 中配置一個 PageDesc，返回該 PageDesc。
         p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
         tb->page_next[n] = p->first_tb; // 將該頁面目前第一個 TB 串接到此 TB。將來有需要將某頁面所屬所有 TB 清空。
         // n 為 1 代表 tb 對應的 guest binary 跨 page。
         p->first_tb = (TranslationBlock *)((long)tb | n);
         invalidate_page_bitmap(p);
       }

     • tb_reset_jump 呼叫 tb_set_jmp_target 使得該 TB 不會鏈結到其它 TB。根據是否使用 direct jump 做 block chaining 與否，tb_set_jmp_target 直接修改 TB (code cache) 跳躍目標或是 TB 的 tb_next。
3. tb_find_fast/slow 傳回 translation block 後，交給 tcg_qemu_tb_exec 執行。

   next_tb = tcg_qemu_tb_exec(tc_ptr);

   • tcg_qemu_tb_exec 被定義在 tcg/tcg.h。

     // code_gen_prologue(tb_ptr) is casted to a function with one parameter,
     // in such a way, execute host machine code stored in code_gen_prologue[]
     #define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)

     (long REGPARM (*)(void *)) 將 code_gen_prologue 轉型成函式指針，void * 為該函式的參數，返回值為 long。REGPARM 指示 GCC 此函式透過暫存器而非棧傳遞參數。至此，(long REGPARM (*)(void *)) 將數組指針 code_gen_prologue 轉型成函式指針。tb_ptr 為該函式指針的參數。綜合以上所述，code_gen_prologue 被視為一函式，其參數為 tb_ptr，返回下一個欲執行的 TB。code_gen_prologue 所做的事為一般函式呼叫前的 prologue，之後將控制交由 tc_ptr 指向的 host binary 並開始執行。

有幾種情況會需要打斷 code cache 的執行，將控制權將還給 QEMU。

• cpu_interrupt: 虛擬外設會發出中斷，最後透過 apic_local_deliver (hw/apic.c) 呼叫 cpu_interrupt 發出中斷給虛擬 CPU。QEMU 0.15 將system mode 和 process mode 的 cpu_interrupt 分離，請見 cpu-all.h 和 exec.c。
• cpu_exit: system mode 會註冊 host alarm signal handler，該 handler 會呼叫 cpu_exit。其它諸如 gdb stub，DMA，IO thread 都會呼叫到 cpu_exit。

針對 self-modifying code 或是 JIT，在內存生成代碼之後通常需要清空快取⁹⁾。

請閱讀一下文章

• QEMU Internal – Block Chaining 1/3
  • http://people.cs.nctu.edu.tw/~chenwj/slide/QEMU/QEMU-block-chaining-01.txt
• QEMU Internal – Block Chaining 2/3
  • http://people.cs.nctu.edu.tw/~chenwj/slide/QEMU/QEMU-block-chaining-02.txt
• QEMU Internal – Block Chaining 3/3
  • http://people.cs.nctu.edu.tw/~chenwj/slide/QEMU/QEMU-block-chaining-03.txt
• QEMU翻译块（TB）分析
• [Qemu-devel] TB chaining in QEMU

為了盡量在 code cache 中執行，QEMU 會做 block chaining。block chaining 是將 code cache 中的 translation block 串接起來。有兩種做法: 第一，採用 direct jump。此法直接修改 code cache 中分支指令的跳躍目標，因此依據 host 有不同的 patch 方式。第二，則是透過修改 TB 的 tb_next 欄位達成 block chaining。exec-all.h 中定義那些 host 可以使用 direct jump。

tb = tb_find_fast(env); 
 
if (tb_invalidated_flag) {
    /* as some TB could have been invalidated because
       of memory exceptions while generating the code, we
       must recompute the hash index here */
    next_tb = 0; // 注意! next_tb 也被用來控制是否要做 block chaining。
    tb_invalidated_flag = 0;
}
 
// 注意!! next_tb 的名字會讓人誤解。block chaining 的方向為: next_tb -> tb。
// next_tb 不為 NULL 且 tb (guest binary) 不跨頁面的話，做 block chaining。
if (next_tb != 0 && tb->page_addr[1] == -1) {
    // 這邊利用 TranlationBlock 指針的最低有效位後兩位指引 block chaining 的方向。
    tb_add_jump((TranslationBlock *)(next_tb & ~3), next_tb & 3, tb);
}
 
  // 執行 TB，也就是 tc_ptr 所指到的位址。注意，產生 TCG IR 的過程中，在 block 的最後會是
  // exit_tb addr，此 addr 是正在執行的這個 block 起始位址，同時也是 tcg_qemu_tb_exec 的回傳值。
  // 該位址後兩位會被填入 0、1 或 2 以指示 block chaining 的方向。
  next_tb = tcg_qemu_tb_exec(env, tc_ptr);

• tb_add_jump 呼叫 tb_set_jmp_target 做 block chaining 的 patch。另外，會利用 tb 的 jmp_next 和 tb_next 的 jmp_first 把 block chaining 中的 tb 串成一個 circular list。這邊要注意到，QEMU 利用 TranslatonBlock 位址後兩位必為零的結果做了一些手腳。(exec-all.h)。

  // block chaining 方向為: tb -> tb_next。n 用來指示 tb 條件分支的方向。
  static inline void tb_add_jump(TranslationBlock *tb, int n,
                                 TranslationBlock *tb_next)
  {
      // jmp_next[0]/jmp_next[1] 代表 tb 條件分支的目標。
      if (!tb->jmp_next[n]) {
          /* patch the native jump address */
          tb_set_jmp_target(tb, n, (unsigned long)tb_next->tc_ptr);
   
          // tb_jmp_remove 會用到 jmp_next 做 unchain。
           // tb_next->jmp_first 初值為自己，末兩位設為 10 (2)。
           // 如果已有其它 TB，tb1，跳至 tb_next，則 tb->jmp_next 指向 tb1 (末兩位代表 tb1 跳至 tb_next 的方向)。
           // tb_next->jmp_first 改指向 tb。 
           tb->jmp_next[n] = tb_next->jmp_first;
          // tb_next 的 jmp_first 指回 tb，末兩位代表由 tb 哪一個條件分支跳至 tb_next。
           tb_next->jmp_first = (TranslationBlock *)((long)(tb) | (n));
      }
  }

• 依據是否採用 direct jump，tb_set_jmp_target (exec-all.h) 有不同做法。採用 direct jump 的話，tb_set_jmp_target 會根據 host 呼叫不同的 tb_set_jmp_target1。tb_set_jmp_target1 會用到 TB 的 tb_jmp_offset。如果不採用 direct jump 做 block chaining，tb_set_jmp_target 會直接修改 TB 的 tb_next。
  • tb_set_jmp_target (exec-all.h)。

    static inline void tb_set_jmp_target(TranslationBlock *tb,
                                         int n, unsigned long addr)
    {
        unsigned long offset;
     
        offset = tb->tb_jmp_offset[n]; // tb 要 patch 的位址相對於 tb->tc_ptr 的偏移量。
        tb_set_jmp_target1((unsigned long)(tb->tc_ptr + offset), addr);
    }

  • tb_set_jmp_target1 (exec-all.h)。

    #elif defined(__i386__) || defined(__x86_64__)
    static inline void tb_set_jmp_target1(unsigned long jmp_addr, unsigned long addr)
    {
        /* patch the branch destination */
        *(uint32_t *)jmp_addr = addr - (jmp_addr + 4); // jmp 的參數為 jmp 下一條指令與目標地址的偏移量。
        /* no need to flush icache explicitly */
    }