084216e44b3072c4b04ff81b82750287ba646947
[kopensolaris-gnu/glibc.git] / nptl / cleanup_defer.c
1 /* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
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 #include "pthreadP.h"
21 #include <atomic.h>
22
23
24 void
25 _pthread_cleanup_push_defer (buffer, routine, arg)
26      struct _pthread_cleanup_buffer *buffer;
27      void (*routine) (void *);
28      void *arg;
29 {
30   struct pthread *self = THREAD_SELF;
31
32   buffer->__routine = routine;
33   buffer->__arg = arg;
34   buffer->__prev = THREAD_GETMEM (self, cleanup);
35
36   if (buffer->__prev != NULL && FRAME_LEFT (buffer, buffer->__prev))
37     buffer->__prev = NULL;
38
39   int cancelhandling = THREAD_GETMEM (self, cancelhandling);
40
41   /* Disable asynchronous cancellation for now.  */
42   if (__builtin_expect (cancelhandling & CANCELTYPE_BITMASK, 0))
43     {
44       while (atomic_compare_and_exchange_acq (&self->cancelhandling,
45                                               cancelhandling
46                                               & ~CANCELTYPE_BITMASK,
47                                               cancelhandling) != 0)
48         cancelhandling = self->cancelhandling;
49     }
50
51   buffer->__canceltype = (cancelhandling & CANCELTYPE_BITMASK
52                           ? PTHREAD_CANCEL_ASYNCHRONOUS
53                           : PTHREAD_CANCEL_DEFERRED);
54
55   THREAD_SETMEM (self, cleanup, buffer);
56 }
57 strong_alias (_pthread_cleanup_push_defer, __pthread_cleanup_push_defer)
58
59 void
60 _pthread_cleanup_pop_restore (buffer, execute)
61      struct _pthread_cleanup_buffer *buffer;
62      int execute;
63 {
64   struct pthread *self = THREAD_SELF;
65
66   THREAD_SETMEM (self, cleanup, buffer->__prev);
67
68   int cancelhandling;
69   if (__builtin_expect (buffer->__canceltype != PTHREAD_CANCEL_DEFERRED, 0)
70       && ((cancelhandling = THREAD_GETMEM (self, cancelhandling))
71           & CANCELTYPE_BITMASK) == 0)
72     {
73       while (atomic_compare_and_exchange_acq (&self->cancelhandling,
74                                               cancelhandling
75                                               | CANCELTYPE_BITMASK,
76                                               cancelhandling) != 0)
77         cancelhandling = self->cancelhandling;
78
79       CANCELLATION_P (self);
80     }
81
82   /* If necessary call the cleanup routine after we removed the
83      current cleanup block from the list.  */
84   if (execute)
85     buffer->__routine (buffer->__arg);
86 }
87 strong_alias (_pthread_cleanup_pop_restore, __pthread_cleanup_pop_restore)