/* libc-internal interface for mutex locks. NPTL version.
Copyright (C) 1996-2018 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 _LIBC_LOCK_H
#define _LIBC_LOCK_H 1
#include <pthread.h>
#define __need_NULL
#include <stddef.h>
/* Mutex type. */
#if defined _LIBC || defined _IO_MTSAFE_IO
# if (!IS_IN (libc) && !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 && (IS_IN (libc) || IS_IN (libpthread))
# define __libc_lock_define_initialized_recursive(CLASS, NAME) \
CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
# 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 && (IS_IN (libc) || IS_IN (libpthread))
# define __libc_lock_init_recursive(NAME) \
((void) ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER))
#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 && (IS_IN (libc) || 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).mutex), 0)
#endif
/* Lock the recursive named lock variable. */
#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
# 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_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
#endif
/* Try to lock the recursive named lock variable. */
#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
# 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_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0)
#endif
/* Unlock the recursive named lock variable. */
#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
/* 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_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 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 /* libc-lock.h */