[PATCH] [RTEMS] Add <sys/lock.h>

[Sebastian Huber]

Provide self-contained synchronization objects for RTEMS.  The API was
designed to be able to use it for the Newlib internal locks, the C11
threads support, the GCC thread model support and the libgomp operating
system configuration in combination with <pthread.h>.

References:

https://lists.rtems.org/pipermail/devel/2015-July/011989.html
https://lists.rtems.org/pipermail/devel/2015-July/012000.html

Tickets:

https://devel.rtems.org/ticket/1247
https://devel.rtems.org/ticket/2274.

newlib/ChangeLog
2015-07-27  Sebastian Huber  <sebastian.huber at embedded-brains.de>

	* libc/sys/rtems/include/sys/lock.h: New.
---
 newlib/libc/sys/rtems/include/sys/lock.h | 235 +++++++++++++++++++++++++++++++
 1 file changed, 235 insertions(+)
 create mode 100644 newlib/libc/sys/rtems/include/sys/lock.h

diff --git a/newlib/libc/sys/rtems/include/sys/lock.h b/newlib/libc/sys/rtems/include/sys/lock.h
new file mode 100644
index 0000000..4657f28
--- /dev/null
+++ b/newlib/libc/sys/rtems/include/sys/lock.h
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2015 embedded brains GmbH.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _SYS_LOCK_H_
+#define _SYS_LOCK_H_
+
+#include <sys/cdefs.h>
+#include <stddef.h>
+
+__BEGIN_DECLS
+
+struct timespec;
+
+struct _Thread_Control;
+
+struct _Thread_queue_Heads;
+
+struct _Ticket_lock_Control {
+	unsigned int _next_ticket;
+	unsigned int _now_serving;
+};
+
+struct _Thread_queue_Queue {
+	struct _Thread_queue_Heads *_heads;
+	struct _Ticket_lock_Control _Lock;
+};
+
+struct _Mutex_Control {
+	struct _Thread_queue_Queue _Queue;
+	struct _Thread_Control *_owner;
+};
+
+struct _Mutex_recursive_Control {
+	struct _Mutex_Control _Mutex;
+	unsigned int _nest_level;
+};
+
+struct _Condition_Control {
+	struct _Thread_queue_Queue _Queue;
+};
+
+struct _Semaphore_Control {
+	struct _Thread_queue_Queue _Queue;
+	unsigned int _count;
+};
+
+struct _Futex_Control {
+	struct _Thread_queue_Queue _Queue;
+};
+
+#define _THREAD_QUEUE_INITIALIZER { 0, { 0, 0 } }
+
+#define _MUTEX_INITIALIZER { _THREAD_QUEUE_INITIALIZER, 0 }
+
+#define _MUTEX_RECURSIVE_INITIALIZER { _MUTEX_INITIALIZER, 0 }
+
+#define _CONDITION_INITIALIZER { _THREAD_QUEUE_INITIALIZER }
+
+#define _SEMAPHORE_INITIALIZER(_count) { _THREAD_QUEUE_INITIALIZER, _count }
+
+#define _FUTEX_INITIALIZER { _THREAD_QUEUE_INITIALIZER }
+
+static inline void
+_Mutex_Initialize(struct _Mutex_Control *_mutex)
+{
+	struct _Mutex_Control _init = _MUTEX_INITIALIZER;
+
+	*_mutex = _init;
+}
+
+void _Mutex_Acquire(struct _Mutex_Control *);
+
+int _Mutex_Acquire_timed(struct _Mutex_Control *, const struct timespec *);
+
+int _Mutex_Try_acquire(struct _Mutex_Control *);
+
+void _Mutex_Release(struct _Mutex_Control *);
+
+static inline void
+_Mutex_Destroy(struct _Mutex_Control *_mutex)
+{
+
+	(void)_mutex;
+}
+
+static inline void
+_Mutex_recursive_Initialize(struct _Mutex_recursive_Control *_mutex)
+{
+	struct _Mutex_recursive_Control _init = _MUTEX_RECURSIVE_INITIALIZER;
+
+	*_mutex = _init;
+}
+
+void _Mutex_recursive_Acquire(struct _Mutex_recursive_Control *);
+
+int _Mutex_recursive_Acquire_timed(struct _Mutex_recursive_Control *,
+    const struct timespec *);
+
+int _Mutex_recursive_Try_acquire(struct _Mutex_recursive_Control *);
+
+void _Mutex_recursive_Release(struct _Mutex_recursive_Control *);
+
+static inline void
+_Mutex_recursive_Destroy(struct _Mutex_recursive_Control *_mutex)
+{
+
+	(void)_mutex;
+}
+
+static inline void
+_Condition_Initialize(struct _Condition_Control *_cond)
+{
+	struct _Condition_Control _init = _CONDITION_INITIALIZER;
+
+	*_cond = _init;
+}
+
+void _Condition_Wait(struct _Condition_Control *, struct _Mutex_Control *);
+
+int _Condition_Wait_timed(struct _Condition_Control *,
+    struct _Mutex_Control *, const struct timespec *);
+
+void _Condition_Wait_recursive(struct _Condition_Control *,
+    struct _Mutex_recursive_Control *);
+
+void _Condition_Wait_recursive_timed(struct _Condition_Control *,
+    struct _Mutex_recursive_Control *, const struct timespec *);
+
+void _Condition_Signal(struct _Condition_Control *);
+
+void _Condition_Broadcast(struct _Condition_Control *);
+
+static inline void
+_Condition_Destroy(struct _Condition_Control *_cond)
+{
+
+	(void)_cond;
+}
+
+static inline void
+_Semaphore_Initialize(struct _Semaphore_Control *_semaphore,
+    unsigned int _count)
+{
+	struct _Semaphore_Control _init = _SEMAPHORE_INITIALIZER(_count);
+
+	*_semaphore = _init;
+}
+
+void _Semaphore_Wait(struct _Semaphore_Control *);
+
+void _Semaphore_Post(struct _Semaphore_Control *);
+
+static inline void
+_Semaphore_Destroy(struct _Semaphore_Control *_semaphore)
+{
+
+	(void)_semaphore;
+}
+
+static inline void
+_Futex_Initialize(struct _Futex_Control *_futex)
+{
+	struct _Futex_Control _init = _FUTEX_INITIALIZER;
+
+	*_futex = _init;
+}
+
+int _Futex_Wait(struct _Futex_Control *, int *, int);
+
+int _Futex_Wake(struct _Futex_Control *, int);
+
+static inline void
+_Futex_Destroy(struct _Futex_Control *_futex)
+{
+
+	(void)_futex;
+}
+
+int _Sched_Count(void);
+
+int _Sched_Index(void);
+
+int _Sched_Name_to_index(const char *, size_t);
+
+int _Sched_Processor_count(int);
+
+/* Newlib internal locks */
+
+typedef struct _Mutex_Control _LOCK_T;
+
+typedef struct _Mutex_recursive_Control _LOCK_RECURSIVE_T;
+
+#define __LOCK_INIT(_qualifier, _designator) \
+    _qualifier _LOCK_T _designator = _MUTEX_INITIALIZER
+
+#define __LOCK_INIT_RECURSIVE(_qualifier, _designator) \
+    _qualifier _LOCK_T _designator = _MUTEX_RECURSIVE_INITIALIZER
+
+#define __lock_init(_lock) _Mutex_Initialize(&_lock)
+#define __lock_acquire(_lock) _Mutex_Acquire(&_lock)
+#define __lock_try_acquire(lock) _Mutex_Try_acquire(&_lock)
+#define __lock_release(_lock) _Mutex_Release(&_lock)
+#define __lock_close(_lock) _Mutex_Destroy(&_lock)
+
+#define __lock_init_recursive(_lock) _Mutex_recursive_Initialize(&_lock)
+#define __lock_acquire_recursive(_lock) _Mutex_recursive_Acquire(&_lock)
+#define __lock_try_acquire_recursive(lock) _Mutex_recursive_Try_acquire(&_lock)
+#define __lock_release_recursive(_lock) _Mutex_recursive_Release(&_lock)
+#define __lock_close_recursive(_lock) _Mutex_recursive_Destroy(&_lock)
+
+__END_DECLS
+
+#endif /* _SYS_LOCK_H_ */
-- 
1.8.4.5