xref: /qemu/accel/tcg/tcg-accel-ops-rr.c (revision c4b8ffcb) 
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 "sysemu/tcg.h"
28 #include "sysemu/replay.h"
29 #include "sysemu/cpu-timers.h"
30 #include "qemu/main-loop.h"
31 #include "qemu/notify.h"
32 #include "qemu/guest-random.h"
33 #include "exec/exec-all.h"
34 
35 #include "tcg-accel-ops.h"
36 #include "tcg-accel-ops-rr.h"
37 #include "tcg-accel-ops-icount.h"
38 
39 /* Kick all RR vCPUs */
40 void rr_kick_vcpu_thread(CPUState *unused)
41 {
42     CPUState *cpu;
43 
44     CPU_FOREACH(cpu) {
45         cpu_exit(cpu);
46     };
47 }
48 
49 /*
50  * TCG vCPU kick timer
51  *
52  * The kick timer is responsible for moving single threaded vCPU
53  * emulation on to the next vCPU. If more than one vCPU is running a
54  * timer event with force a cpu->exit so the next vCPU can get
55  * scheduled.
56  *
57  * The timer is removed if all vCPUs are idle and restarted again once
58  * idleness is complete.
59  */
60 
61 static QEMUTimer *rr_kick_vcpu_timer;
62 static CPUState *rr_current_cpu;
63 
64 static inline int64_t rr_next_kick_time(void)
65 {
66     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
67 }
68 
69 /* Kick the currently round-robin scheduled vCPU to next */
70 static void rr_kick_next_cpu(void)
71 {
72     CPUState *cpu;
73     do {
74         cpu = qatomic_mb_read(&rr_current_cpu);
75         if (cpu) {
76             cpu_exit(cpu);
77         }
78     } while (cpu != qatomic_mb_read(&rr_current_cpu));
79 }
80 
81 static void rr_kick_thread(void *opaque)
82 {
83     timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
84     rr_kick_next_cpu();
85 }
86 
87 static void rr_start_kick_timer(void)
88 {
89     if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
90         rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
91                                            rr_kick_thread, NULL);
92     }
93     if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) {
94         timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
95     }
96 }
97 
98 static void rr_stop_kick_timer(void)
99 {
100     if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) {
101         timer_del(rr_kick_vcpu_timer);
102     }
103 }
104 
105 static void rr_wait_io_event(void)
106 {
107     CPUState *cpu;
108 
109     while (all_cpu_threads_idle()) {
110         rr_stop_kick_timer();
111         qemu_cond_wait_iothread(first_cpu->halt_cond);
112     }
113 
114     rr_start_kick_timer();
115 
116     CPU_FOREACH(cpu) {
117         qemu_wait_io_event_common(cpu);
118     }
119 }
120 
121 /*
122  * Destroy any remaining vCPUs which have been unplugged and have
123  * finished running
124  */
125 static void rr_deal_with_unplugged_cpus(void)
126 {
127     CPUState *cpu;
128 
129     CPU_FOREACH(cpu) {
130         if (cpu->unplug && !cpu_can_run(cpu)) {
131             tcg_cpus_destroy(cpu);
132             break;
133         }
134     }
135 }
136 
137 static void rr_force_rcu(Notifier *notify, void *data)
138 {
139     rr_kick_next_cpu();
140 }
141 
142 /*
143  * In the single-threaded case each vCPU is simulated in turn. If
144  * there is more than a single vCPU we create a simple timer to kick
145  * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
146  * This is done explicitly rather than relying on side-effects
147  * elsewhere.
148  */
149 
150 static void *rr_cpu_thread_fn(void *arg)
151 {
152     Notifier force_rcu;
153     CPUState *cpu = arg;
154 
155     assert(tcg_enabled());
156     rcu_register_thread();
157     force_rcu.notify = rr_force_rcu;
158     rcu_add_force_rcu_notifier(&force_rcu);
159     tcg_register_thread();
160 
161     qemu_mutex_lock_iothread();
162     qemu_thread_get_self(cpu->thread);
163 
164     cpu->thread_id = qemu_get_thread_id();
165     cpu->can_do_io = 1;
166     cpu_thread_signal_created(cpu);
167     qemu_guest_random_seed_thread_part2(cpu->random_seed);
168 
169     /* wait for initial kick-off after machine start */
170     while (first_cpu->stopped) {
171         qemu_cond_wait_iothread(first_cpu->halt_cond);
172 
173         /* process any pending work */
174         CPU_FOREACH(cpu) {
175             current_cpu = cpu;
176             qemu_wait_io_event_common(cpu);
177         }
178     }
179 
180     rr_start_kick_timer();
181 
182     cpu = first_cpu;
183 
184     /* process any pending work */
185     cpu->exit_request = 1;
186 
187     while (1) {
188         qemu_mutex_unlock_iothread();
189         replay_mutex_lock();
190         qemu_mutex_lock_iothread();
191 
192         if (icount_enabled()) {
193             /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
194             icount_account_warp_timer();
195             /*
196              * Run the timers here.  This is much more efficient than
197              * waking up the I/O thread and waiting for completion.
198              */
199             icount_handle_deadline();
200         }
201 
202         replay_mutex_unlock();
203 
204         if (!cpu) {
205             cpu = first_cpu;
206         }
207 
208         while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
209 
210             qatomic_mb_set(&rr_current_cpu, cpu);
211             current_cpu = cpu;
212 
213             qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
214                               (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
215 
216             if (cpu_can_run(cpu)) {
217                 int r;
218 
219                 qemu_mutex_unlock_iothread();
220                 if (icount_enabled()) {
221                     icount_prepare_for_run(cpu);
222                 }
223                 r = tcg_cpus_exec(cpu);
224                 if (icount_enabled()) {
225                     icount_process_data(cpu);
226                 }
227                 qemu_mutex_lock_iothread();
228 
229                 if (r == EXCP_DEBUG) {
230                     cpu_handle_guest_debug(cpu);
231                     break;
232                 } else if (r == EXCP_ATOMIC) {
233                     qemu_mutex_unlock_iothread();
234                     cpu_exec_step_atomic(cpu);
235                     qemu_mutex_lock_iothread();
236                     break;
237                 }
238             } else if (cpu->stop) {
239                 if (cpu->unplug) {
240                     cpu = CPU_NEXT(cpu);
241                 }
242                 break;
243             }
244 
245             cpu = CPU_NEXT(cpu);
246         } /* while (cpu && !cpu->exit_request).. */
247 
248         /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
249         qatomic_set(&rr_current_cpu, NULL);
250 
251         if (cpu && cpu->exit_request) {
252             qatomic_mb_set(&cpu->exit_request, 0);
253         }
254 
255         if (icount_enabled() && all_cpu_threads_idle()) {
256             /*
257              * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
258              * in the main_loop, wake it up in order to start the warp timer.
259              */
260             qemu_notify_event();
261         }
262 
263         rr_wait_io_event();
264         rr_deal_with_unplugged_cpus();
265     }
266 
267     rcu_remove_force_rcu_notifier(&force_rcu);
268     rcu_unregister_thread();
269     return NULL;
270 }
271 
272 void rr_start_vcpu_thread(CPUState *cpu)
273 {
274     char thread_name[VCPU_THREAD_NAME_SIZE];
275     static QemuCond *single_tcg_halt_cond;
276     static QemuThread *single_tcg_cpu_thread;
277 
278     g_assert(tcg_enabled());
279     tcg_cpu_init_cflags(cpu, false);
280 
281     if (!single_tcg_cpu_thread) {
282         cpu->thread = g_new0(QemuThread, 1);
283         cpu->halt_cond = g_new0(QemuCond, 1);
284         qemu_cond_init(cpu->halt_cond);
285 
286         /* share a single thread for all cpus with TCG */
287         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
288         qemu_thread_create(cpu->thread, thread_name,
289                            rr_cpu_thread_fn,
290                            cpu, QEMU_THREAD_JOINABLE);
291 
292         single_tcg_halt_cond = cpu->halt_cond;
293         single_tcg_cpu_thread = cpu->thread;
294 #ifdef _WIN32
295         cpu->hThread = qemu_thread_get_handle(cpu->thread);
296 #endif
297     } else {
298         /* we share the thread */
299         cpu->thread = single_tcg_cpu_thread;
300         cpu->halt_cond = single_tcg_halt_cond;
301         cpu->thread_id = first_cpu->thread_id;
302         cpu->can_do_io = 1;
303         cpu->created = true;
304     }
305 }
306