1  /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C Library is free software; you can redistribute it and/or
       5     modify it under the terms of the GNU Lesser General Public
       6     License as published by the Free Software Foundation; either
       7     version 2.1 of the License, or (at your option) any later version.
       8  
       9     The GNU C Library is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12     Lesser General Public License for more details.
      13  
      14     You should have received a copy of the GNU Lesser General Public
      15     License along with the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <stdlib.h>
      19  #include "pthreadP.h"
      20  #include <shlib-compat.h>
      21  
      22  void
      23  __cleanup_fct_attribute
      24  ___pthread_register_cancel_defer (__pthread_unwind_buf_t *buf)
      25  {
      26    struct pthread_unwind_buf *ibuf = (struct pthread_unwind_buf *) buf;
      27    struct pthread *self = THREAD_SELF;
      28  
      29    /* Store old info.  */
      30    ibuf->priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
      31    ibuf->priv.data.cleanup = THREAD_GETMEM (self, cleanup);
      32  
      33    int cancelhandling = atomic_load_relaxed (&self->cancelhandling);
      34    if (__glibc_unlikely (cancelhandling & CANCELTYPE_BITMASK))
      35      {
      36        int newval;
      37        do
      38  	{
      39  	  newval = cancelhandling & ~CANCELTYPE_BITMASK;
      40  	}
      41        while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling,
      42  						    &cancelhandling,
      43  						    newval));
      44      }
      45  
      46    ibuf->priv.data.canceltype = (cancelhandling & CANCELTYPE_BITMASK
      47  				? PTHREAD_CANCEL_ASYNCHRONOUS
      48  				: PTHREAD_CANCEL_DEFERRED);
      49  
      50    /* Store the new cleanup handler info.  */
      51    THREAD_SETMEM (self, cleanup_jmp_buf, (struct pthread_unwind_buf *) buf);
      52  }
      53  versioned_symbol (libc, ___pthread_register_cancel_defer,
      54  		  __pthread_register_cancel_defer, GLIBC_2_34);
      55  
      56  #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_3_3, GLIBC_2_34)
      57  compat_symbol (libpthread, ___pthread_register_cancel_defer,
      58  	       __pthread_register_cancel_defer, GLIBC_2_3_3);
      59  #endif
      60  
      61  void
      62  __cleanup_fct_attribute
      63  ___pthread_unregister_cancel_restore (__pthread_unwind_buf_t *buf)
      64  {
      65    struct pthread *self = THREAD_SELF;
      66    struct pthread_unwind_buf *ibuf = (struct pthread_unwind_buf *) buf;
      67  
      68    THREAD_SETMEM (self, cleanup_jmp_buf, ibuf->priv.data.prev);
      69  
      70    if (ibuf->priv.data.canceltype == PTHREAD_CANCEL_DEFERRED)
      71      return;
      72  
      73    int cancelhandling = atomic_load_relaxed (&self->cancelhandling);
      74    if ((cancelhandling & CANCELTYPE_BITMASK) == 0)
      75      {
      76        int newval;
      77        do
      78  	{
      79  	  newval = cancelhandling | CANCELTYPE_BITMASK;
      80  	}
      81        while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling,
      82  						    &cancelhandling, newval));
      83  
      84        if (cancel_enabled_and_canceled (cancelhandling))
      85  	{
      86  	  self->result = PTHREAD_CANCELED;
      87  	  __do_cancel ();
      88  	}
      89      }
      90  }
      91  versioned_symbol (libc, ___pthread_unregister_cancel_restore,
      92  		  __pthread_unregister_cancel_restore, GLIBC_2_34);
      93  
      94  #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_3_3, GLIBC_2_34)
      95  compat_symbol (libpthread, ___pthread_unregister_cancel_restore,
      96  	       __pthread_unregister_cancel_restore, GLIBC_2_3_3);
      97  #endif