src/pthread_cancelable.c

   1 /*
   2  * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
  25  *              All Rights Reserved
  26  *
  27  * Permission to use, copy, modify, and distribute this software and
  28  * its documentation for any purpose and without fee is hereby granted,
  29  * provided that the above copyright notice appears in all copies and
  30  * that both the copyright notice and this permission notice appear in
  31  * supporting documentation.
  32  *
  33  * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
  34  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  35  * FOR A PARTICULAR PURPOSE.
  36  *
  37  * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
  38  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  39  * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
  40  * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  41  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  42  *
  43  */
  44 /*
  45  * MkLinux
  46  */
  47
  48 /*
  49  * POSIX Pthread Library
  50  */
  51
  52 #include "resolver.h"
  53 #include "internal.h"
  54
  55 #include <stdio.h>      /* For printf(). */
  56 #include <stdlib.h>
  57 #include <errno.h>      /* For __mach_errno_addr() prototype. */
  58 #include <signal.h>
  59 #include <sys/time.h>
  60 #include <sys/resource.h>
  61 #include <sys/sysctl.h>
  62 #include <sys/queue.h>
  63 #include <sys/ulock.h>
  64 #include <machine/vmparam.h>
  65 #include <mach/vm_statistics.h>
  66
  67 extern int _pthread_cond_wait(pthread_cond_t *cond,
  68                         pthread_mutex_t *mutex,
  69                         const struct timespec *abstime,
  70                         int isRelative,
  71                         int isconforming);
  72 extern int __sigwait(const sigset_t *set, int *sig);
  73 extern int __pthread_sigmask(int, const sigset_t *, sigset_t *);
  74 extern int __pthread_markcancel(mach_port_t);
  75 extern int __pthread_canceled(int);
  76 extern int __semwait_signal_nocancel(int, int, int, int, __int64_t, __int32_t);
  77
  78
  79 PTHREAD_NOEXPORT
  80 int _pthread_join(pthread_t thread, void **value_ptr, int conforming);
  81
  82 static inline int
  83 _pthread_conformance(void)
  84 {
  85 #if __DARWIN_UNIX03
  86         if (__unix_conforming == 0)
  87                 __unix_conforming = 1;
  88 #ifdef VARIANT_CANCELABLE
  89         return PTHREAD_CONFORM_UNIX03_CANCELABLE;
  90 #else /* !VARIANT_CANCELABLE */
  91         return PTHREAD_CONFORM_UNIX03_NOCANCEL;
  92 #endif
  93 #else /* __DARWIN_UNIX03 */
  94         return PTHREAD_CONFORM_DARWIN_LEGACY;
  95 #endif /* __DARWIN_UNIX03 */
  96 }
  97
  98 #ifndef VARIANT_CANCELABLE
  99
 100 PTHREAD_ALWAYS_INLINE
 101 static inline int
 102 _pthread_update_cancel_state(pthread_t thread, int mask, int state)
 103 {
 104         int oldstate, newstate;
 105         os_atomic_rmw_loop2o(thread, cancel_state, oldstate, newstate, seq_cst, {
 106                 newstate = oldstate;
 107                 newstate &= ~mask;
 108                 newstate |= state;
 109         });
 110         return oldstate;
 111 }
 112
 113 /*
 114  * Cancel a thread
 115  */
 116 PTHREAD_NOEXPORT_VARIANT
 117 int
 118 pthread_cancel(pthread_t thread)
 119 {
 120 #if __DARWIN_UNIX03
 121         if (__unix_conforming == 0)
 122                 __unix_conforming = 1;
 123 #endif /* __DARWIN_UNIX03 */
 124
 125         if (!_pthread_is_valid(thread, NULL)) {
 126                 return(ESRCH);
 127         }
 128
 129         /* if the thread is a workqueue thread, then return error */
 130         if (thread->wqthread != 0) {
 131                 return(ENOTSUP);
 132         }
 133 #if __DARWIN_UNIX03
 134         int state = os_atomic_or2o(thread, cancel_state, _PTHREAD_CANCEL_PENDING, relaxed);
 135         if (state & PTHREAD_CANCEL_ENABLE) {
 136                 mach_port_t kport = _pthread_kernel_thread(thread);
 137                 if (kport) __pthread_markcancel(kport);
 138         }
 139 #else /* __DARWIN_UNIX03 */
 140         thread->cancel_state |= _PTHREAD_CANCEL_PENDING;
 141 #endif /* __DARWIN_UNIX03 */
 142         return (0);
 143 }
 144
 145
 146 void
 147 pthread_testcancel(void)
 148 {
 149         _pthread_testcancel(_pthread_conformance());
 150 }
 151
 152 #ifndef BUILDING_VARIANT /* [ */
 153
 154 PTHREAD_NOEXPORT_VARIANT
 155 void
 156 _pthread_exit_if_canceled(int error)
 157 {
 158         if (((error & 0xff) == EINTR) && __unix_conforming && (__pthread_canceled(0) == 0)) {
 159                 pthread_t self = pthread_self();
 160
 161                 self->cancel_error = error;
 162                 self->canceled = true;
 163                 pthread_exit(PTHREAD_CANCELED);
 164         }
 165 }
 166
 167
 168 static inline bool
 169 _pthread_is_canceled(pthread_t thread)
 170 {
 171         const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
 172         int state = os_atomic_load2o(thread, cancel_state, seq_cst);
 173         return (state & flags) == flags;
 174 }
 175
 176 PTHREAD_NOEXPORT_VARIANT
 177 void
 178 _pthread_testcancel(int isconforming)
 179 {
 180         pthread_t self = pthread_self();
 181         if (_pthread_is_canceled(self)) {
 182                 // 4597450: begin
 183                 self->canceled = (isconforming != PTHREAD_CONFORM_DARWIN_LEGACY);
 184                 // 4597450: end
 185                 pthread_exit(isconforming ? PTHREAD_CANCELED : NULL);
 186         }
 187 }
 188
 189 PTHREAD_NOEXPORT
 190 void
 191 _pthread_markcancel_if_canceled(pthread_t thread, mach_port_t kport)
 192 {
 193         const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
 194         int state = os_atomic_load2o(thread, cancel_state, relaxed);
 195         if ((state & flags) == flags && __unix_conforming) {
 196                 __pthread_markcancel(kport);
 197         }
 198 }
 199
 200 /* When a thread exits set the cancellation state to DISABLE and DEFERRED */
 201 PTHREAD_NOEXPORT
 202 void
 203 _pthread_setcancelstate_exit(pthread_t thread, void *value_ptr)
 204 {
 205         _pthread_update_cancel_state(thread,
 206                         _PTHREAD_CANCEL_STATE_MASK | _PTHREAD_CANCEL_TYPE_MASK,
 207                         PTHREAD_CANCEL_DISABLE | PTHREAD_CANCEL_DEFERRED);
 208 }
 209
 210 #endif /* !BUILDING_VARIANT ] */
 211
 212 /*
 213  * Query/update the cancelability 'state' of a thread
 214  */
 215 PTHREAD_ALWAYS_INLINE
 216 static inline int
 217 _pthread_setcancelstate_internal(int state, int *oldstateptr, int conforming)
 218 {
 219         pthread_t self = pthread_self();
 220
 221         switch (state) {
 222         case PTHREAD_CANCEL_ENABLE:
 223                 if (conforming) {
 224                         __pthread_canceled(1);
 225                 }
 226                 break;
 227         case PTHREAD_CANCEL_DISABLE:
 228                 if (conforming) {
 229                         __pthread_canceled(2);
 230                 }
 231                 break;
 232         default:
 233                 return EINVAL;
 234         }
 235
 236         int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_STATE_MASK, state);
 237         if (oldstateptr) {
 238                 *oldstateptr = oldstate & _PTHREAD_CANCEL_STATE_MASK;
 239         }
 240         if (!conforming) {
 241                 /* See if we need to 'die' now... */
 242                 _pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
 243         }
 244         return 0;
 245 }
 246
 247 PTHREAD_NOEXPORT_VARIANT
 248 int
 249 pthread_setcancelstate(int state, int *oldstate)
 250 {
 251 #if __DARWIN_UNIX03
 252         if (__unix_conforming == 0) {
 253                 __unix_conforming = 1;
 254         }
 255         return (_pthread_setcancelstate_internal(state, oldstate, 1));
 256 #else /* __DARWIN_UNIX03 */
 257         return (_pthread_setcancelstate_internal(state, oldstate, 0));
 258 #endif /* __DARWIN_UNIX03 */
 259 }
 260
 261 /*
 262  * Query/update the cancelability 'type' of a thread
 263  */
 264 PTHREAD_NOEXPORT_VARIANT
 265 int
 266 pthread_setcanceltype(int type, int *oldtype)
 267 {
 268         pthread_t self;
 269
 270 #if __DARWIN_UNIX03
 271         if (__unix_conforming == 0)
 272                 __unix_conforming = 1;
 273 #endif /* __DARWIN_UNIX03 */
 274
 275         if ((type != PTHREAD_CANCEL_DEFERRED) &&
 276             (type != PTHREAD_CANCEL_ASYNCHRONOUS))
 277                 return EINVAL;
 278         self = pthread_self();
 279         int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_TYPE_MASK, type);
 280         if (oldtype) {
 281                 *oldtype = oldstate & _PTHREAD_CANCEL_TYPE_MASK;
 282         }
 283 #if !__DARWIN_UNIX03
 284         /* See if we need to 'die' now... */
 285         _pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
 286 #endif /* __DARWIN_UNIX03 */
 287         return (0);
 288 }
 289
 290
 291 int
 292 pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
 293 {
 294 #if __DARWIN_UNIX03
 295         int err = 0;
 296
 297         if (__pthread_sigmask(how, set, oset) == -1) {
 298                 err = errno;
 299         }
 300         return(err);
 301 #else /* __DARWIN_UNIX03 */
 302         return(__pthread_sigmask(how, set, oset));
 303 #endif /* __DARWIN_UNIX03 */
 304 }
 305
 306 #ifndef BUILDING_VARIANT /* [ */
 307
 308 typedef struct pthread_join_context_s {
 309         pthread_t   waiter;
 310         void      **value_ptr;
 311         mach_port_t kport;
 312         semaphore_t custom_stack_sema;
 313         bool        detached;
 314 } pthread_join_context_s, *pthread_join_context_t;
 315
 316 static inline void *
 317 _pthread_get_exit_value(pthread_t thread)
 318 {
 319         if (__unix_conforming && _pthread_is_canceled(thread)) {
 320                 return PTHREAD_CANCELED;
 321         }
 322         return thread->tl_exit_value;
 323 }
 324
 325 // called with _pthread_list_lock held
 326 PTHREAD_NOEXPORT
 327 semaphore_t
 328 _pthread_joiner_prepost_wake(pthread_t thread)
 329 {
 330         pthread_join_context_t ctx = thread->tl_join_ctx;
 331         semaphore_t sema = MACH_PORT_NULL;
 332
 333         if (thread->tl_joinable) {
 334                 sema = ctx->custom_stack_sema;
 335                 thread->tl_joinable = false;
 336         } else {
 337                 ctx->detached = true;
 338                 thread->tl_join_ctx = NULL;
 339         }
 340         if (ctx->value_ptr) *ctx->value_ptr = _pthread_get_exit_value(thread);
 341         return sema;
 342 }
 343
 344 static inline bool
 345 _pthread_joiner_abort_wait(pthread_t thread, pthread_join_context_t ctx)
 346 {
 347         bool aborted = false;
 348
 349         _PTHREAD_LOCK(_pthread_list_lock);
 350         if (!ctx->detached && thread->tl_exit_gate != MACH_PORT_DEAD) {
 351                 /*
 352                  * _pthread_joiner_prepost_wake() didn't happen
 353                  * allow another thread to join
 354                  */
 355                 PTHREAD_DEBUG_ASSERT(thread->tl_join_ctx == ctx);
 356                 thread->tl_join_ctx = NULL;
 357                 thread->tl_exit_gate = MACH_PORT_NULL;
 358                 aborted = true;
 359         }
 360         _PTHREAD_UNLOCK(_pthread_list_lock);
 361         return aborted;
 362 }
 363
 364 static int
 365 _pthread_joiner_wait(pthread_t thread, pthread_join_context_t ctx, int conforming)
 366 {
 367         uint32_t *exit_gate = &thread->tl_exit_gate;
 368         int ulock_op = UL_UNFAIR_LOCK | ULF_NO_ERRNO;
 369
 370         if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
 371                 ulock_op |= ULF_WAIT_CANCEL_POINT;
 372         }
 373
 374         for (;;) {
 375                 uint32_t cur = os_atomic_load(exit_gate, acquire);
 376                 if (cur == MACH_PORT_DEAD) {
 377                         break;
 378                 }
 379                 if (os_unlikely(cur != ctx->kport)) {
 380                         PTHREAD_CLIENT_CRASH(cur, "pthread_join() state corruption");
 381                 }
 382                 int ret = __ulock_wait(ulock_op, exit_gate, ctx->kport, 0);
 383                 switch (-ret) {
 384                 case 0:
 385                 case EFAULT:
 386                         break;
 387                 case EINTR:
 388                         /*
 389                          * POSIX says:
 390                          *
 391                          *   As specified, either the pthread_join() call is canceled, or it
 392                          *   succeeds, but not both. The difference is obvious to the
 393                          *   application, since either a cancellation handler is run or
 394                          *   pthread_join() returns.
 395                          *
 396                          * When __ulock_wait() returns EINTR, we check if we have been
 397                          * canceled, and if we have, we try to abort the wait.
 398                          *
 399                          * If we can't, it means the other thread finished the join while we
 400                          * were being canceled and commited the waiter to return from
 401                          * pthread_join(). Returning from the join then takes precedence
 402                          * over the cancelation which will be acted upon at the next
 403                          * cancelation point.
 404                          */
 405                         if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE &&
 406                                         _pthread_is_canceled(ctx->waiter)) {
 407                                 if (_pthread_joiner_abort_wait(thread, ctx)) {
 408                                         ctx->waiter->canceled = true;
 409                                         pthread_exit(PTHREAD_CANCELED);
 410                                 }
 411                         }
 412                         break;
 413                 }
 414         }
 415
 416         bool cleanup = false;
 417
 418         _PTHREAD_LOCK(_pthread_list_lock);
 419         // If pthread_detach() was called, we can't safely dereference the thread,
 420         // else, decide who gets to deallocate the thread (see _pthread_terminate).
 421         if (!ctx->detached) {
 422                 PTHREAD_DEBUG_ASSERT(thread->tl_join_ctx == ctx);
 423                 thread->tl_join_ctx = NULL;
 424                 cleanup = thread->tl_joiner_cleans_up;
 425         }
 426         _PTHREAD_UNLOCK(_pthread_list_lock);
 427
 428         if (cleanup) {
 429                 _pthread_deallocate(thread, false);
 430         }
 431         return 0;
 432 }
 433
 434 PTHREAD_NOEXPORT PTHREAD_NOINLINE
 435 int
 436 _pthread_join(pthread_t thread, void **value_ptr, int conforming)
 437 {
 438         pthread_t self = pthread_self();
 439         pthread_join_context_s ctx = {
 440                 .waiter = self,
 441                 .value_ptr = value_ptr,
 442                 .kport = MACH_PORT_NULL,
 443                 .custom_stack_sema = MACH_PORT_NULL,
 444         };
 445         int res = 0;
 446         kern_return_t kr;
 447
 448         if (!_pthread_validate_thread_and_list_lock(thread)) {
 449                 return ESRCH;
 450         }
 451
 452         if (!thread->tl_joinable || (thread->tl_join_ctx != NULL)) {
 453                 res = EINVAL;
 454         } else if (thread == self ||
 455                         (self->tl_join_ctx && self->tl_join_ctx->waiter == thread)) {
 456                 res = EDEADLK;
 457         } else if (thread->tl_exit_gate == MACH_PORT_DEAD) {
 458                 TAILQ_REMOVE(&__pthread_head, thread, tl_plist);
 459                 PTHREAD_DEBUG_ASSERT(thread->tl_joiner_cleans_up);
 460                 thread->tl_joinable = false;
 461                 if (value_ptr) *value_ptr = _pthread_get_exit_value(thread);
 462         } else {
 463                 ctx.kport = _pthread_kernel_thread(thread);
 464                 thread->tl_exit_gate = ctx.kport;
 465                 thread->tl_join_ctx = &ctx;
 466                 if (thread->tl_has_custom_stack) {
 467                         ctx.custom_stack_sema = (semaphore_t)os_get_cached_semaphore();
 468                 }
 469         }
 470         _PTHREAD_UNLOCK(_pthread_list_lock);
 471
 472         if (res == 0) {
 473                 if (ctx.kport == MACH_PORT_NULL) {
 474                         _pthread_deallocate(thread, false);
 475                 } else {
 476                         res = _pthread_joiner_wait(thread, &ctx, conforming);
 477                 }
 478         }
 479         if (res == 0 && ctx.custom_stack_sema && !ctx.detached) {
 480                 // threads with a custom stack need to make sure _pthread_terminate
 481                 // returned before the joiner is unblocked, the joiner may quickly
 482                 // deallocate the stack with rather dire consequences.
 483                 //
 484                 // When we reach this point we know the pthread_join has to succeed
 485                 // so this can't be a cancelation point.
 486                 do {
 487                         kr = __semwait_signal_nocancel(ctx.custom_stack_sema, 0, 0, 0, 0, 0);
 488                 } while (kr != KERN_SUCCESS);
 489         }
 490         if (ctx.custom_stack_sema) {
 491                 os_put_cached_semaphore(ctx.custom_stack_sema);
 492         }
 493         return res;
 494 }
 495
 496 #endif /* !BUILDING_VARIANT ] */
 497 #endif /* VARIANT_CANCELABLE */
 498
 499 /*
 500  * Wait for a thread to terminate and obtain its exit value.
 501  */
 502 int
 503 pthread_join(pthread_t thread, void **value_ptr)
 504 {
 505         int conforming = _pthread_conformance();
 506         if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
 507                 _pthread_testcancel(conforming);
 508         }
 509         return _pthread_join(thread, value_ptr, conforming);
 510 }
 511
 512 int
 513 pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 514 {
 515         return _pthread_cond_wait(cond, mutex, NULL, 0, _pthread_conformance());
 516 }
 517
 518 int
 519 pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 520                 const struct timespec *abstime)
 521 {
 522         return _pthread_cond_wait(cond, mutex, abstime, 0, _pthread_conformance());
 523 }
 524
 525 int
 526 sigwait(const sigset_t * set, int * sig)
 527 {
 528 #if __DARWIN_UNIX03
 529         int err = 0, conformance = _pthread_conformance();
 530
 531         if (__unix_conforming == 0)
 532                 __unix_conforming = 1;
 533
 534         if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
 535                 _pthread_testcancel(conformance);
 536         }
 537
 538         if (__sigwait(set, sig) == -1) {
 539                 err = errno;
 540
 541                 if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
 542                         _pthread_testcancel(conformance);
 543                 }
 544
 545                 /*
 546                  * EINTR that isn't a result of pthread_cancel()
 547                  * is translated to 0.
 548                  */
 549                 if (err == EINTR) {
 550                         err = 0;
 551                 }
 552         }
 553         return(err);
 554 #else /* __DARWIN_UNIX03 */
 555         if (__sigwait(set, sig) == -1) {
 556                 /*
 557                  * EINTR that isn't a result of pthread_cancel()
 558                  * is translated to 0.
 559                  */
 560                 if (errno != EINTR) {
 561                         return -1;
 562                 }
 563         }
 564
 565         return 0;
 566 #endif /* __DARWIN_UNIX03 */
 567 }
 568