lib/libthread_xu/thread/thr_cond.c

   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  */
  27
  28 #include "namespace.h"
  29 #include <machine/tls.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <pthread.h>
  33 #include <limits.h>
  34 #include "un-namespace.h"
  35
  36 #include "thr_private.h"
  37
  38 #ifdef _PTHREADS_DEBUGGING
  39 #include <stdio.h>
  40 #include <stdarg.h>
  41 #include <sys/file.h>
  42 #endif
  43
  44 #define cpu_ccfence()   __asm __volatile("" : : : "memory")
  45
  46 umtx_t          _cond_static_lock;
  47
  48 #ifdef _PTHREADS_DEBUGGING
  49
  50 static
  51 void
  52 cond_log(const char *ctl, ...)
  53 {
  54         char buf[256];
  55         va_list va;
  56         size_t len;
  57
  58         va_start(va, ctl);
  59         len = vsnprintf(buf, sizeof(buf), ctl, va);
  60         va_end(va);
  61         _thr_log(buf, len);
  62 }
  63
  64 #else
  65
  66 static __inline
  67 void
  68 cond_log(const char *ctl __unused, ...)
  69 {
  70 }
  71
  72 #endif
  73
  74 /*
  75  * Prototypes
  76  */
  77 int     __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
  78 int     __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
  79                                  const struct timespec *abstime);
  80 static int cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
  81                             const struct timespec *abstime, int cancel);
  82 static int cond_signal_common(pthread_cond_t *cond, int broadcast);
  83
  84 static int
  85 cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
  86 {
  87         pthread_cond_t pcond;
  88         int rval = 0;
  89
  90         pcond = __malloc(sizeof(struct __pthread_cond_s));
  91         if (pcond == NULL) {
  92                 rval = ENOMEM;
  93         } else {
  94                 /*
  95                  * Initialise the condition variable structure:
  96                  */
  97                 _thr_umtx_init(&pcond->c_lock);
  98                 if (cond_attr == NULL || *cond_attr == NULL) {
  99                         pcond->c_pshared = 0;
 100                         pcond->c_clockid = CLOCK_REALTIME;
 101                 } else {
 102                         pcond->c_pshared = (*cond_attr)->c_pshared;
 103                         pcond->c_clockid = (*cond_attr)->c_clockid;
 104                 }
 105                 TAILQ_INIT(&pcond->c_waitlist);
 106                 *cond = pcond;
 107         }
 108         /* Return the completion status: */
 109         return (rval);
 110 }
 111
 112 #if 0
 113 void
 114 _cond_reinit(pthread_cond_t cond)
 115 {
 116         if (cond) {
 117                 _thr_umtx_init(&cond->c_lock);
 118 #if 0
 119                 /* retain state */
 120                 cond->c_pshared = 0;
 121                 cond->c_clockid = CLOCK_REALTIME;
 122 #endif
 123                 TAILQ_INIT(&cond->c_waitlist);
 124         }
 125 }
 126 #endif
 127
 128 static int
 129 init_static(pthread_t thread, pthread_cond_t *cond)
 130 {
 131         int ret;
 132
 133         THR_LOCK_ACQUIRE(thread, &_cond_static_lock);
 134
 135         if (*cond == NULL)
 136                 ret = cond_init(cond, NULL);
 137         else
 138                 ret = 0;
 139
 140         THR_LOCK_RELEASE(thread, &_cond_static_lock);
 141
 142         return (ret);
 143 }
 144
 145 int
 146 _pthread_cond_init(pthread_cond_t * __restrict cond,
 147     const pthread_condattr_t * __restrict cond_attr)
 148 {
 149         *cond = NULL;
 150         return cond_init(cond, cond_attr);
 151 }
 152
 153 int
 154 _pthread_cond_destroy(pthread_cond_t *cond)
 155 {
 156         pthread_cond_t  cv;
 157         pthread_t       curthread = tls_get_curthread();
 158         int             rval = 0;
 159
 160         if (cond == NULL) {
 161                 rval = EINVAL;
 162         } else if (*cond == NULL) {
 163                 rval = 0;
 164         } else {
 165                 /* Lock the condition variable structure: */
 166                 THR_LOCK_ACQUIRE(curthread, &(*cond)->c_lock);
 167                 if (TAILQ_FIRST(&(*cond)->c_waitlist)) {
 168                         THR_LOCK_RELEASE(curthread, &(*cond)->c_lock);
 169                         return (EBUSY);
 170                 }
 171
 172                 /*
 173                  * NULL the caller's pointer now that the condition
 174                  * variable has been destroyed:
 175                  */
 176                 cv = *cond;
 177                 *cond = NULL;
 178
 179                 /* Unlock the condition variable structure: */
 180                 THR_LOCK_RELEASE(curthread, &cv->c_lock);
 181
 182                 /* Free the cond lock structure: */
 183
 184                 /*
 185                  * Free the memory allocated for the condition
 186                  * variable structure:
 187                  */
 188                 __free(cv);
 189
 190         }
 191         /* Return the completion status: */
 192         return (rval);
 193 }
 194
 195 struct cond_cancel_info {
 196         TAILQ_ENTRY(cond_cancel_info) entry;
 197         pthread_mutex_t *mutex;
 198         pthread_cond_t  *cond;
 199         int             count;
 200         int             queued;
 201 };
 202
 203 static void
 204 cond_cancel_handler(void *arg)
 205 {
 206         pthread_t curthread = tls_get_curthread();
 207         struct cond_cancel_info *info = (struct cond_cancel_info *)arg;
 208         pthread_cond_t cv;
 209
 210         cv = *info->cond;
 211         THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
 212         cond_log("cond_cancel %p\n", cv);
 213
 214         if (info->queued) {
 215                 info->queued = 0;
 216                 cond_log("cond_cancel %p: info %p\n", cv, info);
 217                 TAILQ_REMOVE(&cv->c_waitlist, info, entry);
 218                 _thr_umtx_wake(&info->queued, 0);
 219         }
 220         THR_LOCK_RELEASE(curthread, &cv->c_lock);
 221
 222         /* _mutex_cv_lock(info->mutex, info->count); */
 223 }
 224
 225 /*
 226  * Wait for pthread_cond_t to be signaled.
 227  *
 228  * NOTE: EINTR is ignored and may not be returned by this function.
 229  */
 230 static int
 231 cond_wait_common(pthread_cond_t *cond, pthread_mutex_t *mutex,
 232                  const struct timespec *abstime, int cancel)
 233 {
 234         pthread_t curthread = tls_get_curthread();
 235         struct timespec ts, ts2, *tsp;
 236         struct cond_cancel_info info;
 237         pthread_cond_t  cv;
 238         int             oldcancel;
 239         int             ret;
 240
 241         /*
 242          * If the condition variable is statically initialized,
 243          * perform the dynamic initialization:
 244          */
 245         cond_log("cond_wait_common %p on mutex %p info %p\n",
 246                 *cond, *mutex, &info);
 247         if (__predict_false(*cond == NULL &&
 248             (ret = init_static(curthread, cond)) != 0)) {
 249                 cond_log("cond_wait_common %p (failedA %d)\n", *cond, ret);
 250                 return (ret);
 251         }
 252
 253         cv = *cond;
 254         THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
 255         ret = _mutex_cv_unlock(mutex, &info.count);
 256         if (ret) {
 257                 cond_log("cond_wait_common %p (failedB %d)\n", cv, ret);
 258                 THR_LOCK_RELEASE(curthread, &cv->c_lock);
 259                 return ret;
 260         }
 261
 262         cpu_ccfence();
 263         info.mutex = mutex;
 264         info.cond  = cond;
 265         info.queued = 1;
 266         TAILQ_INSERT_TAIL(&cv->c_waitlist, &info, entry);
 267
 268         /*
 269          * loop if we have never been told to wake up
 270          * or we lost a race.
 271          */
 272         while (info.queued) {
 273                 THR_LOCK_RELEASE(curthread, &cv->c_lock);
 274
 275                 if (abstime != NULL) {
 276                         clock_gettime(cv->c_clockid, &ts);
 277                         timespecsub(abstime, &ts, &ts2);
 278                         tsp = &ts2;
 279                 } else {
 280                         tsp = NULL;
 281                 }
 282
 283                 if (cancel) {
 284                         THR_CLEANUP_PUSH(curthread, cond_cancel_handler, &info);
 285                         oldcancel = _thr_cancel_enter(curthread);
 286                         ret = _thr_umtx_wait(&info.queued, 1, tsp,
 287                                              cv->c_clockid);
 288                         _thr_cancel_leave(curthread, oldcancel);
 289                         THR_CLEANUP_POP(curthread, 0);
 290                 } else {
 291                         ret = _thr_umtx_wait(&info.queued, 1, tsp,
 292                                              cv->c_clockid);
 293                 }
 294
 295                 /*
 296                  * Ignore EINTR.  Make sure ret is 0 if not ETIMEDOUT.
 297                  */
 298                 THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
 299                 if (abstime != NULL && ret == ETIMEDOUT)
 300                         break;
 301                 cpu_ccfence();
 302         }
 303
 304         if (info.queued) {
 305                 info.queued = 0;
 306                 TAILQ_REMOVE(&cv->c_waitlist, &info, entry);
 307                 ret = ETIMEDOUT;
 308         } else {
 309                 ret = 0;
 310         }
 311         THR_LOCK_RELEASE(curthread, &cv->c_lock);
 312
 313         cond_log("cond_wait_common %p (doneA)\n", cv);
 314         _mutex_cv_lock(mutex, info.count);
 315
 316         if (ret)
 317                 cond_log("cond_wait_common %p (failed %d)\n", cv, ret);
 318         else
 319                 cond_log("cond_wait_common %p (doneB)\n", cv);
 320
 321         return (ret);
 322 }
 323
 324 int
 325 _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 326 {
 327         return (cond_wait_common(cond, mutex, NULL, 0));
 328 }
 329
 330 int
 331 __pthread_cond_wait(pthread_cond_t * __restrict cond,
 332     pthread_mutex_t * __restrict mutex)
 333 {
 334         return (cond_wait_common(cond, mutex, NULL, 1));
 335 }
 336
 337 int
 338 _pthread_cond_timedwait(pthread_cond_t * __restrict cond,
 339     pthread_mutex_t * __restrict mutex,
 340     const struct timespec * __restrict abstime)
 341 {
 342         if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
 343             abstime->tv_nsec >= 1000000000)
 344                 return (EINVAL);
 345
 346         return (cond_wait_common(cond, mutex, abstime, 0));
 347 }
 348
 349 int
 350 __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 351                        const struct timespec *abstime)
 352 {
 353         if (abstime == NULL || abstime->tv_sec < 0 || abstime->tv_nsec < 0 ||
 354             abstime->tv_nsec >= 1000000000)
 355                 return (EINVAL);
 356
 357         return (cond_wait_common(cond, mutex, abstime, 1));
 358 }
 359
 360 static int
 361 cond_signal_common(pthread_cond_t *cond, int broadcast)
 362 {
 363         pthread_t       curthread = tls_get_curthread();
 364         struct cond_cancel_info *info;
 365         pthread_cond_t  cv;
 366         int             ret = 0;
 367
 368         cond_log("cond_signal_common %p broad=%d\n", *cond, broadcast);
 369
 370         /*
 371          * If the condition variable is statically initialized, perform dynamic
 372          * initialization.
 373          */
 374         if (__predict_false(*cond == NULL &&
 375                             (ret = init_static(curthread, cond)) != 0)) {
 376                 cond_log("cond_signal_common %p (failedA %d)\n", *cond, ret);
 377                 return (ret);
 378         }
 379
 380         cv = *cond;
 381         /* Lock the condition variable structure. */
 382         THR_LOCK_ACQUIRE(curthread, &cv->c_lock);
 383         while ((info = TAILQ_FIRST(&cv->c_waitlist)) != NULL) {
 384                 info->queued = 0;
 385                 TAILQ_REMOVE(&cv->c_waitlist, info, entry);
 386                 cond_log("cond_signal_common %p: wakeup %p\n", *cond, info);
 387                 _thr_umtx_wake(&info->queued, 0);
 388                 if (broadcast == 0)
 389                         break;
 390         }
 391         THR_LOCK_RELEASE(curthread, &cv->c_lock);
 392
 393         if (ret)
 394                 cond_log("cond_signal_common %p (failedB %d)\n", *cond, ret);
 395         else
 396                 cond_log("cond_signal_common %p (done)\n", *cond);
 397
 398         return (ret);
 399 }
 400
 401 int
 402 _pthread_cond_signal(pthread_cond_t * cond)
 403 {
 404         return (cond_signal_common(cond, 0));
 405 }
 406
 407 int
 408 _pthread_cond_broadcast(pthread_cond_t * cond)
 409 {
 410         return (cond_signal_common(cond, 1));
 411 }
 412
 413 /*
 414  * Double underscore versions are cancellation points.  Single underscore
 415  * versions are not and are provided for libc internal usage (which
 416  * shouldn't introduce cancellation points).
 417  */
 418 __strong_reference(__pthread_cond_wait, pthread_cond_wait);
 419 __strong_reference(__pthread_cond_timedwait, pthread_cond_timedwait);
 420
 421 __strong_reference(_pthread_cond_init, pthread_cond_init);
 422 __strong_reference(_pthread_cond_destroy, pthread_cond_destroy);
 423 __strong_reference(_pthread_cond_signal, pthread_cond_signal);
 424 __strong_reference(_pthread_cond_broadcast, pthread_cond_broadcast);