/ - Diff - qemu - Greek Research and Technology Network's projects

Revision cc84de95

             kvm_arch_post_run(env, run);
             if (ret == -EINTR || ret == -EAGAIN) {
                 cpu_exit(env);
                 dprintf("io window exit\n");
                 ret = 0;
                 break;
-...
+    {
+    }
     #endif /* !KVM_CAP_SET_GUEST_DEBUG */
     int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset)
+    {
         struct kvm_signal_mask *sigmask;
         int r;
         if (!sigset)
             return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
         sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
         sigmask->len = 8;
         memcpy(sigmask->sigset, sigset, sizeof(*sigset));
         r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
         free(sigmask);
         return r;
+    }

b/kvm.h
53	53	target_ulong len, int type);
54	54	void kvm_remove_all_breakpoints(CPUState *current_env);
55	55	int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap);
	56	int kvm_set_signal_mask(CPUState env, const sigset_t sigset);
56	57
57	58	int kvm_pit_in_kernel(void);
58	59	int kvm_irqchip_in_kernel(void);

     static QEMUBootSetHandler *boot_set_handler;
     static void *boot_set_opaque;
     #ifdef SIGRTMIN
     #define SIG_IPI (SIGRTMIN+4)
     #else
     #define SIG_IPI SIGUSR1
     #endif
     static int default_serial = 1;
     static int default_parallel = 1;
     static int default_virtcon = 1;
-...
     static QemuCond qemu_system_cond;
     static QemuCond qemu_pause_cond;
     static void block_io_signals(void);
     static void tcg_block_io_signals(void);
     static void kvm_block_io_signals(CPUState *env);
     static void unblock_io_signals(void);
     static int tcg_has_work(void);
     static int cpu_has_work(CPUState *env);
-...
         qemu_wait_io_event_common(env);
+    }
     static void qemu_kvm_eat_signal(CPUState *env, int timeout)
+    {
         struct timespec ts;
         int r, e;
         siginfo_t siginfo;
         sigset_t waitset;
         ts.tv_sec = timeout / 1000;
         ts.tv_nsec = (timeout % 1000) * 1000000;
         sigemptyset(&waitset);
         sigaddset(&waitset, SIG_IPI);
         qemu_mutex_unlock(&qemu_global_mutex);
         r = sigtimedwait(&waitset, &siginfo, &ts);
         e = errno;
         qemu_mutex_lock(&qemu_global_mutex);
         if (r == -1 && !(e == EAGAIN || e == EINTR)) {
             fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
             exit(1);
+        }
+    }
     static void qemu_kvm_wait_io_event(CPUState *env)
+    {
         while (!cpu_has_work(env))
             qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
         qemu_kvm_eat_signal(env, 0);
         qemu_wait_io_event_common(env);
+    }
-...
+    {
         CPUState *env = arg;
         block_io_signals();
         qemu_thread_self(env->thread);
         if (kvm_enabled())
             kvm_init_vcpu(env);
         kvm_block_io_signals(env);
         /* signal CPU creation */
         qemu_mutex_lock(&qemu_global_mutex);
         env->created = 1;
-...
+    {
         CPUState *env = arg;
         block_io_signals();
         tcg_block_io_signals();
         qemu_thread_self(env->thread);
         /* signal CPU creation */
-...
         CPUState *env = _env;
         qemu_cond_broadcast(env->halt_cond);
         if (kvm_enabled())
             qemu_thread_signal(env->thread, SIGUSR1);
             qemu_thread_signal(env->thread, SIG_IPI);
+    }
     int qemu_cpu_self(void *_env)
-...
             cpu_exit(cpu_single_env);
+    }
     static void block_io_signals(void)
     static void tcg_block_io_signals(void)
+    {
         sigset_t set;
         struct sigaction sigact;
-...
         pthread_sigmask(SIG_BLOCK, &set, NULL);
         sigemptyset(&set);
         sigaddset(&set, SIGUSR1);
         sigaddset(&set, SIG_IPI);
         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
         memset(&sigact, 0, sizeof(sigact));
         sigact.sa_handler = cpu_signal;
         sigaction(SIGUSR1, &sigact, NULL);
         sigaction(SIG_IPI, &sigact, NULL);
+    }
     static void dummy_signal(int sig)
+    {
+    }
     static void kvm_block_io_signals(CPUState *env)
+    {
         int r;
         sigset_t set;
         struct sigaction sigact;
         sigemptyset(&set);
         sigaddset(&set, SIGUSR2);
         sigaddset(&set, SIGIO);
         sigaddset(&set, SIGALRM);
         sigaddset(&set, SIGCHLD);
         sigaddset(&set, SIG_IPI);
         pthread_sigmask(SIG_BLOCK, &set, NULL);
         pthread_sigmask(SIG_BLOCK, NULL, &set);
         sigdelset(&set, SIG_IPI);
         memset(&sigact, 0, sizeof(sigact));
         sigact.sa_handler = dummy_signal;
         sigaction(SIG_IPI, &sigact, NULL);
         r = kvm_set_signal_mask(env, &set);
         if (r) {
             fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
             exit(1);
+        }
+    }
     static void unblock_io_signals(void)
-...
         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
         sigemptyset(&set);
         sigaddset(&set, SIGUSR1);
         sigaddset(&set, SIG_IPI);
         pthread_sigmask(SIG_BLOCK, &set, NULL);
+    }
-...
         qemu_mutex_lock(&qemu_fair_mutex);
         while (qemu_mutex_trylock(&qemu_global_mutex)) {
             qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
             qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
             if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
                 break;
+        }
-...
         while (penv) {
             penv->stop = 1;
             qemu_thread_signal(penv->thread, SIGUSR1);
             qemu_thread_signal(penv->thread, SIG_IPI);
             qemu_cpu_kick(penv);
             penv = (CPUState *)penv->next_cpu;
+        }
-...
             qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
             penv = first_cpu;
             while (penv) {
                 qemu_thread_signal(penv->thread, SIGUSR1);
                 qemu_thread_signal(penv->thread, SIG_IPI);
                 penv = (CPUState *)penv->next_cpu;
+            }
+        }
-...
         while (penv) {
             penv->stop = 0;
             penv->stopped = 0;
             qemu_thread_signal(penv->thread, SIGUSR1);
             qemu_thread_signal(penv->thread, SIG_IPI);
             qemu_cpu_kick(penv);
             penv = (CPUState *)penv->next_cpu;
+        }

Also available in: Unified diff

Archipelago » qemu

Revision cc84de95