VirtualBox

Ignore:
Timestamp:
Apr 28, 2019 4:47:51 PM (6 years ago)
Author:
vboxsync
Message:

Config.kmk,Additions/common/crOpenGL,VBox/GuestHost/OpenGL,HostServices/SharedOpenGL: Remove CHROMIUM_THREADSAFE define and apply the current default

Location:
trunk/src/VBox/GuestHost/OpenGL/util
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/util/hash.c

    r63199 r78341  
    3737
    3838struct CRHashTable {
    39         unsigned int num_elements;
    40         CRHashNode *buckets[CR_NUM_BUCKETS];
    41         CRHashIdPool   *idPool;
    42 #ifdef CHROMIUM_THREADSAFE
     39    unsigned int num_elements;
     40    CRHashNode *buckets[CR_NUM_BUCKETS];
     41    CRHashIdPool   *idPool;
    4342    CRmutex mutex;
    44 #endif
    4543};
    4644
    … …  
    382380    }
    383381    hash->idPool = crAllocHashIdPoolEx( min, max );
    384 #ifdef CHROMIUM_THREADSAFE
    385382    crInitMutex(&hash->mutex);
    386 #endif
    387383    return hash;
    388384}
    … …  
    400396    if ( !hash) return;
    401397
    402 #ifdef CHROMIUM_THREADSAFE
    403398    crLockMutex(&hash->mutex);
    404 #endif
    405 
    406399    for ( i = 0; i < CR_NUM_BUCKETS; i++ )
    407400    {
    … …  
    424417    }
    425418    crFreeHashIdPool( hash->idPool );
    426 
    427 #ifdef CHROMIUM_THREADSAFE
    428419    crUnlockMutex(&hash->mutex);
    429420    crFreeMutex(&hash->mutex);
    430 #endif
    431 
    432421    crFree( hash );
    433422}
    … …  
    440429    if (!hash) return;
    441430
    442 #ifdef CHROMIUM_THREADSAFE
    443431    crLockMutex(&hash->mutex);
    444 #endif
    445 
    446432    for (i = 0; i < CR_NUM_BUCKETS; i++)
    447433    {
    … …  
    465451    crFreeHashIdPool(hash->idPool);
    466452
    467 #ifdef CHROMIUM_THREADSAFE
    468453    crUnlockMutex(&hash->mutex);
    469454    crFreeMutex(&hash->mutex);
    470 #endif
    471 
    472455    crFree(hash);
    473456}
    … …  
    476459void crHashtableLock(CRHashTable *h)
    477460{
    478 #ifdef CHROMIUM_THREADSAFE
    479     crLockMutex(&h->mutex);
    480 #endif
     461    crLockMutex(&h->mutex);
    481462}
    482463
    483464void crHashtableUnlock(CRHashTable *h)
    484465{
    485 #ifdef CHROMIUM_THREADSAFE
    486     crUnlockMutex(&h->mutex);
    487 #endif
     466    crUnlockMutex(&h->mutex);
    488467}
    489468
    … …  
    513492        return;
    514493
    515 #ifdef CHROMIUM_THREADSAFE
    516494    crLockMutex(&hash->mutex);
    517 #endif
    518495    crHashtableWalkUnlocked(hash, walkFunc , dataPtr2);
    519 #ifdef CHROMIUM_THREADSAFE
    520496    crUnlockMutex(&hash->mutex);
    521 #endif
    522497}
    523498
    … …  
    531506    unsigned int index = crHash(key);
    532507    CRHashNode *node = (CRHashNode *) crCalloc( sizeof( CRHashNode ) );
    533 #ifdef CHROMIUM_THREADSAFE
    534     crLockMutex(&h->mutex);
    535 #endif
     508
     509    crLockMutex(&h->mutex);
    536510    node->key = key;
    537511    node->data = data;
    … …  
    540514    h->num_elements++;
    541515    crHashIdPoolAllocId (h->idPool, key);
    542 #ifdef CHROMIUM_THREADSAFE
    543     crUnlockMutex(&h->mutex);
    544 #endif
     516    crUnlockMutex(&h->mutex);
    545517}
    546518
    … …  
    548520{
    549521    GLboolean fAllocated;
    550 #ifdef CHROMIUM_THREADSAFE
    551     crLockMutex(&h->mutex);
    552 #endif
     522
     523    crLockMutex(&h->mutex);
    553524    fAllocated = crHashIdPoolAllocId (h->idPool, key);
    554 #ifdef CHROMIUM_THREADSAFE
    555     crUnlockMutex(&h->mutex);
    556 #endif
     525    crUnlockMutex(&h->mutex);
    557526    return fAllocated;
    558527}
    … …  
    560529void crHashtableWalkKeys( CRHashTable *h, CRHashIdWalkKeys walkFunc , void *data)
    561530{
    562 #ifdef CHROMIUM_THREADSAFE
    563     crLockMutex(&h->mutex);
    564 #endif
     531    crLockMutex(&h->mutex);
    565532    crHashIdWalkKeys(h->idPool, walkFunc , data);
    566 #ifdef CHROMIUM_THREADSAFE
    567     crUnlockMutex(&h->mutex);
    568 #endif
     533    crUnlockMutex(&h->mutex);
    569534}
    570535
    … …  
    573538    GLuint res;
    574539
    575 #ifdef CHROMIUM_THREADSAFE
    576     crLockMutex(&h->mutex);
    577 #endif
     540    crLockMutex(&h->mutex);
    578541    res = crHashIdPoolAllocBlock (h->idPool, range);
    579542#ifdef DEBUG_misha
    … …  
    588551    }
    589552#endif
    590 #ifdef CHROMIUM_THREADSAFE
    591     crUnlockMutex(&h->mutex);
    592 #endif
     553    crUnlockMutex(&h->mutex);
    593554    return res;
    594555}
    … …  
    599560    CRHashNode *temp, *beftemp = NULL;
    600561
    601 #ifdef CHROMIUM_THREADSAFE
    602     crLockMutex(&h->mutex);
    603 #endif
     562    crLockMutex(&h->mutex);
    604563    for ( temp = h->buckets[index]; temp; temp = temp->next )
    605564    {
    … …  
    623582   
    624583    crHashIdPoolFreeBlock( h->idPool, key, 1 );
    625 #ifdef CHROMIUM_THREADSAFE
    626     crUnlockMutex(&h->mutex);
    627 #endif
     584    crUnlockMutex(&h->mutex);
    628585}
    629586
    … …  
    633590    CRHashNode *temp, *beftemp = NULL;
    634591
    635 #ifdef CHROMIUM_THREADSAFE
    636     crLockMutex(&h->mutex);
    637 #endif
     592    crLockMutex(&h->mutex);
    638593    for (temp = h->buckets[index]; temp; temp = temp->next)
    639594    {
    … …  
    657612
    658613    crHashIdPoolFreeBlock(h->idPool, key, 1);
    659 #ifdef CHROMIUM_THREADSAFE
    660     crUnlockMutex(&h->mutex);
    661 #endif
     614    crUnlockMutex(&h->mutex);
    662615}
    663616
    … …  
    676629    unsigned int index = crHash( key );
    677630    CRHashNode *temp;
    678 #ifdef CHROMIUM_THREADSAFE
     631
    679632    crLockMutex((CRmutex *)&h->mutex);
    680 #endif
    681633    for ( temp = h->buckets[index]; temp; temp = temp->next )
    682634    {
    … …  
    684636            break;
    685637    }
    686 #ifdef CHROMIUM_THREADSAFE
    687638    crUnlockMutex((CRmutex *)&h->mutex);
    688 #endif
    689639    if ( !temp )
    690640    {
    … …  
    699649    unsigned int index = crHash( key );
    700650    CRHashNode *temp;
    701 #ifdef CHROMIUM_THREADSAFE
    702     crLockMutex(&h->mutex);
    703 #endif
     651
     652    crLockMutex(&h->mutex);
    704653    for ( temp = h->buckets[index]; temp; temp = temp->next )
    705654    {
    … …  
    707656            break;
    708657    }
    709 #ifdef CHROMIUM_THREADSAFE
    710     crUnlockMutex(&h->mutex);
    711 #endif
     658    crUnlockMutex(&h->mutex);
    712659    if ( !temp )
    713660    {
    … …  
    715662        return;
    716663    }
    717 #ifdef CHROMIUM_THREADSAFE
    718     crLockMutex(&h->mutex);
    719 #endif
     664    crLockMutex(&h->mutex);
    720665    if ( temp->data && deleteFunc )
    721666    {
    … …  
    723668    }
    724669    temp->data = data;
    725 #ifdef CHROMIUM_THREADSAFE
    726     crUnlockMutex(&h->mutex);
    727 #endif
     670    crUnlockMutex(&h->mutex);
    728671}
    729672
    … …  
    753696        return rc;
    754697
    755 #ifdef CHROMIUM_THREADSAFE
    756698    crLockMutex(&pHash->mutex);
    757 #endif
    758699    for (i = 0; i<CR_NUM_BUCKETS && !rc; i++)
    759700    {
    … …  
    770711        }
    771712    }
    772 #ifdef CHROMIUM_THREADSAFE
     713
    773714    crUnlockMutex(&pHash->mutex);
    774 #endif
    775 
    776715    return rc;
    777716}

  • trunk/src/VBox/GuestHost/OpenGL/util/net.c

    r78190 r78341  
    4848    int                  num_clients; /* total number of clients (unused?) */
    4949
    50 #ifdef CHROMIUM_THREADSAFE
    5150    CRmutex              mutex;
    52 #endif
    5351} cr_net;
    5452
    … …  
    134132    {
    135133        crDebug("crNetConnectToServer() failed, freeing the connection");
    136         #ifdef CHROMIUM_THREADSAFE
    137             crFreeMutex( &conn->messageList.lock );
    138         #endif
     134        crFreeMutex( &conn->messageList.lock );
    139135        conn->Disconnect(conn);
    140136        crFree( conn );
    … …  
    219215{
    220216    conn->Disconnect(conn);
    221     #ifdef CHROMIUM_THREADSAFE
    222         crFreeMutex( &conn->messageList.lock );
    223     #endif
     217    crFreeMutex( &conn->messageList.lock );
    224218    crFree(conn);
    225219}
    … …  
    244238        cr_net.use_hgcm    = 0;
    245239        cr_net.num_clients = 0;
    246 #ifdef CHROMIUM_THREADSAFE
    247240        crInitMutex(&cr_net.mutex);
    248 #endif
    249241
    250242        cr_net.initialized = 1;
    … …  
    305297    if (!cr_net.initialized) return;
    306298
    307 #ifdef CHROMIUM_THREADSAFE
    308299    crLockMutex(&cr_net.mutex);
    309 #endif
    310300
    311301    /* Note, other protocols used by chromium should free up stuff too,
    … …  
    329319    cr_net.initialized = 0;
    330320
    331 #ifdef CHROMIUM_THREADSAFE
    332321    crUnlockMutex(&cr_net.mutex);
    333322    crFreeMutex(&cr_net.mutex);
    334 #endif
    335323}
    336324
    … …  
    380368    list->head = list->tail = NULL;
    381369    list->numMessages = 0;
    382 #ifdef CHROMIUM_THREADSAFE
    383370    crInitMutex(&list->lock);
    384371    crInitCondition(&list->nonEmpty);
    385 #endif
    386372}
    387373
    … …  
    400386    CRMessageListNode *node;
    401387
    402 #ifdef CHROMIUM_THREADSAFE
    403388    crLockMutex(&list->lock);
    404 #endif
    405389
    406390    node = (CRMessageListNode *) crAlloc(sizeof(CRMessageListNode));
    … …  
    419403    list->numMessages++;
    420404
    421 #ifdef CHROMIUM_THREADSAFE
    422405    crSignalCondition(&list->nonEmpty);
    423406    crUnlockMutex(&list->lock);
    424 #endif
    425407}
    426408
    … …  
    437419    int retval;
    438420
    439 #ifdef CHROMIUM_THREADSAFE
    440421    crLockMutex(&list->lock);
    441 #endif
    442422
    443423    if (list->head) {
    … …  
    467447    }
    468448
    469 #ifdef CHROMIUM_THREADSAFE
    470449    crUnlockMutex(&list->lock);
    471 #endif
    472 
    473450    return retval;
    474451}
    … …  
    488465    CRMessageListNode *node;
    489466
    490 #ifdef CHROMIUM_THREADSAFE
    491467    crLockMutex(&list->lock);
    492 #endif
    493 
    494 #ifdef CHROMIUM_THREADSAFE
     468
    495469    while (!list->head) {
    496470        crWaitCondition(&list->nonEmpty, &list->lock);
    497471    }
    498 #else
    499     CRASSERT(list->head);
    500 #endif
    501472
    502473    node = list->head;
    … …  
    518489
    519490    crFree(node);
    520 
    521 #ifdef CHROMIUM_THREADSAFE
    522491    crUnlockMutex(&list->lock);
    523 #endif
    524492}
    525493
    … …  
    653621{
    654622    conn->Disconnect( conn );
    655 #ifdef CHROMIUM_THREADSAFE
    656623    crFreeMutex( &conn->messageList.lock );
    657 #endif
    658624    crFree( conn );
    659625}

  • trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

    r78263 r78341  
    169169    CRConnection         **conns;
    170170    CRBufferPool         *bufpool;
    171 #ifdef CHROMIUM_THREADSAFE
    172171    CRmutex              mutex;
    173172    CRmutex              recvmutex;
    174 #endif
    175173    CRNetReceiveFuncList *recv_list;
    176174    CRNetCloseFuncList   *close_list;
    … …  
    637635    CRVBOXHGCMBUFFER *buf;
    638636
    639 #ifdef CHROMIUM_THREADSAFE
    640637    crLockMutex(&g_crvboxhgcm.mutex);
    641 #endif
    642 
    643638    buf = (CRVBOXHGCMBUFFER *) crBufferPoolPop(g_crvboxhgcm.bufpool, conn->buffer_size);
    644639
    … …  
    661656    }
    662657
    663 #ifdef CHROMIUM_THREADSAFE
    664658    crUnlockMutex(&g_crvboxhgcm.mutex);
    665 #endif
    666 
    667659    return (void *)( buf + 1 );
    668660
    … …  
    673665    void *pvBuff;
    674666    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    675 #ifdef CHROMIUM_THREADSAFE
    676667    crLockMutex(&g_crvboxhgcm.mutex);
    677 #endif
    678668    pvBuff = _crVBoxHGCMAlloc(conn);
    679 #ifdef CHROMIUM_THREADSAFE
    680669    crUnlockMutex(&g_crvboxhgcm.mutex);
    681 #endif
    682670    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    683671    return pvBuff;
    … …  
    730718{
    731719    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    732 #ifdef CHROMIUM_THREADSAFE
     720
    733721    crLockMutex(&g_crvboxhgcm.mutex);
    734 #endif
    735722    _crVBoxHGCMWriteExact(conn, buf, len);
    736 #ifdef CHROMIUM_THREADSAFE
    737723    crUnlockMutex(&g_crvboxhgcm.mutex);
    738 #endif
    739724    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    740725}
    … …  
    908893    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    909894
    910 #ifdef CHROMIUM_THREADSAFE
    911895    crLockMutex(&g_crvboxhgcm.mutex);
    912 #endif
    913 
    914896    if (!bufp) /* We're sending a user-allocated buffer. */
    915897    {
    … …  
    923905            crVBoxHGCMWriteReadExact(conn, start, len, CR_VBOXHGCM_USERALLOCATED);
    924906#endif
    925 #ifdef CHROMIUM_THREADSAFE
    926907            crUnlockMutex(&g_crvboxhgcm.mutex);
    927 #endif
    928908            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    929909        return;
    … …  
    951931
    952932    /* Reclaim this pointer for reuse */
    953 #ifdef CHROMIUM_THREADSAFE
    954933    crLockMutex(&g_crvboxhgcm.mutex);
    955 #endif
    956934    crBufferPoolPush(g_crvboxhgcm.bufpool, hgcm_buffer, hgcm_buffer->allocated);
    957 #ifdef CHROMIUM_THREADSAFE
    958935    crUnlockMutex(&g_crvboxhgcm.mutex);
    959 #endif
    960936
    961937    /* Since the buffer's now in the 'free' buffer pool, the caller can't
    … …  
    965941    *bufp = NULL;
    966942
    967 #ifdef CHROMIUM_THREADSAFE
    968943    crUnlockMutex(&g_crvboxhgcm.mutex);
    969 #endif
    970 
    971944    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    972945}
    … …  
    1006979{
    1007980    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1008 #ifdef CHROMIUM_THREADSAFE
    1009981    crLockMutex(&g_crvboxhgcm.mutex);
    1010 #endif
    1011982    crVBoxHGCMReadExact(conn, buf, len);
    1012 #ifdef CHROMIUM_THREADSAFE
    1013983    crUnlockMutex(&g_crvboxhgcm.mutex);
    1014 #endif
    1015984    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    1016985}
    … …  
    1028997    {
    1029998        case CR_VBOXHGCM_MEMORY:
    1030 #ifdef CHROMIUM_THREADSAFE
    1031999            crLockMutex(&g_crvboxhgcm.mutex);
    1032 #endif
    10331000            if (g_crvboxhgcm.bufpool) {
    10341001                /** @todo o'rly? */
    … …  
    10381005                crBufferPoolPush(g_crvboxhgcm.bufpool, hgcm_buffer, hgcm_buffer->allocated);
    10391006            }
    1040 #ifdef CHROMIUM_THREADSAFE
    10411007            crUnlockMutex(&g_crvboxhgcm.mutex);
    1042 #endif
    10431008            break;
    10441009
    … …  
    10551020{
    10561021    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1057 #ifdef CHROMIUM_THREADSAFE
    10581022    crLockMutex(&g_crvboxhgcm.mutex);
    1059 #endif
    10601023    _crVBoxHGCMFree(conn, buf);
    1061 #ifdef CHROMIUM_THREADSAFE
    10621024    crUnlockMutex(&g_crvboxhgcm.mutex);
    1063 #endif
    10641025    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    10651026}
    … …  
    11701131{
    11711132    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1172 #ifdef CHROMIUM_THREADSAFE
    11731133    crLockMutex(&g_crvboxhgcm.mutex);
    1174 #endif
    11751134    _crVBoxHGCMReceiveMessage(conn);
    1176 #ifdef CHROMIUM_THREADSAFE
    11771135    crUnlockMutex(&g_crvboxhgcm.mutex);
    1178 #endif
    11791136    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    11801137}
    … …  
    14021359    if (!g_crvboxhgcm.initialized) return;
    14031360
    1404 #ifdef CHROMIUM_THREADSAFE
    14051361    crLockMutex(&g_crvboxhgcm.mutex);
    1406 #endif
    1407 
    14081362    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    14091363
    … …  
    14251379    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    14261380
    1427 #ifdef CHROMIUM_THREADSAFE
    14281381    crUnlockMutex(&g_crvboxhgcm.mutex);
    1429 #endif
    14301382}
    14311383
    … …  
    14331385{
    14341386    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1435 #ifdef CHROMIUM_THREADSAFE
    14361387    crLockMutex(&g_crvboxhgcm.mutex);
    1437 #endif
    14381388    _crVBoxHGCMFree(conn, mess);
    14391389    CRASSERT(FALSE);
    1440 #ifdef CHROMIUM_THREADSAFE
    14411390    crUnlockMutex(&g_crvboxhgcm.mutex);
    1442 #endif
    14431391    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    14441392}
    … …  
    15431491
    15441492    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1545 
    1546 #ifdef CHROMIUM_THREADSAFE
    15471493    crLockMutex(&g_crvboxhgcm.mutex);
    1548 #endif
    1549 
    15501494    pClient = _crVBoxHGSMIClientGet(conn);
    15511495    if (pClient)
    … …  
    15591503    }
    15601504
    1561 #ifdef CHROMIUM_THREADSAFE
    15621505    crUnlockMutex(&g_crvboxhgcm.mutex);
    1563 #endif
    1564 
    15651506    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    15661507
    … …  
    15711512{
    15721513    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    1573 #ifdef CHROMIUM_THREADSAFE
    15741514    crLockMutex(&g_crvboxhgcm.mutex);
    1575 #endif
    15761515    _crVBoxHGSMIFree(conn, buf);
    1577 #ifdef CHROMIUM_THREADSAFE
    15781516    crUnlockMutex(&g_crvboxhgcm.mutex);
    1579 #endif
    15801517    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    15811518}
    … …  
    19211858    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    19221859
    1923 #ifdef CHROMIUM_THREADSAFE
    19241860    crLockMutex(&g_crvboxhgcm.mutex);
    1925 #endif
    1926 
    19271861    if (!bufp) /* We're sending a user-allocated buffer. */
    19281862    {
    … …  
    19391873            _crVBoxHGSMIWriteReadExact(conn, pClient, (void*)start, 0, len, false);
    19401874#endif
    1941 #ifdef CHROMIUM_THREADSAFE
    19421875            crUnlockMutex(&g_crvboxhgcm.mutex);
    1943 #endif
    19441876            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    19451877            return;
    … …  
    19481880        /* fallback */
    19491881        crVBoxHGCMSend(conn, bufp, start, len);
    1950 #ifdef CHROMIUM_THREADSAFE
    19511882        crUnlockMutex(&g_crvboxhgcm.mutex);
    1952 #endif
    19531883        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    19541884        return;
    … …  
    19671897        /* fallback */
    19681898        crVBoxHGCMSend(conn, bufp, start, len);
    1969 #ifdef CHROMIUM_THREADSAFE
    19701899        crUnlockMutex(&g_crvboxhgcm.mutex);
    1971 #endif
    19721900        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    19731901        return;
    … …  
    19841912    {
    19851913        crVBoxHGCMSend(conn, bufp, start, len);
    1986 #ifdef CHROMIUM_THREADSAFE
    19871914        crUnlockMutex(&g_crvboxhgcm.mutex);
    1988 #endif
    19891915        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    19901916        return;
    … …  
    20191945    *bufp = NULL;
    20201946
    2021 #ifdef CHROMIUM_THREADSAFE
    20221947    crUnlockMutex(&g_crvboxhgcm.mutex);
    2023 #endif
    2024 
    20251948    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    20261949}
    … …  
    20481971    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    20491972
    2050 #ifdef CHROMIUM_THREADSAFE
    20511973    crLockMutex(&g_crvboxhgcm.mutex);
    2052 #endif
    2053 
    20541974    CRASSERT(0);
    20551975
    20561976    _crVBoxHGCMReceiveMessage(conn);
    20571977
    2058 #ifdef CHROMIUM_THREADSAFE
    20591978    crUnlockMutex(&g_crvboxhgcm.mutex);
    2060 #endif
    2061 
    20621979    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    20631980}
    … …  
    20832000    int rc = VINF_SUCCESS;
    20842001
    2085 #ifdef CHROMIUM_THREADSAFE
    20862002    crLockMutex(&g_crvboxhgcm.mutex);
    2087 #endif
    2088 
    20892003    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    20902004
    … …  
    21192033    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    21202034
    2121 #ifdef CHROMIUM_THREADSAFE
    21222035    crUnlockMutex(&g_crvboxhgcm.mutex);
    2123 #endif
    21242036    return RT_SUCCESS(rc);
    21252037}
    … …  
    21332045    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    21342046
    2135 #ifdef CHROMIUM_THREADSAFE
    21362047    crLockMutex(&g_crvboxhgcm.mutex);
    2137 #endif
    2138 
    21392048    fHasActiveCons = _crVBoxCommonDoDisconnectLocked(conn);
    21402049
    … …  
    21532062
    21542063    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    2155 
    2156 #ifdef CHROMIUM_THREADSAFE
    21572064    crUnlockMutex(&g_crvboxhgcm.mutex);
    2158 #endif
    21592065}
    21602066
    … …  
    21622068{
    21632069    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    2164 #ifdef CHROMIUM_THREADSAFE
    21652070    crLockMutex(&g_crvboxhgcm.mutex);
    2166 #endif
    21672071    CRASSERT(0);
    21682072
    21692073    _crVBoxHGSMIFree(conn, mess);
    21702074
    2171 #ifdef CHROMIUM_THREADSAFE
    21722075    crUnlockMutex(&g_crvboxhgcm.mutex);
    2173 #endif
    21742076    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    21752077}
    … …  
    22122114#endif
    22132115
    2214 #ifdef CHROMIUM_THREADSAFE
    22152116    crInitMutex(&g_crvboxhgcm.mutex);
    22162117    crInitMutex(&g_crvboxhgcm.recvmutex);
    2217 #endif
    22182118    g_crvboxhgcm.bufpool = crBufferPoolInit(16);
    22192119
    … …  
    22532153    if (!g_crvboxhgcm.initialized) return;
    22542154
    2255 #ifdef CHROMIUM_THREADSAFE
    22562155    crLockMutex(&g_crvboxhgcm.mutex);
    2257 #endif
    22582156
    22592157    /* Connection count would be changed in calls to crNetDisconnect, so we have to store original value.
    … …  
    22752173    g_crvboxhgcm.bufpool = NULL;
    22762174
    2277 #ifdef CHROMIUM_THREADSAFE
    22782175    crUnlockMutex(&g_crvboxhgcm.mutex);
    22792176    crFreeMutex(&g_crvboxhgcm.mutex);
    22802177    crFreeMutex(&g_crvboxhgcm.recvmutex);
    2281 #endif
    22822178
    22832179    crFree(g_crvboxhgcm.conns);
    … …  
    23642260#endif
    23652261
    2366 #ifdef CHROMIUM_THREADSAFE
    23672262    crLockMutex(&g_crvboxhgcm.mutex);
    2368 #endif
     2263
    23692264    /* Find a free slot */
    23702265    for (i = 0; i < g_crvboxhgcm.num_conns; i++) {
    … …  
    23842279        g_crvboxhgcm.conns[g_crvboxhgcm.num_conns++] = conn;
    23852280    }
    2386 #ifdef CHROMIUM_THREADSAFE
    23872281    crUnlockMutex(&g_crvboxhgcm.mutex);
    2388 #endif
    23892282}
    23902283
    … …  
    24432336    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    24442337
    2445 #ifdef CHROMIUM_THREADSAFE
    24462338    crLockMutex(&g_crvboxhgcm.mutex);
    2447 #endif
    24482339
    24492340#ifdef IN_GUEST
    … …  
    24792370    }
    24802371
    2481 #ifdef CHROMIUM_THREADSAFE
    24822372    crUnlockMutex(&g_crvboxhgcm.mutex);
    2483 #endif
    2484 
    24852373    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    24862374
Note: See TracChangeset for help on using the changeset viewer.

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