diff mbox series

[3/3] arm64/locking: qspinlocks and qrwlocks support

Message ID 20170503145141.4966-4-ynorov@caviumnetworks.com
State New
Headers show
Series arm64: queued spinlocks and rw-locks | expand

Commit Message

Yury Norov May 3, 2017, 2:51 p.m. UTC
From: Jan Glauber <jglauber@cavium.com>


Ported from x86_64 with paravirtualization support removed.

Signed-off-by: Jan Glauber <jglauber@cavium.com>


Note. This patch removes protection from direct inclusion of
arch/arm64/include/asm/spinlock_types.h. It's done because
kernel/locking/qrwlock.c file does it thru the header
include/asm-generic/qrwlock_types.h. Until now the only user
of qrwlock.c was x86, and there's no such protection too.

I'm not happy to remove the protection, but if it's OK for x86,
it should be also OK for arm64. If not, I think we'd fix it
for x86, and add the protection there too.

Yury

Signed-off-by: Yury Norov <ynorov@caviumnetworks.com>

---
 arch/arm64/Kconfig                      | 24 +++++++++++++++++++
 arch/arm64/include/asm/qrwlock.h        |  7 ++++++
 arch/arm64/include/asm/qspinlock.h      | 42 +++++++++++++++++++++++++++++++++
 arch/arm64/include/asm/spinlock.h       | 12 ++++++++++
 arch/arm64/include/asm/spinlock_types.h | 14 ++++++++---
 arch/arm64/kernel/Makefile              |  1 +
 arch/arm64/kernel/qspinlock.c           | 34 ++++++++++++++++++++++++++
 7 files changed, 131 insertions(+), 3 deletions(-)
 create mode 100644 arch/arm64/include/asm/qrwlock.h
 create mode 100644 arch/arm64/include/asm/qspinlock.h
 create mode 100644 arch/arm64/kernel/qspinlock.c

-- 
2.11.0

Comments

Boqun Feng May 9, 2017, 4:47 a.m. UTC | #1
On Wed, May 03, 2017 at 05:51:41PM +0300, Yury Norov wrote:
> From: Jan Glauber <jglauber@cavium.com>

> 

> Ported from x86_64 with paravirtualization support removed.

> 

> Signed-off-by: Jan Glauber <jglauber@cavium.com>

> 

> Note. This patch removes protection from direct inclusion of

> arch/arm64/include/asm/spinlock_types.h. It's done because

> kernel/locking/qrwlock.c file does it thru the header

> include/asm-generic/qrwlock_types.h. Until now the only user

> of qrwlock.c was x86, and there's no such protection too.

> 

> I'm not happy to remove the protection, but if it's OK for x86,

> it should be also OK for arm64. If not, I think we'd fix it

> for x86, and add the protection there too.

> 

> Yury

> 

> Signed-off-by: Yury Norov <ynorov@caviumnetworks.com>

> ---

>  arch/arm64/Kconfig                      | 24 +++++++++++++++++++

>  arch/arm64/include/asm/qrwlock.h        |  7 ++++++

>  arch/arm64/include/asm/qspinlock.h      | 42 +++++++++++++++++++++++++++++++++

>  arch/arm64/include/asm/spinlock.h       | 12 ++++++++++

>  arch/arm64/include/asm/spinlock_types.h | 14 ++++++++---

>  arch/arm64/kernel/Makefile              |  1 +

>  arch/arm64/kernel/qspinlock.c           | 34 ++++++++++++++++++++++++++

>  7 files changed, 131 insertions(+), 3 deletions(-)

>  create mode 100644 arch/arm64/include/asm/qrwlock.h

>  create mode 100644 arch/arm64/include/asm/qspinlock.h

>  create mode 100644 arch/arm64/kernel/qspinlock.c

> 

> diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig

> index 22dbde97eefa..db24b3b3f3c6 100644

> --- a/arch/arm64/Kconfig

> +++ b/arch/arm64/Kconfig

> @@ -25,6 +25,8 @@ config ARM64

>  	select ARCH_WANT_COMPAT_IPC_PARSE_VERSION

>  	select ARCH_WANT_FRAME_POINTERS

>  	select ARCH_HAS_UBSAN_SANITIZE_ALL

> +	select ARCH_USE_QUEUED_RWLOCKS if QUEUED_LOCKS

> +	select ARCH_USE_QUEUED_SPINLOCKS if QUEUED_LOCKS

>  	select ARM_AMBA

>  	select ARM_ARCH_TIMER

>  	select ARM_GIC

> @@ -692,6 +694,28 @@ config ARCH_WANT_HUGE_PMD_SHARE

>  config ARCH_HAS_CACHE_LINE_SIZE

>  	def_bool y

>  

> +choice

> +	prompt "Locking type"

> +	default TICKET_LOCKS

> +	help

> +	  Choose between traditional ticked-based locking mechanism and

> +	  queued-based mechanism.

> +

> +config TICKET_LOCKS

> +	bool "Ticket locks"

> +	help

> +	  Ticked-based locking implementation for ARM64

> +

> +config QUEUED_LOCKS

> +	bool "Queued locks"

> +	help

> +	  Queue-based locking mechanism. This option improves

> +	  locking performance in case of high-contended locking

> +	  on many-cpu machines. On low-cpu machines there is no

> +	  difference comparing to ticked-based locking.

> +

> +endchoice

> +

>  source "mm/Kconfig"

>  

>  config SECCOMP

> diff --git a/arch/arm64/include/asm/qrwlock.h b/arch/arm64/include/asm/qrwlock.h

> new file mode 100644

> index 000000000000..626f6ebfb52d

> --- /dev/null

> +++ b/arch/arm64/include/asm/qrwlock.h

> @@ -0,0 +1,7 @@

> +#ifndef _ASM_ARM64_QRWLOCK_H

> +#define _ASM_ARM64_QRWLOCK_H

> +

> +#include <asm-generic/qrwlock_types.h>

> +#include <asm-generic/qrwlock.h>

> +

> +#endif /* _ASM_ARM64_QRWLOCK_H */

> diff --git a/arch/arm64/include/asm/qspinlock.h b/arch/arm64/include/asm/qspinlock.h

> new file mode 100644

> index 000000000000..09ef4f13f549

> --- /dev/null

> +++ b/arch/arm64/include/asm/qspinlock.h

> @@ -0,0 +1,42 @@

> +#ifndef _ASM_ARM64_QSPINLOCK_H

> +#define _ASM_ARM64_QSPINLOCK_H

> +

> +#include <asm-generic/qspinlock_types.h>

> +#include <asm/atomic.h>

> +

> +extern void queued_spin_unlock_wait(struct qspinlock *lock);

> +#define queued_spin_unlock_wait queued_spin_unlock_wait

> +

> +#define	queued_spin_unlock queued_spin_unlock

> +/**

> + * queued_spin_unlock - release a queued spinlock

> + * @lock : Pointer to queued spinlock structure

> + *

> + * A smp_store_release() on the least-significant byte.

> + */

> +static inline void queued_spin_unlock(struct qspinlock *lock)

> +{

> +	smp_store_release((u8 *)lock, 0);


I think this part will cause endian issues, maybe you want something
like what we do in queued_write_lock().

Have you tested this on an BE environment?

Regards,
Boqun

> +}

> +

> +#define queued_spin_is_locked queued_spin_is_locked

> +/**

> + * queued_spin_is_locked - is the spinlock locked?

> + * @lock: Pointer to queued spinlock structure

> + * Return: 1 if it is locked, 0 otherwise

> + */

> +static __always_inline int queued_spin_is_locked(struct qspinlock *lock)

> +{

> +	/*

> +	 * See queued_spin_unlock_wait().

> +	 *

> +	 * Any !0 state indicates it is locked, even if _Q_LOCKED_VAL

> +	 * isn't immediately observable.

> +	 */

> +	smp_mb();

> +	return atomic_read(&lock->val);

> +}

> +

> +#include <asm-generic/qspinlock.h>

> +

> +#endif /* _ASM_ARM64_QSPINLOCK_H */

> diff --git a/arch/arm64/include/asm/spinlock.h b/arch/arm64/include/asm/spinlock.h

> index cae331d553f8..37713397e0c5 100644

> --- a/arch/arm64/include/asm/spinlock.h

> +++ b/arch/arm64/include/asm/spinlock.h

> @@ -20,6 +20,10 @@

>  #include <asm/spinlock_types.h>

>  #include <asm/processor.h>

>  

> +#ifdef CONFIG_QUEUED_SPINLOCKS

> +#include <asm/qspinlock.h>

> +#else

> +

>  /*

>   * Spinlock implementation.

>   *

> @@ -187,6 +191,12 @@ static inline int arch_spin_is_contended(arch_spinlock_t *lock)

>  }

>  #define arch_spin_is_contended	arch_spin_is_contended

>  

> +#endif /* CONFIG_QUEUED_SPINLOCKS */

> +

> +#ifdef CONFIG_QUEUED_RWLOCKS

> +#include <asm/qrwlock.h>

> +#else

> +

>  /*

>   * Write lock implementation.

>   *

> @@ -351,6 +361,8 @@ static inline int arch_read_trylock(arch_rwlock_t *rw)

>  /* read_can_lock - would read_trylock() succeed? */

>  #define arch_read_can_lock(x)		((x)->lock < 0x80000000)

>  

> +#endif /* CONFIG_QUEUED_RWLOCKS */

> +

>  #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)

>  #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)

>  

> diff --git a/arch/arm64/include/asm/spinlock_types.h b/arch/arm64/include/asm/spinlock_types.h

> index 55be59a35e3f..0f0f1561ab6a 100644

> --- a/arch/arm64/include/asm/spinlock_types.h

> +++ b/arch/arm64/include/asm/spinlock_types.h

> @@ -16,9 +16,9 @@

>  #ifndef __ASM_SPINLOCK_TYPES_H

>  #define __ASM_SPINLOCK_TYPES_H

>  

> -#if !defined(__LINUX_SPINLOCK_TYPES_H) && !defined(__ASM_SPINLOCK_H)

> -# error "please don't include this file directly"

> -#endif

> +#ifdef CONFIG_QUEUED_SPINLOCKS

> +#include <asm-generic/qspinlock_types.h>

> +#else

>  

>  #include <linux/types.h>

>  

> @@ -36,10 +36,18 @@ typedef struct {

>  

>  #define __ARCH_SPIN_LOCK_UNLOCKED	{ 0 , 0 }

>  

> +#endif /* CONFIG_QUEUED_SPINLOCKS */

> +

> +#ifdef CONFIG_QUEUED_RWLOCKS

> +#include <asm-generic/qrwlock_types.h>

> +#else

> +

>  typedef struct {

>  	volatile unsigned int lock;

>  } arch_rwlock_t;

>  

>  #define __ARCH_RW_LOCK_UNLOCKED		{ 0 }

>  

> +#endif /* CONFIG_QUEUED_RWLOCKS */

> +

>  #endif

> diff --git a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile

> index 9d56467dc223..f48f6256e893 100644

> --- a/arch/arm64/kernel/Makefile

> +++ b/arch/arm64/kernel/Makefile

> @@ -56,6 +56,7 @@ arm64-obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o	\

>  arm64-obj-$(CONFIG_ARM64_RELOC_TEST)	+= arm64-reloc-test.o

>  arm64-reloc-test-y := reloc_test_core.o reloc_test_syms.o

>  arm64-obj-$(CONFIG_CRASH_DUMP)		+= crash_dump.o

> +arm64-obj-$(CONFIG_QUEUED_SPINLOCKS)	+= qspinlock.o

>  

>  obj-y					+= $(arm64-obj-y) vdso/ probes/

>  obj-$(CONFIG_ARM64_ILP32)		+= vdso-ilp32/

> diff --git a/arch/arm64/kernel/qspinlock.c b/arch/arm64/kernel/qspinlock.c

> new file mode 100644

> index 000000000000..924f19953adb

> --- /dev/null

> +++ b/arch/arm64/kernel/qspinlock.c

> @@ -0,0 +1,34 @@

> +#include <asm/qspinlock.h>

> +#include <asm/processor.h>

> +

> +void queued_spin_unlock_wait(struct qspinlock *lock)

> +{

> +	u32 val;

> +

> +	for (;;) {

> +		smp_mb();

> +		val = atomic_read(&lock->val);

> +

> +		if (!val) /* not locked, we're done */

> +			goto done;

> +

> +		if (val & _Q_LOCKED_MASK) /* locked, go wait for unlock */

> +			break;

> +

> +		/* not locked, but pending, wait until we observe the lock */

> +		cpu_relax();

> +	}

> +

> +	for (;;) {

> +		smp_mb();

> +		val = atomic_read(&lock->val);

> +		if (!(val & _Q_LOCKED_MASK)) /* any unlock is good */

> +			break;

> +

> +		cpu_relax();

> +	}

> +

> +done:

> +	smp_acquire__after_ctrl_dep();

> +}

> +EXPORT_SYMBOL(queued_spin_unlock_wait);

> -- 

> 2.11.0

>
Yury Norov May 9, 2017, 6:48 p.m. UTC | #2
On Tue, May 09, 2017 at 12:47:08PM +0800, Boqun Feng wrote:
> On Wed, May 03, 2017 at 05:51:41PM +0300, Yury Norov wrote:

> > From: Jan Glauber <jglauber@cavium.com>

> > 

> > Ported from x86_64 with paravirtualization support removed.

> > 

> > Signed-off-by: Jan Glauber <jglauber@cavium.com>

> > 

> > Note. This patch removes protection from direct inclusion of

> > arch/arm64/include/asm/spinlock_types.h. It's done because

> > kernel/locking/qrwlock.c file does it thru the header

> > include/asm-generic/qrwlock_types.h. Until now the only user

> > of qrwlock.c was x86, and there's no such protection too.

> > 

> > I'm not happy to remove the protection, but if it's OK for x86,

> > it should be also OK for arm64. If not, I think we'd fix it

> > for x86, and add the protection there too.

> > 

> > Yury

> > 

> > Signed-off-by: Yury Norov <ynorov@caviumnetworks.com>


[...]

> > +#define	queued_spin_unlock queued_spin_unlock

> > +/**

> > + * queued_spin_unlock - release a queued spinlock

> > + * @lock : Pointer to queued spinlock structure

> > + *

> > + * A smp_store_release() on the least-significant byte.

> > + */

> > +static inline void queued_spin_unlock(struct qspinlock *lock)

> > +{

> > +	smp_store_release((u8 *)lock, 0);

> 

> I think this part will cause endian issues, maybe you want something

> like what we do in queued_write_lock().

> 

> Have you tested this on an BE environment?


No. I think I have to. Thanks for the pointing it.

> 

> Regards,

> Boqun


I think it's just the issue of copying from x86, and there's no any
specific need to cast to u8* type on arm64. So the correct version of
it would be like this, I believe: smp_store_release(&lock->val).

Yury
Yury Norov May 9, 2017, 7:37 p.m. UTC | #3
On Tue, May 09, 2017 at 09:48:29PM +0300, Yury Norov wrote:
> On Tue, May 09, 2017 at 12:47:08PM +0800, Boqun Feng wrote:

> > On Wed, May 03, 2017 at 05:51:41PM +0300, Yury Norov wrote:

> > > From: Jan Glauber <jglauber@cavium.com>

> > > 

> > > Ported from x86_64 with paravirtualization support removed.

> > > 

> > > Signed-off-by: Jan Glauber <jglauber@cavium.com>

> > > 

> > > Note. This patch removes protection from direct inclusion of

> > > arch/arm64/include/asm/spinlock_types.h. It's done because

> > > kernel/locking/qrwlock.c file does it thru the header

> > > include/asm-generic/qrwlock_types.h. Until now the only user

> > > of qrwlock.c was x86, and there's no such protection too.

> > > 

> > > I'm not happy to remove the protection, but if it's OK for x86,

> > > it should be also OK for arm64. If not, I think we'd fix it

> > > for x86, and add the protection there too.

> > > 

> > > Yury

> > > 

> > > Signed-off-by: Yury Norov <ynorov@caviumnetworks.com>

> 

> [...]

> 

> > > +#define	queued_spin_unlock queued_spin_unlock

> > > +/**

> > > + * queued_spin_unlock - release a queued spinlock

> > > + * @lock : Pointer to queued spinlock structure

> > > + *

> > > + * A smp_store_release() on the least-significant byte.

> > > + */

> > > +static inline void queued_spin_unlock(struct qspinlock *lock)

> > > +{

> > > +	smp_store_release((u8 *)lock, 0);

> > 

> > I think this part will cause endian issues, maybe you want something

> > like what we do in queued_write_lock().

> > 

> > Have you tested this on an BE environment?

> 

> No. I think I have to. Thanks for the pointing it.

> 

> > 

> > Regards,

> > Boqun

> 

> I think it's just the issue of copying from x86, and there's no any

> specific need to cast to u8* type on arm64. So the correct version of

> it would be like this, I believe: smp_store_release(&lock->val).

> 

> Yury


Oops, it would rather be like this:

static inline void queued_spin_unlock(struct qspinlock *lock)
{
#if IS_BUILTIN(CONFIG_CPU_BIG_ENDIAN)
       smp_store_release((u8 *) &lock->val + 3, 0);
#else
       smp_store_release((u8 *) &lock->val, 0);
#endif
}

Or with the helper, like here in ppc port:
https://www.spinics.net/lists/linux-virtualization/msg29390.html
diff mbox series

Patch

diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index 22dbde97eefa..db24b3b3f3c6 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -25,6 +25,8 @@  config ARM64
 	select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
 	select ARCH_WANT_FRAME_POINTERS
 	select ARCH_HAS_UBSAN_SANITIZE_ALL
+	select ARCH_USE_QUEUED_RWLOCKS if QUEUED_LOCKS
+	select ARCH_USE_QUEUED_SPINLOCKS if QUEUED_LOCKS
 	select ARM_AMBA
 	select ARM_ARCH_TIMER
 	select ARM_GIC
@@ -692,6 +694,28 @@  config ARCH_WANT_HUGE_PMD_SHARE
 config ARCH_HAS_CACHE_LINE_SIZE
 	def_bool y
 
+choice
+	prompt "Locking type"
+	default TICKET_LOCKS
+	help
+	  Choose between traditional ticked-based locking mechanism and
+	  queued-based mechanism.
+
+config TICKET_LOCKS
+	bool "Ticket locks"
+	help
+	  Ticked-based locking implementation for ARM64
+
+config QUEUED_LOCKS
+	bool "Queued locks"
+	help
+	  Queue-based locking mechanism. This option improves
+	  locking performance in case of high-contended locking
+	  on many-cpu machines. On low-cpu machines there is no
+	  difference comparing to ticked-based locking.
+
+endchoice
+
 source "mm/Kconfig"
 
 config SECCOMP
diff --git a/arch/arm64/include/asm/qrwlock.h b/arch/arm64/include/asm/qrwlock.h
new file mode 100644
index 000000000000..626f6ebfb52d
--- /dev/null
+++ b/arch/arm64/include/asm/qrwlock.h
@@ -0,0 +1,7 @@ 
+#ifndef _ASM_ARM64_QRWLOCK_H
+#define _ASM_ARM64_QRWLOCK_H
+
+#include <asm-generic/qrwlock_types.h>
+#include <asm-generic/qrwlock.h>
+
+#endif /* _ASM_ARM64_QRWLOCK_H */
diff --git a/arch/arm64/include/asm/qspinlock.h b/arch/arm64/include/asm/qspinlock.h
new file mode 100644
index 000000000000..09ef4f13f549
--- /dev/null
+++ b/arch/arm64/include/asm/qspinlock.h
@@ -0,0 +1,42 @@ 
+#ifndef _ASM_ARM64_QSPINLOCK_H
+#define _ASM_ARM64_QSPINLOCK_H
+
+#include <asm-generic/qspinlock_types.h>
+#include <asm/atomic.h>
+
+extern void queued_spin_unlock_wait(struct qspinlock *lock);
+#define queued_spin_unlock_wait queued_spin_unlock_wait
+
+#define	queued_spin_unlock queued_spin_unlock
+/**
+ * queued_spin_unlock - release a queued spinlock
+ * @lock : Pointer to queued spinlock structure
+ *
+ * A smp_store_release() on the least-significant byte.
+ */
+static inline void queued_spin_unlock(struct qspinlock *lock)
+{
+	smp_store_release((u8 *)lock, 0);
+}
+
+#define queued_spin_is_locked queued_spin_is_locked
+/**
+ * queued_spin_is_locked - is the spinlock locked?
+ * @lock: Pointer to queued spinlock structure
+ * Return: 1 if it is locked, 0 otherwise
+ */
+static __always_inline int queued_spin_is_locked(struct qspinlock *lock)
+{
+	/*
+	 * See queued_spin_unlock_wait().
+	 *
+	 * Any !0 state indicates it is locked, even if _Q_LOCKED_VAL
+	 * isn't immediately observable.
+	 */
+	smp_mb();
+	return atomic_read(&lock->val);
+}
+
+#include <asm-generic/qspinlock.h>
+
+#endif /* _ASM_ARM64_QSPINLOCK_H */
diff --git a/arch/arm64/include/asm/spinlock.h b/arch/arm64/include/asm/spinlock.h
index cae331d553f8..37713397e0c5 100644
--- a/arch/arm64/include/asm/spinlock.h
+++ b/arch/arm64/include/asm/spinlock.h
@@ -20,6 +20,10 @@ 
 #include <asm/spinlock_types.h>
 #include <asm/processor.h>
 
+#ifdef CONFIG_QUEUED_SPINLOCKS
+#include <asm/qspinlock.h>
+#else
+
 /*
  * Spinlock implementation.
  *
@@ -187,6 +191,12 @@  static inline int arch_spin_is_contended(arch_spinlock_t *lock)
 }
 #define arch_spin_is_contended	arch_spin_is_contended
 
+#endif /* CONFIG_QUEUED_SPINLOCKS */
+
+#ifdef CONFIG_QUEUED_RWLOCKS
+#include <asm/qrwlock.h>
+#else
+
 /*
  * Write lock implementation.
  *
@@ -351,6 +361,8 @@  static inline int arch_read_trylock(arch_rwlock_t *rw)
 /* read_can_lock - would read_trylock() succeed? */
 #define arch_read_can_lock(x)		((x)->lock < 0x80000000)
 
+#endif /* CONFIG_QUEUED_RWLOCKS */
+
 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
 
diff --git a/arch/arm64/include/asm/spinlock_types.h b/arch/arm64/include/asm/spinlock_types.h
index 55be59a35e3f..0f0f1561ab6a 100644
--- a/arch/arm64/include/asm/spinlock_types.h
+++ b/arch/arm64/include/asm/spinlock_types.h
@@ -16,9 +16,9 @@ 
 #ifndef __ASM_SPINLOCK_TYPES_H
 #define __ASM_SPINLOCK_TYPES_H
 
-#if !defined(__LINUX_SPINLOCK_TYPES_H) && !defined(__ASM_SPINLOCK_H)
-# error "please don't include this file directly"
-#endif
+#ifdef CONFIG_QUEUED_SPINLOCKS
+#include <asm-generic/qspinlock_types.h>
+#else
 
 #include <linux/types.h>
 
@@ -36,10 +36,18 @@  typedef struct {
 
 #define __ARCH_SPIN_LOCK_UNLOCKED	{ 0 , 0 }
 
+#endif /* CONFIG_QUEUED_SPINLOCKS */
+
+#ifdef CONFIG_QUEUED_RWLOCKS
+#include <asm-generic/qrwlock_types.h>
+#else
+
 typedef struct {
 	volatile unsigned int lock;
 } arch_rwlock_t;
 
 #define __ARCH_RW_LOCK_UNLOCKED		{ 0 }
 
+#endif /* CONFIG_QUEUED_RWLOCKS */
+
 #endif
diff --git a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile
index 9d56467dc223..f48f6256e893 100644
--- a/arch/arm64/kernel/Makefile
+++ b/arch/arm64/kernel/Makefile
@@ -56,6 +56,7 @@  arm64-obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o	\
 arm64-obj-$(CONFIG_ARM64_RELOC_TEST)	+= arm64-reloc-test.o
 arm64-reloc-test-y := reloc_test_core.o reloc_test_syms.o
 arm64-obj-$(CONFIG_CRASH_DUMP)		+= crash_dump.o
+arm64-obj-$(CONFIG_QUEUED_SPINLOCKS)	+= qspinlock.o
 
 obj-y					+= $(arm64-obj-y) vdso/ probes/
 obj-$(CONFIG_ARM64_ILP32)		+= vdso-ilp32/
diff --git a/arch/arm64/kernel/qspinlock.c b/arch/arm64/kernel/qspinlock.c
new file mode 100644
index 000000000000..924f19953adb
--- /dev/null
+++ b/arch/arm64/kernel/qspinlock.c
@@ -0,0 +1,34 @@ 
+#include <asm/qspinlock.h>
+#include <asm/processor.h>
+
+void queued_spin_unlock_wait(struct qspinlock *lock)
+{
+	u32 val;
+
+	for (;;) {
+		smp_mb();
+		val = atomic_read(&lock->val);
+
+		if (!val) /* not locked, we're done */
+			goto done;
+
+		if (val & _Q_LOCKED_MASK) /* locked, go wait for unlock */
+			break;
+
+		/* not locked, but pending, wait until we observe the lock */
+		cpu_relax();
+	}
+
+	for (;;) {
+		smp_mb();
+		val = atomic_read(&lock->val);
+		if (!(val & _Q_LOCKED_MASK)) /* any unlock is good */
+			break;
+
+		cpu_relax();
+	}
+
+done:
+	smp_acquire__after_ctrl_dep();
+}
+EXPORT_SYMBOL(queued_spin_unlock_wait);