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

[Jeff Johnston <jjohnstn at redhat dot com>]

I am fine with this.

-- Jeff J.

----- Original Message -----
> This file is RTEMS specific and I am OK with it.
> 
> Sebastian is about to go on holiday so it would be appreciated
> to get this approved before he leaves.
> 
> OK to commit?
> 
> 
> On 07/27/2015 07:45 AM, Sebastian Huber wrote:
> > 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@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_ */
> 
> 
> --
> -- Joel Sherrill
> Ask me about RTEMS: a free RTOS
> Support and Training Available
> 
>