xref: /freebsd/lib/libthr/thread/thr_cancel.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
1 /*
2  * Copyright (c) 2005, David Xu <davidxu@freebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  *
28  */
29 
30 #include "namespace.h"
31 #include <pthread.h>
32 #include "un-namespace.h"
33 
34 #include "thr_private.h"
35 
36 __weak_reference(_pthread_cancel, pthread_cancel);
37 __weak_reference(_pthread_setcancelstate, pthread_setcancelstate);
38 __weak_reference(_pthread_setcanceltype, pthread_setcanceltype);
39 __weak_reference(_pthread_testcancel, pthread_testcancel);
40 
41 static inline void
42 testcancel(struct pthread *curthread)
43 {
44 	if (__predict_false(SHOULD_CANCEL(curthread) &&
45 	    !THR_IN_CRITICAL(curthread)))
46 		_pthread_exit(PTHREAD_CANCELED);
47 }
48 
49 void
50 _thr_testcancel(struct pthread *curthread)
51 {
52 	testcancel(curthread);
53 }
54 
55 int
56 _pthread_cancel(pthread_t pthread)
57 {
58 	struct pthread *curthread = _get_curthread();
59 	int ret;
60 
61 	/*
62 	 * POSIX says _pthread_cancel should be async cancellation safe.
63 	 * _thr_find_thread and THR_THREAD_UNLOCK will enter and leave critical
64 	 * region automatically.
65 	 */
66 	if ((ret = _thr_find_thread(curthread, pthread, 0)) == 0) {
67 		if (!pthread->cancel_pending) {
68 			pthread->cancel_pending = 1;
69 			if (pthread->state != PS_DEAD)
70 				_thr_send_sig(pthread, SIGCANCEL);
71 		}
72 		THR_THREAD_UNLOCK(curthread, pthread);
73 	}
74 	return (ret);
75 }
76 
77 int
78 _pthread_setcancelstate(int state, int *oldstate)
79 {
80 	struct pthread *curthread = _get_curthread();
81 	int oldval;
82 
83 	oldval = curthread->cancel_enable;
84 	switch (state) {
85 	case PTHREAD_CANCEL_DISABLE:
86 		curthread->cancel_enable = 0;
87 		break;
88 	case PTHREAD_CANCEL_ENABLE:
89 		curthread->cancel_enable = 1;
90 		testcancel(curthread);
91 		break;
92 	default:
93 		return (EINVAL);
94 	}
95 
96 	if (oldstate) {
97 		*oldstate = oldval ? PTHREAD_CANCEL_ENABLE :
98 			PTHREAD_CANCEL_DISABLE;
99 	}
100 	return (0);
101 }
102 
103 int
104 _pthread_setcanceltype(int type, int *oldtype)
105 {
106 	struct pthread	*curthread = _get_curthread();
107 	int oldval;
108 
109 	oldval = curthread->cancel_async;
110 	switch (type) {
111 	case PTHREAD_CANCEL_ASYNCHRONOUS:
112 		curthread->cancel_async = 1;
113 		testcancel(curthread);
114 		break;
115 	case PTHREAD_CANCEL_DEFERRED:
116 		curthread->cancel_async = 0;
117 		break;
118 	default:
119 		return (EINVAL);
120 	}
121 
122 	if (oldtype) {
123 		*oldtype = oldval ? PTHREAD_CANCEL_ASYNCHRONOUS :
124 		 	PTHREAD_CANCEL_DEFERRED;
125 	}
126 	return (0);
127 }
128 
129 void
130 _pthread_testcancel(void)
131 {
132 	struct pthread *curthread = _get_curthread();
133 
134 	testcancel(curthread);
135 }
136 
137 void
138 _thr_cancel_enter(struct pthread *curthread)
139 {
140 	curthread->cancel_point = 1;
141 	testcancel(curthread);
142 }
143 
144 void
145 _thr_cancel_enter2(struct pthread *curthread, int maycancel)
146 {
147 	curthread->cancel_point = 1;
148 	if (__predict_false(SHOULD_CANCEL(curthread) &&
149 	    !THR_IN_CRITICAL(curthread))) {
150 		if (!maycancel)
151 			thr_wake(curthread->tid);
152 		else
153 			_pthread_exit(PTHREAD_CANCELED);
154 	}
155 }
156 
157 void
158 _thr_cancel_leave(struct pthread *curthread, int maycancel)
159 {
160 	curthread->cancel_point = 0;
161 	if (__predict_false(SHOULD_CANCEL(curthread) &&
162 	    !THR_IN_CRITICAL(curthread) && maycancel))
163 		_pthread_exit(PTHREAD_CANCELED);
164 }
165 
166 void
167 _pthread_cancel_enter(int maycancel)
168 {
169 	_thr_cancel_enter2(_get_curthread(), maycancel);
170 }
171 
172 void
173 _pthread_cancel_leave(int maycancel)
174 {
175 	_thr_cancel_leave(_get_curthread(), maycancel);
176 }
177