glibc: fix pthread_cond_broadcast issue (arm)

pthread_mutex functions such as pthread_cond_wait(), pthread_mutex_unlock() return
errors after PTHREAD_PRIO_INHERIT is enabled

Reference:
https://sourceware.org/bugzilla/show_bug.cgi?id=18463

Upstream patches:
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=f0e3925bf3b8df6940c3346db17e42615979d458
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=13cb8f76da9d9420330796f469dbf10643ba5b12
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=23b5cae1af04f2d912910fdaf73cb482265798c1
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=ed19993b5b0d05d62cc883571519a67dae481a14
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=2e4cf778972573221e9b87fd992844ea9b67b9bf
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=abff18c0c6055ca5d1cd46923fd1205c057139a5

This issue is Morty specific (glibc 2.24).
The issue is no longer present in glibc 2.25 (master branch).

(From OE-Core rev: 6dc1f1c3cc871d00ecd59d5aeeef86b7e6965750)

Signed-off-by: Catalin Enache <catalin.enache@windriver.com>
Signed-off-by: Armin Kuster <akuster808@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 124 insertions, 0 deletions

diff --git a/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch b/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch
new file mode 100644
index 0000000000..c4747fa27a
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch
@@ -0,0 +1,124 @@
+From b85e30e655027132c4326d2fdde010c517165aaf Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache@windriver.com>
+Date: Fri, 30 Jun 2017 14:27:34 +0300
+Subject: [PATCH 2/6] Add atomic operations required by the new condition
+ variable.
+
+    * include/atomic.h (atomic_fetch_and_relaxed,
+    atomic_fetch_and_release, atomic_fetch_or_release,
+    atomic_fetch_xor_release): New.
+
+Upstream-Status: Backport
+
+Author: Torvald Riegel <triegel@redhat.com>
+Signed-off-by: Catalin Enache <catalin.enache@windriver.com>
+---
+ ChangeLog        |  6 ++++++
+ include/atomic.h | 47 +++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 53 insertions(+)
+
+diff --git a/ChangeLog b/ChangeLog
+index cb87279..96b6da2 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,9 @@
++2016-08-09  Torvald Riegel  <triegel@redhat.com>
++
++       * include/atomic.h (atomic_fetch_and_relaxed,
++       atomic_fetch_and_release, atomic_fetch_or_release,
++       atomic_fetch_xor_release): New.
++
+ 2016-08-05  Torvald Riegel  <triegel@redhat.com>
+ 
+        * include/atomic.h (atomic_exchange_relaxed): New.
+diff --git a/include/atomic.h b/include/atomic.h
+index 129ee24..5a8e7e7 100644
+--- a/include/atomic.h
++++ b/include/atomic.h
+@@ -611,9 +611,15 @@ void __atomic_link_error (void);
+   ({ __atomic_check_size((mem));                                             \
+   __atomic_fetch_add ((mem), (operand), __ATOMIC_ACQ_REL); })
+ 
++# define atomic_fetch_and_relaxed(mem, operand) \
++  ({ __atomic_check_size((mem));                                             \
++  __atomic_fetch_and ((mem), (operand), __ATOMIC_RELAXED); })
+ # define atomic_fetch_and_acquire(mem, operand) \
+   ({ __atomic_check_size((mem));                                             \
+   __atomic_fetch_and ((mem), (operand), __ATOMIC_ACQUIRE); })
++# define atomic_fetch_and_release(mem, operand) \
++  ({ __atomic_check_size((mem));                                             \
++  __atomic_fetch_and ((mem), (operand), __ATOMIC_RELEASE); })
+ 
+ # define atomic_fetch_or_relaxed(mem, operand) \
+   ({ __atomic_check_size((mem));                                             \
+@@ -621,6 +627,13 @@ void __atomic_link_error (void);
+ # define atomic_fetch_or_acquire(mem, operand) \
+   ({ __atomic_check_size((mem));                                             \
+   __atomic_fetch_or ((mem), (operand), __ATOMIC_ACQUIRE); })
++# define atomic_fetch_or_release(mem, operand) \
++  ({ __atomic_check_size((mem));                                             \
++  __atomic_fetch_or ((mem), (operand), __ATOMIC_RELEASE); })
++
++# define atomic_fetch_xor_release(mem, operand) \
++  ({ __atomic_check_size((mem));                                             \
++  __atomic_fetch_xor ((mem), (operand), __ATOMIC_RELEASE); })
+ 
+ #else /* !USE_ATOMIC_COMPILER_BUILTINS  */
+ 
+@@ -724,12 +737,24 @@ void __atomic_link_error (void);
+    atomic_exchange_and_add_acq ((mem), (operand)); })
+ # endif
+ 
++/* XXX Fall back to acquire MO because archs do not define a weaker
++   atomic_and_val.  */
++# ifndef atomic_fetch_and_relaxed
++#  define atomic_fetch_and_relaxed(mem, operand) \
++   atomic_fetch_and_acquire ((mem), (operand))
++# endif
+ /* XXX The default for atomic_and_val has acquire semantics, but this is not
+    documented.  */
+ # ifndef atomic_fetch_and_acquire
+ #  define atomic_fetch_and_acquire(mem, operand) \
+    atomic_and_val ((mem), (operand))
+ # endif
++# ifndef atomic_fetch_and_release
++/* XXX This unnecessarily has acquire MO.  */
++#  define atomic_fetch_and_release(mem, operand) \
++   ({ atomic_thread_fence_release ();                                        \
++   atomic_and_val ((mem), (operand)); })
++# endif
+ 
+ /* XXX The default for atomic_or_val has acquire semantics, but this is not
+    documented.  */
+@@ -743,6 +768,28 @@ void __atomic_link_error (void);
+ #  define atomic_fetch_or_relaxed(mem, operand) \
+    atomic_fetch_or_acquire ((mem), (operand))
+ # endif
++/* XXX Contains an unnecessary acquire MO because archs do not define a weaker
++   atomic_or_val.  */
++# ifndef atomic_fetch_or_release
++#  define atomic_fetch_or_release(mem, operand) \
++   ({ atomic_thread_fence_release ();                                        \
++   atomic_fetch_or_acquire ((mem), (operand)); })
++# endif
++
++# ifndef atomic_fetch_xor_release
++# define atomic_fetch_xor_release(mem, operand) \
++  ({ __typeof (*(mem)) __atg104_old;                                         \
++     __typeof (mem) __atg104_memp = (mem);                                   \
++     __typeof (*(mem)) __atg104_op = (operand);                                      \
++                                                                             \
++     do                                                                              \
++       __atg104_old = (*__atg104_memp);                                              \
++     while (__builtin_expect                                                 \
++           (atomic_compare_and_exchange_bool_rel (                           \
++               __atg104_memp, __atg104_old ^ __atg104_op, __atg104_old), 0));\
++                                                                             \
++     __atg104_old; })
++#endif
+ 
+ #endif /* !USE_ATOMIC_COMPILER_BUILTINS  */
+ 
+-- 
+2.10.2
+