Merge branch 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull locking and atomic updates from Ingo Molnar:
 "Main changes in this cycle are:

   - Extend atomic primitives with coherent logic op primitives
     (atomic_{or,and,xor}()) and deprecate the old partial APIs
     (atomic_{set,clear}_mask())

     The old ops were incoherent with incompatible signatures across
     architectures and with incomplete support.  Now every architecture
     supports the primitives consistently (by Peter Zijlstra)

   - Generic support for 'relaxed atomics':

       - _acquire/release/relaxed() flavours of xchg(), cmpxchg() and {add,sub}_return()
       - atomic_read_acquire()
       - atomic_set_release()

     This came out of porting qwrlock code to arm64 (by Will Deacon)

   - Clean up the fragile static_key APIs that were causing repeat bugs,
     by introducing a new one:

       DEFINE_STATIC_KEY_TRUE(name);
       DEFINE_STATIC_KEY_FALSE(name);

     which define a key of different types with an initial true/false
     value.

     Then allow:

       static_branch_likely()
       static_branch_unlikely()

     to take a key of either type and emit the right instruction for the
     case.  To be able to know the 'type' of the static key we encode it
     in the jump entry (by Peter Zijlstra)

   - Static key self-tests (by Jason Baron)

   - qrwlock optimizations (by Waiman Long)

   - small futex enhancements (by Davidlohr Bueso)

   - ... and misc other changes"

* 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (63 commits)
  jump_label/x86: Work around asm build bug on older/backported GCCs
  locking, ARM, atomics: Define our SMP atomics in terms of _relaxed() operations
  locking, include/llist: Use linux/atomic.h instead of asm/cmpxchg.h
  locking/qrwlock: Make use of _{acquire|release|relaxed}() atomics
  locking/qrwlock: Implement queue_write_unlock() using smp_store_release()
  locking/lockref: Remove homebrew cmpxchg64_relaxed() macro definition
  locking, asm-generic: Add _{relaxed|acquire|release}() variants for 'atomic_long_t'
  locking, asm-generic: Rework atomic-long.h to avoid bulk code duplication
  locking/atomics: Add _{acquire|release|relaxed}() variants of some atomic operations
  locking, compiler.h: Cast away attributes in the WRITE_ONCE() magic
  locking/static_keys: Make verify_keys() static
  jump label, locking/static_keys: Update docs
  locking/static_keys: Provide a selftest
  jump_label: Provide a self-test
  s390/uaccess, locking/static_keys: employ static_branch_likely()
  x86, tsc, locking/static_keys: Employ static_branch_likely()
  locking/static_keys: Add selftest
  locking/static_keys: Add a new static_key interface
  locking/static_keys: Rework update logic
  locking/static_keys: Add static_key_{en,dis}able() helpers
  ...

2 files changed, 31 insertions, 31 deletions

diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index b277d50dcf76..5c2c169395c3 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -173,20 +173,20 @@ static unsigned long deliverable_irqs(struct kvm_vcpu *vcpu)
 
 static void __set_cpu_idle(struct kvm_vcpu *vcpu)
 {
-        atomic_set_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
         set_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
 }
 
 static void __unset_cpu_idle(struct kvm_vcpu *vcpu)
 {
-        atomic_clear_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
+        atomic_andnot(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
         clear_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
 }
 
 static void __reset_intercept_indicators(struct kvm_vcpu *vcpu)
 {
-        atomic_clear_mask(CPUSTAT_IO_INT | CPUSTAT_EXT_INT | CPUSTAT_STOP_INT,
-                          &vcpu->arch.sie_block->cpuflags);
+        atomic_andnot(CPUSTAT_IO_INT | CPUSTAT_EXT_INT | CPUSTAT_STOP_INT,
+                    &vcpu->arch.sie_block->cpuflags);
         vcpu->arch.sie_block->lctl = 0x0000;
         vcpu->arch.sie_block->ictl &= ~(ICTL_LPSW | ICTL_STCTL | ICTL_PINT);
 
@@ -199,7 +199,7 @@ static void __reset_intercept_indicators(struct kvm_vcpu *vcpu)
 
 static void __set_cpuflag(struct kvm_vcpu *vcpu, u32 flag)
 {
-        atomic_set_mask(flag, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(flag, &vcpu->arch.sie_block->cpuflags);
 }
 
 static void set_intercept_indicators_io(struct kvm_vcpu *vcpu)
@@ -928,7 +928,7 @@ void kvm_s390_clear_local_irqs(struct kvm_vcpu *vcpu)
         spin_unlock(&li->lock);
 
         /* clear pending external calls set by sigp interpretation facility */
-        atomic_clear_mask(CPUSTAT_ECALL_PEND, li->cpuflags);
+        atomic_andnot(CPUSTAT_ECALL_PEND, li->cpuflags);
         vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sigp_ctrl = 0;
 }
 
@@ -1026,7 +1026,7 @@ static int __inject_pfault_init(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
 
         li->irq.ext = irq->u.ext;
         set_bit(IRQ_PEND_PFAULT_INIT, &li->pending_irqs);
-        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
         return 0;
 }
 
@@ -1041,7 +1041,7 @@ static int __inject_extcall_sigpif(struct kvm_vcpu *vcpu, uint16_t src_id)
                 /* another external call is pending */
                 return -EBUSY;
         }
-        atomic_set_mask(CPUSTAT_ECALL_PEND, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(CPUSTAT_ECALL_PEND, &vcpu->arch.sie_block->cpuflags);
         return 0;
 }
 
@@ -1067,7 +1067,7 @@ static int __inject_extcall(struct kvm_vcpu *vcpu, struct kvm_s390_irq *irq)
         if (test_and_set_bit(IRQ_PEND_EXT_EXTERNAL, &li->pending_irqs))
                 return -EBUSY;
         *extcall = irq->u.extcall;
-        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
         return 0;
 }
 
@@ -1139,7 +1139,7 @@ static int __inject_sigp_emergency(struct kvm_vcpu *vcpu,
 
         set_bit(irq->u.emerg.code, li->sigp_emerg_pending);
         set_bit(IRQ_PEND_EXT_EMERGENCY, &li->pending_irqs);
-        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
         return 0;
 }
 
@@ -1183,7 +1183,7 @@ static int __inject_ckc(struct kvm_vcpu *vcpu)
                                    0, 0);
 
         set_bit(IRQ_PEND_EXT_CLOCK_COMP, &li->pending_irqs);
-        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
         return 0;
 }
 
@@ -1196,7 +1196,7 @@ static int __inject_cpu_timer(struct kvm_vcpu *vcpu)
                                    0, 0);
 
         set_bit(IRQ_PEND_EXT_CPU_TIMER, &li->pending_irqs);
-        atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+        atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
         return 0;
 }
 
@@ -1375,13 +1375,13 @@ static void __floating_irq_kick(struct kvm *kvm, u64 type)
         spin_lock(&li->lock);
         switch (type) {
         case KVM_S390_MCHK:
-                atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
+                atomic_or(CPUSTAT_STOP_INT, li->cpuflags);
                 break;
         case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:
-                atomic_set_mask(CPUSTAT_IO_INT, li->cpuflags);
+                atomic_or(CPUSTAT_IO_INT, li->cpuflags);
                 break;
         default:
-                atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
+                atomic_or(CPUSTAT_EXT_INT, li->cpuflags);
                 break;
         }
         spin_unlock(&li->lock);
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index 98df53c01343..c91eb941b444 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -1333,12 +1333,12 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
         save_access_regs(vcpu->arch.host_acrs);
         restore_access_regs(vcpu->run->s.regs.acrs);
         gmap_enable(vcpu->arch.gmap);
-        atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
 }
 
 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 {
-        atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
+        atomic_andnot(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
         gmap_disable(vcpu->arch.gmap);
 
         save_fpu_regs();
@@ -1443,9 +1443,9 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
                                                     CPUSTAT_STOPPED);
 
         if (test_kvm_facility(vcpu->kvm, 78))
-                atomic_set_mask(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags);
+                atomic_or(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags);
         else if (test_kvm_facility(vcpu->kvm, 8))
-                atomic_set_mask(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags);
+                atomic_or(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags);
 
         kvm_s390_vcpu_setup_model(vcpu);
 
@@ -1557,24 +1557,24 @@ int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
 
 void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu)
 {
-        atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
+        atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
         exit_sie(vcpu);
 }
 
 void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu)
 {
-        atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
+        atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
 }
 
 static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu)
 {
-        atomic_set_mask(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
+        atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
         exit_sie(vcpu);
 }
 
 static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu)
 {
-        atomic_clear_mask(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
+        atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
 }
 
 /*
@@ -1583,7 +1583,7 @@ static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu)
  * return immediately. */
 void exit_sie(struct kvm_vcpu *vcpu)
 {
-        atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
         while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
                 cpu_relax();
 }
@@ -1807,19 +1807,19 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
         if (dbg->control & KVM_GUESTDBG_ENABLE) {
                 vcpu->guest_debug = dbg->control;
                 /* enforce guest PER */
-                atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+                atomic_or(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
 
                 if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
                         rc = kvm_s390_import_bp_data(vcpu, dbg);
         } else {
-                atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+                atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
                 vcpu->arch.guestdbg.last_bp = 0;
         }
 
         if (rc) {
                 vcpu->guest_debug = 0;
                 kvm_s390_clear_bp_data(vcpu);
-                atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
+                atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
         }
 
         return rc;
@@ -1894,7 +1894,7 @@ retry:
         if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
                 if (!ibs_enabled(vcpu)) {
                         trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
-                        atomic_set_mask(CPUSTAT_IBS,
+                        atomic_or(CPUSTAT_IBS,
                                         &vcpu->arch.sie_block->cpuflags);
                 }
                 goto retry;
@@ -1903,7 +1903,7 @@ retry:
         if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
                 if (ibs_enabled(vcpu)) {
                         trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
-                        atomic_clear_mask(CPUSTAT_IBS,
+                        atomic_andnot(CPUSTAT_IBS,
                                           &vcpu->arch.sie_block->cpuflags);
                 }
                 goto retry;
@@ -2419,7 +2419,7 @@ void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
                 __disable_ibs_on_all_vcpus(vcpu->kvm);
         }
 
-        atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
+        atomic_andnot(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
         /*
          * Another VCPU might have used IBS while we were offline.
          * Let's play safe and flush the VCPU at startup.
@@ -2445,7 +2445,7 @@ void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
         /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
         kvm_s390_clear_stop_irq(vcpu);
 
-        atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
+        atomic_or(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
         __disable_ibs_on_vcpu(vcpu);
 
         for (i = 0; i < online_vcpus; i++) {