1 /* 2 * QEMU TCG Single Threaded vCPUs implementation 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2014 Red Hat Inc. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a copy 8 * of this software and associated documentation files (the "Software"), to deal 9 * in the Software without restriction, including without limitation the rights 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the Software, and to permit persons to whom the Software is 12 * furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 * THE SOFTWARE. 24 */ 25 26 #include "qemu/osdep.h" 27 #include "qemu-common.h" 28 #include "sysemu/tcg.h" 29 #include "sysemu/replay.h" 30 #include "qemu/main-loop.h" 31 #include "qemu/guest-random.h" 32 #include "exec/exec-all.h" 33 34 #include "tcg-accel-ops.h" 35 #include "tcg-accel-ops-rr.h" 36 #include "tcg-accel-ops-icount.h" 37 38 /* Kick all RR vCPUs */ 39 void rr_kick_vcpu_thread(CPUState *unused) 40 { 41 CPUState *cpu; 42 43 CPU_FOREACH(cpu) { 44 cpu_exit(cpu); 45 }; 46 } 47 48 /* 49 * TCG vCPU kick timer 50 * 51 * The kick timer is responsible for moving single threaded vCPU 52 * emulation on to the next vCPU. If more than one vCPU is running a 53 * timer event with force a cpu->exit so the next vCPU can get 54 * scheduled. 55 * 56 * The timer is removed if all vCPUs are idle and restarted again once 57 * idleness is complete. 58 */ 59 60 static QEMUTimer *rr_kick_vcpu_timer; 61 static CPUState *rr_current_cpu; 62 63 static inline int64_t rr_next_kick_time(void) 64 { 65 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD; 66 } 67 68 /* Kick the currently round-robin scheduled vCPU to next */ 69 static void rr_kick_next_cpu(void) 70 { 71 CPUState *cpu; 72 do { 73 cpu = qatomic_mb_read(&rr_current_cpu); 74 if (cpu) { 75 cpu_exit(cpu); 76 } 77 } while (cpu != qatomic_mb_read(&rr_current_cpu)); 78 } 79 80 static void rr_kick_thread(void *opaque) 81 { 82 timer_mod(rr_kick_vcpu_timer, rr_next_kick_time()); 83 rr_kick_next_cpu(); 84 } 85 86 static void rr_start_kick_timer(void) 87 { 88 if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) { 89 rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, 90 rr_kick_thread, NULL); 91 } 92 if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) { 93 timer_mod(rr_kick_vcpu_timer, rr_next_kick_time()); 94 } 95 } 96 97 static void rr_stop_kick_timer(void) 98 { 99 if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) { 100 timer_del(rr_kick_vcpu_timer); 101 } 102 } 103 104 static void rr_wait_io_event(void) 105 { 106 CPUState *cpu; 107 108 while (all_cpu_threads_idle()) { 109 rr_stop_kick_timer(); 110 qemu_cond_wait_iothread(first_cpu->halt_cond); 111 } 112 113 rr_start_kick_timer(); 114 115 CPU_FOREACH(cpu) { 116 qemu_wait_io_event_common(cpu); 117 } 118 } 119 120 /* 121 * Destroy any remaining vCPUs which have been unplugged and have 122 * finished running 123 */ 124 static void rr_deal_with_unplugged_cpus(void) 125 { 126 CPUState *cpu; 127 128 CPU_FOREACH(cpu) { 129 if (cpu->unplug && !cpu_can_run(cpu)) { 130 tcg_cpus_destroy(cpu); 131 break; 132 } 133 } 134 } 135 136 /* 137 * In the single-threaded case each vCPU is simulated in turn. If 138 * there is more than a single vCPU we create a simple timer to kick 139 * the vCPU and ensure we don't get stuck in a tight loop in one vCPU. 140 * This is done explicitly rather than relying on side-effects 141 * elsewhere. 142 */ 143 144 static void *rr_cpu_thread_fn(void *arg) 145 { 146 CPUState *cpu = arg; 147 148 assert(tcg_enabled()); 149 rcu_register_thread(); 150 tcg_register_thread(); 151 152 qemu_mutex_lock_iothread(); 153 qemu_thread_get_self(cpu->thread); 154 155 cpu->thread_id = qemu_get_thread_id(); 156 cpu->can_do_io = 1; 157 cpu_thread_signal_created(cpu); 158 qemu_guest_random_seed_thread_part2(cpu->random_seed); 159 160 /* wait for initial kick-off after machine start */ 161 while (first_cpu->stopped) { 162 qemu_cond_wait_iothread(first_cpu->halt_cond); 163 164 /* process any pending work */ 165 CPU_FOREACH(cpu) { 166 current_cpu = cpu; 167 qemu_wait_io_event_common(cpu); 168 } 169 } 170 171 rr_start_kick_timer(); 172 173 cpu = first_cpu; 174 175 /* process any pending work */ 176 cpu->exit_request = 1; 177 178 while (1) { 179 qemu_mutex_unlock_iothread(); 180 replay_mutex_lock(); 181 qemu_mutex_lock_iothread(); 182 183 if (icount_enabled()) { 184 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */ 185 icount_account_warp_timer(); 186 /* 187 * Run the timers here. This is much more efficient than 188 * waking up the I/O thread and waiting for completion. 189 */ 190 icount_handle_deadline(); 191 } 192 193 replay_mutex_unlock(); 194 195 if (!cpu) { 196 cpu = first_cpu; 197 } 198 199 while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) { 200 201 qatomic_mb_set(&rr_current_cpu, cpu); 202 current_cpu = cpu; 203 204 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, 205 (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0); 206 207 if (cpu_can_run(cpu)) { 208 int r; 209 210 qemu_mutex_unlock_iothread(); 211 if (icount_enabled()) { 212 icount_prepare_for_run(cpu); 213 } 214 r = tcg_cpus_exec(cpu); 215 if (icount_enabled()) { 216 icount_process_data(cpu); 217 } 218 qemu_mutex_lock_iothread(); 219 220 if (r == EXCP_DEBUG) { 221 cpu_handle_guest_debug(cpu); 222 break; 223 } else if (r == EXCP_ATOMIC) { 224 qemu_mutex_unlock_iothread(); 225 cpu_exec_step_atomic(cpu); 226 qemu_mutex_lock_iothread(); 227 break; 228 } 229 } else if (cpu->stop) { 230 if (cpu->unplug) { 231 cpu = CPU_NEXT(cpu); 232 } 233 break; 234 } 235 236 cpu = CPU_NEXT(cpu); 237 } /* while (cpu && !cpu->exit_request).. */ 238 239 /* Does not need qatomic_mb_set because a spurious wakeup is okay. */ 240 qatomic_set(&rr_current_cpu, NULL); 241 242 if (cpu && cpu->exit_request) { 243 qatomic_mb_set(&cpu->exit_request, 0); 244 } 245 246 if (icount_enabled() && all_cpu_threads_idle()) { 247 /* 248 * When all cpus are sleeping (e.g in WFI), to avoid a deadlock 249 * in the main_loop, wake it up in order to start the warp timer. 250 */ 251 qemu_notify_event(); 252 } 253 254 rr_wait_io_event(); 255 rr_deal_with_unplugged_cpus(); 256 } 257 258 rcu_unregister_thread(); 259 return NULL; 260 } 261 262 void rr_start_vcpu_thread(CPUState *cpu) 263 { 264 char thread_name[VCPU_THREAD_NAME_SIZE]; 265 static QemuCond *single_tcg_halt_cond; 266 static QemuThread *single_tcg_cpu_thread; 267 268 g_assert(tcg_enabled()); 269 tcg_cpu_init_cflags(cpu, false); 270 271 if (!single_tcg_cpu_thread) { 272 cpu->thread = g_malloc0(sizeof(QemuThread)); 273 cpu->halt_cond = g_malloc0(sizeof(QemuCond)); 274 qemu_cond_init(cpu->halt_cond); 275 276 /* share a single thread for all cpus with TCG */ 277 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG"); 278 qemu_thread_create(cpu->thread, thread_name, 279 rr_cpu_thread_fn, 280 cpu, QEMU_THREAD_JOINABLE); 281 282 single_tcg_halt_cond = cpu->halt_cond; 283 single_tcg_cpu_thread = cpu->thread; 284 #ifdef _WIN32 285 cpu->hThread = qemu_thread_get_handle(cpu->thread); 286 #endif 287 } else { 288 /* we share the thread */ 289 cpu->thread = single_tcg_cpu_thread; 290 cpu->halt_cond = single_tcg_halt_cond; 291 cpu->thread_id = first_cpu->thread_id; 292 cpu->can_do_io = 1; 293 cpu->created = true; 294 } 295 } 296