1 files changed, 113 insertions, 0 deletions
diff --git a/include/asm-x86_64/mutex.h b/include/asm-x86_64/mutex.h
new file mode 100644
index 000000000000..818abfd262d1
--- /dev/null
+++ b/include/asm-x86_64/mutex.h
@@ -0,0 +1,113 @@
+/*
+ * Assembly implementation of the mutex fastpath, based on atomic
+ * decrement/increment.
+ *
+ * started by Ingo Molnar:
+ *
+ *  Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ */
+#ifndef _ASM_MUTEX_H
+#define _ASM_MUTEX_H
+/**
+ * __mutex_fastpath_lock - decrement and call function if negative
+ * @v: pointer of type atomic_t
+ * @fail_fn: function to call if the result is negative
+ *
+ * Atomically decrements @v and calls <fail_fn> if the result is negative.
+ */
+#define __mutex_fastpath_lock(v, fail_fn)                               \
+do {                                                                    \
+        unsigned long dummy;                                            \
+                                                                        \
+        typecheck(atomic_t *, v);                                       \
+        typecheck_fn(fastcall void (*)(atomic_t *), fail_fn);           \
+                                                                        \
+        __asm__ __volatile__(                                           \
+                LOCK    "   decl (%%rdi)        \n"                     \
+                        "   js 2f               \n"                     \
+                        "1:                     \n"                     \
+                                                                        \
+                LOCK_SECTION_START("")                                  \
+                        "2: call "#fail_fn"     \n"                     \
+                        "   jmp 1b              \n"                     \
+                LOCK_SECTION_END                                        \
+                                                                        \
+                :"=D" (dummy)                                           \
+                : "D" (v)                                               \
+                : "rax", "rsi", "rdx", "rcx",                           \
+                  "r8", "r9", "r10", "r11", "memory");                  \
+} while (0)
+/**
+ *  __mutex_fastpath_lock_retval - try to take the lock by moving the count
+ *                                 from 1 to a 0 value
+ *  @count: pointer of type atomic_t
+ *  @fail_fn: function to call if the original value was not 1
+ *
+ * Change the count from 1 to a value lower than 1, and call <fail_fn> if
+ * it wasn't 1 originally. This function returns 0 if the fastpath succeeds,
+ * or anything the slow path function returns
+ */
+static inline int
+__mutex_fastpath_lock_retval(atomic_t *count,
+                             int fastcall (*fail_fn)(atomic_t *))
+{
+        if (unlikely(atomic_dec_return(count) < 0))
+                return fail_fn(count);
+        else
+                return 0;
+}
+/**
+ * __mutex_fastpath_unlock - increment and call function if nonpositive
+ * @v: pointer of type atomic_t
+ * @fail_fn: function to call if the result is nonpositive
+ *
+ * Atomically increments @v and calls <fail_fn> if the result is nonpositive.
+ */
+#define __mutex_fastpath_unlock(v, fail_fn)                             \
+do {                                                                    \
+        unsigned long dummy;                                            \
+                                                                        \
+        typecheck(atomic_t *, v);                                       \
+        typecheck_fn(fastcall void (*)(atomic_t *), fail_fn);           \
+                                                                        \
+        __asm__ __volatile__(                                           \
+                LOCK    "   incl (%%rdi)        \n"                     \
+                        "   jle 2f              \n"                     \
+                        "1:                     \n"                     \
+                                                                        \
+                LOCK_SECTION_START("")                                  \
+                        "2: call "#fail_fn"     \n"                     \
+                        "   jmp 1b              \n"                     \
+                LOCK_SECTION_END                                        \
+                                                                        \
+                :"=D" (dummy)                                           \
+                : "D" (v)                                               \
+                : "rax", "rsi", "rdx", "rcx",                           \
+                  "r8", "r9", "r10", "r11", "memory");                  \
+} while (0)
+#define __mutex_slowpath_needs_to_unlock()      1
+/**
+ * __mutex_fastpath_trylock - try to acquire the mutex, without waiting
+ *
+ *  @count: pointer of type atomic_t
+ *  @fail_fn: fallback function
+ *
+ * Change the count from 1 to 0 and return 1 (success), or return 0 (failure)
+ * if it wasn't 1 originally. [the fallback function is never used on
+ * x86_64, because all x86_64 CPUs have a CMPXCHG instruction.]
+ */
+static inline int
+__mutex_fastpath_trylock(atomic_t *count, int (*fail_fn)(atomic_t *))
+{
+        if (likely(atomic_cmpxchg(count, 1, 0)) == 1)
+                return 1;
+        else
+                return 0;
+}
+#endif

diff --git a/include/asm-x86_64/mutex.h b/include/asm-x86_64/mutex.h new file mode 100644 index 000000000000..818abfd262d1 --- /dev/null +++ b/include/asm-x86_64/mutex.h
@@ -0,0 +1,113 @@
	1	/*
	2	* Assembly implementation of the mutex fastpath, based on atomic
	3	* decrement/increment.
	4	*
	5	* started by Ingo Molnar:
	6	*
	7	* Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
	8	*/
	9	#ifndef _ASM_MUTEX_H
	10	#define _ASM_MUTEX_H
	11
	12	/**
	13	* __mutex_fastpath_lock - decrement and call function if negative
	14	* @v: pointer of type atomic_t
	15	* @fail_fn: function to call if the result is negative
	16	*
	17	* Atomically decrements @v and calls <fail_fn> if the result is negative.
	18	*/
	19	#define __mutex_fastpath_lock(v, fail_fn) \
	20	do { \
	21	unsigned long dummy; \
	22	\
	23	typecheck(atomic_t *, v); \
	24	typecheck_fn(fastcall void ()(atomic_t ), fail_fn); \
	25	\
	26	__asm__ __volatile__( \
	27	LOCK " decl (%%rdi) \n" \
	28	" js 2f \n" \
	29	"1: \n" \
	30	\
	31	LOCK_SECTION_START("") \
	32	"2: call "#fail_fn" \n" \
	33	" jmp 1b \n" \
	34	LOCK_SECTION_END \
	35	\
	36	:"=D" (dummy) \
	37	: "D" (v) \
	38	: "rax", "rsi", "rdx", "rcx", \
	39	"r8", "r9", "r10", "r11", "memory"); \
	40	} while (0)
	41
	42	/**
	43	* __mutex_fastpath_lock_retval - try to take the lock by moving the count
	44	* from 1 to a 0 value
	45	* @count: pointer of type atomic_t
	46	* @fail_fn: function to call if the original value was not 1
	47	*
	48	* Change the count from 1 to a value lower than 1, and call <fail_fn> if
	49	* it wasn't 1 originally. This function returns 0 if the fastpath succeeds,
	50	* or anything the slow path function returns
	51	*/
	52	static inline int
	53	__mutex_fastpath_lock_retval(atomic_t *count,
	54	int fastcall (fail_fn)(atomic_t ))
	55	{
	56	if (unlikely(atomic_dec_return(count) < 0))
	57	return fail_fn(count);
	58	else
	59	return 0;
	60	}
	61
	62	/**
	63	* __mutex_fastpath_unlock - increment and call function if nonpositive
	64	* @v: pointer of type atomic_t
	65	* @fail_fn: function to call if the result is nonpositive
	66	*
	67	* Atomically increments @v and calls <fail_fn> if the result is nonpositive.
	68	*/
	69	#define __mutex_fastpath_unlock(v, fail_fn) \
	70	do { \
	71	unsigned long dummy; \
	72	\
	73	typecheck(atomic_t *, v); \
	74	typecheck_fn(fastcall void ()(atomic_t ), fail_fn); \
	75	\
	76	__asm__ __volatile__( \
	77	LOCK " incl (%%rdi) \n" \
	78	" jle 2f \n" \
	79	"1: \n" \
	80	\
	81	LOCK_SECTION_START("") \
	82	"2: call "#fail_fn" \n" \
	83	" jmp 1b \n" \
	84	LOCK_SECTION_END \
	85	\
	86	:"=D" (dummy) \
	87	: "D" (v) \
	88	: "rax", "rsi", "rdx", "rcx", \
	89	"r8", "r9", "r10", "r11", "memory"); \
	90	} while (0)
	91
	92	#define __mutex_slowpath_needs_to_unlock() 1
	93
	94	/**
	95	* __mutex_fastpath_trylock - try to acquire the mutex, without waiting
	96	*
	97	* @count: pointer of type atomic_t
	98	* @fail_fn: fallback function
	99	*
	100	* Change the count from 1 to 0 and return 1 (success), or return 0 (failure)
	101	* if it wasn't 1 originally. [the fallback function is never used on
	102	* x86_64, because all x86_64 CPUs have a CMPXCHG instruction.]
	103	*/
	104	static inline int
	105	__mutex_fastpath_trylock(atomic_t count, int (fail_fn)(atomic_t *))
	106	{
	107	if (likely(atomic_cmpxchg(count, 1, 0)) == 1)
	108	return 1;
	109	else
	110	return 0;
	111	}
	112
	113	#endif