1 /* 2 * TCG CPU-specific operations 3 * 4 * Copyright 2021 SUSE LLC 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 */ 9 10 #ifndef TCG_CPU_OPS_H 11 #define TCG_CPU_OPS_H 12 13 #include "exec/breakpoint.h" 14 #include "exec/hwaddr.h" 15 #include "exec/memattrs.h" 16 #include "exec/mmu-access-type.h" 17 #include "exec/vaddr.h" 18 19 struct TCGCPUOps { 20 /** 21 * @initialize: Initialize TCG state 22 * 23 * Called when the first CPU is realized. 24 */ 25 void (*initialize)(void); 26 /** 27 * @synchronize_from_tb: Synchronize state from a TCG #TranslationBlock 28 * 29 * This is called when we abandon execution of a TB before starting it, 30 * and must set all parts of the CPU state which the previous TB in the 31 * chain may not have updated. 32 * By default, when this is NULL, a call is made to @set_pc(tb->pc). 33 * 34 * If more state needs to be restored, the target must implement a 35 * function to restore all the state, and register it here. 36 */ 37 void (*synchronize_from_tb)(CPUState *cpu, const TranslationBlock *tb); 38 /** 39 * @restore_state_to_opc: Synchronize state from INDEX_op_start_insn 40 * 41 * This is called when we unwind state in the middle of a TB, 42 * usually before raising an exception. Set all part of the CPU 43 * state which are tracked insn-by-insn in the target-specific 44 * arguments to start_insn, passed as @data. 45 */ 46 void (*restore_state_to_opc)(CPUState *cpu, const TranslationBlock *tb, 47 const uint64_t *data); 48 49 /** @cpu_exec_enter: Callback for cpu_exec preparation */ 50 void (*cpu_exec_enter)(CPUState *cpu); 51 /** @cpu_exec_exit: Callback for cpu_exec cleanup */ 52 void (*cpu_exec_exit)(CPUState *cpu); 53 /** @debug_excp_handler: Callback for handling debug exceptions */ 54 void (*debug_excp_handler)(CPUState *cpu); 55 56 #ifdef CONFIG_USER_ONLY 57 /** 58 * @fake_user_interrupt: Callback for 'fake exception' handling. 59 * 60 * Simulate 'fake exception' which will be handled outside the 61 * cpu execution loop (hack for x86 user mode). 62 */ 63 void (*fake_user_interrupt)(CPUState *cpu); 64 65 /** 66 * record_sigsegv: 67 * @cpu: cpu context 68 * @addr: faulting guest address 69 * @access_type: access was read/write/execute 70 * @maperr: true for invalid page, false for permission fault 71 * @ra: host pc for unwinding 72 * 73 * We are about to raise SIGSEGV with si_code set for @maperr, 74 * and si_addr set for @addr. Record anything further needed 75 * for the signal ucontext_t. 76 * 77 * If the emulated kernel does not provide anything to the signal 78 * handler with anything besides the user context registers, and 79 * the siginfo_t, then this hook need do nothing and may be omitted. 80 * Otherwise, record the data and return; the caller will raise 81 * the signal, unwind the cpu state, and return to the main loop. 82 * 83 * If it is simpler to re-use the sysemu tlb_fill code, @ra is provided 84 * so that a "normal" cpu exception can be raised. In this case, 85 * the signal must be raised by the architecture cpu_loop. 86 */ 87 void (*record_sigsegv)(CPUState *cpu, vaddr addr, 88 MMUAccessType access_type, 89 bool maperr, uintptr_t ra); 90 /** 91 * record_sigbus: 92 * @cpu: cpu context 93 * @addr: misaligned guest address 94 * @access_type: access was read/write/execute 95 * @ra: host pc for unwinding 96 * 97 * We are about to raise SIGBUS with si_code BUS_ADRALN, 98 * and si_addr set for @addr. Record anything further needed 99 * for the signal ucontext_t. 100 * 101 * If the emulated kernel does not provide the signal handler with 102 * anything besides the user context registers, and the siginfo_t, 103 * then this hook need do nothing and may be omitted. 104 * Otherwise, record the data and return; the caller will raise 105 * the signal, unwind the cpu state, and return to the main loop. 106 * 107 * If it is simpler to re-use the sysemu do_unaligned_access code, 108 * @ra is provided so that a "normal" cpu exception can be raised. 109 * In this case, the signal must be raised by the architecture cpu_loop. 110 */ 111 void (*record_sigbus)(CPUState *cpu, vaddr addr, 112 MMUAccessType access_type, uintptr_t ra); 113 #else 114 /** @do_interrupt: Callback for interrupt handling. */ 115 void (*do_interrupt)(CPUState *cpu); 116 /** @cpu_exec_interrupt: Callback for processing interrupts in cpu_exec */ 117 bool (*cpu_exec_interrupt)(CPUState *cpu, int interrupt_request); 118 /** 119 * @cpu_exec_halt: Callback for handling halt in cpu_exec. 120 * 121 * The target CPU should do any special processing here that it needs 122 * to do when the CPU is in the halted state. 123 * 124 * Return true to indicate that the CPU should now leave halt, false 125 * if it should remain in the halted state. (This should generally 126 * be the same value that cpu_has_work() would return.) 127 * 128 * This method must be provided. If the target does not need to 129 * do anything special for halt, the same function used for its 130 * CPUClass::has_work method can be used here, as they have the 131 * same function signature. 132 */ 133 bool (*cpu_exec_halt)(CPUState *cpu); 134 /** 135 * @tlb_fill: Handle a softmmu tlb miss 136 * 137 * If the access is valid, call tlb_set_page and return true; 138 * if the access is invalid and probe is true, return false; 139 * otherwise raise an exception and do not return. 140 */ 141 bool (*tlb_fill)(CPUState *cpu, vaddr address, int size, 142 MMUAccessType access_type, int mmu_idx, 143 bool probe, uintptr_t retaddr); 144 /** 145 * @do_transaction_failed: Callback for handling failed memory transactions 146 * (ie bus faults or external aborts; not MMU faults) 147 */ 148 void (*do_transaction_failed)(CPUState *cpu, hwaddr physaddr, vaddr addr, 149 unsigned size, MMUAccessType access_type, 150 int mmu_idx, MemTxAttrs attrs, 151 MemTxResult response, uintptr_t retaddr); 152 /** 153 * @do_unaligned_access: Callback for unaligned access handling 154 * The callback must exit via raising an exception. 155 */ 156 G_NORETURN void (*do_unaligned_access)(CPUState *cpu, vaddr addr, 157 MMUAccessType access_type, 158 int mmu_idx, uintptr_t retaddr); 159 160 /** 161 * @adjust_watchpoint_address: hack for cpu_check_watchpoint used by ARM 162 */ 163 vaddr (*adjust_watchpoint_address)(CPUState *cpu, vaddr addr, int len); 164 165 /** 166 * @debug_check_watchpoint: return true if the architectural 167 * watchpoint whose address has matched should really fire, used by ARM 168 * and RISC-V 169 */ 170 bool (*debug_check_watchpoint)(CPUState *cpu, CPUWatchpoint *wp); 171 172 /** 173 * @debug_check_breakpoint: return true if the architectural 174 * breakpoint whose PC has matched should really fire. 175 */ 176 bool (*debug_check_breakpoint)(CPUState *cpu); 177 178 /** 179 * @io_recompile_replay_branch: Callback for cpu_io_recompile. 180 * 181 * The cpu has been stopped, and cpu_restore_state_from_tb has been 182 * called. If the faulting instruction is in a delay slot, and the 183 * target architecture requires re-execution of the branch, then 184 * adjust the cpu state as required and return true. 185 */ 186 bool (*io_recompile_replay_branch)(CPUState *cpu, 187 const TranslationBlock *tb); 188 /** 189 * @need_replay_interrupt: Return %true if @interrupt_request 190 * needs to be recorded for replay purposes. 191 */ 192 bool (*need_replay_interrupt)(int interrupt_request); 193 #endif /* !CONFIG_USER_ONLY */ 194 }; 195 196 #if defined(CONFIG_USER_ONLY) 197 198 static inline void cpu_check_watchpoint(CPUState *cpu, vaddr addr, vaddr len, 199 MemTxAttrs atr, int fl, uintptr_t ra) 200 { 201 } 202 203 static inline int cpu_watchpoint_address_matches(CPUState *cpu, 204 vaddr addr, vaddr len) 205 { 206 return 0; 207 } 208 209 #else 210 211 /** 212 * cpu_check_watchpoint: 213 * @cpu: cpu context 214 * @addr: guest virtual address 215 * @len: access length 216 * @attrs: memory access attributes 217 * @flags: watchpoint access type 218 * @ra: unwind return address 219 * 220 * Check for a watchpoint hit in [addr, addr+len) of the type 221 * specified by @flags. Exit via exception with a hit. 222 */ 223 void cpu_check_watchpoint(CPUState *cpu, vaddr addr, vaddr len, 224 MemTxAttrs attrs, int flags, uintptr_t ra); 225 226 /** 227 * cpu_watchpoint_address_matches: 228 * @cpu: cpu context 229 * @addr: guest virtual address 230 * @len: access length 231 * 232 * Return the watchpoint flags that apply to [addr, addr+len). 233 * If no watchpoint is registered for the range, the result is 0. 234 */ 235 int cpu_watchpoint_address_matches(CPUState *cpu, vaddr addr, vaddr len); 236 237 #endif 238 239 #endif /* TCG_CPU_OPS_H */ 240