1  /* Thread package specific definitions of stream lock type.  NPTL version.
       2     Copyright (C) 2000-2023 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, see
      17     <https://www.gnu.org/licenses/>.  */
      18  
      19  #ifndef _STDIO_LOCK_H
      20  #define _STDIO_LOCK_H 1
      21  
      22  #include <libc-lock.h>
      23  #include <lowlevellock.h>
      24  
      25  
      26  typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
      27  #define _IO_lock_t_defined 1
      28  
      29  #define _IO_lock_initializer { LLL_LOCK_INITIALIZER, 0, NULL }
      30  
      31  #define _IO_lock_init(_name) \
      32    ((void) ((_name) = (_IO_lock_t) _IO_lock_initializer))
      33  
      34  #define _IO_lock_fini(_name) \
      35    ((void) 0)
      36  
      37  #define _IO_lock_lock(_name) \
      38    do {									      \
      39      void *__self = THREAD_SELF;						      \
      40      if (SINGLE_THREAD_P && (_name).owner == NULL)			      \
      41        {									      \
      42  	(_name).lock = LLL_LOCK_INITIALIZER_LOCKED;			      \
      43  	(_name).owner = __self;						      \
      44        }									      \
      45      else if ((_name).owner != __self)					      \
      46        {									      \
      47  	lll_lock ((_name).lock, LLL_PRIVATE);				      \
      48  	(_name).owner = __self;						      \
      49        }									      \
      50      else								      \
      51        ++(_name).cnt;							      \
      52    } while (0)
      53  
      54  #define _IO_lock_trylock(_name) \
      55    ({									      \
      56      int __result = 0;							      \
      57      void *__self = THREAD_SELF;						      \
      58      if ((_name).owner != __self)					      \
      59        {									      \
      60          if (lll_trylock ((_name).lock) == 0)				      \
      61  	  (_name).owner = __self;					      \
      62          else								      \
      63            __result = EBUSY;						      \
      64        }									      \
      65      else								      \
      66        ++(_name).cnt;							      \
      67      __result;								      \
      68    })
      69  
      70  #define _IO_lock_unlock(_name) \
      71    do {									      \
      72      if (SINGLE_THREAD_P && (_name).cnt == 0)				      \
      73        {									      \
      74  	(_name).owner = NULL;						      \
      75  	(_name).lock = 0;						      \
      76        }									      \
      77      else if ((_name).cnt == 0)						      \
      78        {									      \
      79  	(_name).owner = NULL;						      \
      80  	lll_unlock ((_name).lock, LLL_PRIVATE);				      \
      81        }									      \
      82      else								      \
      83        --(_name).cnt;							      \
      84    } while (0)
      85  
      86  
      87  
      88  #define _IO_cleanup_region_start(_fct, _fp) \
      89    __libc_cleanup_region_start (((_fp)->_flags & _IO_USER_LOCK) == 0, _fct, _fp)
      90  #define _IO_cleanup_region_start_noarg(_fct) \
      91    __libc_cleanup_region_start (1, _fct, NULL)
      92  #define _IO_cleanup_region_end(_doit) \
      93    __libc_cleanup_region_end (_doit)
      94  
      95  #if defined _LIBC && IS_IN (libc)
      96  
      97  # ifdef __EXCEPTIONS
      98  #  define _IO_acquire_lock(_fp) \
      99    do {									      \
     100      FILE *_IO_acquire_lock_file						      \
     101  	__attribute__((cleanup (_IO_acquire_lock_fct)))			      \
     102  	= (_fp);							      \
     103      _IO_flockfile (_IO_acquire_lock_file);
     104  # else
     105  #  define _IO_acquire_lock(_fp) _IO_acquire_lock_needs_exceptions_enabled
     106  # endif
     107  # define _IO_release_lock(_fp) ; } while (0)
     108  
     109  #endif
     110  
     111  #endif /* stdio-lock.h */