VirtualBox

Changeset 403 in vbox for trunk/src/VBox/Runtime/r0drv


Ignore:
Timestamp:
Jan 28, 2007 8:45:05 AM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
17974
Message:

Need RTThreadWait in ring-0 too when using the generic timers, so thread.cpp was ported to ring-0. Fixed a bug in RTTimerStart() (the generic code). (hope this doesn't break the other platforms...)

Location:
trunk/src/VBox/Runtime/r0drv
Files:
1 deleted
5 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/r0drv/darwin/semaphore-r0drv-darwin.cpp

    r205 r403  
    5656#define RTSEMEVENT_MAGIC 0x19601110
    5757
     58
     59/**
     60 * Darwin multiple release event semaphore.
     61 */
     62typedef struct RTSEMEVENTMULTIINTERNAL
     63{
     64    /** Magic value (RTSEMEVENTMULTI_MAGIC). */
     65    uint32_t volatile   u32Magic;
     66    /** The number of waiting threads. */
     67    uint32_t volatile   cWaiters;
     68    /** Set if the event object is signaled. */
     69    uint8_t volatile    fSignaled;
     70    /** The number of threads in the process of waking up. */
     71    uint32_t volatile   cWaking;
     72    /** The spinlock protecting us. */
     73    lck_spin_t         *pSpinlock;
     74} RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL;
     75
     76/** Magic for the Darwin multiple release event semaphore structure. (Isaac Asimov) */
     77#define RTSEMEVENTMULTI_MAGIC 0x19200102
     78
     79
    5880#if 0 /** @todo */
    5981/**
    … …  
    187209        Assert(!pEventInt->cWaiters);
    188210        ASMAtomicXchgU8(&pEventInt->fSignaled, false);
    189         rc = 0;
     211        rc = VINF_SUCCESS;
    190212    }
    191213    else
    … …  
    270292    return rtSemEventWait(EventSem, cMillies, TRUE /* interruptable */);
    271293}
     294
     295
     296
     297RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
     298{
     299    Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
     300    AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
     301
     302    PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pEventMultiInt));
     303    if (pEventMultiInt)
     304    {
     305        pEventMultiInt->u32Magic = RTSEMEVENTMULTI_MAGIC;
     306        pEventMultiInt->cWaiters = 0;
     307        pEventMultiInt->cWaking = 0;
     308        pEventMultiInt->fSignaled = 0;
     309        Assert(g_pDarwinLockGroup);
     310        pEventMultiInt->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
     311        if (pEventMultiInt->pSpinlock)
     312        {
     313            *pEventMultiSem = pEventMultiInt;
     314            return VINF_SUCCESS;
     315        }
     316
     317        pEventMultiInt->u32Magic = 0;
     318        RTMemFree(pEventMultiInt);
     319    }
     320    return VERR_NO_MEMORY;
     321}
     322
     323
     324RTDECL(int)  RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
     325{
     326    if (EventMultiSem == NIL_RTSEMEVENTMULTI)     /* don't bitch */
     327        return VERR_INVALID_HANDLE;
     328    PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     329    AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
     330    AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
     331                    ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     332                    VERR_INVALID_HANDLE);
     333
     334    lck_spin_lock(pEventMultiInt->pSpinlock);
     335    ASMAtomicIncU32(&pEventMultiInt->u32Magic); /* make the handle invalid */
     336    if (pEventMultiInt->cWaiters > 0)
     337    {
     338        /* abort waiting thread, last man cleans up. */
     339        ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
     340        thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_RESTART);
     341        lck_spin_unlock(pEventMultiInt->pSpinlock);
     342    }
     343    else if (pEventMultiInt->cWaking)
     344        /* the last waking thread is gonna do the cleanup */
     345        lck_spin_unlock(pEventMultiInt->pSpinlock);
     346    else
     347    {
     348        lck_spin_unlock(pEventMultiInt->pSpinlock);
     349        lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
     350        RTMemFree(pEventMultiInt);
     351    }
     352
     353    return VINF_SUCCESS;
     354}
     355
     356
     357RTDECL(int)  RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
     358{
     359    PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     360    AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
     361    AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
     362                    ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     363                    VERR_INVALID_HANDLE);
     364
     365    lck_spin_lock(pEventMultiInt->pSpinlock);
     366
     367    ASMAtomicXchgU8(&pEventMultiInt->fSignaled, true);
     368    if (pEventMultiInt->cWaiters > 0)
     369    {
     370        ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
     371        ASMAtomicXchgU32(&pEventMultiInt->cWaiters, 0);
     372        thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_AWAKENED);
     373    }
     374
     375    lck_spin_unlock(pEventMultiInt->pSpinlock);
     376    return VINF_SUCCESS;
     377}
     378
     379
     380RTDECL(int)  RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
     381{
     382    PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     383    AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
     384    AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
     385                    ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     386                    VERR_INVALID_HANDLE);
     387
     388    lck_spin_lock(pEventMultiInt->pSpinlock);
     389    ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
     390    lck_spin_unlock(pEventMultiInt->pSpinlock);
     391    return VINF_SUCCESS;
     392}
     393
     394
     395static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, wait_interrupt_t fInterruptible)
     396{
     397    PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
     398    AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
     399    AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
     400                    ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
     401                    VERR_INVALID_HANDLE);
     402
     403    lck_spin_lock(pEventMultiInt->pSpinlock);
     404
     405    int rc;
     406    if (pEventMultiInt->fSignaled)
     407    {
     408        ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
     409        rc = VINF_SUCCESS;
     410    }
     411    else
     412    {
     413        ASMAtomicIncU32(&pEventMultiInt->cWaiters);
     414
     415        wait_result_t rcWait;
     416        if (cMillies == RT_INDEFINITE_WAIT)
     417            rcWait = lck_spin_sleep(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pEventMultiInt, fInterruptible);
     418        else
     419        {
     420            uint64_t u64AbsTime;
     421            nanoseconds_to_absolutetime(cMillies * UINT64_C(1000000), &u64AbsTime);
     422            u64AbsTime += mach_absolute_time();
     423
     424            rcWait = lck_spin_sleep_deadline(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT,
     425                                             (event_t)pEventMultiInt, fInterruptible, u64AbsTime);
     426        }
     427        switch (rcWait)
     428        {
     429            case THREAD_AWAKENED:
     430                Assert(pEventMultiInt->cWaking > 0);
     431                if (    !ASMAtomicDecU32(&pEventMultiInt->cWaking)
     432                    &&  pEventMultiInt->u32Magic != RTSEMEVENTMULTI_MAGIC)
     433                {
     434                    /* the event was destroyed after we woke up, as the last thread do the cleanup. */
     435                    lck_spin_unlock(pEventMultiInt->pSpinlock);
     436                    Assert(g_pDarwinLockGroup);
     437                    lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
     438                    RTMemFree(pEventMultiInt);
     439                    return VINF_SUCCESS;
     440                }
     441                rc = VINF_SUCCESS;
     442                break;
     443
     444            case THREAD_TIMED_OUT:
     445                Assert(cMillies != RT_INDEFINITE_WAIT);
     446                ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     447                rc = VERR_TIMEOUT;
     448                break;
     449
     450            case THREAD_INTERRUPTED:
     451                Assert(fInterruptible);
     452                ASMAtomicDecU32(&pEventMultiInt->cWaiters);
     453                rc = VERR_INTERRUPTED;
     454                break;
     455
     456            case THREAD_RESTART:
     457                /* Last one out does the cleanup. */
     458                if (!ASMAtomicDecU32(&pEventMultiInt->cWaking))
     459                {
     460                    lck_spin_unlock(pEventMultiInt->pSpinlock);
     461                    Assert(g_pDarwinLockGroup);
     462                    lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
     463                    RTMemFree(pEventMultiInt);
     464                    return VERR_SEM_DESTROYED;
     465                }
     466
     467                rc = VERR_SEM_DESTROYED;
     468                break;
     469
     470            default:
     471                AssertMsgFailed(("rcWait=%d\n", rcWait));
     472                rc = VERR_GENERAL_FAILURE;
     473                break;
     474        }
     475    }
     476
     477    lck_spin_unlock(pEventMultiInt->pSpinlock);
     478    return rc;
     479}
     480
     481
     482RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     483{
     484    return rtSemEventMultiWait(EventMultiSem, cMillies, FALSE /* not interruptable */);
     485}
     486
     487
     488RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
     489{
     490    return rtSemEventMultiWait(EventMultiSem, cMillies, TRUE /* interruptable */);
     491}
     492
    272493
    273494

  • trunk/src/VBox/Runtime/r0drv/darwin/thread-r0drv-darwin.cpp

    r197 r403  
    2626#include <iprt/thread.h>
    2727#include <iprt/err.h>
    28 #include <iprt/assert.h>
    29 #include "internal/thread.h"
    3028
    3129
    32 RTDECL(RTTHREAD) RTThreadSelf(void)
     30
     31RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
    3332{
    34     return (RTTHREAD)current_thread();
     33    return (RTNATIVETHREAD)current_thread();
    3534}
    3635
    3736
    38 RTDECL(int)   RTThreadSleep(unsigned cMillies)
     37RTDECL(int) RTThreadSleep(unsigned cMillies)
    3938{
    4039    uint64_t u64Deadline;
    … …  
    5150}
    5251
    53 
    54 int rtThreadNativeSetPriority(RTTHREAD Thread, RTTHREADTYPE enmType)
    55 {
    56     /*
    57      * Convert the priority type to scheduling policies.
    58      */
    59     bool                            fSetExtended = false;
    60     thread_extended_policy          Extended = { true };
    61     bool                            fSetTimeContstraint = false;
    62     thread_time_constraint_policy   TimeConstraint = { 0, 0, 0, true };
    63     thread_precedence_policy        Precedence = { 0 };
    64     switch (enmType)
    65     {
    66         case RTTHREADTYPE_INFREQUENT_POLLER:
    67             Precedence.importance = 1;
    68             break;
    69 
    70         case RTTHREADTYPE_EMULATION:
    71             Precedence.importance = 30;
    72             break;
    73 
    74         case RTTHREADTYPE_DEFAULT:
    75             Precedence.importance = 31;
    76             break;
    77 
    78         case RTTHREADTYPE_MSG_PUMP:
    79             Precedence.importance = 34;
    80             break;
    81 
    82         case RTTHREADTYPE_IO:
    83             Precedence.importance = 98;
    84             break;
    85 
    86         case RTTHREADTYPE_TIMER:
    87             Precedence.importance = 0x7fffffff;
    88 
    89             fSetExtended = true;
    90             Extended.timeshare = FALSE;
    91 
    92             fSetTimeContstraint = true;
    93             TimeConstraint.period = 0; /* not really true for a real timer thread, but we've really no idea. */
    94             TimeConstraint.computation = rtDarwinAbsTimeFromNano(100000); /* 100 us*/
    95             TimeConstraint.constraint = rtDarwinAbsTimeFromNano(500000);  /* 500 us */
    96             TimeConstraint.preemptible = FALSE;
    97             break;
    98 
    99         default:
    100             AssertMsgFailed(("enmType=%d\n", enmType));
    101             return VERR_INVALID_PARAMETER;
    102     }
    103 
    104     /*
    105      * Do the actual modification.
    106      */
    107     kern_return_t rc = thread_policy_set((thread_t)Thread, THREAD_PRECEDENCE_POLICY,
    108                                          (thread_policy_t)&Precedence, THREAD_PRECEDENCE_POLICY_COUNT);
    109     AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc)); NOREF(rc);
    110 
    111     if (fSetExtended)
    112     {
    113         rc = thread_policy_set((thread_t)Thread, THREAD_EXTENDED_POLICY,
    114                                (thread_policy_t)&Extended, THREAD_EXTENDED_POLICY_COUNT);
    115         AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc));
    116     }
    117 
    118     if (fSetTimeContstraint)
    119     {
    120         rc = thread_policy_set((thread_t)Thread, THREAD_TIME_CONSTRAINT_POLICY,
    121                                (thread_policy_t)&TimeConstraint, THREAD_TIME_CONSTRAINT_POLICY_COUNT);
    122         AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc));
    123     }
    124 
    125     return VINF_SUCCESS; /* ignore any errors for now */
    126 }
    127 
    128 
    129 /**
    130  * Native kernel thread wrapper function.
    131  *
    132  * This will forward to rtThreadMain and do termination upon return.
    133  *
    134  * @param pvArg         Pointer to the argument package.
    135  * @param Ignored       Wait result, which we ignore.
    136  */
    137 static void rtThreadNativeMain(void *pvArg, wait_result_t Ignored)
    138 {
    139     const thread_t Self = current_thread();
    140 
    141     rtThreadMain((PRTR0THREADARGS)pvArg, (RTNATIVETHREAD)Self);
    142 
    143     kern_return_t rc = thread_terminate(Self);
    144     AssertFatalMsgFailed(("rc=%d\n", rc));
    145 }
    146 
    147 
    148 int rtThreadNativeCreate(PRTR0THREADARGS pArgs, PRTNATIVETHREAD pNativeThread)
    149 {
    150     thread_t NativeThread;
    151     kern_return_t rc = kernel_thread_start(rtThreadNativeMain, pArgs, &NativeThread);
    152     if (rc == KERN_SUCCESS)
    153     {
    154         *pNativeThread = (RTNATIVETHREAD)NativeThread;
    155         thread_deallocate(NativeThread);
    156         return VINF_SUCCESS;
    157     }
    158     return RTErrConvertFromMachKernReturn(rc);
    159 }
    160 

  • trunk/src/VBox/Runtime/r0drv/darwin/thread2-r0drv-darwin.cpp

    r375 r403  
    11/* $Id$ */
    22/** @file
    3  * InnoTek Portable Runtime - Threads, Ring-0 Driver, Darwin.
     3 * InnoTek Portable Runtime - Threads (Part 2), Ring-0 Driver, Darwin.
    44 */
    55
    … …  
    3030
    3131
    32 RTDECL(RTTHREAD) RTThreadSelf(void)
     32int rtThreadNativeInit(void)
    3333{
    34     return (RTTHREAD)current_thread();
    35 }
    36 
    37 
    38 RTDECL(int)   RTThreadSleep(unsigned cMillies)
    39 {
    40     uint64_t u64Deadline;
    41     clock_interval_to_deadline(cMillies, kMillisecondScale, &u64Deadline);
    42     clock_delay_until(u64Deadline);
     34    /* No TLS in Ring-0. :-/ */
    4335    return VINF_SUCCESS;
    4436}
    4537
    4638
    47 RTDECL(bool) RTThreadYield(void)
     39RTDECL(RTTHREAD) RTThreadSelf(void)
    4840{
    49     thread_block(THREAD_CONTINUE_NULL);
    50     return true; /* this is fishy */
     41    return rtThreadGetByNative((RTNATIVETHREAD)current_thread());
    5142}
    5243
    5344
    54 int rtThreadNativeSetPriority(RTTHREAD Thread, RTTHREADTYPE enmType)
     45int rtThreadNativeSetPriority(PRTTHREADINT pThread, RTTHREADTYPE enmType)
    5546{
    5647    /*
    5748     * Convert the priority type to scheduling policies.
     49     * (This is really just guess work.)
    5850     */
    5951    bool                            fSetExtended = false;
    … …  
    10597     * Do the actual modification.
    10698     */
    107     kern_return_t rc = thread_policy_set((thread_t)Thread, THREAD_PRECEDENCE_POLICY,
     99    kern_return_t kr = thread_policy_set((thread_t)pThread->Core.Key, THREAD_PRECEDENCE_POLICY,
    108100                                         (thread_policy_t)&Precedence, THREAD_PRECEDENCE_POLICY_COUNT);
    109     AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc)); NOREF(rc);
     101    AssertMsg(kr == KERN_SUCCESS, ("%rc\n", kr)); NOREF(kr);
    110102
    111103    if (fSetExtended)
    112104    {
    113         rc = thread_policy_set((thread_t)Thread, THREAD_EXTENDED_POLICY,
     105        kr = thread_policy_set((thread_t)pThread->Core.Key, THREAD_EXTENDED_POLICY,
    114106                               (thread_policy_t)&Extended, THREAD_EXTENDED_POLICY_COUNT);
    115         AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc));
     107        AssertMsg(kr == KERN_SUCCESS, ("%rc\n", kr));
    116108    }
    117109
    118110    if (fSetTimeContstraint)
    119111    {
    120         rc = thread_policy_set((thread_t)Thread, THREAD_TIME_CONSTRAINT_POLICY,
     112        kr = thread_policy_set((thread_t)pThread->Core.Key, THREAD_TIME_CONSTRAINT_POLICY,
    121113                               (thread_policy_t)&TimeConstraint, THREAD_TIME_CONSTRAINT_POLICY_COUNT);
    122         AssertMsg(rc == KERN_SUCCESS, ("%rc\n", rc));
     114        AssertMsg(kr == KERN_SUCCESS, ("%rc\n", kr));
    123115    }
    124116
    125117    return VINF_SUCCESS; /* ignore any errors for now */
     118}
     119
     120
     121int rtThreadNativeAdopt(PRTTHREADINT pThread)
     122{
     123    return VERR_NOT_IMPLEMENTED;
    126124}
    127125
    … …  
    139137    const thread_t Self = current_thread();
    140138
    141     rtThreadMain((PRTR0THREADARGS)pvArg, (RTNATIVETHREAD)Self);
     139    rtThreadMain((PRTTHREADINT)pvArg, (RTNATIVETHREAD)Self);
    142140
    143     kern_return_t rc = thread_terminate(Self);
    144     AssertFatalMsgFailed(("rc=%d\n", rc));
     141    kern_return_t kr = thread_terminate(Self);
     142    AssertFatalMsgFailed(("kr=%d\n", kr));
    145143}
    146144
    147145
    148 int rtThreadNativeCreate(PRTR0THREADARGS pArgs, PRTNATIVETHREAD pNativeThread)
     146int rtThreadNativeCreate(PRTTHREADINT pThreadInt, PRTNATIVETHREAD pNativeThread)
    149147{
    150148    thread_t NativeThread;
    151     kern_return_t rc = kernel_thread_start(rtThreadNativeMain, pArgs, &NativeThread);
    152     if (rc == KERN_SUCCESS)
     149    kern_return_t kr = kernel_thread_start(rtThreadNativeMain, pThreadInt, &NativeThread);
     150    if (kr == KERN_SUCCESS)
    153151    {
    154152        *pNativeThread = (RTNATIVETHREAD)NativeThread;
    … …  
    156154        return VINF_SUCCESS;
    157155    }
    158     return RTErrConvertFromMachKernReturn(rc);
     156    return RTErrConvertFromMachKernReturn(kr);
    159157}
    160158

  • trunk/src/VBox/Runtime/r0drv/initterm-r0drv.cpp

    r207 r403  
    2626#include <iprt/initterm.h>
    2727#include <iprt/assert.h>
     28#include <iprt/err.h>
     29
    2830#include "internal/initterm.h"
     31#include "internal/thread.h"
    2932
    3033
    … …  
    3740RTR0DECL(int) RTR0Init(unsigned fReserved)
    3841{
     42    int rc;
    3943    Assert(fReserved == 0);
    40     return rtR0InitNative();
     44    rc = rtR0InitNative();
     45    if (RT_SUCCESS(rc))
     46    {
     47#if !defined(__LINUX__) && !defined(__WIN__)
     48        rc = rtThreadInit();
     49#endif
     50        if (RT_SUCCESS(rc))
     51            return rc;
     52
     53        rtR0TermNative();
     54    }
     55    return rc;
    4156}
    4257
    … …  
    4762RTR0DECL(void) RTR0Term(void)
    4863{
    49     return rtR0TermNative();
     64#if !defined(__LINUX__) && !defined(__WIN__)
     65    rtThreadTerm();
     66#endif
     67    rtR0TermNative();
    5068}
    5169

  • trunk/src/VBox/Runtime/r0drv/linux/thread-r0drv-linux.c

    r1 r403  
    2929
    3030
    31 RTDECL(RTTHREAD) RTThreadSelf(void)
     31RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
    3232{
    33     return (RTTHREAD)current;
     33    return (RTNATIVETHREAD)current;
    3434}
    3535

  • trunk/src/VBox/Runtime/r0drv/linux/thread2-r0drv-linux.c

    r375 r403  
    11/* $Id$ */
    22/** @file
    3  * InnoTek Portable Runtime - Threads, Ring-0 Driver, Linux.
     3 * InnoTek Portable Runtime - Threads (Part 2), Ring-0 Driver, Linux.
    44 */
    55
    … …  
    2727#include <iprt/thread.h>
    2828#include <iprt/err.h>
     29#include "internal/thread.h"
    2930
    3031
    3132RTDECL(RTTHREAD) RTThreadSelf(void)
    3233{
    33     return (RTTHREAD)current;
     34    return rtThreadGetByNative(((RTNATIVETHREAD)current);
    3435}
    3536
    36 
    37 RTDECL(int)   RTThreadSleep(unsigned cMillies)
    38 {
    39     long cJiffies = msecs_to_jiffies(cMillies);
    40     set_current_state(TASK_INTERRUPTIBLE);
    41     cJiffies = schedule_timeout(cJiffies);
    42     if (!cJiffies)
    43         return VINF_SUCCESS;
    44     return VERR_INTERRUPTED;
    45 }
    46 
    47 
    48 RTDECL(bool) RTThreadYield(void)
    49 {
    50 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 20)
    51     yield();
    52 #else
    53     set_current_state(TASK_RUNNING);
    54     sys_sched_yield();
    55     schedule();
    56 #endif
    57     return true;
    58 }
    59 

  • trunk/src/VBox/Runtime/r0drv/nt/thread-r0drv-nt.cpp

    r1 r403  
    3333
    3434
    35 RTDECL(RTTHREAD) RTThreadSelf(void)
     35RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
    3636{
    37     return (RTTHREAD)PsGetCurrentThread();
     37    return (RTNATIVETHREAD)PsGetCurrentThread();
    3838}
    3939
    … …  
    6262}
    6363
     64

  • trunk/src/VBox/Runtime/r0drv/nt/thread2-r0drv-nt.cpp

    r375 r403  
    11/* $Id$ */
    22/** @file
    3  * InnoTek Portable Runtime - Threads, Ring-0 Driver, NT.
     3 * InnoTek Portable Runtime - Threads (Part 2), Ring-0 Driver, NT.
    44 */
    55
    … …  
    2828#include <iprt/err.h>
    2929
    30 __BEGIN_DECLS
    31 NTSTATUS NTAPI ZwYieldExecution(void);
    32 __END_DECLS
     30#include "internal/thread.h"
    3331
    3432
    3533RTDECL(RTTHREAD) RTThreadSelf(void)
    3634{
    37     return (RTTHREAD)PsGetCurrentThread();
     35    return rtThreadGetByNative((RTNATIVETHREAD)PsGetCurrentThread());
    3836}
    3937
    40 
    41 RTDECL(int)   RTThreadSleep(unsigned cMillies)
    42 {
    43     LARGE_INTEGER Interval;
    44     Interval.QuadPart = -(int64_t)cMillies * 10000;
    45     NTSTATUS rcNt = KeDelayExecutionThread(KernelMode, TRUE, &Interval);
    46     switch (rcNt)
    47     {
    48         case STATUS_SUCCESS:
    49             return VINF_SUCCESS;
    50         case STATUS_ALERTED:
    51         case STATUS_USER_APC:
    52             return VERR_INTERRUPTED;
    53         default:
    54             return RTErrConvertFromNtStatus(rcNt);
    55     }
    56 }
    57 
    58 
    59 RTDECL(bool) RTThreadYield(void)
    60 {
    61     return ZwYieldExecution() != STATUS_NO_YIELD_PERFORMED;
    62 }
    63 
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette