--- initial
+++ final
@@ -1,104 +1,104 @@
 static int kvmppc_run_vcpu(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) {
   int n_ceded, i, r;
   struct kvmppc_vcore *vc;
   struct kvm_vcpu *v;
   trace_kvmppc_run_vcpu_enter(vcpu);
   kvm_run->exit_reason = 0;
   vcpu->arch.ret = RESUME_GUEST;
   vcpu->arch.trap = 0;
   kvmppc_update_vpas(vcpu);
   /*
    * Synchronize with other threads in this virtual core
    */
   vc = vcpu->arch.vcore;
   spin_lock(&vc->lock);
   vcpu->arch.ceded = 0;
   vcpu->arch.run_task = current;
   vcpu->arch.kvm_run = kvm_run;
   vcpu->arch.stolen_logged = vcore_stolen_time(vc, mftb());
   vcpu->arch.state = KVMPPC_VCPU_RUNNABLE;
   vcpu->arch.busy_preempt = TB_NIL;
   WRITE_ONCE(vc->runnable_threads[vcpu->arch.ptid], vcpu);
   ++vc->n_runnable;
   /*
    * This happens the first time this is called for a vcpu.
    * If the vcore is already running, we may be able to start
    * this thread straight away and have it join in.
    */
   if (!signal_pending(current)) {
     if ((vc->vcore_state == VCORE_PIGGYBACK || vc->vcore_state == VCORE_RUNNING) && !VCORE_IS_EXITING(vc)) {
       kvmppc_create_dtl_entry(vcpu, vc);
       kvmppc_start_thread(vcpu, vc);
       trace_kvm_guest_enter(vcpu);
     } else if (vc->vcore_state == VCORE_SLEEPING) {
-      swake_up(&vc->wq);
+      swake_up_one(&vc->wq);
     }
   }
   while (vcpu->arch.state == KVMPPC_VCPU_RUNNABLE && !signal_pending(current)) {
     /* See if the MMU is ready to go */
     if (!vcpu->kvm->arch.mmu_ready) {
       spin_unlock(&vc->lock);
       r = kvmhv_setup_mmu(vcpu);
       spin_lock(&vc->lock);
       if (r) {
         kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
         kvm_run->fail_entry.hardware_entry_failure_reason = 0;
         vcpu->arch.ret = r;
         break;
       }
     }
     if (vc->vcore_state == VCORE_PREEMPT && vc->runner == NULL) kvmppc_vcore_end_preempt(vc);
     if (vc->vcore_state != VCORE_INACTIVE) {
       kvmppc_wait_for_exec(vc, vcpu, TASK_INTERRUPTIBLE);
       continue;
     }
     for_each_runnable_thread(i, v, vc) {
       kvmppc_core_prepare_to_enter(v);
       if (signal_pending(v->arch.run_task)) {
         kvmppc_remove_runnable(vc, v);
         v->stat.signal_exits++;
         v->arch.kvm_run->exit_reason = KVM_EXIT_INTR;
         v->arch.ret = -EINTR;
         wake_up(&v->arch.cpu_run);
       }
     }
     if (!vc->n_runnable || vcpu->arch.state != KVMPPC_VCPU_RUNNABLE) break;
     n_ceded = 0;
     for_each_runnable_thread(i, v, vc) {
       if (!kvmppc_vcpu_woken(v))
         n_ceded += v->arch.ceded;
       else
         v->arch.ceded = 0;
     }
     vc->runner = vcpu;
     if (n_ceded == vc->n_runnable) {
       kvmppc_vcore_blocked(vc);
     } else if (need_resched()) {
       kvmppc_vcore_preempt(vc);
       /* Let something else run */
       cond_resched_lock(&vc->lock);
       if (vc->vcore_state == VCORE_PREEMPT) kvmppc_vcore_end_preempt(vc);
     } else {
       kvmppc_run_core(vc);
     }
     vc->runner = NULL;
   }
   while (vcpu->arch.state == KVMPPC_VCPU_RUNNABLE && (vc->vcore_state == VCORE_RUNNING || vc->vcore_state == VCORE_EXITING || vc->vcore_state == VCORE_PIGGYBACK))
     kvmppc_wait_for_exec(vc, vcpu, TASK_UNINTERRUPTIBLE);
   if (vc->vcore_state == VCORE_PREEMPT && vc->runner == NULL) kvmppc_vcore_end_preempt(vc);
   if (vcpu->arch.state == KVMPPC_VCPU_RUNNABLE) {
     kvmppc_remove_runnable(vc, vcpu);
     vcpu->stat.signal_exits++;
     kvm_run->exit_reason = KVM_EXIT_INTR;
     vcpu->arch.ret = -EINTR;
   }
   if (vc->n_runnable && vc->vcore_state == VCORE_INACTIVE) {
     /* Wake up some vcpu to run the core */
     i = -1;
     v = next_runnable_thread(vc, &i);
     wake_up(&v->arch.cpu_run);
   }
   trace_kvmppc_run_vcpu_exit(vcpu, kvm_run);
   spin_unlock(&vc->lock);
   return vcpu->arch.ret;
 }<sep>@@
expression e;
@@
-               swake_up
+               swake_up_one
			(e)