[PATCH v4 0/7] <asm/atomic.h> adjustments

[PATCH v4 0/7] <asm/atomic.h> adjustments

[Corneliu ZUZU]

Corneliu ZUZU (7):
  1/7: asm-arm/atomic.h: fix arm32|arm64 macros duplication
    Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
    Changed:
        * update README.LinuxPrimitives file

  2/7: asm-x86/atomic.h: minor: proper atomic_inc_and_test() placement
    Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
    Changed: <nothing>

  3/7: asm-arm/atomic.h: reorder macros to match x86-side
    Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
    Changed: <nothing>

  4/7: asm/atomic.h: common prototyping (add xen/atomic.h)
    Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
    Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
    Changed:
        * update README.LinuxPrimitives file

  5/7: xen/atomic.h: fix: make atomic_read() param const
    Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
    Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
    Changed: <nothing>

  6/7: asm-arm/atomic.h: atomic_{inc,dec}_return: macros to inline functions
    Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
    Changed:
        * update README.LinuxPrimitives file

  7/7: asm/atomic.h: implement missing and add common prototypes
    Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
    Changed:
        * add wrapper over arm-side __atomic_add_unless() instead of removing
          the leading underscores

 xen/arch/arm/README.LinuxPrimitives |  24 +++++
 xen/include/asm-arm/arm32/atomic.h  |  15 +--
 xen/include/asm-arm/arm64/atomic.h  |  15 +--
 xen/include/asm-arm/atomic.h        |  60 +++++++++--
 xen/include/asm-x86/atomic.h        | 151 +++++++-------------------
 xen/include/xen/atomic.h            | 207 ++++++++++++++++++++++++++++++++++++
 6 files changed, 323 insertions(+), 149 deletions(-)
 create mode 100644 xen/include/xen/atomic.h

-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 1/7] asm-arm/atomic.h: fix arm32|arm64 macros duplication

[Corneliu ZUZU]

Move duplicate macros between asm-arm/arm32/atomic.h and asm-arm/arm64/atomic.h
to asm-arm/atomic.h. Adjust README.LinuxPrimitives in the process.
Also empty line fixes.

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
---
Changed since v3:
  * update README.LinuxPrimitives file
---
 xen/arch/arm/README.LinuxPrimitives | 20 ++++++++++++++++++++
 xen/include/asm-arm/arm32/atomic.h  | 15 ++-------------
 xen/include/asm-arm/arm64/atomic.h  | 15 ++-------------
 xen/include/asm-arm/atomic.h        | 14 ++++++++++++++
 4 files changed, 38 insertions(+), 26 deletions(-)

diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
index 3115f51..4906593 100644
--- a/xen/arch/arm/README.LinuxPrimitives
+++ b/xen/arch/arm/README.LinuxPrimitives
@@ -23,6 +23,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 8715466b6027)
 
 linux/arch/arm64/include/asm/atomic.h   xen/include/asm-arm/arm64/atomic.h
 
+The following functions were taken from Linux:
+    atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
+    atomic_cmpxchg(), __atomic_add_unless()
+
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
+    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
+    atomic_inc_and_test(v), atomic_dec_and_test(v),
+    atomic_inc_return(v), atomic_dec_return(v),
+    atomic_sub_and_test(i, v), atomic_add_negative(i,v)
+
 ---------------------------------------------------------------------
 
 mem*: last sync @ v3.16-rc6 (last commit: d875c9b37240)
@@ -91,6 +101,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 030d0178bdbd)
 
 linux/arch/arm/include/asm/atomic.h     xen/include/asm-arm/arm32/atomic.h
 
+The following functions were taken from Linux:
+    atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
+    atomic_cmpxchg(), __atomic_add_unless()
+
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
+    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
+    atomic_inc_and_test(v), atomic_dec_and_test(v),
+    atomic_inc_return(v), atomic_dec_return(v),
+    atomic_sub_and_test(i, v), atomic_add_negative(i,v)
+
 ---------------------------------------------------------------------
 
 mem*: last sync @ v3.16-rc6 (last commit: d98b90ea22b0)
diff --git a/xen/include/asm-arm/arm32/atomic.h b/xen/include/asm-arm/arm32/atomic.h
index 7ec712f..78de60f 100644
--- a/xen/include/asm-arm/arm32/atomic.h
+++ b/xen/include/asm-arm/arm32/atomic.h
@@ -8,6 +8,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 #ifndef __ARCH_ARM_ARM32_ATOMIC__
 #define __ARCH_ARM_ARM32_ATOMIC__
 
@@ -147,20 +148,8 @@ static inline int __atomic_add_unless(atomic_t *v, int a, int u)
 	return oldval;
 }
 
-#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
-
-#define atomic_inc(v)		atomic_add(1, v)
-#define atomic_dec(v)		atomic_sub(1, v)
-
-#define atomic_inc_and_test(v)	(atomic_add_return(1, v) == 0)
-#define atomic_dec_and_test(v)	(atomic_sub_return(1, v) == 0)
-#define atomic_inc_return(v)    (atomic_add_return(1, v))
-#define atomic_dec_return(v)    (atomic_sub_return(1, v))
-#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
-
-#define atomic_add_negative(i,v) (atomic_add_return(i, v) < 0)
-
 #endif /* __ARCH_ARM_ARM32_ATOMIC__ */
+
 /*
  * Local variables:
  * mode: C
diff --git a/xen/include/asm-arm/arm64/atomic.h b/xen/include/asm-arm/arm64/atomic.h
index b49219e..d640bef 100644
--- a/xen/include/asm-arm/arm64/atomic.h
+++ b/xen/include/asm-arm/arm64/atomic.h
@@ -19,6 +19,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef __ARCH_ARM_ARM64_ATOMIC
 #define __ARCH_ARM_ARM64_ATOMIC
 
@@ -113,8 +114,6 @@ static inline int atomic_cmpxchg(atomic_t *ptr, int old, int new)
 	return oldval;
 }
 
-#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
-
 static inline int __atomic_add_unless(atomic_t *v, int a, int u)
 {
 	int c, old;
@@ -125,18 +124,8 @@ static inline int __atomic_add_unless(atomic_t *v, int a, int u)
 	return c;
 }
 
-#define atomic_inc(v)		atomic_add(1, v)
-#define atomic_dec(v)		atomic_sub(1, v)
-
-#define atomic_inc_and_test(v)	(atomic_add_return(1, v) == 0)
-#define atomic_dec_and_test(v)	(atomic_sub_return(1, v) == 0)
-#define atomic_inc_return(v)    (atomic_add_return(1, v))
-#define atomic_dec_return(v)    (atomic_sub_return(1, v))
-#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
-
-#define atomic_add_negative(i,v) (atomic_add_return(i, v) < 0)
-
 #endif
+
 /*
  * Local variables:
  * mode: C
diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index 29ab265..32771e9 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -138,7 +138,21 @@ static inline void _atomic_set(atomic_t *v, int i)
 # error "unknown ARM variant"
 #endif
 
+#define atomic_inc(v)       atomic_add(1, v)
+#define atomic_dec(v)       atomic_sub(1, v)
+
+#define atomic_inc_and_test(v)  (atomic_add_return(1, v) == 0)
+#define atomic_dec_and_test(v)  (atomic_sub_return(1, v) == 0)
+#define atomic_inc_return(v)    (atomic_add_return(1, v))
+#define atomic_dec_return(v)    (atomic_sub_return(1, v))
+#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
+
+#define atomic_add_negative(i,v) (atomic_add_return(i, v) < 0)
+
+#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
+
 #endif /* __ARCH_ARM_ATOMIC__ */
+
 /*
  * Local variables:
  * mode: C
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 2/7] asm-x86/atomic.h: minor: proper atomic_inc_and_test() placement

[Corneliu ZUZU]

Place atomic_inc_and_test() implementation after atomic_inc().
Also empty line fix.

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
---
Changed since v3: <nothing>
---
 xen/include/asm-x86/atomic.h | 39 +++++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/xen/include/asm-x86/atomic.h b/xen/include/asm-x86/atomic.h
index d246b70..5f9f2dd 100644
--- a/xen/include/asm-x86/atomic.h
+++ b/xen/include/asm-x86/atomic.h
@@ -110,7 +110,6 @@ static inline int _atomic_read(atomic_t v)
     return v.counter;
 }
 
-
 /**
  * atomic_set - set atomic variable
  * @v: pointer of type atomic_t
@@ -217,6 +216,25 @@ static inline void atomic_inc(atomic_t *v)
 }
 
 /**
+ * atomic_inc_and_test - increment and test
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1
+ * and returns true if the result is zero, or false for all
+ * other cases.
+ */
+static inline int atomic_inc_and_test(atomic_t *v)
+{
+    unsigned char c;
+
+    asm volatile (
+        "lock; incl %0; sete %1"
+        : "=m" (*(volatile int *)&v->counter), "=qm" (c)
+        : "m" (*(volatile int *)&v->counter) : "memory" );
+    return c != 0;
+}
+
+/**
  * atomic_dec - decrement atomic variable
  * @v: pointer of type atomic_t
  * 
@@ -250,25 +268,6 @@ static inline int atomic_dec_and_test(atomic_t *v)
 }
 
 /**
- * atomic_inc_and_test - increment and test 
- * @v: pointer of type atomic_t
- * 
- * Atomically increments @v by 1
- * and returns true if the result is zero, or false for all
- * other cases.
- */ 
-static inline int atomic_inc_and_test(atomic_t *v)
-{
-    unsigned char c;
-
-    asm volatile (
-        "lock; incl %0; sete %1"
-        : "=m" (*(volatile int *)&v->counter), "=qm" (c)
-        : "m" (*(volatile int *)&v->counter) : "memory" );
-    return c != 0;
-}
-
-/**
  * atomic_add_negative - add and test if negative
  * @v: pointer of type atomic_t
  * @i: integer value to add
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 3/7] asm-arm/atomic.h: reorder macros to match x86-side

[Corneliu ZUZU]

Reorder macro definitions to match x86-side.

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
---
Changed since v3: <nothing>
---
 xen/include/asm-arm/atomic.h | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index 32771e9..620c636 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -138,16 +138,15 @@ static inline void _atomic_set(atomic_t *v, int i)
 # error "unknown ARM variant"
 #endif
 
-#define atomic_inc(v)       atomic_add(1, v)
-#define atomic_dec(v)       atomic_sub(1, v)
-
-#define atomic_inc_and_test(v)  (atomic_add_return(1, v) == 0)
-#define atomic_dec_and_test(v)  (atomic_sub_return(1, v) == 0)
-#define atomic_inc_return(v)    (atomic_add_return(1, v))
-#define atomic_dec_return(v)    (atomic_sub_return(1, v))
-#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
-
-#define atomic_add_negative(i,v) (atomic_add_return(i, v) < 0)
+#define atomic_inc_return(v)        (atomic_add_return(1, v))
+#define atomic_dec_return(v)        (atomic_sub_return(1, v))
+
+#define atomic_sub_and_test(i, v)   (atomic_sub_return(i, v) == 0)
+#define atomic_inc(v)               atomic_add(1, v)
+#define atomic_inc_and_test(v)      (atomic_add_return(1, v) == 0)
+#define atomic_dec(v)               atomic_sub(1, v)
+#define atomic_dec_and_test(v)      (atomic_sub_return(1, v) == 0)
+#define atomic_add_negative(i,v)    (atomic_add_return(i, v) < 0)
 
 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
 
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 4/7] asm/atomic.h: common prototyping (add xen/atomic.h)

[Corneliu ZUZU]

Create a common-side <xen/atomic.h> to establish, among others, prototypes of
atomic functions called from common-code. Done to avoid introducing
inconsistencies between arch-side <asm/atomic.h> headers when we make subtle
changes to one of them. Some arm-side macros had to be turned into inline
functions in the process (also updated README.LinuxPrimitives file).

Removed outdated comment ("NB. I've [...]").

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Suggested-by: Andrew Cooper <andrew.cooper3@citrix.com>
Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
---
Changed since v3:
  * update README.LinuxPrimitives file
---
 xen/arch/arm/README.LinuxPrimitives |  14 +--
 xen/include/asm-arm/atomic.h        |  45 ++++++----
 xen/include/asm-x86/atomic.h        | 103 +---------------------
 xen/include/xen/atomic.h            | 171 ++++++++++++++++++++++++++++++++++++
 4 files changed, 210 insertions(+), 123 deletions(-)
 create mode 100644 xen/include/xen/atomic.h

diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
index 4906593..2fcdfa4 100644
--- a/xen/arch/arm/README.LinuxPrimitives
+++ b/xen/arch/arm/README.LinuxPrimitives
@@ -27,10 +27,11 @@ The following functions were taken from Linux:
     atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
     atomic_cmpxchg(), __atomic_add_unless()
 
-Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
-    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h
+and most of them turned to inline functions:
+    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
     atomic_inc_and_test(v), atomic_dec_and_test(v),
-    atomic_inc_return(v), atomic_dec_return(v),
+    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
     atomic_sub_and_test(i, v), atomic_add_negative(i,v)
 
 ---------------------------------------------------------------------
@@ -105,10 +106,11 @@ The following functions were taken from Linux:
     atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
     atomic_cmpxchg(), __atomic_add_unless()
 
-Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
-    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h
+and most of them turned to inline functions:
+    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
     atomic_inc_and_test(v), atomic_dec_and_test(v),
-    atomic_inc_return(v), atomic_dec_return(v),
+    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
     atomic_sub_and_test(i, v), atomic_add_negative(i,v)
 
 ---------------------------------------------------------------------
diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index 620c636..a79420a 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -2,6 +2,7 @@
 #define __ARCH_ARM_ATOMIC__
 
 #include <xen/config.h>
+#include <xen/atomic.h>
 #include <xen/prefetch.h>
 #include <asm/system.h>
 
@@ -95,15 +96,6 @@ void __bad_atomic_size(void);
     default: __bad_atomic_size(); break;                                \
     }                                                                   \
 })
-    
-/*
- * NB. I've pushed the volatile qualifier into the operations. This allows
- * fast accessors such as _atomic_read() and _atomic_set() which don't give
- * the compiler a fit.
- */
-typedef struct { int counter; } atomic_t;
-
-#define ATOMIC_INIT(i) { (i) }
 
 /*
  * On ARM, ordinary assignment (str instruction) doesn't clear the local
@@ -141,12 +133,35 @@ static inline void _atomic_set(atomic_t *v, int i)
 #define atomic_inc_return(v)        (atomic_add_return(1, v))
 #define atomic_dec_return(v)        (atomic_sub_return(1, v))
 
-#define atomic_sub_and_test(i, v)   (atomic_sub_return(i, v) == 0)
-#define atomic_inc(v)               atomic_add(1, v)
-#define atomic_inc_and_test(v)      (atomic_add_return(1, v) == 0)
-#define atomic_dec(v)               atomic_sub(1, v)
-#define atomic_dec_and_test(v)      (atomic_sub_return(1, v) == 0)
-#define atomic_add_negative(i,v)    (atomic_add_return(i, v) < 0)
+static inline int atomic_sub_and_test(int i, atomic_t *v)
+{
+    return atomic_sub_return(i, v) == 0;
+}
+
+static inline void atomic_inc(atomic_t *v)
+{
+    atomic_add(1, v);
+}
+
+static inline int atomic_inc_and_test(atomic_t *v)
+{
+    return atomic_add_return(1, v) == 0;
+}
+
+static inline void atomic_dec(atomic_t *v)
+{
+    atomic_sub(1, v);
+}
+
+static inline int atomic_dec_and_test(atomic_t *v)
+{
+    return atomic_sub_return(1, v) == 0;
+}
+
+static inline int atomic_add_negative(int i, atomic_t *v)
+{
+    return atomic_add_return(i, v) < 0;
+}
 
 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
 
diff --git a/xen/include/asm-x86/atomic.h b/xen/include/asm-x86/atomic.h
index 5f9f2dd..3e99b03 100644
--- a/xen/include/asm-x86/atomic.h
+++ b/xen/include/asm-x86/atomic.h
@@ -2,6 +2,7 @@
 #define __ARCH_X86_ATOMIC__
 
 #include <xen/config.h>
+#include <xen/atomic.h>
 #include <asm/system.h>
 
 #define build_read_atomic(name, size, type, reg, barrier) \
@@ -79,56 +80,21 @@ void __bad_atomic_size(void);
     }                                                     \
 })
 
-/*
- * NB. I've pushed the volatile qualifier into the operations. This allows
- * fast accessors such as _atomic_read() and _atomic_set() which don't give
- * the compiler a fit.
- */
-typedef struct { int counter; } atomic_t;
-
-#define ATOMIC_INIT(i) { (i) }
-
-/**
- * atomic_read - read atomic variable
- * @v: pointer of type atomic_t
- *
- * Atomically reads the value of @v.
- */
 static inline int atomic_read(atomic_t *v)
 {
     return read_atomic(&v->counter);
 }
 
-/**
- * _atomic_read - read atomic variable non-atomically
- * @v atomic_t
- *
- * Non-atomically reads the value of @v
- */
 static inline int _atomic_read(atomic_t v)
 {
     return v.counter;
 }
 
-/**
- * atomic_set - set atomic variable
- * @v: pointer of type atomic_t
- * @i: required value
- *
- * Atomically sets the value of @v to @i.
- */
 static inline void atomic_set(atomic_t *v, int i)
 {
     write_atomic(&v->counter, i);
 }
 
-/**
- * _atomic_set - set atomic variable non-atomically
- * @v: pointer of type atomic_t
- * @i: required value
- *
- * Non-atomically sets the value of @v to @i.
- */
 static inline void _atomic_set(atomic_t *v, int i)
 {
     v->counter = i;
@@ -139,13 +105,6 @@ static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
     return cmpxchg(&v->counter, old, new);
 }
 
-/**
- * atomic_add - add integer to atomic variable
- * @i: integer value to add
- * @v: pointer of type atomic_t
- * 
- * Atomically adds @i to @v.
- */
 static inline void atomic_add(int i, atomic_t *v)
 {
     asm volatile (
@@ -154,25 +113,11 @@ static inline void atomic_add(int i, atomic_t *v)
         : "ir" (i), "m" (*(volatile int *)&v->counter) );
 }
 
-/**
- * atomic_add_return - add integer and return
- * @i: integer value to add
- * @v: pointer of type atomic_t
- *
- * Atomically adds @i to @v and returns @i + @v
- */
 static inline int atomic_add_return(int i, atomic_t *v)
 {
     return i + arch_fetch_and_add(&v->counter, i);
 }
 
-/**
- * atomic_sub - subtract the atomic variable
- * @i: integer value to subtract
- * @v: pointer of type atomic_t
- * 
- * Atomically subtracts @i from @v.
- */
 static inline void atomic_sub(int i, atomic_t *v)
 {
     asm volatile (
@@ -181,15 +126,6 @@ static inline void atomic_sub(int i, atomic_t *v)
         : "ir" (i), "m" (*(volatile int *)&v->counter) );
 }
 
-/**
- * atomic_sub_and_test - subtract value from variable and test result
- * @i: integer value to subtract
- * @v: pointer of type atomic_t
- * 
- * Atomically subtracts @i from @v and returns
- * true if the result is zero, or false for all
- * other cases.
- */
 static inline int atomic_sub_and_test(int i, atomic_t *v)
 {
     unsigned char c;
@@ -201,12 +137,6 @@ static inline int atomic_sub_and_test(int i, atomic_t *v)
     return c;
 }
 
-/**
- * atomic_inc - increment atomic variable
- * @v: pointer of type atomic_t
- * 
- * Atomically increments @v by 1.
- */ 
 static inline void atomic_inc(atomic_t *v)
 {
     asm volatile (
@@ -215,14 +145,6 @@ static inline void atomic_inc(atomic_t *v)
         : "m" (*(volatile int *)&v->counter) );
 }
 
-/**
- * atomic_inc_and_test - increment and test
- * @v: pointer of type atomic_t
- *
- * Atomically increments @v by 1
- * and returns true if the result is zero, or false for all
- * other cases.
- */
 static inline int atomic_inc_and_test(atomic_t *v)
 {
     unsigned char c;
@@ -234,12 +156,6 @@ static inline int atomic_inc_and_test(atomic_t *v)
     return c != 0;
 }
 
-/**
- * atomic_dec - decrement atomic variable
- * @v: pointer of type atomic_t
- * 
- * Atomically decrements @v by 1.
- */ 
 static inline void atomic_dec(atomic_t *v)
 {
     asm volatile (
@@ -248,14 +164,6 @@ static inline void atomic_dec(atomic_t *v)
         : "m" (*(volatile int *)&v->counter) );
 }
 
-/**
- * atomic_dec_and_test - decrement and test
- * @v: pointer of type atomic_t
- * 
- * Atomically decrements @v by 1 and
- * returns true if the result is 0, or false for all other
- * cases.
- */ 
 static inline int atomic_dec_and_test(atomic_t *v)
 {
     unsigned char c;
@@ -267,15 +175,6 @@ static inline int atomic_dec_and_test(atomic_t *v)
     return c != 0;
 }
 
-/**
- * atomic_add_negative - add and test if negative
- * @v: pointer of type atomic_t
- * @i: integer value to add
- * 
- * Atomically adds @i to @v and returns true
- * if the result is negative, or false when
- * result is greater than or equal to zero.
- */ 
 static inline int atomic_add_negative(int i, atomic_t *v)
 {
     unsigned char c;
diff --git a/xen/include/xen/atomic.h b/xen/include/xen/atomic.h
new file mode 100644
index 0000000..d072912
--- /dev/null
+++ b/xen/include/xen/atomic.h
@@ -0,0 +1,171 @@
+/*
+ * include/xen/atomic.h
+ *
+ * Common atomic operations entities (atomic_t, function prototypes).
+ * Include _from_ arch-side <asm/atomic.h>.
+ *
+ * Copyright (c) 2016 Bitdefender S.R.L.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __XEN_ATOMIC_H__
+#define __XEN_ATOMIC_H__
+
+typedef struct { int counter; } atomic_t;
+
+#define ATOMIC_INIT(i) { (i) }
+
+/**
+ * atomic_read - read atomic variable
+ * @v: pointer of type atomic_t
+ *
+ * Atomically reads the value of @v.
+ */
+static inline int atomic_read(atomic_t *v);
+
+/**
+ * _atomic_read - read atomic variable non-atomically
+ * @v atomic_t
+ *
+ * Non-atomically reads the value of @v
+ */
+static inline int _atomic_read(atomic_t v);
+
+/**
+ * atomic_set - set atomic variable
+ * @v: pointer of type atomic_t
+ * @i: required value
+ *
+ * Atomically sets the value of @v to @i.
+ */
+static inline void atomic_set(atomic_t *v, int i);
+
+/**
+ * _atomic_set - set atomic variable non-atomically
+ * @v: pointer of type atomic_t
+ * @i: required value
+ *
+ * Non-atomically sets the value of @v to @i.
+ */
+static inline void _atomic_set(atomic_t *v, int i);
+
+/**
+ * atomic_cmpxchg - compare and exchange an atomic variable
+ * @v: pointer of type atomic_t
+ * @old: old value
+ * @new: new value
+ *
+ * Before calling, @old should be set to @v.
+ * Succeeds if @old == @v (likely), in which case stores @new in @v.
+ * Returns the initial value in @v, hence succeeds when the return value
+ * matches that of @old.
+ *
+ * Sample (tries atomic increment of v until the operation succeeds):
+ *
+ *  while(1)
+ *  {
+ *      int old = atomic_read(&v);
+ *      int new = old + 1;
+ *      if ( likely(old == atomic_cmpxchg(&v, old, new)) )
+ *          break; // success!
+ *  }
+ */
+static inline int atomic_cmpxchg(atomic_t *v, int old, int new);
+
+/**
+ * atomic_add - add integer to atomic variable
+ * @i: integer value to add
+ * @v: pointer of type atomic_t
+ *
+ * Atomically adds @i to @v.
+ */
+static inline void atomic_add(int i, atomic_t *v);
+
+/**
+ * atomic_add_return - add integer and return
+ * @i: integer value to add
+ * @v: pointer of type atomic_t
+ *
+ * Atomically adds @i to @v and returns @i + @v
+ */
+static inline int atomic_add_return(int i, atomic_t *v);
+
+/**
+ * atomic_sub - subtract the atomic variable
+ * @i: integer value to subtract
+ * @v: pointer of type atomic_t
+ *
+ * Atomically subtracts @i from @v.
+ */
+static inline void atomic_sub(int i, atomic_t *v);
+
+/**
+ * atomic_sub_and_test - subtract value from variable and test result
+ * @i: integer value to subtract
+ * @v: pointer of type atomic_t
+ *
+ * Atomically subtracts @i from @v and returns
+ * true if the result is zero, or false for all
+ * other cases.
+ */
+static inline int atomic_sub_and_test(int i, atomic_t *v);
+
+/**
+ * atomic_inc - increment atomic variable
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1.
+ */
+static inline void atomic_inc(atomic_t *v);
+
+/**
+ * atomic_inc_and_test - increment and test
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1
+ * and returns true if the result is zero, or false for all
+ * other cases.
+ */
+static inline int atomic_inc_and_test(atomic_t *v);
+
+/**
+ * atomic_dec - decrement atomic variable
+ * @v: pointer of type atomic_t
+ *
+ * Atomically decrements @v by 1.
+ */
+static inline void atomic_dec(atomic_t *v);
+
+/**
+ * atomic_dec_and_test - decrement and test
+ * @v: pointer of type atomic_t
+ *
+ * Atomically decrements @v by 1 and
+ * returns true if the result is 0, or false for all other
+ * cases.
+ */
+static inline int atomic_dec_and_test(atomic_t *v);
+
+/**
+ * atomic_add_negative - add and test if negative
+ * @v: pointer of type atomic_t
+ * @i: integer value to add
+ *
+ * Atomically adds @i to @v and returns true
+ * if the result is negative, or false when
+ * result is greater than or equal to zero.
+ */
+static inline int atomic_add_negative(int i, atomic_t *v);
+
+#endif /* __XEN_ATOMIC_H__ */
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 5/7] xen/atomic.h: fix: make atomic_read() param const

[Corneliu ZUZU]

This wouldn't let me make a param of a function that used atomic_read() const.

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
---
Changed since v3: <nothing>
---
 xen/include/asm-arm/atomic.h | 2 +-
 xen/include/asm-x86/atomic.h | 2 +-
 xen/include/xen/atomic.h     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index a79420a..78dad29 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -102,7 +102,7 @@ void __bad_atomic_size(void);
  * strex/ldrex monitor on some implementations. The reason we can use it for
  * atomic_set() is the clrex or dummy strex done on every exception return.
  */
-static inline int atomic_read(atomic_t *v)
+static inline int atomic_read(const atomic_t *v)
 {
     return *(volatile int *)&v->counter;
 }
diff --git a/xen/include/asm-x86/atomic.h b/xen/include/asm-x86/atomic.h
index 3e99b03..1729e29 100644
--- a/xen/include/asm-x86/atomic.h
+++ b/xen/include/asm-x86/atomic.h
@@ -80,7 +80,7 @@ void __bad_atomic_size(void);
     }                                                     \
 })
 
-static inline int atomic_read(atomic_t *v)
+static inline int atomic_read(const atomic_t *v)
 {
     return read_atomic(&v->counter);
 }
diff --git a/xen/include/xen/atomic.h b/xen/include/xen/atomic.h
index d072912..6827468 100644
--- a/xen/include/xen/atomic.h
+++ b/xen/include/xen/atomic.h
@@ -32,7 +32,7 @@ typedef struct { int counter; } atomic_t;
  *
  * Atomically reads the value of @v.
  */
-static inline int atomic_read(atomic_t *v);
+static inline int atomic_read(const atomic_t *v);
 
 /**
  * _atomic_read - read atomic variable non-atomically
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 6/7] asm-arm/atomic.h: atomic_{inc, dec}_return: macros to inline functions

[Corneliu ZUZU]

Turn atomic_inc_return and atomic_dec_return atomic.h macros to inline
functions. Adjust README.LinuxPrimitives in the process.

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
---
Changed since v3:
  * update README.LinuxPrimitives file
---
 xen/arch/arm/README.LinuxPrimitives | 18 ++++++++++--------
 xen/include/asm-arm/atomic.h        | 13 ++++++++++---
 2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
index 2fcdfa4..efdc00c 100644
--- a/xen/arch/arm/README.LinuxPrimitives
+++ b/xen/arch/arm/README.LinuxPrimitives
@@ -27,13 +27,14 @@ The following functions were taken from Linux:
     atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
     atomic_cmpxchg(), __atomic_add_unless()
 
-Also, the following macros which were in the meantime moved to asm-arm/atomic.h
-and most of them turned to inline functions:
-    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
+    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
     atomic_inc_and_test(v), atomic_dec_and_test(v),
-    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
+    atomic_inc_return(v), atomic_dec_return(v),
     atomic_sub_and_test(i, v), atomic_add_negative(i,v)
 
+    * Note: all but atomic_xchg() were turned to inline functions
+
 ---------------------------------------------------------------------
 
 mem*: last sync @ v3.16-rc6 (last commit: d875c9b37240)
@@ -106,13 +107,14 @@ The following functions were taken from Linux:
     atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
     atomic_cmpxchg(), __atomic_add_unless()
 
-Also, the following macros which were in the meantime moved to asm-arm/atomic.h
-and most of them turned to inline functions:
-    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
+Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
+    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
     atomic_inc_and_test(v), atomic_dec_and_test(v),
-    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
+    atomic_inc_return(v), atomic_dec_return(v),
     atomic_sub_and_test(i, v), atomic_add_negative(i,v)
 
+	* Note: all but atomic_xchg() were turned to inline functions
+
 ---------------------------------------------------------------------
 
 mem*: last sync @ v3.16-rc6 (last commit: d98b90ea22b0)
diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index 78dad29..c69aae6 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -130,9 +130,6 @@ static inline void _atomic_set(atomic_t *v, int i)
 # error "unknown ARM variant"
 #endif
 
-#define atomic_inc_return(v)        (atomic_add_return(1, v))
-#define atomic_dec_return(v)        (atomic_sub_return(1, v))
-
 static inline int atomic_sub_and_test(int i, atomic_t *v)
 {
     return atomic_sub_return(i, v) == 0;
@@ -143,6 +140,11 @@ static inline void atomic_inc(atomic_t *v)
     atomic_add(1, v);
 }
 
+static inline int atomic_inc_return(atomic_t *v)
+{
+    return atomic_add_return(1, v);
+}
+
 static inline int atomic_inc_and_test(atomic_t *v)
 {
     return atomic_add_return(1, v) == 0;
@@ -153,6 +155,11 @@ static inline void atomic_dec(atomic_t *v)
     atomic_sub(1, v);
 }
 
+static inline int atomic_dec_return(atomic_t *v)
+{
+    return atomic_sub_return(1, v);
+}
+
 static inline int atomic_dec_and_test(atomic_t *v)
 {
     return atomic_sub_return(1, v) == 0;
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

[PATCH v4 7/7] asm/atomic.h: implement missing and add common prototypes

[Corneliu ZUZU]

ARM (<asm-arm/atomic.h>):
* add atomic_add_unless() wrapper over __atomic_add_unless()
  (for common-code interface, i.e. <xen/atomic.h>)

X86 (<asm-x86/atomic.h>):
* implement missing functions atomic_{sub,inc,dec}_return(), atomic_add_unless()
* implement missing macro atomic_xchg()

COMMON (<xen/atomic.h>):
* add prototypes for the aforementioned newly implemented X86 functions in
  common <xen/atomic.h>

Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
---
Changed since v3:
  * add wrapper over arm-side __atomic_add_unless() instead of removing the
    leading underscores
---
 xen/include/asm-arm/atomic.h |  5 +++++
 xen/include/asm-x86/atomic.h | 27 +++++++++++++++++++++++++++
 xen/include/xen/atomic.h     | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 68 insertions(+)

diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
index c69aae6..b6aaf57 100644
--- a/xen/include/asm-arm/atomic.h
+++ b/xen/include/asm-arm/atomic.h
@@ -170,6 +170,11 @@ static inline int atomic_add_negative(int i, atomic_t *v)
     return atomic_add_return(i, v) < 0;
 }
 
+static inline int atomic_add_unless(atomic_t *v, int a, int u)
+{
+    return __atomic_add_unless(v, a, u);
+}
+
 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
 
 #endif /* __ARCH_ARM_ATOMIC__ */
diff --git a/xen/include/asm-x86/atomic.h b/xen/include/asm-x86/atomic.h
index 1729e29..101eded 100644
--- a/xen/include/asm-x86/atomic.h
+++ b/xen/include/asm-x86/atomic.h
@@ -126,6 +126,11 @@ static inline void atomic_sub(int i, atomic_t *v)
         : "ir" (i), "m" (*(volatile int *)&v->counter) );
 }
 
+static inline int atomic_sub_return(int i, atomic_t *v)
+{
+    return arch_fetch_and_add(&v->counter, -i) - i;
+}
+
 static inline int atomic_sub_and_test(int i, atomic_t *v)
 {
     unsigned char c;
@@ -145,6 +150,11 @@ static inline void atomic_inc(atomic_t *v)
         : "m" (*(volatile int *)&v->counter) );
 }
 
+static inline int atomic_inc_return(atomic_t *v)
+{
+    return atomic_add_return(1, v);
+}
+
 static inline int atomic_inc_and_test(atomic_t *v)
 {
     unsigned char c;
@@ -164,6 +174,11 @@ static inline void atomic_dec(atomic_t *v)
         : "m" (*(volatile int *)&v->counter) );
 }
 
+static inline int atomic_dec_return(atomic_t *v)
+{
+    return atomic_sub_return(1, v);
+}
+
 static inline int atomic_dec_and_test(atomic_t *v)
 {
     unsigned char c;
@@ -186,4 +201,16 @@ static inline int atomic_add_negative(int i, atomic_t *v)
     return c;
 }
 
+static inline int atomic_add_unless(atomic_t *v, int a, int u)
+{
+    int c, old;
+
+    c = atomic_read(v);
+    while (c != u && (old = atomic_cmpxchg(v, c, c + a)) != c)
+        c = old;
+    return c;
+}
+
+#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
+
 #endif /* __ARCH_X86_ATOMIC__ */
diff --git a/xen/include/xen/atomic.h b/xen/include/xen/atomic.h
index 6827468..529213e 100644
--- a/xen/include/xen/atomic.h
+++ b/xen/include/xen/atomic.h
@@ -111,6 +111,15 @@ static inline int atomic_add_return(int i, atomic_t *v);
 static inline void atomic_sub(int i, atomic_t *v);
 
 /**
+ * atomic_sub_return - sub integer and return
+ * @i: integer value to sub
+ * @v: pointer of type atomic_t
+ *
+ * Atomically subtracts @i from @v and returns @v - @i.
+ */
+static inline int atomic_sub_return(int i, atomic_t *v);
+
+/**
  * atomic_sub_and_test - subtract value from variable and test result
  * @i: integer value to subtract
  * @v: pointer of type atomic_t
@@ -130,6 +139,14 @@ static inline int atomic_sub_and_test(int i, atomic_t *v);
 static inline void atomic_inc(atomic_t *v);
 
 /**
+ * atomic_inc_return - increment atomic variable and return
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1 and returns @v + 1.
+ */
+static inline int atomic_inc_return(atomic_t *v);
+
+/**
  * atomic_inc_and_test - increment and test
  * @v: pointer of type atomic_t
  *
@@ -148,6 +165,14 @@ static inline int atomic_inc_and_test(atomic_t *v);
 static inline void atomic_dec(atomic_t *v);
 
 /**
+ * atomic_dec_return - decrement atomic variable and return
+ * @v: pointer of type atomic_t
+ *
+ * Atomically decrements @v by 1 and returns @v - 1.
+ */
+static inline int atomic_dec_return(atomic_t *v);
+
+/**
  * atomic_dec_and_test - decrement and test
  * @v: pointer of type atomic_t
  *
@@ -168,4 +193,15 @@ static inline int atomic_dec_and_test(atomic_t *v);
  */
 static inline int atomic_add_negative(int i, atomic_t *v);
 
+/**
+ * atomic_add_unless - add to atomic variable unless it has a specified value
+ * @v: pointer of type atomic_t
+ * @a: integer value to add
+ * @u: integer value @v must -not- be for the add to be performed
+ *
+ * If @v != @u, adds @a to @v and returns @v + @a.
+ * Otherwise returns @u (== @v).
+ */
+static inline int atomic_add_unless(atomic_t *v, int a, int u);
+
 #endif /* __XEN_ATOMIC_H__ */
-- 
2.5.0


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 6/7] asm-arm/atomic.h: atomic_{inc, dec}_return: macros to inline functions

[Corneliu ZUZU]

On 7/15/2016 9:51 AM, Corneliu ZUZU wrote:
> Turn atomic_inc_return and atomic_dec_return atomic.h macros to inline
> functions. Adjust README.LinuxPrimitives in the process.
>
> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
> ---
> Changed since v3:
>    * update README.LinuxPrimitives file
> ---
>   xen/arch/arm/README.LinuxPrimitives | 18 ++++++++++--------
>   xen/include/asm-arm/atomic.h        | 13 ++++++++++---
>   2 files changed, 20 insertions(+), 11 deletions(-)
>
> diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
> index 2fcdfa4..efdc00c 100644
> --- a/xen/arch/arm/README.LinuxPrimitives
> +++ b/xen/arch/arm/README.LinuxPrimitives
> @@ -27,13 +27,14 @@ The following functions were taken from Linux:
>       atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
>       atomic_cmpxchg(), __atomic_add_unless()
>   
> -Also, the following macros which were in the meantime moved to asm-arm/atomic.h
> -and most of them turned to inline functions:
> -    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>       atomic_inc_and_test(v), atomic_dec_and_test(v),
> -    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
> +    atomic_inc_return(v), atomic_dec_return(v),
>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>   
> +    * Note: all but atomic_xchg() were turned to inline functions
> +
>   ---------------------------------------------------------------------
>   
>   mem*: last sync @ v3.16-rc6 (last commit: d875c9b37240)
> @@ -106,13 +107,14 @@ The following functions were taken from Linux:
>       atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
>       atomic_cmpxchg(), __atomic_add_unless()
>   
> -Also, the following macros which were in the meantime moved to asm-arm/atomic.h
> -and most of them turned to inline functions:
> -    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>       atomic_inc_and_test(v), atomic_dec_and_test(v),
> -    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
> +    atomic_inc_return(v), atomic_dec_return(v),
>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>   
> +	* Note: all but atomic_xchg() were turned to inline functions
> +
>   ---------------------------------------------------------------------
>   
>   mem*: last sync @ v3.16-rc6 (last commit: d98b90ea22b0)
> diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
> index 78dad29..c69aae6 100644
> --- a/xen/include/asm-arm/atomic.h
> +++ b/xen/include/asm-arm/atomic.h
> @@ -130,9 +130,6 @@ static inline void _atomic_set(atomic_t *v, int i)
>   # error "unknown ARM variant"
>   #endif
>   
> -#define atomic_inc_return(v)        (atomic_add_return(1, v))
> -#define atomic_dec_return(v)        (atomic_sub_return(1, v))
> -
>   static inline int atomic_sub_and_test(int i, atomic_t *v)
>   {
>       return atomic_sub_return(i, v) == 0;
> @@ -143,6 +140,11 @@ static inline void atomic_inc(atomic_t *v)
>       atomic_add(1, v);
>   }
>   
> +static inline int atomic_inc_return(atomic_t *v)
> +{
> +    return atomic_add_return(1, v);
> +}
> +
>   static inline int atomic_inc_and_test(atomic_t *v)
>   {
>       return atomic_add_return(1, v) == 0;
> @@ -153,6 +155,11 @@ static inline void atomic_dec(atomic_t *v)
>       atomic_sub(1, v);
>   }
>   
> +static inline int atomic_dec_return(atomic_t *v)
> +{
> +    return atomic_sub_return(1, v);
> +}
> +
>   static inline int atomic_dec_and_test(atomic_t *v)
>   {
>       return atomic_sub_return(1, v) == 0;

I mistakenly inserted a TAB instead of 4 spaces in 
README.LinuxPrimitives (under arm32/atomic.h):

+	* Note: all but atomic_xchg() were turned to inline functions

If there won't be a v5 only for this change, please correct that before pushing the commit.

Thanks,
Corneliu.


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 1/7] asm-arm/atomic.h: fix arm32|arm64 macros duplication

[Julien Grall]

Hi Corneliu,

On 15/07/16 07:48, Corneliu ZUZU wrote:
> Move duplicate macros between asm-arm/arm32/atomic.h and asm-arm/arm64/atomic.h
> to asm-arm/atomic.h. Adjust README.LinuxPrimitives in the process.
> Also empty line fixes.

Why do you add empty lines?

They are not necessary nor coding style requirement nor in Linux 
headers. Please don't introduce changes without a valid reason.

> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
> ---
> Changed since v3:
>    * update README.LinuxPrimitives file
> ---
>   xen/arch/arm/README.LinuxPrimitives | 20 ++++++++++++++++++++
>   xen/include/asm-arm/arm32/atomic.h  | 15 ++-------------
>   xen/include/asm-arm/arm64/atomic.h  | 15 ++-------------
>   xen/include/asm-arm/atomic.h        | 14 ++++++++++++++
>   4 files changed, 38 insertions(+), 26 deletions(-)
>
> diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
> index 3115f51..4906593 100644
> --- a/xen/arch/arm/README.LinuxPrimitives
> +++ b/xen/arch/arm/README.LinuxPrimitives
> @@ -23,6 +23,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 8715466b6027)
>
>   linux/arch/arm64/include/asm/atomic.h   xen/include/asm-arm/arm64/atomic.h
>
> +The following functions were taken from Linux:
> +    atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
> +    atomic_cmpxchg(), __atomic_add_unless()
> +
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
> +    atomic_inc_and_test(v), atomic_dec_and_test(v),
> +    atomic_inc_return(v), atomic_dec_return(v),
> +    atomic_sub_and_test(i, v), atomic_add_negative(i,v)

I would drop the second paragraph because they are moved outside of 
arm/*atomic.h and you turn into inline. So IHMO they are not sync-able 
anymore.


> +
>   ---------------------------------------------------------------------
>
>   mem*: last sync @ v3.16-rc6 (last commit: d875c9b37240)
> @@ -91,6 +101,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 030d0178bdbd)
>
>   linux/arch/arm/include/asm/atomic.h     xen/include/asm-arm/arm32/atomic.h
>
> +The following functions were taken from Linux:
> +    atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
> +    atomic_cmpxchg(), __atomic_add_unless()
> +
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
> +    atomic_inc_and_test(v), atomic_dec_and_test(v),
> +    atomic_inc_return(v), atomic_dec_return(v),
> +    atomic_sub_and_test(i, v), atomic_add_negative(i,v)

Ditto.

Regards,


-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 3/7] asm-arm/atomic.h: reorder macros to match x86-side

[Julien Grall]

On 15/07/16 07:49, Corneliu ZUZU wrote:
> Reorder macro definitions to match x86-side.
>
> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>

Acked-by: Julien Grall <julien.grall@arm.com>

Regards,

> ---
> Changed since v3: <nothing>
> ---
>   xen/include/asm-arm/atomic.h | 19 +++++++++----------
>   1 file changed, 9 insertions(+), 10 deletions(-)
>
> diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
> index 32771e9..620c636 100644
> --- a/xen/include/asm-arm/atomic.h
> +++ b/xen/include/asm-arm/atomic.h
> @@ -138,16 +138,15 @@ static inline void _atomic_set(atomic_t *v, int i)
>   # error "unknown ARM variant"
>   #endif
>
> -#define atomic_inc(v)       atomic_add(1, v)
> -#define atomic_dec(v)       atomic_sub(1, v)
> -
> -#define atomic_inc_and_test(v)  (atomic_add_return(1, v) == 0)
> -#define atomic_dec_and_test(v)  (atomic_sub_return(1, v) == 0)
> -#define atomic_inc_return(v)    (atomic_add_return(1, v))
> -#define atomic_dec_return(v)    (atomic_sub_return(1, v))
> -#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
> -
> -#define atomic_add_negative(i,v) (atomic_add_return(i, v) < 0)
> +#define atomic_inc_return(v)        (atomic_add_return(1, v))
> +#define atomic_dec_return(v)        (atomic_sub_return(1, v))
> +
> +#define atomic_sub_and_test(i, v)   (atomic_sub_return(i, v) == 0)
> +#define atomic_inc(v)               atomic_add(1, v)
> +#define atomic_inc_and_test(v)      (atomic_add_return(1, v) == 0)
> +#define atomic_dec(v)               atomic_sub(1, v)
> +#define atomic_dec_and_test(v)      (atomic_sub_return(1, v) == 0)
> +#define atomic_add_negative(i,v)    (atomic_add_return(i, v) < 0)
>
>   #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
>
>

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 4/7] asm/atomic.h: common prototyping (add xen/atomic.h)

[Julien Grall]

On 15/07/16 07:50, Corneliu ZUZU wrote:
> Create a common-side <xen/atomic.h> to establish, among others, prototypes of
> atomic functions called from common-code. Done to avoid introducing
> inconsistencies between arch-side <asm/atomic.h> headers when we make subtle
> changes to one of them. Some arm-side macros had to be turned into inline
> functions in the process (also updated README.LinuxPrimitives file).
>
> Removed outdated comment ("NB. I've [...]").
>
> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Suggested-by: Andrew Cooper <andrew.cooper3@citrix.com>
> Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
> ---
> Changed since v3:
>    * update README.LinuxPrimitives file
> ---
>   xen/arch/arm/README.LinuxPrimitives |  14 +--
>   xen/include/asm-arm/atomic.h        |  45 ++++++----
>   xen/include/asm-x86/atomic.h        | 103 +---------------------
>   xen/include/xen/atomic.h            | 171 ++++++++++++++++++++++++++++++++++++
>   4 files changed, 210 insertions(+), 123 deletions(-)
>   create mode 100644 xen/include/xen/atomic.h
>
> diff --git a/xen/arch/arm/README.LinuxPrimitives b/xen/arch/arm/README.LinuxPrimitives
> index 4906593..2fcdfa4 100644
> --- a/xen/arch/arm/README.LinuxPrimitives
> +++ b/xen/arch/arm/README.LinuxPrimitives
> @@ -27,10 +27,11 @@ The following functions were taken from Linux:
>       atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
>       atomic_cmpxchg(), __atomic_add_unless()
>
> -Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> -    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h
> +and most of them turned to inline functions:
> +    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
>       atomic_inc_and_test(v), atomic_dec_and_test(v),
> -    atomic_inc_return(v), atomic_dec_return(v),
> +    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)

As mentioned in patch #1, those functions are not easily sync-able after 
this patch. Please drop them from README.LinuxPrimitives.

>
>   ---------------------------------------------------------------------
> @@ -105,10 +106,11 @@ The following functions were taken from Linux:
>       atomic_add(), atomic_add_return(), atomic_sub(), atomic_sub_return(),
>       atomic_cmpxchg(), __atomic_add_unless()
>
> -Also, the following macros which were in the meantime moved to asm-arm/atomic.h:
> -    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
> +Also, the following macros which were in the meantime moved to asm-arm/atomic.h
> +and most of them turned to inline functions:
> +    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
>       atomic_inc_and_test(v), atomic_dec_and_test(v),
> -    atomic_inc_return(v), atomic_dec_return(v),
> +    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still macro],
>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)

Ditto.


With that:

Acked-by: Julien Grall <julien.grall@arm.com>

Regards,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 5/7] xen/atomic.h: fix: make atomic_read() param const

[Julien Grall]

On 15/07/16 07:50, Corneliu ZUZU wrote:
> This wouldn't let me make a param of a function that used atomic_read() const.
>
> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>

Reviewed-by: Julien Grall <julien.grall@arm.com>

Regards,

> ---
> Changed since v3: <nothing>
> ---
>   xen/include/asm-arm/atomic.h | 2 +-
>   xen/include/asm-x86/atomic.h | 2 +-
>   xen/include/xen/atomic.h     | 2 +-
>   3 files changed, 3 insertions(+), 3 deletions(-)
>
> diff --git a/xen/include/asm-arm/atomic.h b/xen/include/asm-arm/atomic.h
> index a79420a..78dad29 100644
> --- a/xen/include/asm-arm/atomic.h
> +++ b/xen/include/asm-arm/atomic.h
> @@ -102,7 +102,7 @@ void __bad_atomic_size(void);
>    * strex/ldrex monitor on some implementations. The reason we can use it for
>    * atomic_set() is the clrex or dummy strex done on every exception return.
>    */
> -static inline int atomic_read(atomic_t *v)
> +static inline int atomic_read(const atomic_t *v)
>   {
>       return *(volatile int *)&v->counter;
>   }
> diff --git a/xen/include/asm-x86/atomic.h b/xen/include/asm-x86/atomic.h
> index 3e99b03..1729e29 100644
> --- a/xen/include/asm-x86/atomic.h
> +++ b/xen/include/asm-x86/atomic.h
> @@ -80,7 +80,7 @@ void __bad_atomic_size(void);
>       }                                                     \
>   })
>
> -static inline int atomic_read(atomic_t *v)
> +static inline int atomic_read(const atomic_t *v)
>   {
>       return read_atomic(&v->counter);
>   }
> diff --git a/xen/include/xen/atomic.h b/xen/include/xen/atomic.h
> index d072912..6827468 100644
> --- a/xen/include/xen/atomic.h
> +++ b/xen/include/xen/atomic.h
> @@ -32,7 +32,7 @@ typedef struct { int counter; } atomic_t;
>    *
>    * Atomically reads the value of @v.
>    */
> -static inline int atomic_read(atomic_t *v);
> +static inline int atomic_read(const atomic_t *v);
>
>   /**
>    * _atomic_read - read atomic variable non-atomically
>

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 7/7] asm/atomic.h: implement missing and add common prototypes

[Julien Grall]

On 15/07/16 07:52, Corneliu ZUZU wrote:
> ARM (<asm-arm/atomic.h>):
> * add atomic_add_unless() wrapper over __atomic_add_unless()
>    (for common-code interface, i.e. <xen/atomic.h>)
>
> X86 (<asm-x86/atomic.h>):
> * implement missing functions atomic_{sub,inc,dec}_return(), atomic_add_unless()
> * implement missing macro atomic_xchg()
>
> COMMON (<xen/atomic.h>):
> * add prototypes for the aforementioned newly implemented X86 functions in
>    common <xen/atomic.h>
>
> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
> Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>

For ARM bits:

Acked-by: Julien Grall <julien.grall@arm.com>

Regards,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 1/7] asm-arm/atomic.h: fix arm32|arm64 macros duplication

[Corneliu ZUZU]

On 7/15/2016 12:28 PM, Julien Grall wrote:
> Hi Corneliu,
>
> On 15/07/16 07:48, Corneliu ZUZU wrote:
>> Move duplicate macros between asm-arm/arm32/atomic.h and 
>> asm-arm/arm64/atomic.h
>> to asm-arm/atomic.h. Adjust README.LinuxPrimitives in the process.
>> Also empty line fixes.
>
> Why do you add empty lines?

A little picky today, aren't we? :-)

I added empty lines:
- before local variables block
- between header comment and #ifndef guard
because IMO -it looks better- and is consistent with the format of -most 
of- the rest of the files (thus I assumed that's the preferred format 
and that deviations from that are honest mistakes :-)).

> They are not necessary nor coding style requirement nor in Linux 
> headers. Please don't introduce changes without a valid reason.

I just peeked in the Linux source tree and I noticed there are also 
headers there with an empty line between the file-comment and #ifndef.
Plus, this is the Xen code-base and I don't see why I'd look in the 
Linux source tree to determine rules that apply to the Xen source-tree.
I didn't expect for a rule like this to -need- putting in CODING_STYLE. 
Anyway, they'll be dropped in v5 if it really matters.

>
>
>> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
>> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
>> ---
>> Changed since v3:
>>    * update README.LinuxPrimitives file
>> ---
>>   xen/arch/arm/README.LinuxPrimitives | 20 ++++++++++++++++++++
>>   xen/include/asm-arm/arm32/atomic.h  | 15 ++-------------
>>   xen/include/asm-arm/arm64/atomic.h  | 15 ++-------------
>>   xen/include/asm-arm/atomic.h        | 14 ++++++++++++++
>>   4 files changed, 38 insertions(+), 26 deletions(-)
>>
>> diff --git a/xen/arch/arm/README.LinuxPrimitives 
>> b/xen/arch/arm/README.LinuxPrimitives
>> index 3115f51..4906593 100644
>> --- a/xen/arch/arm/README.LinuxPrimitives
>> +++ b/xen/arch/arm/README.LinuxPrimitives
>> @@ -23,6 +23,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 
>> 8715466b6027)
>>
>>   linux/arch/arm64/include/asm/atomic.h 
>> xen/include/asm-arm/arm64/atomic.h
>>
>> +The following functions were taken from Linux:
>> +    atomic_add(), atomic_add_return(), atomic_sub(), 
>> atomic_sub_return(),
>> +    atomic_cmpxchg(), __atomic_add_unless()
>> +
>> +Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h:
>> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>> +    atomic_inc_and_test(v), atomic_dec_and_test(v),
>> +    atomic_inc_return(v), atomic_dec_return(v),
>> +    atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>
> I would drop the second paragraph because they are moved outside of 
> arm/*atomic.h and you turn into inline. So IHMO they are not sync-able 
> anymore.
>

Ok.

>
>> +
>> ---------------------------------------------------------------------
>>
>>   mem*: last sync @ v3.16-rc6 (last commit: d875c9b37240)
>> @@ -91,6 +101,16 @@ atomics: last sync @ v3.16-rc6 (last commit: 
>> 030d0178bdbd)
>>
>>   linux/arch/arm/include/asm/atomic.h xen/include/asm-arm/arm32/atomic.h
>>
>> +The following functions were taken from Linux:
>> +    atomic_add(), atomic_add_return(), atomic_sub(), 
>> atomic_sub_return(),
>> +    atomic_cmpxchg(), __atomic_add_unless()
>> +
>> +Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h:
>> +    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>> +    atomic_inc_and_test(v), atomic_dec_and_test(v),
>> +    atomic_inc_return(v), atomic_dec_return(v),
>> +    atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>
> Ditto.
>
> Regards,

Ack.

Corneliu.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 4/7] asm/atomic.h: common prototyping (add xen/atomic.h)

[Corneliu ZUZU]

On 7/15/2016 12:30 PM, Julien Grall wrote:
>
>
> On 15/07/16 07:50, Corneliu ZUZU wrote:
>> Create a common-side <xen/atomic.h> to establish, among others, 
>> prototypes of
>> atomic functions called from common-code. Done to avoid introducing
>> inconsistencies between arch-side <asm/atomic.h> headers when we make 
>> subtle
>> changes to one of them. Some arm-side macros had to be turned into 
>> inline
>> functions in the process (also updated README.LinuxPrimitives file).
>>
>> Removed outdated comment ("NB. I've [...]").
>>
>> Signed-off-by: Corneliu ZUZU <czuzu@bitdefender.com>
>> Suggested-by: Andrew Cooper <andrew.cooper3@citrix.com>
>> Reviewed-by: Andrew Cooper <andrew.cooper3@citrix.com>
>> Reviewed-by: Stefano Stabellini <sstabellini@kernel.org>
>> ---
>> Changed since v3:
>>    * update README.LinuxPrimitives file
>> ---
>>   xen/arch/arm/README.LinuxPrimitives |  14 +--
>>   xen/include/asm-arm/atomic.h        |  45 ++++++----
>>   xen/include/asm-x86/atomic.h        | 103 +---------------------
>>   xen/include/xen/atomic.h            | 171 
>> ++++++++++++++++++++++++++++++++++++
>>   4 files changed, 210 insertions(+), 123 deletions(-)
>>   create mode 100644 xen/include/xen/atomic.h
>>
>> diff --git a/xen/arch/arm/README.LinuxPrimitives 
>> b/xen/arch/arm/README.LinuxPrimitives
>> index 4906593..2fcdfa4 100644
>> --- a/xen/arch/arm/README.LinuxPrimitives
>> +++ b/xen/arch/arm/README.LinuxPrimitives
>> @@ -27,10 +27,11 @@ The following functions were taken from Linux:
>>       atomic_add(), atomic_add_return(), atomic_sub(), 
>> atomic_sub_return(),
>>       atomic_cmpxchg(), __atomic_add_unless()
>>
>> -Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h:
>> -    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>> +Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h
>> +and most of them turned to inline functions:
>> +    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
>>       atomic_inc_and_test(v), atomic_dec_and_test(v),
>> -    atomic_inc_return(v), atomic_dec_return(v),
>> +    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still 
>> macro],
>>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>
> As mentioned in patch #1, those functions are not easily sync-able 
> after this patch. Please drop them from README.LinuxPrimitives.
>

Ack.

>>
>> ---------------------------------------------------------------------
>> @@ -105,10 +106,11 @@ The following functions were taken from Linux:
>>       atomic_add(), atomic_add_return(), atomic_sub(), 
>> atomic_sub_return(),
>>       atomic_cmpxchg(), __atomic_add_unless()
>>
>> -Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h:
>> -    atomic_xchg(v, new), atomic_inc(v), atomic_dec(v),
>> +Also, the following macros which were in the meantime moved to 
>> asm-arm/atomic.h
>> +and most of them turned to inline functions:
>> +    atomic_xchg(v, new) [still macro], atomic_inc(v), atomic_dec(v),
>>       atomic_inc_and_test(v), atomic_dec_and_test(v),
>> -    atomic_inc_return(v), atomic_dec_return(v),
>> +    atomic_inc_return(v) [still macro], atomic_dec_return(v) [still 
>> macro],
>>       atomic_sub_and_test(i, v), atomic_add_negative(i,v)
>
> Ditto.
>
>
> With that:
>
> Acked-by: Julien Grall <julien.grall@arm.com>
>
> Regards,
>

Thanks,
Corneliu.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 1/7] asm-arm/atomic.h: fix arm32|arm64 macros duplication

[Julien Grall]

On 15/07/16 10:55, Corneliu ZUZU wrote:
> On 7/15/2016 12:28 PM, Julien Grall wrote:
>> Hi Corneliu,
>>
>> On 15/07/16 07:48, Corneliu ZUZU wrote:
>>> Move duplicate macros between asm-arm/arm32/atomic.h and
>>> asm-arm/arm64/atomic.h
>>> to asm-arm/atomic.h. Adjust README.LinuxPrimitives in the process.
>>> Also empty line fixes.
>>
>> Why do you add empty lines?
>
> A little picky today, aren't we? :-)

Same as usual ;).

[...]

>> They are not necessary nor coding style requirement nor in Linux
>> headers. Please don't introduce changes without a valid reason.
>
> I just peeked in the Linux source tree and I noticed there are also
> headers there with an empty line between the file-comment and #ifndef.
> Plus, this is the Xen code-base and I don't see why I'd look in the
> Linux source tree to determine rules that apply to the Xen source-tree.

Because files taken from Linux respect Linux coding style.

I did the mistake on other files to diverge (such as the SMMU code) and 
it was a pain to re-sync it later. So I prefer to have a strict rule on 
it, even for cosmetic changes.

Regards,

-- 
Julien Grall

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel

Re: [PATCH v4 1/7] asm-arm/atomic.h: fix arm32|arm64 macros duplication

[Corneliu ZUZU]

On 7/15/2016 1:06 PM, Julien Grall wrote:
>
>
> On 15/07/16 10:55, Corneliu ZUZU wrote:
>> On 7/15/2016 12:28 PM, Julien Grall wrote:
>>> Hi Corneliu,
>>>
>>> On 15/07/16 07:48, Corneliu ZUZU wrote:
>>>> Move duplicate macros between asm-arm/arm32/atomic.h and
>>>> asm-arm/arm64/atomic.h
>>>> to asm-arm/atomic.h. Adjust README.LinuxPrimitives in the process.
>>>> Also empty line fixes.
>>>
>>> Why do you add empty lines?
>>
>> A little picky today, aren't we? :-)
>
> Same as usual ;).
>
> [...]
>
>>> They are not necessary nor coding style requirement nor in Linux
>>> headers. Please don't introduce changes without a valid reason.
>>
>> I just peeked in the Linux source tree and I noticed there are also
>> headers there with an empty line between the file-comment and #ifndef.
>> Plus, this is the Xen code-base and I don't see why I'd look in the
>> Linux source tree to determine rules that apply to the Xen source-tree.
>
> Because files taken from Linux respect Linux coding style.
>
> I did the mistake on other files to diverge (such as the SMMU code) 
> and it was a pain to re-sync it later. So I prefer to have a strict 
> rule on it, even for cosmetic changes.
>
> Regards,

Makes sense and much better than "Please don't introduce changes without 
a valid reason". ;-)

Corneliu.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel