1: /* libc-internal interface for mutex locks. Stub version. 2: Copyright (C) 1996,97,99,2000-2002,2003 Free Software Foundation, Inc. 3: This file is part of the GNU C Library. 4: 5: The GNU C Library is free software; you can redistribute it and/or 6: modify it under the terms of the GNU Lesser General Public 7: License as published by the Free Software Foundation; either 8: version 2.1 of the License, or (at your option) any later version. 9: 10: The GNU C Library is distributed in the hope that it will be useful, 11: but WITHOUT ANY WARRANTY; without even the implied warranty of 12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13: Lesser General Public License for more details. 14: 15: You should have received a copy of the GNU Lesser General Public 16: License along with the GNU C Library; if not, write to the Free 17: Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 18: 02111-1307 USA. */ 19: 20: #ifndef _BITS_LIBC_LOCK_H 21: #define _BITS_LIBC_LOCK_H 1 22: 23: 24: /* Define a lock variable NAME with storage class CLASS. The lock must be 25: initialized with __libc_lock_init before it can be used (or define it 26: with __libc_lock_define_initialized, below). Use `extern' for CLASS to 27: declare a lock defined in another module. In public structure 28: definitions you must use a pointer to the lock structure (i.e., NAME 29: begins with a `*'), because its storage size will not be known outside 30: of libc. */ 31: #define __libc_lock_define(CLASS,NAME) 32: #define __libc_lock_define_recursive(CLASS,NAME) 33: #define __rtld_lock_define_recursive(CLASS,NAME) 34: #define __libc_rwlock_define(CLASS,NAME) 35: 36: /* Define an initialized lock variable NAME with storage class CLASS. */ 37: #define __libc_lock_define_initialized(CLASS,NAME) 38: #define __libc_rwlock_define_initialized(CLASS,NAME) 39: 40: /* Define an initialized recursive lock variable NAME with storage 41: class CLASS. */ 42: #define __libc_lock_define_initialized_recursive(CLASS,NAME) 43: #define __rtld_lock_define_initialized_recursive(CLASS,NAME) 44: 45: /* Initialize the named lock variable, leaving it in a consistent, unlocked 46: state. */ 47: #define __libc_lock_init(NAME) 48: #define __libc_rwlock_init(NAME) 49: 50: /* Same as last but this time we initialize a recursive mutex. */ 51: #define __libc_lock_init_recursive(NAME) 52: #define __rtld_lock_init_recursive(NAME) 53: 54: /* Finalize the named lock variable, which must be locked. It cannot be 55: used again until __libc_lock_init is called again on it. This must be 56: called on a lock variable before the containing storage is reused. */ 57: #define __libc_lock_fini(NAME) 58: #define __libc_rwlock_fini(NAME) 59: 60: /* Finalize recursive named lock. */ 61: #define __libc_lock_fini_recursive(NAME) 62: 63: /* Lock the named lock variable. */ 64: #define __libc_lock_lock(NAME) 65: #define __libc_rwlock_rdlock(NAME) 66: #define __libc_rwlock_wrlock(NAME) 67: 68: /* Lock the recursive named lock variable. */ 69: #define __libc_lock_lock_recursive(NAME) 70: #define __rtld_lock_lock_recursive(NAME) 71: 72: /* Try to lock the named lock variable. */ 73: #define __libc_lock_trylock(NAME) 0 74: #define __libc_rwlock_tryrdlock(NAME) 0 75: #define __libc_rwlock_trywrlock(NAME) 0 76: 77: /* Try to lock the recursive named lock variable. */ 78: #define __libc_lock_trylock_recursive(NAME) 0 79: 80: /* Unlock the named lock variable. */ 81: #define __libc_lock_unlock(NAME) 82: #define __libc_rwlock_unlock(NAME) 83: 84: /* Unlock the recursive named lock variable. */ 85: #define __libc_lock_unlock_recursive(NAME) 86: #define __rtld_lock_unlock_recursive(NAME) 87: 88: 89: /* Define once control variable. */ 90: #define __libc_once_define(CLASS, NAME) CLASS int NAME = 0 91: 92: /* Call handler iff the first call. */ 93: #define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \ 94: do { \ 95: if ((ONCE_CONTROL) == 0) { \ 96: INIT_FUNCTION (); \ 97: (ONCE_CONTROL) = 1; \ 98: } \ 99: } while (0) 100: 101: 102: /* Start a critical region with a cleanup function */ 103: #define __libc_cleanup_region_start(DOIT, FCT, ARG) \ 104: { \ 105: typeof (***(FCT)) *__save_FCT = (DOIT) ? (FCT) : 0; \ 106: typeof (ARG) __save_ARG = ARG; \ 107: /* close brace is in __libc_cleanup_region_end below. */ 108: 109: /* End a critical region started with __libc_cleanup_region_start. */ 110: #define __libc_cleanup_region_end(DOIT) \ 111: if ((DOIT) && __save_FCT != 0) \ 112: (*__save_FCT)(__save_ARG); \ 113: } 114: 115: /* Sometimes we have to exit the block in the middle. */ 116: #define __libc_cleanup_end(DOIT) \ 117: if ((DOIT) && __save_FCT != 0) \ 118: (*__save_FCT)(__save_ARG); \ 119: 120: #define __libc_cleanup_push(fct, arg) __libc_cleanup_region_start (1, fct, arg) 121: #define __libc_cleanup_pop(execute) __libc_cleanup_region_end (execute) 122: 123: /* We need portable names for some of the functions. */ 124: #define __libc_mutex_unlock 125: 126: /* Type for key of thread specific data. */ 127: typedef int __libc_key_t; 128: 129: /* Create key for thread specific data. */ 130: #define __libc_key_create(KEY,DEST) -1 131: 132: /* Set thread-specific data associated with KEY to VAL. */ 133: #define __libc_setspecific(KEY,VAL) ((void)0) 134: 135: /* Get thread-specific data associated with KEY. */ 136: #define __libc_getspecific(KEY) 0 137: 138: #endif /* bits/libc-lock.h */