1 /*
   2  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 
   5 /*
   6  * include/k5-thread.h
   7  *
   8  * Copyright 2004,2005,2006 by the Massachusetts Institute of Technology.
   9  * All Rights Reserved.
  10  *
  11  * Export of this software from the United States of America may
  12  *   require a specific license from the United States Government.
  13  *   It is the responsibility of any person or organization contemplating
  14  *   export to obtain such a license before exporting.
  15  * 
  16  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  17  * distribute this software and its documentation for any purpose and
  18  * without fee is hereby granted, provided that the above copyright
  19  * notice appear in all copies and that both that copyright notice and
  20  * this permission notice appear in supporting documentation, and that
  21  * the name of M.I.T. not be used in advertising or publicity pertaining
  22  * to distribution of the software without specific, written prior
  23  * permission.  Furthermore if you modify this software you must label
  24  * your software as modified software and not distribute it in such a
  25  * fashion that it might be confused with the original M.I.T. software.
  26  * M.I.T. makes no representations about the suitability of
  27  * this software for any purpose.  It is provided "as is" without express
  28  * or implied warranty.
  29  * 
  30  *
  31  * Preliminary thread support.
  32  */
  33 
  34 #ifndef K5_THREAD_H
  35 #define K5_THREAD_H
  36 
  37 #ifdef _KERNEL
  38 
  39 #include <sys/ksynch.h>
  40 
  41 typedef kmutex_t k5_mutex_t;
  42 
  43 #define K5_MUTEX_PARTIAL_INITIALIZER {{NULL}}
  44 
  45 /* ARGSUSED */
  46 static void k5_mutex_assert_locked(k5_mutex_t *m) { }
  47 
  48 static int
  49 k5_mutex_lock(k5_mutex_t *m)
  50 {
  51   mutex_enter(m);
  52   return (0);
  53 }
  54 
  55 static int
  56 k5_mutex_unlock(k5_mutex_t *m)
  57 {
  58   mutex_exit(m);
  59   return(0);
  60 }
  61 
  62 
  63 #else /* _KERNEL */
  64 
  65 #include "autoconf.h"
  66 #ifndef KRB5_CALLCONV
  67 # define KRB5_CALLCONV
  68 #endif
  69 #ifndef KRB5_CALLCONV_C
  70 # define KRB5_CALLCONV_C
  71 #endif
  72 
  73 /* Interface (tentative):
  74 
  75    Mutex support:
  76 
  77    // Between these two, we should be able to do pure compile-time
  78    // and pure run-time initialization.
  79    //   POSIX:   partial initializer is PTHREAD_MUTEX_INITIALIZER,
  80    //            finish does nothing
  81    //   Windows: partial initializer is an invalid handle,
  82    //            finish does the real initialization work
  83    //   debug:   partial initializer sets one magic value,
  84    //            finish verifies and sets a new magic value for
  85    //              lock/unlock to check
  86    k5_mutex_t foo_mutex = K5_MUTEX_PARTIAL_INITIALIZER;
  87    int k5_mutex_finish_init(k5_mutex_t *);
  88    // for dynamic allocation
  89    int k5_mutex_init(k5_mutex_t *);
  90    // Must work for both kinds of alloc, even if it means adding flags.
  91    int k5_mutex_destroy(k5_mutex_t *);
  92 
  93    // As before.
  94    int k5_mutex_lock(k5_mutex_t *);
  95    int k5_mutex_unlock(k5_mutex_t *);
  96 
  97    In each library, one new function to finish the static mutex init,
  98    and any other library-wide initialization that might be desired.
  99    On POSIX, this function would be called via the second support
 100    function (see below).  On Windows, it would be called at library
 101    load time.  These functions, or functions they calls, should be the
 102    only places that k5_mutex_finish_init gets called.
 103 
 104    A second function or macro called at various possible "first" entry
 105    points which either calls pthread_once on the first function
 106    (POSIX), or checks some flag set by the first function (Windows,
 107    debug support), and possibly returns an error.  (In the
 108    non-threaded case, a simple flag can be used to avoid multiple
 109    invocations, and the mutexes don't need run-time initialization
 110    anyways.)
 111 
 112    A third function for library termination calls mutex_destroy on
 113    each mutex for the library.  This function would be called
 114    automatically at library unload time.  If it turns out to be needed
 115    at exit time for libraries that don't get unloaded, perhaps we
 116    should also use atexit().  Any static mutexes should be cleaned up
 117    with k5_mutex_destroy here.
 118 
 119    How does that second support function invoke the first support
 120    function only once?  Through something modelled on pthread_once
 121    that I haven't written up yet.  Probably:
 122 
 123    k5_once_t foo_once = K5_ONCE_INIT;
 124    k5_once(k5_once_t *, void (*)(void));
 125 
 126    For POSIX: Map onto pthread_once facility.
 127    For non-threaded case: A simple flag.
 128    For Windows: Not needed; library init code takes care of it.
 129 
 130    XXX: A general k5_once mechanism isn't possible for Windows,
 131    without faking it through named mutexes or mutexes initialized at
 132    startup.  I was only using it in one place outside these headers,
 133    so I'm dropping the general scheme.  Eventually the existing uses
 134    in k5-thread.h and k5-platform.h will be converted to pthread_once
 135    or static variables.
 136 
 137 
 138    Thread-specific data:
 139 
 140    // TSD keys are limited in number in gssapi/krb5/com_err; enumerate
 141    // them all.  This allows support code init to allocate the
 142    // necessary storage for pointers all at once, and avoids any
 143    // possible error in key creation.
 144    enum { ... } k5_key_t;
 145    // Register destructor function.  Called in library init code.
 146    int k5_key_register(k5_key_t, void (*destructor)(void *));
 147    // Returns NULL or data.
 148    void *k5_getspecific(k5_key_t);
 149    // Returns error if key out of bounds, or the pointer table can't
 150    // be allocated.  A call to k5_key_register must have happened first.
 151    // This may trigger the calling of pthread_setspecific on POSIX.
 152    int k5_setspecific(k5_key_t, void *);
 153    // Called in library termination code.
 154    // Trashes data in all threads, calling the registered destructor
 155    // (but calling it from the current thread).
 156    int k5_key_delete(k5_key_t);
 157 
 158    For the non-threaded version, the support code will have a static
 159    array indexed by k5_key_t values, and get/setspecific simply access
 160    the array elements.
 161 
 162    The TSD destructor table is global state, protected by a mutex if
 163    threads are enabled.
 164 
 165    Debug support: Not much.  Might check if k5_key_register has been
 166    called and abort if not.
 167 
 168 
 169    Any actual external symbols will use the krb5int_ prefix.  The k5_
 170    names will be simple macros or inline functions to rename the
 171    external symbols, or slightly more complex ones to expand the
 172    implementation inline (e.g., map to POSIX versions and/or debug
 173    code using __FILE__ and the like).
 174 
 175 
 176    More to be added, perhaps.  */
 177 
 178 #undef DEBUG_THREADS /* SUNW14resync XXX */
 179 #undef DEBUG_THREADS_LOC /* SUNW14resync XXX */
 180 #undef DEBUG_THREADS_SLOW /* debugging stuff that'll slow things down? */
 181 #undef DEBUG_THREADS_STATS
 182 
 183 #ifndef _KERNEL
 184 #include <assert.h>
 185 #include <stdarg.h> 
 186 #define ASSERT assert 
 187 #endif
 188 
 189 /* For tracking locations, of (e.g.) last lock or unlock of mutex.  */
 190 #ifdef DEBUG_THREADS_LOC
 191 typedef struct {
 192     const char *filename;
 193     int lineno;
 194 } k5_debug_loc;
 195 #define K5_DEBUG_LOC_INIT       { __FILE__, __LINE__ }
 196 #if __GNUC__ >= 2
 197 #define K5_DEBUG_LOC            (__extension__ (k5_debug_loc)K5_DEBUG_LOC_INIT)
 198 #else
 199 static inline k5_debug_loc k5_debug_make_loc(const char *file, int line)
 200 {
 201     k5_debug_loc l;
 202     l.filename = file;
 203     l.lineno = line;
 204     return l;
 205 }
 206 #define K5_DEBUG_LOC            (k5_debug_make_loc(__FILE__,__LINE__))
 207 #endif
 208 #else /* ! DEBUG_THREADS_LOC */
 209 typedef char k5_debug_loc;
 210 #define K5_DEBUG_LOC_INIT       0
 211 #define K5_DEBUG_LOC            0
 212 #endif
 213 
 214 #define k5_debug_update_loc(L)  ((L) = K5_DEBUG_LOC)
 215 
 216 
 217 
 218 /* Statistics gathering:
 219 
 220    Currently incomplete, don't try enabling it.
 221 
 222    Eventually: Report number of times locked, total and standard
 223    deviation of the time the lock was held, total and std dev time
 224    spent waiting for the lock.  "Report" will probably mean "write a
 225    line to a file if a magic environment variable is set."  */
 226 
 227 #ifdef DEBUG_THREADS_STATS
 228 
 229 #if HAVE_TIME_H && (!defined(HAVE_SYS_TIME_H) || defined(TIME_WITH_SYS_TIME))
 230 # include <time.h>
 231 #endif
 232 #if HAVE_SYS_TIME_H
 233 # include <sys/time.h>
 234 #endif
 235 #ifdef HAVE_STDINT_H
 236 # include <stdint.h>
 237 #endif
 238 /* for memset */
 239 #include <string.h>
 240 /* for uint64_t */
 241 #include <inttypes.h>
 242 typedef uint64_t k5_debug_timediff_t; /* or long double */
 243 typedef struct timeval k5_debug_time_t;
 244 static inline k5_debug_timediff_t
 245 timediff(k5_debug_time_t t2, k5_debug_time_t t1)
 246 {
 247     return (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
 248 }
 249 static inline k5_debug_time_t get_current_time(void)
 250 {
 251     struct timeval tv;
 252     if (gettimeofday(&tv,0) < 0) { tv.tv_sec = tv.tv_usec = 0; }
 253     return tv;
 254 }
 255 struct k5_timediff_stats {
 256     k5_debug_timediff_t valmin, valmax, valsum, valsqsum;
 257 };
 258 typedef struct {
 259     int count;
 260     k5_debug_time_t time_acquired, time_created;
 261     struct k5_timediff_stats lockwait, lockheld;
 262 } k5_debug_mutex_stats;
 263 #define k5_mutex_init_stats(S)                                  \
 264         (memset((S), 0, sizeof(k5_debug_mutex_stats)),  \
 265          (S)->time_created = get_current_time(),             \
 266          0)
 267 #define k5_mutex_finish_init_stats(S)   (0)
 268 #define K5_MUTEX_STATS_INIT     { 0, {0}, {0}, {0}, {0} }
 269 typedef k5_debug_time_t k5_mutex_stats_tmp;
 270 #define k5_mutex_stats_start()  get_current_time()
 271 void KRB5_CALLCONV krb5int_mutex_lock_update_stats(k5_debug_mutex_stats *m,
 272                                                    k5_mutex_stats_tmp start);
 273 void KRB5_CALLCONV krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m);
 274 #define k5_mutex_lock_update_stats      krb5int_mutex_lock_update_stats
 275 #define k5_mutex_unlock_update_stats    krb5int_mutex_unlock_update_stats
 276 void KRB5_CALLCONV krb5int_mutex_report_stats(/* k5_mutex_t *m */);
 277 
 278 #else
 279 
 280 typedef char k5_debug_mutex_stats;
 281 #define k5_mutex_init_stats(S)          (*(S) = 's', 0)
 282 #define k5_mutex_finish_init_stats(S)   (0)
 283 #define K5_MUTEX_STATS_INIT             's'
 284 typedef int k5_mutex_stats_tmp;
 285 #define k5_mutex_stats_start()          (0)
 286 #ifdef __GNUC__
 287 static void
 288 k5_mutex_lock_update_stats(k5_debug_mutex_stats *m, k5_mutex_stats_tmp t)
 289 {
 290 }
 291 #else
 292 # define k5_mutex_lock_update_stats(M,S)        (S)
 293 #endif
 294 #define k5_mutex_unlock_update_stats(M) (*(M) = 's')
 295 
 296 /* If statistics tracking isn't enabled, these functions don't actually
 297    do anything.  Declare anyways so we can do type checking etc.  */
 298 void KRB5_CALLCONV krb5int_mutex_lock_update_stats(k5_debug_mutex_stats *m,
 299                                                    k5_mutex_stats_tmp start);
 300 void KRB5_CALLCONV krb5int_mutex_unlock_update_stats(k5_debug_mutex_stats *m);
 301 void KRB5_CALLCONV krb5int_mutex_report_stats(/* k5_mutex_t *m */);
 302 
 303 #define krb5int_mutex_report_stats(M)   ((M)->stats = 'd')
 304 
 305 #endif
 306 
 307 
 308 
 309 /* Define the OS mutex bit.  */
 310 
 311 /* First, if we're not actually doing multiple threads, do we
 312    want the debug support or not?  */
 313 
 314 #ifdef DEBUG_THREADS
 315 
 316 enum k5_mutex_init_states {
 317     K5_MUTEX_DEBUG_PARTLY_INITIALIZED = 0x12,
 318     K5_MUTEX_DEBUG_INITIALIZED,
 319     K5_MUTEX_DEBUG_DESTROYED
 320 };
 321 enum k5_mutex_flag_states {
 322     K5_MUTEX_DEBUG_UNLOCKED = 0x23,
 323     K5_MUTEX_DEBUG_LOCKED
 324 };
 325 
 326 typedef struct {
 327     enum k5_mutex_init_states initialized;
 328     enum k5_mutex_flag_states locked;
 329 } k5_os_nothread_mutex;
 330 
 331 # define K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER \
 332         { K5_MUTEX_DEBUG_PARTLY_INITIALIZED, K5_MUTEX_DEBUG_UNLOCKED }
 333 
 334 # define k5_os_nothread_mutex_finish_init(M)                            \
 335         (ASSERT((M)->initialized != K5_MUTEX_DEBUG_INITIALIZED),     \
 336          ASSERT((M)->initialized == K5_MUTEX_DEBUG_PARTLY_INITIALIZED),      \
 337          ASSERT((M)->locked == K5_MUTEX_DEBUG_UNLOCKED),             \
 338          (M)->initialized = K5_MUTEX_DEBUG_INITIALIZED, 0)
 339 # define k5_os_nothread_mutex_init(M)                   \
 340         ((M)->initialized = K5_MUTEX_DEBUG_INITIALIZED,      \
 341          (M)->locked = K5_MUTEX_DEBUG_UNLOCKED, 0)
 342 # define k5_os_nothread_mutex_destroy(M)                                \
 343         (ASSERT((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),     \
 344          (M)->initialized = K5_MUTEX_DEBUG_DESTROYED, 0)
 345 
 346 # define k5_os_nothread_mutex_lock(M)                   \
 347         (k5_os_nothread_mutex_assert_unlocked(M),       \
 348          (M)->locked = K5_MUTEX_DEBUG_LOCKED, 0)
 349 # define k5_os_nothread_mutex_unlock(M)                 \
 350         (k5_os_nothread_mutex_assert_locked(M),         \
 351          (M)->locked = K5_MUTEX_DEBUG_UNLOCKED, 0)
 352 
 353 # define k5_os_nothread_mutex_assert_locked(M)                          \
 354         (ASSERT((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),     \
 355          ASSERT((M)->locked != K5_MUTEX_DEBUG_UNLOCKED),             \
 356          ASSERT((M)->locked == K5_MUTEX_DEBUG_LOCKED))
 357 # define k5_os_nothread_mutex_assert_unlocked(M)                        \
 358         (ASSERT((M)->initialized == K5_MUTEX_DEBUG_INITIALIZED),     \
 359          ASSERT((M)->locked != K5_MUTEX_DEBUG_LOCKED),                       \
 360          ASSERT((M)->locked == K5_MUTEX_DEBUG_UNLOCKED))
 361 
 362 #else /* threads disabled and not debugging */
 363 typedef char k5_os_nothread_mutex;
 364 # define K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER       0
 365 /* Empty inline functions avoid the "statement with no effect"
 366    warnings, and do better type-checking than functions that don't use
 367    their arguments.  */
 368 /* SUNW 1.4resync, remove "inline" to avoid warning */
 369 /* ARGSUSED */
 370 /* LINTED */
 371 static int k5_os_nothread_mutex_finish_init(k5_os_nothread_mutex *m) {
 372     return 0;
 373 }
 374 /* ARGSUSED */
 375 /* LINTED */
 376 static int k5_os_nothread_mutex_init(k5_os_nothread_mutex *m) {
 377     return 0;
 378 }
 379 /* ARGSUSED */
 380 /* LINTED */
 381 static int k5_os_nothread_mutex_destroy(k5_os_nothread_mutex *m) {
 382     return 0;
 383 }
 384 /* ARGSUSED */
 385 /* LINTED */
 386 static int k5_os_nothread_mutex_lock(k5_os_nothread_mutex *m) {
 387     return 0;
 388 }
 389 /* ARGSUSED */
 390 /* LINTED */
 391 static int k5_os_nothread_mutex_unlock(k5_os_nothread_mutex *m) {
 392     return 0;
 393 }
 394 # define k5_os_nothread_mutex_assert_locked(M)          ((void)0)
 395 # define k5_os_nothread_mutex_assert_unlocked(M)        ((void)0)
 396 
 397 #endif
 398 
 399 /* Values:
 400    2 - function has not been run
 401    3 - function has been run
 402    4 - function is being run -- deadlock detected */
 403 typedef unsigned char k5_os_nothread_once_t;
 404 # define K5_OS_NOTHREAD_ONCE_INIT       2
 405 # define k5_os_nothread_once(O,F)                                       \
 406         (*(O) == 3 ? 0                                                  \
 407          : *(O) == 2 ? (*(O) = 4, (F)(), *(O) = 3, 0)                   \
 408          : (ASSERT(*(O) != 4), ASSERT(*(O) == 2 || *(O) == 3), 0))
 409 
 410 
 411 
 412 #ifndef ENABLE_THREADS
 413 typedef k5_os_nothread_mutex k5_os_mutex;
 414 # define K5_OS_MUTEX_PARTIAL_INITIALIZER        \
 415                 K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER
 416 # define k5_os_mutex_finish_init        k5_os_nothread_mutex_finish_init
 417 # define k5_os_mutex_init               k5_os_nothread_mutex_init
 418 # define k5_os_mutex_destroy            k5_os_nothread_mutex_destroy
 419 # define k5_os_mutex_lock               k5_os_nothread_mutex_lock
 420 # define k5_os_mutex_unlock             k5_os_nothread_mutex_unlock
 421 # define k5_os_mutex_assert_locked      k5_os_nothread_mutex_assert_locked
 422 # define k5_os_mutex_assert_unlocked    k5_os_nothread_mutex_assert_unlocked
 423 
 424 # define k5_once_t                      k5_os_nothread_once_t
 425 # define K5_ONCE_INIT                   K5_OS_NOTHREAD_ONCE_INIT
 426 # define k5_once                        k5_os_nothread_once
 427 
 428 #elif HAVE_PTHREAD
 429 
 430 # include <pthread.h>
 431 
 432 /* Weak reference support, etc.
 433 
 434    Linux: Stub mutex routines exist, but pthread_once does not.
 435 
 436    Solaris: In libc there's a pthread_once that doesn't seem to do
 437    anything.  Bleah.  But pthread_mutexattr_setrobust_np is defined
 438    only in libpthread.  However, some version of GNU libc (Red Hat's
 439    Fedora Core 5, reportedly) seems to have that function, but no
 440    declaration, so we'd have to declare it in order to test for its
 441    address.  We now have tests to see if pthread_once actually works,
 442    so stick with that for now.
 443 
 444    IRIX 6.5 stub pthread support in libc is really annoying.  The
 445    pthread_mutex_lock function returns ENOSYS for a program not linked
 446    against -lpthread.  No link-time failure, no weak symbols, etc.
 447    The C library doesn't provide pthread_once; we can use weak
 448    reference support for that.
 449 
 450    If weak references are not available, then for now, we assume that
 451    the pthread support routines will always be available -- either the
 452    real thing, or functional stubs that merely prohibit creating
 453    threads.
 454 
 455    If we find a platform with non-functional stubs and no weak
 456    references, we may have to resort to some hack like dlsym on the
 457    symbol tables of the current process.  */
 458 #ifdef HAVE_PRAGMA_WEAK_REF
 459 # pragma weak pthread_once
 460 # pragma weak pthread_mutex_lock
 461 # pragma weak pthread_mutex_unlock
 462 # pragma weak pthread_mutex_destroy
 463 # pragma weak pthread_mutex_init
 464 # pragma weak pthread_self
 465 # pragma weak pthread_equal
 466 # ifdef HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP_IN_THREAD_LIB
 467 #  pragma weak pthread_mutexattr_setrobust_np
 468 # endif
 469 # if !defined HAVE_PTHREAD_ONCE
 470 #  define K5_PTHREADS_LOADED    (&pthread_once != 0)
 471 # elif !defined HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP \
 472         && defined HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP_IN_THREAD_LIB
 473 #  define K5_PTHREADS_LOADED    (&pthread_mutexattr_setrobust_np != 0)
 474 # else
 475 #  define K5_PTHREADS_LOADED    (1)
 476 # endif
 477 #else
 478 /* no pragma weak support */
 479 # define K5_PTHREADS_LOADED     (1)
 480 #endif
 481 
 482 #if defined(__mips) && defined(__sgi) && (defined(_SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__))
 483 /* IRIX 6.5 stub pthread support in libc is really annoying.  The
 484    pthread_mutex_lock function returns ENOSYS for a program not linked
 485    against -lpthread.  No link-time failure, no weak reference tests,
 486    etc.
 487 
 488    The C library doesn't provide pthread_once; we can use weak
 489    reference support for that.  */
 490 # ifndef HAVE_PRAGMA_WEAK_REF
 491 #  if defined(__GNUC__) && __GNUC__ < 3
 492 #   error "Please update to a newer gcc with weak symbol support, or switch to native cc, reconfigure and recompile."
 493 #  else
 494 #   error "Weak reference support is required"
 495 #  endif
 496 # endif
 497 # define USE_PTHREAD_LOCK_ONLY_IF_LOADED
 498 #endif
 499 
 500 #if !defined(HAVE_PTHREAD_MUTEX_LOCK) && !defined(USE_PTHREAD_LOCK_ONLY_IF_LOADED)
 501 # define USE_PTHREAD_LOCK_ONLY_IF_LOADED
 502 #endif
 503 
 504 #ifdef HAVE_PRAGMA_WEAK_REF
 505 /* Can't rely on useful stubs -- see above regarding Solaris.  */
 506 typedef struct {
 507     pthread_once_t o;
 508     k5_os_nothread_once_t n;
 509 } k5_once_t;
 510 # define K5_ONCE_INIT   { PTHREAD_ONCE_INIT, K5_OS_NOTHREAD_ONCE_INIT }
 511 # define k5_once(O,F)   (K5_PTHREADS_LOADED                     \
 512                          ? pthread_once(&(O)->o,F)               \
 513                          : k5_os_nothread_once(&(O)->n,F))
 514 #else
 515 typedef pthread_once_t k5_once_t;
 516 # define K5_ONCE_INIT   PTHREAD_ONCE_INIT
 517 # define k5_once        pthread_once
 518 #endif
 519 
 520 typedef struct {
 521     pthread_mutex_t p;
 522 #ifdef DEBUG_THREADS
 523     pthread_t owner;
 524 #endif
 525 #ifdef USE_PTHREAD_LOCK_ONLY_IF_LOADED
 526     k5_os_nothread_mutex n;
 527 #endif
 528 } k5_os_mutex;
 529 
 530 #ifdef DEBUG_THREADS
 531 # ifdef __GNUC__
 532 #  define k5_pthread_mutex_lock(M)                      \
 533         ({                                              \
 534             k5_os_mutex *_m2 = (M);                     \
 535             int _r2 = pthread_mutex_lock(&_m2->p);       \
 536             if (_r2 == 0) _m2->owner = pthread_self();       \
 537             _r2;                                        \
 538         })
 539 # else
 540 static int
 541 k5_pthread_mutex_lock(k5_os_mutex *m)
 542 {
 543     int r = pthread_mutex_lock(&m->p);
 544     if (r)
 545         return r;
 546     m->owner = pthread_self();
 547     return 0;
 548 }
 549 # endif
 550 # define k5_pthread_assert_locked(M)                            \
 551         (K5_PTHREADS_LOADED                                     \
 552          ? ASSERT(pthread_equal((M)->owner, pthread_self())) \
 553          : (void)0)
 554 # define k5_pthread_mutex_unlock(M)     \
 555         (k5_pthread_assert_locked(M),   \
 556          (M)->owner = (pthread_t) 0, \
 557          pthread_mutex_unlock(&(M)->p))
 558 #else
 559 # define k5_pthread_mutex_lock(M) pthread_mutex_lock(&(M)->p)
 560 /* LINTED */
 561 static void k5_pthread_assert_locked(k5_os_mutex *m) { }
 562 # define k5_pthread_mutex_unlock(M) pthread_mutex_unlock(&(M)->p)
 563 #endif
 564 
 565 /* Define as functions to:
 566    (1) eliminate "statement with no effect" warnings for "0"
 567    (2) encourage type-checking in calling code  */
 568 
 569 /* LINTED */
 570 static void k5_pthread_assert_unlocked(pthread_mutex_t *m) { }
 571 
 572 #if defined(DEBUG_THREADS_SLOW) && HAVE_SCHED_H && (HAVE_SCHED_YIELD || HAVE_PRAGMA_WEAK_REF)
 573 # include <sched.h>
 574 # if !HAVE_SCHED_YIELD
 575 #  pragma weak sched_yield
 576 #  define MAYBE_SCHED_YIELD()   ((void)((&sched_yield != NULL) ? sched_yield() : 0))
 577 # else
 578 #  define MAYBE_SCHED_YIELD()   ((void)sched_yield())
 579 # endif
 580 #else
 581 # define MAYBE_SCHED_YIELD()    ((void)0)
 582 #endif
 583 
 584 /* It may not be obvious why this function is desirable.
 585 
 586    I want to call pthread_mutex_lock, then sched_yield, then look at
 587    the return code from pthread_mutex_lock.  That can't be implemented
 588    in a macro without a temporary variable, or GNU C extensions.
 589 
 590    There used to be an inline function which did it, with both
 591    functions called from the inline function.  But that messes with
 592    the debug information on a lot of configurations, and you can't
 593    tell where the inline function was called from.  (Typically, gdb
 594    gives you the name of the function from which the inline function
 595    was called, and a line number within the inline function itself.)
 596 
 597    With this auxiliary function, pthread_mutex_lock can be called at
 598    the invoking site via a macro; once it returns, the inline function
 599    is called (with messed-up line-number info for gdb hopefully
 600    localized to just that call).  */
 601 #ifdef __GNUC__
 602 #define return_after_yield(R)                   \
 603         __extension__ ({                        \
 604             int _r = (R);                       \
 605             MAYBE_SCHED_YIELD();                \
 606             _r;                                 \
 607         })
 608 #else
 609 static int return_after_yield(int r)
 610 {
 611     MAYBE_SCHED_YIELD();
 612     return r;
 613 }
 614 #endif
 615 
 616 #ifdef USE_PTHREAD_LOCK_ONLY_IF_LOADED
 617 
 618 # if defined(PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP) && defined(DEBUG_THREADS)
 619 #  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 620         { PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, (pthread_t) 0, \
 621           K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
 622 # elif defined(DEBUG_THREADS)
 623 #  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 624         { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0, \
 625           K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
 626 # else
 627 #  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 628         { PTHREAD_MUTEX_INITIALIZER, K5_OS_NOTHREAD_MUTEX_PARTIAL_INITIALIZER }
 629 # endif
 630 asdfsdf
 631 # define k5_os_mutex_finish_init(M)             \
 632         k5_os_nothread_mutex_finish_init(&(M)->n)
 633 # define k5_os_mutex_init(M)                    \
 634         (k5_os_nothread_mutex_init(&(M)->n),     \
 635          (K5_PTHREADS_LOADED                    \
 636           ? pthread_mutex_init(&(M)->p, 0)       \
 637           : 0))
 638 # define k5_os_mutex_destroy(M)                 \
 639         (k5_os_nothread_mutex_destroy(&(M)->n),  \
 640          (K5_PTHREADS_LOADED                    \
 641           ? pthread_mutex_destroy(&(M)->p)       \
 642           : 0))
 643 
 644 # define k5_os_mutex_lock(M)                                            \
 645         return_after_yield(K5_PTHREADS_LOADED                           \
 646                            ? k5_pthread_mutex_lock(M)                   \
 647                            : k5_os_nothread_mutex_lock(&(M)->n))
 648 # define k5_os_mutex_unlock(M)                          \
 649         (MAYBE_SCHED_YIELD(),                           \
 650          (K5_PTHREADS_LOADED                            \
 651           ? k5_pthread_mutex_unlock(M)                  \
 652           : k5_os_nothread_mutex_unlock(&(M)->n)))
 653 
 654 # define k5_os_mutex_assert_unlocked(M)                 \
 655         (K5_PTHREADS_LOADED                             \
 656          ? k5_pthread_assert_unlocked(&(M)->p)           \
 657          : k5_os_nothread_mutex_assert_unlocked(&(M)->n))
 658 # define k5_os_mutex_assert_locked(M)                   \
 659         (K5_PTHREADS_LOADED                             \
 660          ? k5_pthread_assert_locked(M)                  \
 661          : k5_os_nothread_mutex_assert_locked(&(M)->n))
 662 
 663 #else
 664 
 665 # ifdef DEBUG_THREADS
 666 #  ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
 667 #   define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 668         { PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, (pthread_t) 0 }
 669 #  else
 670 #   define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 671         { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0 }
 672 #  endif
 673 # else
 674 #  define K5_OS_MUTEX_PARTIAL_INITIALIZER \
 675         { PTHREAD_MUTEX_INITIALIZER }
 676 # endif
 677 
 678 /* LINTED */
 679 static  int k5_os_mutex_finish_init(k5_os_mutex *m) { return 0; }
 680 # define k5_os_mutex_init(M)            pthread_mutex_init(&(M)->p, 0)
 681 # define k5_os_mutex_destroy(M)         pthread_mutex_destroy(&(M)->p)
 682 # define k5_os_mutex_lock(M)    return_after_yield(k5_pthread_mutex_lock(M))
 683 # define k5_os_mutex_unlock(M)          (MAYBE_SCHED_YIELD(),k5_pthread_mutex_unlock(M))
 684 
 685 # define k5_os_mutex_assert_unlocked(M) k5_pthread_assert_unlocked(&(M)->p)
 686 # define k5_os_mutex_assert_locked(M)   k5_pthread_assert_locked(M)
 687 
 688 #endif /* is pthreads always available? */
 689 
 690 #elif defined _WIN32
 691 
 692 typedef struct {
 693     HANDLE h;
 694     int is_locked;
 695 } k5_os_mutex;
 696 
 697 # define K5_OS_MUTEX_PARTIAL_INITIALIZER { INVALID_HANDLE_VALUE, 0 }
 698 
 699 # define k5_os_mutex_finish_init(M)                                      \
 700         (ASSERT((M)->h == INVALID_HANDLE_VALUE),                      \
 701          ((M)->h = CreateMutex(NULL, FALSE, NULL)) ? 0 : GetLastError())
 702 # define k5_os_mutex_init(M)                                             \
 703         ((M)->is_locked = 0,                                          \
 704          ((M)->h = CreateMutex(NULL, FALSE, NULL)) ? 0 : GetLastError())
 705 # define k5_os_mutex_destroy(M)         \
 706         (CloseHandle((M)->h) ? ((M)->h = 0, 0) : GetLastError())
 707 
 708 static int k5_os_mutex_lock(k5_os_mutex *m)
 709 {
 710     DWORD res;
 711     res = WaitForSingleObject(m->h, INFINITE);
 712     if (res == WAIT_FAILED)
 713         return GetLastError();
 714     /* Eventually these should be turned into some reasonable error
 715        code.  */
 716     ASSERT(res != WAIT_TIMEOUT);
 717     ASSERT(res != WAIT_ABANDONED);
 718     ASSERT(res == WAIT_OBJECT_0);
 719     /* Avoid locking twice.  */
 720     ASSERT(m->is_locked == 0);
 721     m->is_locked = 1;
 722     return 0;
 723 }
 724 
 725 # define k5_os_mutex_unlock(M)                          \
 726         (ASSERT((M)->is_locked == 1),                        \
 727          (M)->is_locked = 0,                         \
 728          ReleaseMutex((M)->h) ? 0 : GetLastError())
 729 
 730 # define k5_os_mutex_assert_unlocked(M) ((void)0)
 731 # define k5_os_mutex_assert_locked(M)   ((void)0)
 732 
 733 #else
 734 
 735 # error "Thread support enabled, but thread system unknown"
 736 
 737 #endif
 738 
 739 
 740 
 741 
 742 typedef struct {
 743     k5_debug_loc loc_last, loc_created;
 744     k5_os_mutex os;
 745     k5_debug_mutex_stats stats;
 746 } k5_mutex_t;
 747 #define K5_MUTEX_PARTIAL_INITIALIZER            \
 748         { K5_DEBUG_LOC_INIT, K5_DEBUG_LOC_INIT, \
 749           K5_OS_MUTEX_PARTIAL_INITIALIZER, K5_MUTEX_STATS_INIT }
 750 /* LINTED */
 751 static int k5_mutex_init_1(k5_mutex_t *m, k5_debug_loc l)
 752 {
 753     int err = k5_os_mutex_init(&m->os);
 754     if (err) return err;
 755     m->loc_created = m->loc_last = l;
 756     err = k5_mutex_init_stats(&m->stats);
 757     ASSERT(err == 0);
 758     return 0;
 759 }
 760 #define k5_mutex_init(M)        k5_mutex_init_1((M), K5_DEBUG_LOC)
 761 /* LINTED */
 762 static  int k5_mutex_finish_init_1(k5_mutex_t *m, k5_debug_loc l)
 763 {
 764     int err = k5_os_mutex_finish_init(&m->os);
 765     if (err) return err;
 766     m->loc_created = m->loc_last = l;
 767     err = k5_mutex_finish_init_stats(&m->stats);
 768     ASSERT(err == 0);
 769     return 0;
 770 }
 771 #define k5_mutex_finish_init(M) k5_mutex_finish_init_1((M), K5_DEBUG_LOC)
 772 #define k5_mutex_destroy(M)                     \
 773         (k5_os_mutex_assert_unlocked(&(M)->os),  \
 774          k5_mutex_lock(M), (M)->loc_last = K5_DEBUG_LOC, k5_mutex_unlock(M), \
 775          k5_os_mutex_destroy(&(M)->os))
 776 #ifdef __GNUC__
 777 #define k5_mutex_lock(M)                                \
 778         __extension__ ({                                \
 779             int _err = 0;                               \
 780             k5_mutex_t *_m = (M);                       \
 781             _err = k5_os_mutex_lock(&_m->os);            \
 782             if (_err == 0) _m->loc_last = K5_DEBUG_LOC;      \
 783             _err;                                       \
 784         })
 785 #else
 786 /* LINTED */
 787 static  int k5_mutex_lock_1(k5_mutex_t *m, k5_debug_loc l)
 788 {
 789     int err = 0;
 790     err = k5_os_mutex_lock(&m->os);
 791     if (err)
 792         return err;
 793     m->loc_last = l;
 794     return err;
 795 }
 796 #define k5_mutex_lock(M)        k5_mutex_lock_1(M, K5_DEBUG_LOC)
 797 #endif
 798 #define k5_mutex_unlock(M)                              \
 799         (k5_mutex_assert_locked(M),                     \
 800          (M)->loc_last = K5_DEBUG_LOC,                       \
 801          k5_os_mutex_unlock(&(M)->os))
 802 
 803 #define k5_mutex_assert_locked(M)       k5_os_mutex_assert_locked(&(M)->os)
 804 #define k5_mutex_assert_unlocked(M)     k5_os_mutex_assert_unlocked(&(M)->os)
 805 
 806 #define k5_assert_locked        k5_mutex_assert_locked
 807 #define k5_assert_unlocked      k5_mutex_assert_unlocked
 808 
 809 
 810 /* Thread-specific data; implemented in a support file, because we'll
 811    need to keep track of some global data for cleanup purposes.
 812 
 813    Note that the callback function type is such that the C library
 814    routine free() is a valid callback.  */
 815 typedef enum {
 816     K5_KEY_COM_ERR,
 817     K5_KEY_GSS_KRB5_SET_CCACHE_OLD_NAME,
 818     K5_KEY_GSS_KRB5_CCACHE_NAME,
 819     K5_KEY_GSS_KRB5_ERROR_MESSAGE,
 820     K5_KEY_GSS_SPNEGO_ERROR_MESSAGE,
 821     K5_KEY_MAX
 822 } k5_key_t;
 823 /* rename shorthand symbols for export */
 824 #define k5_key_register krb5int_key_register
 825 #define k5_getspecific  krb5int_getspecific
 826 #define k5_setspecific  krb5int_setspecific
 827 #define k5_key_delete   krb5int_key_delete
 828 extern int k5_key_register(k5_key_t, void (*)(void *));
 829 extern void *k5_getspecific(k5_key_t);
 830 extern int k5_setspecific(k5_key_t, void *);
 831 extern int k5_key_delete(k5_key_t);
 832 
 833 extern int  KRB5_CALLCONV krb5int_mutex_alloc  (k5_mutex_t **);
 834 extern void KRB5_CALLCONV krb5int_mutex_free   (k5_mutex_t *);
 835 extern int  KRB5_CALLCONV krb5int_mutex_lock   (k5_mutex_t *);
 836 extern int  KRB5_CALLCONV krb5int_mutex_unlock (k5_mutex_t *);
 837 
 838 /* In time, many of the definitions above should move into the support
 839    library, and this file should be greatly simplified.  For type
 840    definitions, that'll take some work, since other data structures
 841    incorporate mutexes directly, and our mutex type is dependent on
 842    configuration options and system attributes.  For most functions,
 843    though, it should be relatively easy.
 844 
 845    For now, plugins should use the exported functions, and not the
 846    above macros, and use krb5int_mutex_alloc for allocations.  */
 847 #ifdef PLUGIN
 848 #undef k5_mutex_lock
 849 #define k5_mutex_lock krb5int_mutex_lock
 850 #undef k5_mutex_unlock
 851 #define k5_mutex_unlock krb5int_mutex_unlock
 852 #endif
 853 
 854 #endif /* _KERNEL */
 855 
 856 
 857 #endif /* multiple inclusion? */