refresh all the other patches in the series

1 files changed, 40 insertions, 21 deletions

diff --git a/debian/patches/0002-include-add-lock-less-reference-counting-primitives.patch b/debian/patches/0002-include-add-lock-less-reference-counting-primitives.patch
index 145d340e..6718ab31 100644
--- a/debian/patches/0002-include-add-lock-less-reference-counting-primitives.patch
+++ b/debian/patches/0002-include-add-lock-less-reference-counting-primitives.patch
@@ -1,20 +1,20 @@
-From 8faea20349dc1d8cfd0117d28a3f1271083192d0 Mon Sep 17 00:00:00 2001
+From 55ddd1b28a57492c5df4afcdf167910fb7bbc3a1 Mon Sep 17 00:00:00 2001
 From: Justus Winter <4winter@informatik.uni-hamburg.de>
 Date: Tue, 6 May 2014 19:52:04 +0200
-Subject: [PATCH 2/5] include: add lock-less reference counting primitives
+Subject: [PATCH 02/11] include: add lock-less reference counting primitives
 
 * include/refcount.h: New file.
 ---
- include/refcount.h | 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++
- 1 file changed, 155 insertions(+)
+ include/refcount.h | 174 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 174 insertions(+)
  create mode 100644 include/refcount.h
 
 diff --git a/include/refcount.h b/include/refcount.h
 new file mode 100644
-index 0000000..946938a
+index 0000000..0a9ed8e
 --- /dev/null
 +++ b/include/refcount.h
-@@ -0,0 +1,155 @@
+@@ -0,0 +1,174 @@
 +/* Lock-less reference counting primitives
 +
 +   Copyright (C) 2014 Free Software Foundation, Inc.
@@ -44,31 +44,36 @@ index 0000000..946938a
 +/* Simple reference counting.  */
 +
 +/* An opaque type.  You must not access these values directly.  */
-+typedef uint32_t refcount_t;
++typedef unsigned int refcount_t;
 +
 +/* Initialize REF with REFERENCES.  */
 +static inline void
-+refcount_init (refcount_t *ref, uint32_t references)
++refcount_init (refcount_t *ref, unsigned int references)
 +{
 +  *ref = references;
 +}
 +
-+/* Increment REF.  Return the result of the operation.  */
-+static inline uint32_t
++/* Increment REF.  Return the result of the operation.  This function
++   uses atomic operations.  It is not required to serialize calls to
++   this function.  */
++static inline unsigned int
 +refcount_ref (refcount_t *ref)
 +{
 +  return __atomic_add_fetch (ref, 1, __ATOMIC_RELAXED);
 +}
 +
-+/* Decrement REF.  Return the result of the operation.  */
-+static inline uint32_t
++/* Decrement REF.  Return the result of the operation.  This function
++   uses atomic operations.  It is not required to serialize calls to
++   this function.  */
++static inline unsigned int
 +refcount_deref (refcount_t *ref)
 +{
 +  return __atomic_sub_fetch (ref, 1, __ATOMIC_RELAXED);
 +}
 +
-+/* Return REF.  */
-+static inline uint32_t
++/* Return REF.  This function uses atomic operations.  It is not
++   required to serialize calls to this function.  */
++static inline unsigned int
 +refcount_references (refcount_t *ref)
 +{
 +  return __atomic_load_n (ref, __ATOMIC_RELAXED);
@@ -100,7 +105,9 @@ index 0000000..946938a
 +}
 +
 +/* Increment the hard reference count of REF.  If RESULT is not NULL,
-+   the result of the operation is written there.  */
++   the result of the operation is written there.  This function uses
++   atomic operations.  It is not required to serialize calls to this
++   function.  */
 +static inline void
 +refcounts_ref (refcounts_t *ref, struct references *result)
 +{
@@ -111,7 +118,9 @@ index 0000000..946938a
 +}
 +
 +/* Decrement the hard reference count of REF.  If RESULT is not NULL,
-+   the result of the operation is written there.  */
++   the result of the operation is written there.  This function uses
++   atomic operations.  It is not required to serialize calls to this
++   function.  */
 +static inline void
 +refcounts_deref (refcounts_t *ref, struct references *result)
 +{
@@ -122,7 +131,9 @@ index 0000000..946938a
 +}
 +
 +/* Increment the weak reference count of REF.  If RESULT is not NULL,
-+   the result of the operation is written there.  */
++   the result of the operation is written there.  This function uses
++   atomic operations.  It is not required to serialize calls to this
++   function.  */
 +static inline void
 +refcounts_ref_weak (refcounts_t *ref, struct references *result)
 +{
@@ -133,7 +144,9 @@ index 0000000..946938a
 +}
 +
 +/* Decrement the weak reference count of REF.  If RESULT is not NULL,
-+   the result of the operation is written there.  */
++   the result of the operation is written there.  This function uses
++   atomic operations.  It is not required to serialize calls to this
++   function.  */
 +static inline void
 +refcounts_deref_weak (refcounts_t *ref, struct references *result)
 +{
@@ -143,7 +156,9 @@ index 0000000..946938a
 +    ((union _references *) result)->rc = r;
 +}
 +
-+/* Store the current reference counts of REF in RESULT.  */
++/* Store the current reference counts of REF in RESULT.  This function
++   uses atomic operations.  It is not required to serialize calls to
++   this function.  */
 +static inline void
 +refcounts_references (refcounts_t *ref, struct references *result)
 +{
@@ -151,7 +166,9 @@ index 0000000..946938a
 +    __atomic_load_n (ref, __ATOMIC_RELAXED);
 +}
 +
-+/* Return the hard reference count of REF.  */
++/* Return the hard reference count of REF.  This function uses atomic
++   operations.  It is not required to serialize calls to this
++   function.  */
 +static inline uint32_t
 +refcounts_hard_references (refcounts_t *ref)
 +{
@@ -160,7 +177,9 @@ index 0000000..946938a
 +  return result.hard;
 +}
 +
-+/* Return the weak reference count of REF.  */
++/* Return the weak reference count of REF.  This function uses atomic
++   operations.  It is not required to serialize calls to this
++   function.  */
 +static inline uint32_t
 +refcounts_weak_references (refcounts_t *ref)
 +{