arm-linux-gnueabihf/sys-root/usr/include/bits/libc-lock.h - toolchains/bruno_arm - Git at Google

 /* libc-internal interface for mutex locks.  NPTL version.
    Copyright (C) 1996-2013 Free Software Foundation, Inc.
    This file is part of the GNU C Library.

    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 of the
    License, or (at your option) any later version.

    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with the GNU C Library; see the file COPYING.LIB.  If
    not, see <http://www.gnu.org/licenses/>.  */

 #ifndef _BITS_LIBC_LOCK_H
 #define _BITS_LIBC_LOCK_H 1

 #include <pthread.h>
 #define __need_NULL
 #include <stddef.h>


 #ifdef _LIBC
 # include <lowlevellock.h>
 # include <tls.h>
 # include <pthread-functions.h>
 # include <errno.h> /* For EBUSY.  */
 # include <gnu/option-groups.h> /* For __OPTION_EGLIBC_BIG_MACROS.  */
 #endif

 /* Mutex type.  */
 #if defined _LIBC || defined _IO_MTSAFE_IO
 # if (defined NOT_IN_libc && !defined IS_IN_libpthread) || !defined _LIBC
 typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
 # else
 typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t;
 # endif
 #else
 typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
 #endif

 /* Define a lock variable NAME with storage class CLASS.  The lock must be
    initialized with __libc_lock_init before it can be used (or define it
    with __libc_lock_define_initialized, below).  Use `extern' for CLASS to
    declare a lock defined in another module.  In public structure
    definitions you must use a pointer to the lock structure (i.e., NAME
    begins with a `*'), because its storage size will not be known outside
    of libc.  */
 #define __libc_lock_define_recursive(CLASS,NAME) \
   CLASS __libc_lock_recursive_t NAME;

 /* Define an initialized recursive lock variable NAME with storage
    class CLASS.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # if LLL_LOCK_INITIALIZER == 0
 #  define __libc_lock_define_initialized_recursive(CLASS,NAME) \
   CLASS __libc_lock_recursive_t NAME;
 # else
 #  define __libc_lock_define_initialized_recursive(CLASS,NAME) \
   CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
 # endif
 # define _LIBC_LOCK_RECURSIVE_INITIALIZER \
   { LLL_LOCK_INITIALIZER, 0, NULL }
 #else
 # define __libc_lock_define_initialized_recursive(CLASS,NAME) \
   CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
 # define _LIBC_LOCK_RECURSIVE_INITIALIZER \
   {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
 #endif

 /* Initialize a recursive mutex.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # define __libc_lock_init_recursive(NAME) \
   ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0)
 #else
 # define __libc_lock_init_recursive(NAME) \
   do {									      \
     if (__pthread_mutex_init != NULL)					      \
       {									      \
 	pthread_mutexattr_t __attr;					      \
 	__pthread_mutexattr_init (&__attr);				      \
 	__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP);    \
 	__pthread_mutex_init (&(NAME).mutex, &__attr);			      \
 	__pthread_mutexattr_destroy (&__attr);				      \
       }									      \
   } while (0)
 #endif

 /* Finalize recursive named lock.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # define __libc_lock_fini_recursive(NAME) ((void) 0)
 #else
 # define __libc_lock_fini_recursive(NAME) \
   __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
 #endif

 /* Lock the recursive named lock variable.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # if __OPTION_EGLIBC_BIG_MACROS != 1
 /* EGLIBC: Declare wrapper function for a big macro if either
    !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from
    small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2).  */
 extern void __libc_lock_lock_recursive_fn (__libc_lock_recursive_t *);
 libc_hidden_proto (__libc_lock_lock_recursive_fn);
 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
 # if __OPTION_EGLIBC_BIG_MACROS
 # define __libc_lock_lock_recursive(NAME) \
   do {									      \
     void *self = THREAD_SELF;						      \
     if ((NAME).owner != self)						      \
       {									      \
 	lll_lock ((NAME).lock, LLL_PRIVATE);				      \
 	(NAME).owner = self;						      \
       }									      \
     ++(NAME).cnt;							      \
   } while (0)
 # else
 # define __libc_lock_lock_recursive(NAME)				\
   __libc_lock_lock_recursive_fn (&(NAME))
 # endif /* __OPTION_EGLIBC_BIG_MACROS */
 #else
 # define __libc_lock_lock_recursive(NAME) \
   __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
 #endif

 /* Try to lock the recursive named lock variable.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # if __OPTION_EGLIBC_BIG_MACROS != 1
 /* EGLIBC: Declare wrapper function for a big macro if either
    !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from
    small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2).  */
 extern int __libc_lock_trylock_recursive_fn (__libc_lock_recursive_t *);
 libc_hidden_proto (__libc_lock_trylock_recursive_fn);
 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
 # if __OPTION_EGLIBC_BIG_MACROS
 # define __libc_lock_trylock_recursive(NAME) \
   ({									      \
     int result = 0;							      \
     void *self = THREAD_SELF;						      \
     if ((NAME).owner != self)						      \
       {									      \
 	if (lll_trylock ((NAME).lock) == 0)				      \
 	  {								      \
 	    (NAME).owner = self;					      \
 	    (NAME).cnt = 1;						      \
 	  }								      \
 	else								      \
 	  result = EBUSY;						      \
       }									      \
     else								      \
       ++(NAME).cnt;							      \
     result;								      \
   })
 # else
 # define __libc_lock_trylock_recursive(NAME) \
   __libc_lock_trylock_recursive_fn (&(NAME))
 # endif /* __OPTION_EGLIBC_BIG_MACROS */
 #else
 # define __libc_lock_trylock_recursive(NAME) \
   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
 #endif

 /* Unlock the recursive named lock variable.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # if __OPTION_EGLIBC_BIG_MACROS != 1
 /* EGLIBC: Declare wrapper function for a big macro if either
    !__OPTION_EGLIBC_BIG_MACROS, or we are using a back door from
    small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2).  */
 extern void __libc_lock_unlock_recursive_fn (__libc_lock_recursive_t *);
 libc_hidden_proto (__libc_lock_unlock_recursive_fn);
 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
 # if __OPTION_EGLIBC_BIG_MACROS
 /* We do no error checking here.  */
 # define __libc_lock_unlock_recursive(NAME) \
   do {									      \
     if (--(NAME).cnt == 0)						      \
       {									      \
 	(NAME).owner = NULL;						      \
 	lll_unlock ((NAME).lock, LLL_PRIVATE);				      \
       }									      \
   } while (0)
 # else
 # define __libc_lock_unlock_recursive(NAME) \
   __libc_lock_unlock_recursive_fn (&(NAME))
 # endif /* __OPTION_EGLIBC_BIG_MACROS */
 #else
 # define __libc_lock_unlock_recursive(NAME) \
   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
 #endif

 /* Note that for I/O cleanup handling we are using the old-style
    cancel handling.  It does not have to be integrated with C++ since
    no C++ code is called in the middle.  The old-style handling is
    faster and the support is not going away.  */
 extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
 					 void (*routine) (void *), void *arg);
 extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
 					  int execute);

 /* Start critical region with cleanup.  */
 #define __libc_cleanup_region_start(DOIT, FCT, ARG) \
   { struct _pthread_cleanup_buffer _buffer;				      \
     int _avail;								      \
     if (DOIT) {								      \
       _avail = PTFAVAIL (_pthread_cleanup_push_defer);			      \
       if (_avail) {							      \
 	__libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT,  \
 							      ARG));	      \
       } else {								      \
 	_buffer.__routine = (FCT);					      \
 	_buffer.__arg = (ARG);						      \
       }									      \
     } else {								      \
       _avail = 0;							      \
     }

 /* End critical region with cleanup.  */
 #define __libc_cleanup_region_end(DOIT) \
     if (_avail) {							      \
       __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
     } else if (DOIT)							      \
       _buffer.__routine (_buffer.__arg);				      \
   }


 /* Hide the definitions which are only supposed to be used inside libc in
    a separate file.  This file is not present in the installation!  */
 #ifdef _LIBC
 # include "libc-lockP.h"
 #endif

 #endif	/* bits/libc-lock.h */
	/* libc-internal interface for mutex locks. NPTL version.
	Copyright (C) 1996-2013 Free Software Foundation, Inc.
	This file is part of the GNU C Library.

	The GNU C Library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public License as
	published by the Free Software Foundation; either version 2.1 of the
	License, or (at your option) any later version.

	The GNU C Library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with the GNU C Library; see the file COPYING.LIB. If
	not, see <http://www.gnu.org/licenses/>. */

	#ifndef _BITS_LIBC_LOCK_H
	#define _BITS_LIBC_LOCK_H 1

	#include <pthread.h>
	#define __need_NULL
	#include <stddef.h>


	#ifdef _LIBC
	# include <lowlevellock.h>
	# include <tls.h>
	# include <pthread-functions.h>
	# include <errno.h> /* For EBUSY. */
	# include <gnu/option-groups.h> /* For __OPTION_EGLIBC_BIG_MACROS. */
	#endif

	/* Mutex type. */
	#if defined _LIBC \|\| defined _IO_MTSAFE_IO
	# if (defined NOT_IN_libc && !defined IS_IN_libpthread) \|\| !defined _LIBC
	typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
	# else
	typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t;
	# endif
	#else
	typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
	#endif

	/* Define a lock variable NAME with storage class CLASS. The lock must be
	initialized with __libc_lock_init before it can be used (or define it
	with __libc_lock_define_initialized, below). Use `extern' for CLASS to
	declare a lock defined in another module. In public structure
	definitions you must use a pointer to the lock structure (i.e., NAME
	begins with a `*'), because its storage size will not be known outside
	of libc. */
	#define __libc_lock_define_recursive(CLASS,NAME) \
	CLASS __libc_lock_recursive_t NAME;

	/* Define an initialized recursive lock variable NAME with storage
	class CLASS. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# if LLL_LOCK_INITIALIZER == 0
	# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
	CLASS __libc_lock_recursive_t NAME;
	# else
	# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
	CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
	# endif
	# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
	{ LLL_LOCK_INITIALIZER, 0, NULL }
	#else
	# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
	CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
	# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
	{PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
	#endif

	/* Initialize a recursive mutex. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# define __libc_lock_init_recursive(NAME) \
	((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0)
	#else
	# define __libc_lock_init_recursive(NAME) \
	do { \
	if (__pthread_mutex_init != NULL) \
	{ \
	pthread_mutexattr_t __attr; \
	__pthread_mutexattr_init (&__attr); \
	__pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
	__pthread_mutex_init (&(NAME).mutex, &__attr); \
	__pthread_mutexattr_destroy (&__attr); \
	} \
	} while (0)
	#endif

	/* Finalize recursive named lock. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# define __libc_lock_fini_recursive(NAME) ((void) 0)
	#else
	# define __libc_lock_fini_recursive(NAME) \
	__libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
	#endif

	/* Lock the recursive named lock variable. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# if __OPTION_EGLIBC_BIG_MACROS != 1
	/* EGLIBC: Declare wrapper function for a big macro if either
	!__OPTION_EGLIBC_BIG_MACROS or we are using a back door from
	small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */
	extern void __libc_lock_lock_recursive_fn (__libc_lock_recursive_t *);
	libc_hidden_proto (__libc_lock_lock_recursive_fn);
	# endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
	# if __OPTION_EGLIBC_BIG_MACROS
	# define __libc_lock_lock_recursive(NAME) \
	do { \
	void *self = THREAD_SELF; \
	if ((NAME).owner != self) \
	{ \
	lll_lock ((NAME).lock, LLL_PRIVATE); \
	(NAME).owner = self; \
	} \
	++(NAME).cnt; \
	} while (0)
	# else
	# define __libc_lock_lock_recursive(NAME) \
	__libc_lock_lock_recursive_fn (&(NAME))
	# endif /* __OPTION_EGLIBC_BIG_MACROS */
	#else
	# define __libc_lock_lock_recursive(NAME) \
	__libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
	#endif

	/* Try to lock the recursive named lock variable. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# if __OPTION_EGLIBC_BIG_MACROS != 1
	/* EGLIBC: Declare wrapper function for a big macro if either
	!__OPTION_EGLIBC_BIG_MACROS or we are using a back door from
	small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */
	extern int __libc_lock_trylock_recursive_fn (__libc_lock_recursive_t *);
	libc_hidden_proto (__libc_lock_trylock_recursive_fn);
	# endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
	# if __OPTION_EGLIBC_BIG_MACROS
	# define __libc_lock_trylock_recursive(NAME) \
	({ \
	int result = 0; \
	void *self = THREAD_SELF; \
	if ((NAME).owner != self) \
	{ \
	if (lll_trylock ((NAME).lock) == 0) \
	{ \
	(NAME).owner = self; \
	(NAME).cnt = 1; \
	} \
	else \
	result = EBUSY; \
	} \
	else \
	++(NAME).cnt; \
	result; \
	})
	# else
	# define __libc_lock_trylock_recursive(NAME) \
	__libc_lock_trylock_recursive_fn (&(NAME))
	# endif /* __OPTION_EGLIBC_BIG_MACROS */
	#else
	# define __libc_lock_trylock_recursive(NAME) \
	__libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
	#endif

	/* Unlock the recursive named lock variable. */
	#if defined _LIBC && (!defined NOT_IN_libc \|\| defined IS_IN_libpthread)
	# if __OPTION_EGLIBC_BIG_MACROS != 1
	/* EGLIBC: Declare wrapper function for a big macro if either
	!__OPTION_EGLIBC_BIG_MACROS, or we are using a back door from
	small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */
	extern void __libc_lock_unlock_recursive_fn (__libc_lock_recursive_t *);
	libc_hidden_proto (__libc_lock_unlock_recursive_fn);
	# endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */
	# if __OPTION_EGLIBC_BIG_MACROS
	/* We do no error checking here. */
	# define __libc_lock_unlock_recursive(NAME) \
	do { \
	if (--(NAME).cnt == 0) \
	{ \
	(NAME).owner = NULL; \
	lll_unlock ((NAME).lock, LLL_PRIVATE); \
	} \
	} while (0)
	# else
	# define __libc_lock_unlock_recursive(NAME) \
	__libc_lock_unlock_recursive_fn (&(NAME))
	# endif /* __OPTION_EGLIBC_BIG_MACROS */
	#else
	# define __libc_lock_unlock_recursive(NAME) \
	__libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
	#endif

	/* Note that for I/O cleanup handling we are using the old-style
	cancel handling. It does not have to be integrated with C++ since
	no C++ code is called in the middle. The old-style handling is
	faster and the support is not going away. */
	extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
	void (routine) (void ), void *arg);
	extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
	int execute);

	/* Start critical region with cleanup. */
	#define __libc_cleanup_region_start(DOIT, FCT, ARG) \
	{ struct _pthread_cleanup_buffer _buffer; \
	int _avail; \
	if (DOIT) { \
	_avail = PTFAVAIL (_pthread_cleanup_push_defer); \
	if (_avail) { \
	__libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT, \
	ARG)); \
	} else { \
	_buffer.__routine = (FCT); \
	_buffer.__arg = (ARG); \
	} \
	} else { \
	_avail = 0; \
	}

	/* End critical region with cleanup. */
	#define __libc_cleanup_region_end(DOIT) \
	if (_avail) { \
	__libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
	} else if (DOIT) \
	_buffer.__routine (_buffer.__arg); \
	}


	/* Hide the definitions which are only supposed to be used inside libc in
	a separate file. This file is not present in the installation! */
	#ifdef _LIBC
	# include "libc-lockP.h"
	#endif

	#endif /* bits/libc-lock.h */