kProfiler2/kProfileR3.cpp

   1 /* $Id$ */
   2 /** @file
   3  * kProfiler Mark 2 - The Ring-3 Implementation.
   4  */
   5
   6 /*
   7  * Copyright (c) 2006-2007 Knut St. Osmundsen <bird-kStuff-spamix@anduin.net>
   8  *
   9  * Permission is hereby granted, free of charge, to any person
  10  * obtaining a copy of this software and associated documentation
  11  * files (the "Software"), to deal in the Software without
  12  * restriction, including without limitation the rights to use,
  13  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following
  16  * conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be
  19  * included in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  23  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  25  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  26  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  27  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  28  * OTHER DEALINGS IN THE SOFTWARE.
  29  */
  30
  31 /*******************************************************************************
  32 *   Header Files                                                               *
  33 *******************************************************************************/
  34 #include <k/kDefs.h>
  35 #if K_OS == K_OS_WINDOWS
  36 # include <windows.h>
  37 # include <psapi.h>
  38 # include <malloc.h>
  39 # if _MSC_VER >= 1400
  40 #  include <intrin.h>
  41 #  define HAVE_INTRIN
  42 # endif
  43
  44 #elif K_OS == K_OS_LINUX || K_OS == K_OS_FREEBSD
  45 # define KPRF_USE_PTHREAD
  46 # include <pthread.h>
  47 # include <stdint.h>
  48 # define KPRF_USE_MMAN
  49 # include <sys/mman.h>
  50 # include <sys/fcntl.h>
  51 # include <unistd.h>
  52 # include <stdlib.h>
  53 # ifndef O_BINARY
  54 #  define O_BINARY 0
  55 # endif
  56
  57 #elif K_OS == K_OS_OS2
  58 # define INCL_BASE
  59 # include <os2.h>
  60 # include <stdint.h>
  61 # include <sys/fmutex.h>
  62
  63 #else
  64 # error "not ported to this OS..."
  65 #endif
  66
  67 #include <k/kDefs.h>
  68 #include <k/kTypes.h>
  69
  70 /*
  71  * Instantiate the header.
  72  */
  73 #define KPRF_NAME(Suffix)               KPrf##Suffix
  74 #define KPRF_TYPE(Prefix,Suffix)        Prefix##KPRF##Suffix
  75 #if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
  76 # define KPRF_DECL_FUNC(type, name)     extern "C"  __declspec(dllexport) type __cdecl KPRF_NAME(name)
  77 #else
  78 # define KPRF_DECL_FUNC(type, name)     extern "C" type KPRF_NAME(name)
  79 #endif
  80 #if 1
  81 # ifdef __GNUC__
  82 #  define KPRF_ASSERT(expr) do { if (!(expr)) { __asm__ __volatile__("int3\n\tnop\n\t");} } while (0)
  83 # else
  84 #  define KPRF_ASSERT(expr) do { if (!(expr)) { __debugbreak(); } } while (0)
  85 # endif
  86 #else
  87 # define KPRF_ASSERT(expr) do { } while (0)
  88 #endif
  89
  90 #include "prfcore.h.h"
  91
  92
  93
  94 /*******************************************************************************
  95 *   Structures and Typedefs                                                    *
  96 *******************************************************************************/
  97 /** Mutex lock type. */
  98 #if defined(KPRF_USE_PTHREAD)
  99 typedef pthread_mutex_t     KPRF_TYPE(,MUTEX);
 100 #elif K_OS == K_OS_WINDOWS
 101 typedef CRITICAL_SECTION    KPRF_TYPE(,MUTEX);
 102 #elif K_OS == K_OS_OS2
 103 typedef struct _fmutex      KPRF_TYPE(,MUTEX);
 104 #endif
 105 /** Pointer to a mutex lock. */
 106 typedef KPRF_TYPE(,MUTEX)  *KPRF_TYPE(P,MUTEX);
 107
 108
 109 #if defined(KPRF_USE_PTHREAD)
 110 /** Read/Write lock type. */
 111 typedef pthread_rwlock_t    KPRF_TYPE(,RWLOCK);
 112 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 113 /** Read/Write lock state. */
 114 typedef enum KPRF_TYPE(,RWLOCKSTATE)
 115 {
 116     RWLOCK_STATE_UNINITIALIZED = 0,
 117     RWLOCK_STATE_SHARED,
 118     RWLOCK_STATE_LOCKING,
 119     RWLOCK_STATE_EXCLUSIVE,
 120     RWLOCK_STATE_32BIT_HACK = 0x7fffffff
 121 } KPRF_TYPE(,RWLOCKSTATE);
 122 /** Update the state. */
 123 #define KPRF_RWLOCK_SETSTATE(pRWLock, enmNewState) \
 124     kPrfAtomicSet32((volatile KU32 *)&(pRWLock)->enmState, (KU32)(enmNewState))
 125
 126 /** Read/Write lock type. */
 127 typedef struct KPRF_TYPE(,RWLOCK)
 128 {
 129     /** This mutex serialize the access and updating of the members
 130      * of this structure. */
 131     KPRF_TYPE(,MUTEX)       Mutex;
 132     /** The current number of readers. */
 133     KU32                    cReaders;
 134     /** The number of readers waiting. */
 135     KU32                    cReadersWaiting;
 136     /** The current number of waiting writers. */
 137     KU32                    cWritersWaiting;
 138 # if K_OS == K_OS_WINDOWS
 139     /** The handle of the event object on which the waiting readers block. (manual reset). */
 140     HANDLE                  hevReaders;
 141     /** The handle of the event object on which the waiting writers block. (manual reset). */
 142     HANDLE                  hevWriters;
 143 # elif K_OS == K_OS_OS2
 144     /** The handle of the event semaphore on which the waiting readers block. */
 145     HEV                     hevReaders;
 146     /** The handle of the event semaphore on which the waiting writers block. */
 147     HEV                     hevWriters;
 148 # endif
 149     /** The current state of the read-write lock. */
 150     KPRF_TYPE(,RWLOCKSTATE) enmState;
 151 } KPRF_TYPE(,RWLOCK);
 152 #endif
 153 /** Pointer to a Read/Write lock. */
 154 typedef KPRF_TYPE(,RWLOCK) *KPRF_TYPE(P,RWLOCK);
 155
 156
 157
 158 /*******************************************************************************
 159 *   Global Variables                                                           *
 160 *******************************************************************************/
 161 /** The TLS index / key. */
 162 #if K_OS == K_OS_WINDOWS
 163 static DWORD                g_dwThreadTLS = TLS_OUT_OF_INDEXES;
 164
 165 #elif defined(KPRF_USE_PTHREAD)
 166 static pthread_key_t        g_ThreadKey = (pthread_key_t)-1;
 167
 168 #elif K_OS == K_OS_OS2
 169 static KPRF_TYPE(P,THREAD) *g_ppThread = NULL;
 170
 171 #else
 172 # error "Not ported to your OS - or you're missing the OS define(s)."
 173 #endif
 174
 175 /** Pointer to the profiler header. */
 176 static KPRF_TYPE(P,HDR)     g_pHdr = NULL;
 177 #define KPRF_GET_HDR()                  g_pHdr
 178
 179 /** Whether the profiler is enabled or not. */
 180 static bool                 g_fEnabled = false;
 181 #define KPRF_IS_ACTIVE()                g_fEnabled
 182
 183
 184 /** The mutex protecting the threads in g_pHdr. */
 185 static KPRF_TYPE(,MUTEX)   g_ThreadsMutex;
 186
 187 /** The mutex protecting the module segments in g_pHdr. */
 188 static KPRF_TYPE(,MUTEX)   g_ModSegsMutex;
 189
 190 /** The read-write lock protecting the functions in g_pHdr. */
 191 static KPRF_TYPE(,RWLOCK)  g_FunctionsRWLock;
 192
 193
 194
 195 /*******************************************************************************
 196 *   Internal Functions                                                         *
 197 *******************************************************************************/
 198 static KPRF_TYPE(P,THREAD) kPrfGetThreadAutoReg(void);
 199 #ifdef KPRF_USE_PTHREAD
 200 static void kPrfPThreadKeyDtor(void *pvThread);
 201 #endif
 202
 203
 204 /**
 205  * Gets the pointer to the profiler data for the current thread.
 206  *
 207  * This implementation automatically adds unknown threads.
 208  *
 209  * @returns Pointer to the profiler thread data.
 210  * @returns NULL if we're out of thread space.
 211  */
 212 static inline KPRF_TYPE(P,THREAD) kPrfGetThread(void)
 213 {
 214     KPRF_TYPE(P,THREAD) pThread;
 215
 216 /* Win32/64 */
 217 #if K_OS == K_OS_WINDOWS
 218     pThread = (KPRF_TYPE(P,THREAD))TlsGetValue(g_dwThreadTLS);
 219
 220 /* Posix Threads */
 221 #elif defined(KPRF_USE_PTHREAD)
 222     pThread = (KPRF_TYPE(P,THREAD))pthread_getspecific(g_ThreadKey);
 223
 224 #elif K_OS == K_OS_OS2
 225     pThread = *g_ppThread;
 226
 227 #else
 228 # error not implemented
 229 #endif
 230     if (!pThread)
 231         pThread = kPrfGetThreadAutoReg();
 232     return pThread;
 233 }
 234 #define KPRF_GET_THREAD()               kPrfGetThread()
 235
 236
 237 /**
 238  * The the ID of the current thread.
 239  *
 240  * @returns The thread id.
 241  */
 242 static inline KUPTR kPrfGetThreadId(void)
 243 {
 244 /* Win32/64 */
 245 #if K_OS == K_OS_WINDOWS
 246     KUPTR ThreadId = (KUPTR)GetCurrentThreadId();
 247
 248 /* Posix Threads */
 249 #elif defined(KPRF_USE_PTHREAD)
 250     KUPTR ThreadId = (KUPTR)pthread_self();
 251
 252 #elif K_OS == K_OS_OS2
 253     PTIB pTib;
 254     PPIB pPib;
 255     DosGetInfoBlocks(&pTib, &pPib);
 256     ThreadId = pTib->tib_ptib2->tib2_ultid;
 257
 258 #else
 259 # error not implemented
 260 #endif
 261
 262     return ThreadId;
 263 }
 264 #define KPRF_GET_THREADID()             kPrfGetThreadId()
 265
 266
 267 /**
 268  * The the ID of the current process.
 269  *
 270  * @returns The process id.
 271  */
 272 static inline KUPTR kPrfGetProcessId(void)
 273 {
 274 /* Win32/64 */
 275 #if K_OS == K_OS_WINDOWS
 276     KUPTR ThreadId = (KUPTR)GetProcessId(GetCurrentProcess());
 277
 278 #elif K_OS == K_OS_OS2
 279     PTIB pTib;
 280     PPIB pPib;
 281     DosGetInfoBlocks(&pTib, &pPib);
 282     ThreadId = pPib->pib_pid;
 283
 284 #else
 285     KUPTR ThreadId = (KUPTR)getpid();
 286 #endif
 287
 288     return ThreadId;
 289 }
 290 #define KPRF_GET_PROCESSID()            kPrfGetProcessId()
 291
 292
 293 /**
 294  * Sets the pointer to the profiler data for the current thread.
 295  *
 296  * We require fast access to the profiler thread data, so we store
 297  * it in a TLS (thread local storage) item/key where the implementation
 298  * allows that.
 299  *
 300  * @param   pThread         The pointer to the profiler thread data for the current thread.
 301  */
 302 static inline void kPrfSetThread(KPRF_TYPE(P,THREAD) pThread)
 303 {
 304 /* Win32/64 */
 305 #if K_OS == K_OS_WINDOWS
 306     BOOL fRc = TlsSetValue(g_dwThreadTLS, pThread);
 307
 308 /* Posix Threads */
 309 #elif defined(KPRF_USE_PTHREAD)
 310     int rc = pthread_setspecific(g_ThreadKey, pThread);
 311
 312 #elif K_OS == K_OS_OS2
 313     *g_ppThread = pThread;
 314
 315 #else
 316 # error not implemented
 317 #endif
 318 }
 319 #define KPRF_SET_THREAD(pThread)        kPrfSetThread(pThread)
 320
 321
 322 /**
 323  * Get the now timestamp.
 324  * This must correspond to what the assembly code are doing.
 325  */
 326 static inline KU64 kPrfNow(void)
 327 {
 328 #if defined(HAVE_INTRIN)
 329     return __rdtsc();
 330 # else
 331     union
 332     {
 333         KU64 u64;
 334         struct
 335         {
 336             KU32 u32Lo;
 337             KU32 u32Hi;
 338         } s;
 339     } u;
 340 # if defined(__GNUC__)
 341     __asm__ __volatile__ ("rdtsc\n\t" : "=a" (u.s.u32Lo), "=d" (u.s.u32Hi));
 342 # else
 343     __asm
 344     {
 345         rdtsc
 346         mov     [u.s.u32Lo], eax
 347         mov     [u.s.u32Hi], edx
 348     }
 349
 350 # endif
 351     return u.u64;
 352 #endif
 353 }
 354 #define KPRF_NOW()                      kPrfNow()
 355
 356
 357 /**
 358  * Atomically set a 32-bit value.
 359  */
 360 static inline void kPrfAtomicSet32(volatile KU32 *pu32, const KU32 u32)
 361 {
 362 #if defined(HAVE_INTRIN)
 363     _InterlockedExchange((long volatile *)pu32, (const long)u32);
 364
 365 #elif defined(__GNUC__)
 366     __asm__ __volatile__("xchgl %0, %1\n\t"
 367                          : "=m" (*pu32)
 368                          : "r" (u32));
 369
 370 #elif _MSC_VER
 371     __asm
 372     {
 373         mov     edx, [pu32]
 374         mov     eax, [u32]
 375         xchg    [edx], eax
 376     }
 377
 378 #else
 379     *pu32 = u32;
 380 #endif
 381 }
 382 #define KPRF_ATOMIC_SET32(a,b)          kPrfAtomicSet32(a, b)
 383
 384
 385
 386 /**
 387  * Atomically set a 64-bit value.
 388  */
 389 static inline void kPrfAtomicSet64(volatile KU64 *pu64, KU64 u64)
 390 {
 391 #if defined(HAVE_INTRIN) && KPRF_BITS == 64
 392     _InterlockedExchange64((KI64 *)pu64, (const KI64)u64);
 393
 394 #elif defined(__GNUC__) && KPRF_BITS == 64
 395     __asm__ __volatile__("xchgq %0, %1\n\t"
 396                          : "=m" (*pu64)
 397                          : "r" (u64));
 398
 399 #elif defined(__GNUC__) && KPRF_BITS == 32
 400     __asm__ __volatile__("1:\n\t"
 401                          "lock; cmpxchg8b %1\n\t"
 402                          "jnz 1b\n\t"
 403                          : "=A" (u64),
 404                            "=m" (*pu64)
 405                          : "0" (*pu64),
 406                            "b" ( (KU32)u64 ),
 407                            "c" ( (KU32)(u64 >> 32) ));
 408
 409 #elif _MSC_VER
 410     __asm
 411     {
 412         mov     ebx, dword ptr [u64]
 413         mov     ecx, dword ptr [u64 + 4]
 414         mov     esi, pu64
 415         mov     eax, dword ptr [esi]
 416         mov     edx, dword ptr [esi + 4]
 417     retry:
 418         lock cmpxchg8b [esi]
 419         jnz retry
 420     }
 421 #else
 422     *pu64 = u64;
 423 #endif
 424 }
 425 #define KPRF_ATOMIC_SET64(a,b)          kPrfAtomicSet64(a, b)
 426
 427
 428 /**
 429  * Atomically add a 32-bit integer to another.
 430  */
 431 static inline void kPrfAtomicAdd32(volatile KU32 *pu32, const KU32 u32)
 432 {
 433 #if defined(HAVE_INTRIN)
 434     _InterlockedExchangeAdd((volatile long *)pu32, (const long)u32);
 435
 436 #elif defined(__GNUC__)
 437     __asm__ __volatile__("lock; addl %0, %1\n\t"
 438                          : "=m" (*pu32)
 439                          : "r" (u32));
 440
 441 #elif _MSC_VER
 442     __asm
 443     {
 444         mov     edx, [pu32]
 445         mov     eax, dword ptr [u32]
 446         lock add [edx], eax
 447     }
 448
 449 #else
 450     *pu32 += u32;
 451 #endif
 452 }
 453 #define KPRF_ATOMIC_ADD32(a,b)          kPrfAtomicAdd32(a, b)
 454 #define KPRF_ATOMIC_INC32(a)            kPrfAtomicAdd32(a, 1);
 455 #define KPRF_ATOMIC_DEC32(a)            kPrfAtomicAdd32(a, (KU32)-1);
 456
 457
 458 /**
 459  * Atomically add a 64-bit integer to another.
 460  * Atomically isn't quite required, just a non-corruptive manner, assuming all updates are adds.
 461  */
 462 static inline void kPrfAtomicAdd64(volatile KU64 *pu64, const KU64 u64)
 463 {
 464 #if defined(HAVE_INTRIN) && KPRF_BITS == 64
 465     _InterlockedExchangeAdd64((volatile KI64 *)pu64, (const KI64)u64);
 466
 467 #elif defined(__GNUC__) && KPRF_BITS == 64
 468     __asm__ __volatile__("lock; addq %0, %1\n\t"
 469                          : "=m" (*pu64)
 470                          : "r" (u64));
 471
 472 #elif defined(__GNUC__) && KPRF_BITS == 32
 473     __asm__ __volatile__("lock; addl %0, %2\n\t"
 474                          "lock; adcl %1, %3\n\t"
 475                          : "=m" (*(volatile KU32 *)pu64),
 476                            "=m" (*((volatile KU32 *)pu64 + 1))
 477                          : "r" ((KU32)u64),
 478                            "r" ((KU32)(u64 >> 32)));
 479
 480 #elif _MSC_VER
 481     __asm
 482     {
 483         mov     edx, [pu64]
 484         mov     eax, dword ptr [u64]
 485         mov     ecx, dword ptr [u64 + 4]
 486         lock add [edx], eax
 487         lock adc [edx + 4], ecx
 488     }
 489
 490 #else
 491     *pu64 += u64;
 492 #endif
 493 }
 494 #define KPRF_ATOMIC_ADD64(a,b)          kPrfAtomicAdd64(a, b)
 495 #define KPRF_ATOMIC_INC64(a)            kPrfAtomicAdd64(a, 1);
 496
 497
 498 /**
 499  * Initializes a mutex.
 500  *
 501  * @returns 0 on success.
 502  * @returns -1 on failure.
 503  * @param   pMutex      The mutex to init.
 504  */
 505 static int kPrfMutexInit(KPRF_TYPE(P,MUTEX) pMutex)
 506 {
 507 #if defined(KPRF_USE_PTHREAD)
 508     if (!pthread_mutex_init(pMutex, NULL));
 509         return 0;
 510     return -1;
 511
 512 #elif K_OS == K_OS_WINDOWS
 513     InitializeCriticalSection(pMutex);
 514     return 0;
 515
 516 #elif K_OS == K_OS_OS2
 517     if (!_fmutex_create(pMutex, 0))
 518         return 0;
 519     return -1;
 520 #endif
 521 }
 522
 523 /**
 524  * Deletes a mutex.
 525  *
 526  * @param   pMutex      The mutex to delete.
 527  */
 528 static void kPrfMutexDelete(KPRF_TYPE(P,MUTEX) pMutex)
 529 {
 530 #if defined(KPRF_USE_PTHREAD)
 531     pthread_mutex_destroy(pMutex);
 532
 533 #elif K_OS == K_OS_WINDOWS
 534     DeleteCriticalSection(pMutex);
 535
 536 #elif K_OS == K_OS_OS2
 537     _fmutex_close(pMutex);
 538 #endif
 539 }
 540
 541 /**
 542  * Locks a mutex.
 543  * @param   pMutex      The mutex lock.
 544  */
 545 static inline void kPrfMutexAcquire(KPRF_TYPE(P,MUTEX) pMutex)
 546 {
 547 #if K_OS == K_OS_WINDOWS
 548     EnterCriticalSection(pMutex);
 549
 550 #elif defined(KPRF_USE_PTHREAD)
 551     pthread_mutex_lock(pMutex);
 552
 553 #elif K_OS == K_OS_OS2
 554     fmutex_request(pMutex);
 555 #endif
 556 }
 557
 558
 559 /**
 560  * Unlocks a mutex.
 561  * @param   pMutex      The mutex lock.
 562  */
 563 static inline void kPrfMutexRelease(KPRF_TYPE(P,MUTEX) pMutex)
 564 {
 565 #if K_OS == K_OS_WINDOWS
 566     LeaveCriticalSection(pMutex);
 567
 568 #elif defined(KPRF_USE_PTHREAD)
 569     pthread_mutex_lock(pMutex);
 570
 571 #elif K_OS == K_OS_OS2
 572     fmutex_request(pMutex);
 573 #endif
 574 }
 575
 576
 577 #define KPRF_THREADS_LOCK()             kPrfMutexAcquire(&g_ThreadsMutex)
 578 #define KPRF_THREADS_UNLOCK()           kPrfMutexRelease(&g_ThreadsMutex)
 579
 580 #define KPRF_MODSEGS_LOCK()             kPrfMutexAcquire(&g_ModSegsMutex)
 581 #define KPRF_MODSEGS_UNLOCK()           kPrfMutexRelease(&g_ModSegsMutex)
 582
 583
 584 /**
 585  * Initializes a read-write lock.
 586  *
 587  * @returns 0 on success.
 588  * @returns -1 on failure.
 589  * @param   pRWLock     The read-write lock to initialize.
 590  */
 591 static inline int kPrfRWLockInit(KPRF_TYPE(P,RWLOCK) pRWLock)
 592 {
 593 #if defined(KPRF_USE_PTHREAD)
 594     if (!pthread_rwlock_init(pRWLock, NULL))
 595         return 0;
 596     return -1;
 597
 598 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 599     if (kPrfMutexInit(&pRWLock->Mutex))
 600         return -1;
 601     pRWLock->cReaders = 0;
 602     pRWLock->cReadersWaiting = 0;
 603     pRWLock->cWritersWaiting = 0;
 604     pRWLock->enmState = RWLOCK_STATE_SHARED;
 605 # if K_OS == K_OS_WINDOWS
 606     pRWLock->hevReaders = CreateEvent(NULL, TRUE, TRUE, NULL);
 607     pRWLock->hevWriters = CreateEvent(NULL, FALSE, FALSE, NULL);
 608     if (    pRWLock->hevReaders != INVALID_HANDLE_VALUE
 609         &&  pRWLock->hevWriters != INVALID_HANDLE_VALUE)
 610         return 0;
 611     CloseHandle(pRWLock->hevReaders);
 612     CloseHandle(pRWLock->hevWriters);
 613
 614 # elif K_OS == K_OS_OS2
 615     APIRET rc = DosCreateEventSem(NULL, &pRWLock->hevReaders, 0, TRUE);
 616     if (!rc)
 617     {
 618         rc = DosCreateEventSem(NULL, &pRWLock->hevWriters, 0, TRUE);
 619         if (!rc)
 620             return 0;
 621         pRWLock->hevWriters = NULLHANDLE;
 622         DosCloseEventSem(pRWLock->hevReaders);
 623     }
 624     pRWLock->hevReaders = NULLHANDLE;
 625 # endif
 626
 627     pRWLock->enmState = RWLOCK_STATE_UNINITIALIZED;
 628     kPrfMutexDelete(&pRWLock->Mutex);
 629     return -1;
 630 #endif
 631 }
 632
 633
 634 /**
 635  * Deleters a read-write lock.
 636  *
 637  * @param   pRWLock     The read-write lock to delete.
 638  */
 639 static inline void kPrfRWLockDelete(KPRF_TYPE(P,RWLOCK) pRWLock)
 640 {
 641 #if defined(KPRF_USE_PTHREAD)
 642     pthread_rwlock_destroy(pRWLock);
 643
 644 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 645     if (pRWLock->enmState == RWLOCK_STATE_UNINITIALIZED)
 646         return;
 647
 648     pRWLock->enmState = RWLOCK_STATE_UNINITIALIZED;
 649     kPrfMutexDelete(&pRWLock->Mutex);
 650     pRWLock->cReaders = 0;
 651     pRWLock->cReadersWaiting = 0;
 652     pRWLock->cWritersWaiting = 0;
 653 # if K_OS == K_OS_WINDOWS
 654     CloseHandle(pRWLock->hevReaders);
 655     pRWLock->hevReaders = INVALID_HANDLE_VALUE;
 656     CloseHandle(pRWLock->hevWriters);
 657     pRWLock->hevWriters = INVALID_HANDLE_VALUE;
 658
 659 # elif K_OS == K_OS_OS2
 660     DosCloseEventSem(pRWLock->hevReaders);
 661     pRWLock->hevReaders = NULLHANDLE;
 662     DosCloseEventSem(pRWLock->hevWriters);
 663     pRWLock->hevWriters = NULLHANDLE;
 664 # endif
 665 #endif
 666 }
 667
 668
 669 /**
 670  * Acquires read access to the read-write lock.
 671  * @param   pRWLock     The read-write lock.
 672  */
 673 static inline void kPrfRWLockAcquireRead(KPRF_TYPE(P,RWLOCK) pRWLock)
 674 {
 675 #if defined(KPRF_USE_PTHREAD)
 676     pthread_rwlock_rdlock(pRWLock);
 677
 678 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 679     if (pRWLock->enmState == RWLOCK_STATE_UNINITIALIZED)
 680         return;
 681
 682     kPrfMutexAcquire(&pRWLock->Mutex);
 683     if (pRWLock->enmState == RWLOCK_STATE_SHARED)
 684     {
 685         KPRF_ATOMIC_INC32(&pRWLock->cReaders);
 686         kPrfMutexRelease(&pRWLock->Mutex);
 687         return;
 688     }
 689
 690     for (;;)
 691     {
 692         /* have to wait */
 693         KPRF_ATOMIC_INC32(&pRWLock->cReadersWaiting);
 694 # if K_OS == K_OS_WINDOWS
 695         HANDLE hev = pRWLock->hevReaders;
 696         ResetEvent(hev);
 697
 698 # elif K_OS == K_OS_OS2
 699         HEV    hev = pRWLock->hevReaders;
 700         ULONG cIgnored;
 701         DosResetEventSem(hev, &cIgnored);
 702
 703 # endif
 704         kPrfMutexRelease(&pRWLock->Mutex);
 705
 706 # if K_OS == K_OS_WINDOWS
 707         switch (WaitForSingleObject(hev, INFINITE))
 708         {
 709             case WAIT_IO_COMPLETION:
 710             case WAIT_TIMEOUT:
 711             case WAIT_OBJECT_0:
 712                 break;
 713             case WAIT_ABANDONED:
 714             default:
 715                 return;
 716         }
 717
 718 # elif K_OS == K_OS_OS2
 719         switch (DosWaitEventSem(hev, SEM_INDEFINITE_WAIT))
 720         {
 721             case NO_ERROR:
 722             case ERROR_SEM_TIMEOUT:
 723             case ERROR_TIMEOUT:
 724             case ERROR_INTERRUPT:
 725                 break;
 726             default:
 727                 return;
 728         }
 729 # endif
 730
 731         kPrfMutexAcquire(&pRWLock->Mutex);
 732         if (pRWLock->enmState == RWLOCK_STATE_SHARED)
 733         {
 734             KPRF_ATOMIC_INC32(&pRWLock->cReaders);
 735             KPRF_ATOMIC_DEC32(&pRWLock->cReadersWaiting);
 736             kPrfMutexRelease(&pRWLock->Mutex);
 737             return;
 738         }
 739     }
 740 #endif
 741 }
 742
 743
 744 /**
 745  * Releases read access to the read-write lock.
 746  * @param   pRWLock     The read-write lock.
 747  */
 748 static inline void kPrfRWLockReleaseRead(KPRF_TYPE(P,RWLOCK) pRWLock)
 749 {
 750 #if defined(KPRF_USE_PTHREAD)
 751     pthread_rwlock_unlock(pRWLock);
 752
 753 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 754     if (pRWLock->enmState == RWLOCK_STATE_UNINITIALIZED)
 755         return;
 756
 757     /*
 758      * If we're still in the shared state, or if there
 759      * are more readers out there, or if there are no
 760      * waiting writers, all we have to do is decrement an leave.
 761      *
 762      * That's the most frequent, thing and should be fast.
 763      */
 764     kPrfMutexAcquire(&pRWLock->Mutex);
 765     KPRF_ATOMIC_DEC32(&pRWLock->cReaders);
 766     if (    pRWLock->enmState == RWLOCK_STATE_SHARED
 767         ||  pRWLock->cReaders
 768         ||  !pRWLock->cWritersWaiting)
 769     {
 770         kPrfMutexRelease(&pRWLock->Mutex);
 771         return;
 772     }
 773
 774     /*
 775      * Wake up one (or more on OS/2) waiting writers.
 776      */
 777 # if K_OS == K_OS_WINDOWS
 778     SetEvent(pRWLock->hevWriters);
 779 # elif K_OS == K_OS_OS2
 780     DosPostEvent(pRWLock->hevwriters);
 781 # endif
 782     kPrfMutexRelease(&pRWLock->Mutex);
 783
 784 #endif
 785 }
 786
 787
 788 /**
 789  * Acquires write access to the read-write lock.
 790  * @param   pRWLock     The read-write lock.
 791  */
 792 static inline void kPrfRWLockAcquireWrite(KPRF_TYPE(P,RWLOCK) pRWLock)
 793 {
 794 #if defined(KPRF_USE_PTHREAD)
 795     pthread_rwlock_wrlock(pRWLock);
 796
 797 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 798     if (pRWLock->enmState == RWLOCK_STATE_UNINITIALIZED)
 799         return;
 800
 801     kPrfMutexAcquire(&pRWLock->Mutex);
 802     if (    !pRWLock->cReaders
 803         &&  (   pRWLock->enmState == RWLOCK_STATE_SHARED
 804              || pRWLock->enmState == RWLOCK_STATE_LOCKING)
 805         )
 806     {
 807         KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_EXCLUSIVE);
 808         kPrfMutexRelease(&pRWLock->Mutex);
 809         return;
 810     }
 811
 812     /*
 813      * We'll have to wait.
 814      */
 815     if (pRWLock->enmState == RWLOCK_STATE_SHARED)
 816         KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_LOCKING);
 817     KPRF_ATOMIC_INC32(&pRWLock->cWritersWaiting);
 818     for (;;)
 819     {
 820 # if K_OS == K_OS_WINDOWS
 821         HANDLE hev = pRWLock->hevWriters;
 822 # elif K_OS == K_OS_OS2
 823         HEV    hev = pRWLock->hevWriters;
 824 # endif
 825         kPrfMutexRelease(&pRWLock->Mutex);
 826 # if K_OS == K_OS_WINDOWS
 827         switch (WaitForSingleObject(hev, INFINITE))
 828         {
 829             case WAIT_IO_COMPLETION:
 830             case WAIT_TIMEOUT:
 831             case WAIT_OBJECT_0:
 832                 break;
 833             case WAIT_ABANDONED:
 834             default:
 835                 KPRF_ATOMIC_DEC32(&pRWLock->cWritersWaiting);
 836                 return;
 837         }
 838
 839 # elif K_OS == K_OS_OS2
 840         switch (DosWaitEventSem(hev, SEM_INDEFINITE_WAIT))
 841         {
 842             case NO_ERROR:
 843             case ERROR_SEM_TIMEOUT:
 844             case ERROR_TIMEOUT:
 845             case ERROR_INTERRUPT:
 846                 break;
 847             default:
 848                 KPRF_ATOMIC_DEC32(&pRWLock->cWritersWaiting);
 849                 return;
 850         }
 851         ULONG cIgnored;
 852         DosResetEventSem(hev, &cIgnored);
 853 # endif
 854
 855         /*
 856          * Try acquire the lock.
 857          */
 858         kPrfMutexAcquire(&pRWLock->Mutex);
 859         if (    !pRWLock->cReaders
 860             &&  (   pRWLock->enmState == RWLOCK_STATE_SHARED
 861                  || pRWLock->enmState == RWLOCK_STATE_LOCKING)
 862             )
 863         {
 864             KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_EXCLUSIVE);
 865             KPRF_ATOMIC_DEC32(&pRWLock->cWritersWaiting);
 866             kPrfMutexRelease(&pRWLock->Mutex);
 867             return;
 868         }
 869     }
 870 #endif
 871 }
 872
 873
 874 /**
 875  * Releases write access to the read-write lock.
 876  * @param   pRWLock     The read-write lock.
 877  */
 878 static inline void kPrfRWLockReleaseWrite(KPRF_TYPE(P,RWLOCK) pRWLock)
 879 {
 880 #if defined(KPRF_USE_PTHREAD)
 881     pthread_rwlock_unlock(pRWLock);
 882
 883 #elif K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
 884     if (pRWLock->enmState == RWLOCK_STATE_UNINITIALIZED)
 885         return;
 886
 887     /*
 888      * The common thing is that there are noone waiting.
 889      * But, before that usual paranoia.
 890      */
 891     kPrfMutexAcquire(&pRWLock->Mutex);
 892     if (pRWLock->enmState != RWLOCK_STATE_EXCLUSIVE)
 893     {
 894         kPrfMutexRelease(&pRWLock->Mutex);
 895         return;
 896     }
 897     if (    !pRWLock->cReadersWaiting
 898         &&  !pRWLock->cWritersWaiting)
 899     {
 900         KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_SHARED);
 901         kPrfMutexRelease(&pRWLock->Mutex);
 902         return;
 903     }
 904
 905     /*
 906      * Someone is waiting, wake them up as we change the state.
 907      */
 908 # if K_OS == K_OS_WINDOWS
 909     HANDLE hev = INVALID_HANDLE_VALUE;
 910 # elif K_OS == K_OS_OS2
 911     HEV    hev = NULLHANDLE;
 912 # endif
 913
 914     if (pRWLock->cWritersWaiting)
 915     {
 916         KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_LOCKING);
 917         hev = pRWLock->hevWriters;
 918     }
 919     else
 920     {
 921         KPRF_RWLOCK_SETSTATE(pRWLock, RWLOCK_STATE_SHARED);
 922         hev = pRWLock->hevReaders;
 923     }
 924 # if K_OS == K_OS_WINDOWS
 925     SetEvent(hev);
 926 # elif K_OS == K_OS_OS2
 927     DosPostEvent(pRWLock->hevwriters);
 928 # endif
 929     kPrfMutexRelease(&pRWLock->Mutex);
 930
 931 #endif
 932 }
 933
 934 #define KPRF_FUNCS_WRITE_LOCK()         kPrfRWLockAcquireWrite(&g_FunctionsRWLock)
 935 #define KPRF_FUNCS_WRITE_UNLOCK()       kPrfRWLockReleaseWrite(&g_FunctionsRWLock)
 936 #define KPRF_FUNCS_READ_LOCK()          kPrfRWLockAcquireRead(&g_FunctionsRWLock)
 937 #define KPRF_FUNCS_READ_UNLOCK()        kPrfRWLockReleaseRead(&g_FunctionsRWLock)
 938
 939
 940
 941
 942 /**
 943  * Finds the module segment which the address belongs to.
 944  *
 945  */
 946 static int kPrfGetModSeg(KPRF_TYPE(,UPTR) uAddress, char *pszPath, KU32 cchPath, KU32 *piSegment,
 947                          KPRF_TYPE(P,UPTR) puBasePtr, KPRF_TYPE(P,UPTR) pcbSegmentMinusOne)
 948 {
 949 #if K_OS == K_OS_WINDOWS
 950     /*
 951      * Enumerate the module handles.
 952      */
 953     HANDLE      hProcess = GetCurrentProcess();
 954     DWORD       cbNeeded = 0;
 955     HMODULE     hModIgnored;
 956     if (    !EnumProcessModules(hProcess, &hModIgnored, sizeof(hModIgnored), &cbNeeded)
 957         &&  GetLastError() != ERROR_BUFFER_OVERFLOW) /** figure out what this actually returns */
 958         cbNeeded = 256 * sizeof(HMODULE);
 959
 960     cbNeeded += sizeof(HMODULE) * 32;
 961     HMODULE *pahModules = (HMODULE *)alloca(cbNeeded);
 962     if (EnumProcessModules(hProcess, pahModules, cbNeeded, &cbNeeded))
 963     {
 964         const unsigned cModules = cbNeeded / sizeof(HMODULE);
 965         for (unsigned i = 0; i < cModules; i++)
 966         {
 967             __try
 968             {
 969                 const KUPTR uImageBase = (KUPTR)pahModules[i];
 970                 union
 971                 {
 972                     KU8                *pu8;
 973                     PIMAGE_DOS_HEADER   pDos;
 974                     PIMAGE_NT_HEADERS   pNt;
 975                     PIMAGE_NT_HEADERS32 pNt32;
 976                     PIMAGE_NT_HEADERS64 pNt64;
 977                     KUPTR               u;
 978                 } u;
 979                 u.u = uImageBase;
 980
 981                 /* reject modules higher than the address. */
 982                 if (uAddress < u.u)
 983                     continue;
 984
 985                 /* Skip past the MZ header */
 986                 if (u.pDos->e_magic == IMAGE_DOS_SIGNATURE)
 987                     u.pu8 += u.pDos->e_lfanew;
 988
 989                 /* Ignore anything which isn't an NT header. */
 990                 if (u.pNt->Signature != IMAGE_NT_SIGNATURE)
 991                     continue;
 992
 993                 /* Extract necessary info from the optional header (comes in 32-bit and 64-bit variations, we simplify a bit). */
 994                 KU32                    cbImage;
 995                 PIMAGE_SECTION_HEADER   paSHs;
 996                 if (u.pNt->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32))
 997                 {
 998                     paSHs = (PIMAGE_SECTION_HEADER)(u.pNt32 + 1);
 999                     cbImage = u.pNt32->OptionalHeader.SizeOfImage;
1000                 }
1001                 else if (u.pNt->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER64))
1002                 {
1003                     paSHs = (PIMAGE_SECTION_HEADER)(u.pNt64 + 1);
1004                     cbImage = u.pNt64->OptionalHeader.SizeOfImage;
1005                 }
1006                 else
1007                     continue;
1008
1009                 /* Is our address within the image size */
1010                 KUPTR uRVA = uAddress - (KUPTR)pahModules[i];
1011                 if (uRVA >= cbImage)
1012                     continue;
1013
1014                 /*
1015                  * Iterate the section headers and figure which section we're in.
1016                  * (segment == section + 1)
1017                  */
1018                 const KU32 cSHs = u.pNt->FileHeader.NumberOfSections;
1019                 if (uRVA < paSHs[0].VirtualAddress)
1020                 {
1021                     /* the implicit header section */
1022                     *puBasePtr          = uImageBase;
1023                     *pcbSegmentMinusOne = paSHs[0].VirtualAddress - 1;
1024                     *piSegment          = 0;
1025                 }
1026                 else
1027                 {
1028                     KU32 iSH = 0;
1029                     for (;;)
1030                     {
1031                         if (iSH >= cSHs)
1032                         {
1033                             /* this shouldn't happen, but in case it does simply deal with it. */
1034                             *puBasePtr          = paSHs[iSH - 1].VirtualAddress + paSHs[iSH - 1].Misc.VirtualSize + uImageBase;
1035                             *pcbSegmentMinusOne = cbImage - *puBasePtr;
1036                             *piSegment          = iSH + 1;
1037                             break;
1038                         }
1039                         if (uRVA - paSHs[iSH].VirtualAddress < paSHs[iSH].Misc.VirtualSize)
1040                         {
1041                             *puBasePtr          = paSHs[iSH].VirtualAddress + uImageBase;
1042                             *pcbSegmentMinusOne = paSHs[iSH].Misc.VirtualSize;
1043                             *piSegment          = iSH + 1;
1044                             break;
1045                         }
1046                         iSH++;
1047                     }
1048                 }
1049
1050                 /*
1051                  * Finally, get the module name.
1052                  * There are multiple ways, try them all before giving up.
1053                  */
1054                 if (    !GetModuleFileNameEx(hProcess, pahModules[i], pszPath, cchPath)
1055                     &&  !GetModuleFileName(pahModules[i], pszPath, cchPath)
1056                     &&  !GetMappedFileName(hProcess, (PVOID)uAddress, pszPath, cchPath)
1057                     &&  !GetModuleBaseName(hProcess, pahModules[i], pszPath, cchPath))
1058                     *pszPath = '\0';
1059                 return 0;
1060             }
1061             __except (EXCEPTION_EXECUTE_HANDLER)
1062             {
1063             }
1064         }
1065     }
1066
1067 #elif K_OS == K_OS_OS2
1068     /*
1069      * Just ask the loader.
1070      */
1071     ULONG   offObj = 0;
1072     ULONG   iObj = 0;
1073     HMODULE hmod = NULLHANDLE;
1074     APIRET rc = DosQueryModFromEIP(&hmod, &iObj, cchPath, pszPath, &offObj, uAddress);
1075     if (!rc)
1076     {
1077         *piSegment = iObj;
1078         *puBasePtr = uAddress - offObj;
1079         *pcbSegmentMinusOne = KPRF_ALIGN(offObj, 0x1000) - 1; /* minimum size */
1080
1081         /*
1082          * Query the page attributes starting at the current page. The query will not enter
1083          * into the next object since PAG_BASE is requested.
1084          */
1085         ULONG cb     = ~0UL;
1086         ULONG fFlags = ~0UL;
1087         uAddress &= ~(KUPTR)0xfff;
1088         rc = DosQueryMem((PVOID)(uAddress, &cb, &fFlags);
1089         if (!rc)
1090         {
1091             *pcbSegmentMinusOne = (offObj & ~(KUPTR)0xfff) + KPRF_ALIGN(cb, 0x1000) - 1;
1092             if ((fFlags & PAG_BASE) && cb <= 0x1000) /* don't quite remember if PAG_BASE returns one page or not */
1093             {
1094                 cb = ~0UL;
1095                 fFlags = ~0UL;
1096                 rc = DosQueryMem((PVOID)(uAddress + 0x1000), &cb, &fFlags);
1097                 if (!rc & !(fFlags & (PAG_BASE | PAG_FREE)))
1098                     *pcbSegmentMinusOne += KPRF_ALIGN(cb, 0x1000);
1099             }
1100         }
1101         return 0;
1102     }
1103
1104 #endif
1105     /* The common fallback */
1106     *pszPath = '\0';
1107     *piSegment = 0;
1108     *puBasePtr = 0;
1109     *pcbSegmentMinusOne = ~(KPRF_TYPE(,UPTR))0;
1110     return -1;
1111 }
1112 #define KPRF_GET_MODSEG(uAddress, pszPath, cchPath, piSegment, puBasePtr, pcbSegmentMinusOne) \
1113                                         kPrfGetModSeg(uAddress, pszPath, cchPath, piSegment, puBasePtr, pcbSegmentMinusOne)
1114
1115
1116
1117
1118 /*
1119  * Instantiate the implementation
1120  */
1121 #include "prfcorepre.cpp.h"
1122
1123 #include "prfcoremodseg.cpp.h"
1124 #include "prfcorefunction.cpp.h"
1125 #include "prfcore.cpp.h"
1126 #include "prfcoreinit.cpp.h"
1127 #include "prfcoreterm.cpp.h"
1128
1129 #include "prfcorepost.cpp.h"
1130
1131
1132
1133
1134
1135 /**
1136  * Registers an unknown thread.
1137  *
1138  * @returns Pointer to the registered thread.
1139  */
1140 static KPRF_TYPE(P,THREAD) kPrfGetThreadAutoReg(void)
1141 {
1142     KUPTR uStackBasePtr;
1143
1144 #if 0
1145     /** @todo I'm sure Win32 has a way of obtaining the top and bottom of the stack, OS/2 did...
1146      * Some limit stuff in posix / ansi also comes to mind... */
1147
1148 #elif K_OS == K_OS_OS2
1149     PTIB pTib;
1150     PPIB pPib;
1151     DosGetInfoBlocks(&pTib, &pPib); /* never fails except if you give it bad input, thus 'Get' not 'Query'. */
1152     /* I never recall which of these is the right one... */
1153     uStackBasePtr = (KUPTR)pTib->tib_pstack < (KUPTR)pTib->tib_pstack_limit
1154         ? (KUPTR)pTib->tib_pstack
1155         : (KUPTR)pTib->tib_pstack_limit;
1156
1157 #else
1158     /* the default is top of the current stack page (assuming a page to be 4KB) */
1159     uStackBasePtr = (KUPTR)&uStackBasePtr;
1160     uStackBasePtr = (uStackBasePtr + 0xfff) & ~(KUPTR)0xfff;
1161 #endif
1162
1163     return KPRF_NAME(RegisterThread)(uStackBasePtr, "");
1164 }
1165
1166
1167 /**
1168  * Get a env.var. variable.
1169  *
1170  * @returns pszValue.
1171  * @param   pszVar      The variable name.
1172  * @param   pszValue    Where to store the value.
1173  * @param   cchValue    The size of the value buffer.
1174  * @param   pszDefault  The default value.
1175  */
1176 static char *kPrfGetEnvString(const char *pszVar, char *pszValue, KU32 cchValue, const char *pszDefault)
1177 {
1178 #if K_OS == K_OS_WINDOWS
1179     if (GetEnvironmentVariable(pszVar, pszValue, cchValue))
1180         return pszValue;
1181
1182 #elif K_OS == K_OS_OS2
1183     PSZ pszValue;
1184     if (    !DosScanEnv((PCSZ)pszVar, &pszValue)
1185         &&  !*pszValue)
1186         pszDefault = pszValue;
1187
1188 #else
1189     const char *pszTmp = getenv(pszVar);
1190     if (pszTmp)
1191         pszDefault = pszTmp;
1192
1193 #endif
1194
1195     /*
1196      * Copy the result into the buffer.
1197      */
1198     char *psz = pszValue;
1199     while (*pszDefault && cchValue-- > 1)
1200         *psz++ = *pszDefault++;
1201     *psz = '\0';
1202
1203     return pszValue;
1204 }
1205
1206
1207 /**
1208  * The the value of an env.var.
1209  *
1210  * @returns The value of the env.var.
1211  * @returns The default if the value was not found.
1212  * @param   pszVar      The variable name.
1213  * @param   uDefault    The default value.
1214  */
1215 static KU32 kPrfGetEnvValue(const char *pszVar, KU32 uDefault)
1216 {
1217 #if K_OS == K_OS_WINDOWS
1218     char szBuf[128];
1219     const char *pszValue = szBuf;
1220     if (!GetEnvironmentVariable(pszVar, szBuf, sizeof(szBuf)))
1221         pszValue = NULL;
1222
1223 #elif K_OS == K_OS_OS2
1224     PSZ pszValue;
1225     if (DosScanEnv((PCSZ)pszVar, &pszValue))
1226         pszValue = NULL;
1227
1228 #else
1229     const char *pszValue = getenv(pszVar);
1230
1231 #endif
1232
1233     /*
1234      * Discard the obvious stuff.
1235      */
1236     if (!pszValue)
1237         return uDefault;
1238     while (*pszValue == ' ' || *pszValue == '\t')
1239         pszValue++;
1240     if (!*pszValue)
1241         return uDefault;
1242
1243     /*
1244      * Interpret the value.
1245      */
1246     unsigned    uBase = 10;
1247     KU32        uValue = 0;
1248     const char *psz = pszValue;
1249
1250     /* prefix - only hex */
1251     if (*psz == '0' && (psz[1] == 'x' || psz[1] == 'X'))
1252     {
1253         uBase = 16;
1254         psz += 2;
1255     }
1256
1257     /* read the value */
1258     while (*psz)
1259     {
1260         unsigned char ch = (unsigned char)*psz;
1261         if (ch >= '0' && ch <= '9')
1262             ch -= '0';
1263         else if (   uBase > 10
1264                  && ch >= 'a' && ch <= 'f')
1265             ch -= 'a' + 10;
1266         else if (   uBase > 10
1267                  && ch >= 'a' && ch <= 'F')
1268             ch -= 'a' + 10;
1269         else
1270             break;
1271         uValue *= uBase;
1272         uValue += ch;
1273         psz++;
1274     }
1275
1276     /* postfixes */
1277     switch (*psz)
1278     {
1279         case 'm':
1280         case 'M':
1281             uValue *= 1024*1024;
1282             break;
1283
1284         case 'k':
1285         case 'K':
1286             uValue *= 1024;
1287             break;
1288     }
1289
1290     /*
1291      * If the value is still 0, we return the default.
1292      */
1293     return uValue ? uValue : uDefault;
1294 }
1295
1296
1297 /**
1298  * Allocates memory.
1299  *
1300  * @returns Pointer to the allocated memory.
1301  * @returns NULL on failure.
1302  * @param   cb      The amount of memory (in bytes) to allocate.
1303  */
1304 static void *kPrfAllocMem(KU32 cb)
1305 {
1306 #if K_OS == K_OS_WINDOWS
1307     void *pv = VirtualAlloc(NULL, cb, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
1308
1309 #elif defined(KPRF_USE_MMAN)
1310     void *pv = mmap(NULL, cb, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1311
1312 #elif K_OS == K_OS_OS2
1313     void *pv;
1314 # ifdef INCL_DOSEXAPIS
1315     if (DosAllocMemEx(&pv, cb, PAG_READ | PAG_WRITE | PAG_EXECUTE | PAG_COMMIT | OBJ_FORK))s
1316 # else
1317     if (DosAllocMem(&pv, cb, PAG_READ | PAG_WRITE | PAG_EXECUTE | PAG_COMMIT))
1318 # endif
1319         pvBuf = NULL;
1320
1321 #else
1322 # error not implemented
1323 #endif
1324     return pv;
1325 }
1326
1327
1328 /**
1329  * Frees memory.
1330  *
1331  * @param   pv      The memory to free.
1332  */
1333 static void kPrfFreeMem(void *pv)
1334 {
1335 #if K_OS == K_OS_WINDOWS
1336     VirtualFree(pv, 0, MEM_RELEASE);
1337
1338 #elif defined(KPRF_USE_MMAN)
1339     munmap(pv, 0); /** @todo check if 0 is allowed here.. */
1340
1341 #elif K_OS == K_OS_OS2
1342 # ifdef INCL_DOSEXAPIS
1343     DosFreeMemEx(&pv);
1344 # else
1345     DosFreeMem(&pv);
1346 # endif
1347
1348 #else
1349 # error not implemented
1350 #endif
1351 }
1352
1353
1354 /**
1355  * Writes a data buffer to a new file.
1356  *
1357  * Any existing file will be overwritten.
1358  *
1359  *
1360  * @returns 0 on success.
1361  * @returns -1 on failure.
1362  *
1363  * @param   pszName     The name of the file.
1364  * @param   pvData      The data to write.
1365  * @param   cbData      The amount of data to write.
1366  */
1367 static int kPrfWriteFile(const char *pszName, const void *pvData, KU32 cbData)
1368 {
1369 #if K_OS == K_OS_WINDOWS
1370     int rc = -1;
1371     HANDLE hFile = CreateFile(pszName,GENERIC_WRITE, FILE_SHARE_READ, NULL,
1372                               CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, INVALID_HANDLE_VALUE);
1373     if (hFile != INVALID_HANDLE_VALUE)
1374     {
1375         DWORD dwWritten;
1376         if (    WriteFile(hFile, pvData, cbData, &dwWritten, NULL)
1377             &&  dwWritten == cbData)
1378             rc = 0;
1379         CloseHandle(hFile);
1380     }
1381     return rc;
1382
1383 #elif K_OS == K_OS_OS2
1384     HFILE hFile;
1385     ULONG ulAction = 0;
1386     APIRET rc = DosOpen(pszName, &hFile, &ulAction, cbData, FILE_NORMAL,
1387                         OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
1388                         OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYWRITE | OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_SEQUENTIAL,
1389                         NULL);
1390     if (!rc)
1391     {
1392         ULONG cbWritten;
1393         rc = DosWrite(hFile, pvData, cbData, &cbWritten);
1394         if (!rc && cbWritten != cbData)
1395             rc = -1;
1396         DosClose(hFile);
1397     }
1398     return rc ? -1 : 0;
1399
1400 #else
1401     int rc = -1;
1402     int fd = open(pszName, O_WRONLY | O_CREAT | O_BINARY | O_TRUNC, 0666);
1403     if (fd >= 0)
1404     {
1405         if (write(fd, pvData, cbData) == cbData)
1406             rc = 0;
1407         close(fd);
1408     }
1409     return rc;
1410
1411 #endif
1412 }
1413
1414
1415
1416 /**
1417  * Initializes and start the profiling.
1418  *
1419  * This should typically be called from some kind of module init
1420  * function, so we can start profiling upon/before entering main().
1421  *
1422  * @returns 0 on success
1423  * @returns -1 on failure.
1424  *
1425  */
1426 int kPrfInitialize(void)
1427 {
1428     /*
1429      * Only initialize once.
1430      */
1431     if (KPRF_GET_HDR())
1432         return 0;
1433
1434     /*
1435      * Initial suggestions.
1436      */
1437     KU32    cbModSegs  = kPrfGetEnvValue("KPRF2_CBMODSEGS",  128*1024);
1438     KU32    cFunctions = kPrfGetEnvValue("KPRF2_CFUNCTIONS", 8192);
1439     KU32    cThreads   = kPrfGetEnvValue("KPRF2_CTHREADS",   256);
1440     KU32    cStacks    = kPrfGetEnvValue("KPRF2_CSTACKS",    48);
1441     KU32    cFrames    = kPrfGetEnvValue("KPRF2_CFRAMES",    448);
1442     KU32    fAffinity  = kPrfGetEnvValue("KPRF2_AFFINITY",   0);
1443
1444     KU32    cb = KPRF_NAME(CalcSize)(cFunctions, cbModSegs, cThreads, cStacks, cFrames);
1445
1446     /*
1447      * Allocate and initialize the data set.
1448      */
1449     void *pvBuf = kPrfAllocMem(cb);
1450     if (!pvBuf)
1451         return -1;
1452
1453     KPRF_TYPE(P,HDR) pHdr = KPRF_NAME(Init)(pvBuf, cb, cFunctions, cbModSegs, cThreads, cStacks, cFrames);
1454     if (pHdr)
1455     {
1456         /*
1457          * Initialize semaphores.
1458          */
1459         if (!kPrfMutexInit(&g_ThreadsMutex))
1460         {
1461             if (!kPrfMutexInit(&g_ModSegsMutex))
1462             {
1463                 if (!kPrfRWLockInit(&g_FunctionsRWLock))
1464                 {
1465                     /*
1466                      * Allocate the TLS entry.
1467                      */
1468 #if K_OS == K_OS_WINDOWS
1469                     g_dwThreadTLS = TlsAlloc();
1470                     if (g_dwThreadTLS != TLS_OUT_OF_INDEXES)
1471
1472 #elif defined(KPRF_USE_PTHREAD)
1473                     int rc = pthread_key_create(&g_ThreadKey, kPrfPThreadKeyDtor);
1474                     if (!rc)
1475
1476 #elif K_OS == K_OS_OS2
1477                     int rc = DosAllocThreadLocalMemory(sizeof(void *), (PULONG*)&g_ppThread); /** @todo check if this is a count or a size. */
1478                     if (!rc)
1479
1480 #endif
1481                     {
1482                         /*
1483                          * Apply the affinity mask, if specified.
1484                          */
1485                         if (fAffinity)
1486                         {
1487 #if K_OS == K_OS_WINDOWS
1488                             SetProcessAffinityMask(GetCurrentProcess(), fAffinity);
1489 #endif
1490                         }
1491
1492                         g_pHdr = pHdr;
1493                         g_fEnabled = true;
1494                         return 0;
1495                     }
1496                     kPrfRWLockDelete(&g_FunctionsRWLock);
1497                 }
1498                 kPrfMutexDelete(&g_ModSegsMutex);
1499             }
1500             kPrfMutexDelete(&g_ThreadsMutex);
1501         }
1502     }
1503     kPrfFreeMem(pvBuf);
1504     return -1;
1505 }
1506
1507
1508 /**
1509  * Stops, dumps, and terminates the profiling.
1510  *
1511  * This should typically be called from some kind of module destruction
1512  * function, so we can profile parts of the termination sequence too.
1513  *
1514  * @returns 0 on success
1515  * @returns -1 on failure.
1516  *
1517  */
1518 int kPrfTerminate(void)
1519 {
1520     /*
1521      * Stop the profiling.
1522      * As a safety precaution, sleep a little bit to allow threads
1523      * still at large inside profiler code some time to get out.
1524      */
1525     g_fEnabled = false;
1526     KPRF_TYPE(P,HDR) pHdr = g_pHdr;
1527     g_pHdr = NULL;
1528     if (!pHdr)
1529         return -1;
1530
1531 #if K_OS == K_OS_WINDOWS
1532     Sleep(10);
1533 #elif K_OS == K_OS_OS2
1534     DosSleep(10);
1535 #else
1536     usleep(10000);
1537 #endif
1538
1539     /*
1540      * Unwind all active threads and so forth.
1541      */
1542     KPRF_NAME(TerminateAll)(pHdr);
1543
1544     /*
1545      * Use the stack space to fill in process details.
1546      */
1547 #if K_OS == K_OS_WINDOWS
1548     /* all is one single string */
1549     const char *pszCommandLine = GetCommandLine();
1550     if (pszCommandLine)
1551         KPRF_NAME(SetCommandLine)(pHdr, 1, &pszCommandLine);
1552
1553 #elif K_OS == K_OS_OS2 || K_OS == K_OS_OS2
1554     PTIB pTib;
1555     PPIB pPib;
1556     DosGetInfoBlocks(&pTib, &pPib);
1557     if (pPib->pib_pchcmd)
1558     {
1559         /* Tradition say that the commandline is made up of two zero terminate strings
1560          * - first the executable name, then the arguments. Similar to what unix does,
1561          *   only completely mocked up because of the CMD.EXE tradition.
1562          */
1563         const char *apszArgs[2];
1564         apszArgs[0] = pPib->pib_pchcmd;
1565         apszArgs[1] = pPib->pib_pchcmd;
1566         while (apszArgs[1][0])
1567             apszArgs[1]++;
1568         apszArgs[1]++;
1569         KPRF_NAME(SetCommandLine)(pHdr, 2, apszArgs);
1570     }
1571
1572 #else
1573     /* linux can read /proc/self/something I guess. Don't know about the rest... */
1574
1575 #endif
1576
1577     /*
1578      * Write the file to disk.
1579      */
1580     char szName[260 + 16];
1581     kPrfGetEnvString("KPRF2_FILE", szName, sizeof(szName) - 16, "kPrf2-");
1582
1583     /* append the process id */
1584     KUPTR pid = kPrfGetProcessId();
1585     char *psz = szName;
1586     while (*psz)
1587         psz++;
1588
1589     static char s_szDigits[0x11] = "0123456789abcdef";
1590     KU32 uShift = KPRF_BITS - 4;
1591     while (     uShift > 0
1592            &&   !(pid & (0xf << uShift)))
1593         uShift -= 4;
1594     *psz++ = s_szDigits[(pid >> uShift) & 0xf];
1595      while (uShift > 0)
1596      {
1597          uShift -= 4;
1598          *psz++ = s_szDigits[(pid >> uShift) & 0xf];
1599      }
1600
1601     /* .kPrf2 */
1602     *psz++ = '.';
1603     *psz++ = 'k';
1604     *psz++ = 'P';
1605     *psz++ = 'r';
1606     *psz++ = 'f';
1607     *psz++ = '2';
1608     *psz++ = '\0';
1609
1610     /* write the file. */
1611     int rc = kPrfWriteFile(szName, pHdr, pHdr->cb);
1612
1613     /*
1614      * Free resources.
1615      */
1616     kPrfFreeMem(pHdr);
1617 #if K_OS == K_OS_WINDOWS
1618     TlsFree(g_dwThreadTLS);
1619     g_dwThreadTLS = TLS_OUT_OF_INDEXES;
1620
1621 #elif defined(KPRF_USE_PTHREAD)
1622     pthread_key_delete(g_ThreadKey);
1623     g_ThreadKey = (pthread_key_t)-1;
1624
1625 #elif K_OS == K_OS_OS2
1626     DosFreeThreadLocalMemory((PULONG)g_ppThread);
1627     g_ppThread = NULL;
1628
1629 #else
1630 # error "port me!"
1631 #endif
1632
1633     kPrfMutexDelete(&g_ThreadsMutex);
1634     kPrfMutexDelete(&g_ModSegsMutex);
1635     kPrfRWLockDelete(&g_FunctionsRWLock);
1636
1637     return rc;
1638 }
1639
1640
1641 /**
1642  * Terminate the current thread.
1643  */
1644 void kPrfTerminateThread(void)
1645 {
1646     KPRF_NAME(DeregisterThread)();
1647 }
1648
1649
1650 #ifdef KPRF_USE_PTHREAD
1651 /**
1652  * TLS destructor.
1653  */
1654 static void kPrfPThreadKeyDtor(void *pvThread)
1655 {
1656     KPRF_TYPE(P,HDR) pHdr = KPRF_GET_HDR();
1657     if (pHdr)
1658     {
1659         KPRF_TYPE(P,THREAD) pThread = (KPRF_TYPE(P,THREAD))pvThread;
1660         pthread_setspecific(g_ThreadKey, pvThread);
1661         KPRF_NAME(TerminateThread)(pHdr, pThread, KPRF_NOW());
1662         pthread_setspecific(g_ThreadKey, NULL);
1663     }
1664 }
1665 #endif
1666