Adjust for new form of compare&exchange macros.
[kopensolaris-gnu/glibc.git] / nptl / cancellation.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 <setjmp.h>
21 #include <stdlib.h>
22 #include "pthreadP.h"
23 #include "atomic.h"
24
25
26 /* The next two functions are similar to pthread_setcanceltype() but
27    more specialized for the use in the cancelable functions like write().
28    They do not need to check parameters etc.  */
29 int
30 attribute_hidden
31 __pthread_enable_asynccancel (void)
32 {
33   struct pthread *self = THREAD_SELF;
34   int oldval;
35
36   while (1)
37     {
38       oldval = THREAD_GETMEM (self, cancelhandling);
39       int newval = oldval | CANCELTYPE_BITMASK;
40
41       if (newval == oldval)
42         break;
43
44       if (! atomic_compare_and_exchange_bool_acq (&self->cancelhandling,
45                                                   newval, oldval))
46         {
47           if (CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS (newval))
48             {
49               THREAD_SETMEM (self, result, PTHREAD_CANCELED);
50               __do_cancel ();
51             }
52
53           break;
54         }
55     }
56
57   return oldval;
58 }
59
60 /* XXX Ideally we have only one version.  But this needs preparation.  */
61 void
62 internal_function attribute_hidden
63 __pthread_enable_asynccancel_2 (int *oldvalp)
64 {
65   struct pthread *self = THREAD_SELF;
66
67   while (1)
68     {
69       int oldval = *oldvalp = THREAD_GETMEM (self, cancelhandling);
70       int newval = oldval | CANCELTYPE_BITMASK;
71
72       if (newval == oldval)
73         break;
74
75       if (! atomic_compare_and_exchange_bool_acq (&self->cancelhandling,
76                                                   newval, oldval))
77         {
78           if (CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS (newval))
79             {
80               THREAD_SETMEM (self, result, PTHREAD_CANCELED);
81               __do_cancel ();
82             }
83
84           break;
85         }
86     }
87 }
88
89
90 void
91 internal_function attribute_hidden
92 __pthread_disable_asynccancel (int oldtype)
93 {
94   /* If asynchronous cancellation was enabled before we do not have
95      anything to do.  */
96   if (oldtype & CANCELTYPE_BITMASK)
97     return;
98
99   struct pthread *self = THREAD_SELF;
100
101   while (1)
102     {
103       int oldval = THREAD_GETMEM (self, cancelhandling);
104       int newval = oldval & ~CANCELTYPE_BITMASK;
105
106       if (newval == oldval)
107         break;
108
109       if (! atomic_compare_and_exchange_bool_acq (&self->cancelhandling,
110                                                   newval, oldval))
111         break;
112     }
113 }