1                 : /*
       2                 :  * Copyright (c) 2011 The Native Client Authors. All rights reserved.
       3                 :  * Use of this source code is governed by a BSD-style license that can be
       4                 :  * found in the LICENSE file.
       5                 :  */
       6                 : 
       7                 : /*
       8                 :  * NaCl Server Runtime mutex and condition variable abstraction layer.
       9                 :  * The NaClX* interfaces just invoke the no-X versions of the
      10                 :  * synchronization routines, and aborts if there are any error
      11                 :  * returns.
      12                 :  */
      13                 : 
      14                 : #include "native_client/src/shared/platform/nacl_log.h"
      15                 : #include "native_client/src/shared/platform/nacl_sync_checked.h"
      16                 : 
      17           20684 : void NaClXMutexCtor(struct NaClMutex *mp) {
      18           20684 :   if (!NaClMutexCtor(mp)) {
      19               0 :     NaClLog(LOG_FATAL, "NaClXMutexCtor failed\n");
      20                 :   }
      21           20684 : }
      22                 : 
      23        13693530 : void NaClXMutexLock(struct NaClMutex *mp) {
      24                 :   NaClSyncStatus  status;
      25                 : 
      26        13693530 :   if (NACL_SYNC_OK == (status = NaClMutexLock(mp))) {
      27        27404522 :     return;
      28                 :   }
      29               0 :   NaClLog(LOG_FATAL, "NaClMutexLock returned %d\n", status);
      30                 : }
      31                 : 
      32               0 : NaClSyncStatus NaClXMutexTryLock(struct NaClMutex *mp) {
      33                 :   NaClSyncStatus  status;
      34                 : 
      35               0 :   if (NACL_SYNC_OK == (status = NaClMutexUnlock(mp)) ||
      36                 :       NACL_SYNC_BUSY == status) {
      37               0 :     return status;
      38                 :   }
      39               0 :   NaClLog(LOG_FATAL, "NaClMutexUnlock returned %d\n", status);
      40                 :   /* NOTREACHED */
      41               0 :   return NACL_SYNC_INTERNAL_ERROR;
      42                 : }
      43                 : 
      44        13698599 : void NaClXMutexUnlock(struct NaClMutex *mp) {
      45                 :   NaClSyncStatus  status;
      46                 : 
      47        13698599 :   if (NACL_SYNC_OK == (status = NaClMutexUnlock(mp))) {
      48        27400032 :     return;
      49                 :   }
      50               0 :   NaClLog(LOG_FATAL, "NaClMutexUnlock returned %d\n", status);
      51                 : }
      52                 : 
      53           18947 : void NaClXCondVarCtor(struct NaClCondVar *cvp) {
      54           18947 :   if (!NaClCondVarCtor(cvp)) {
      55               0 :     NaClLog(LOG_FATAL, "NaClCondVarCtor failed\n");
      56                 :   }
      57           18947 : }
      58                 : 
      59           82863 : void NaClXCondVarSignal(struct NaClCondVar *cvp) {
      60                 :   NaClSyncStatus  status;
      61                 : 
      62           82863 :   if (NACL_SYNC_OK == (status = NaClCondVarSignal(cvp))) {
      63          165726 :     return;
      64                 :   }
      65               0 :   NaClLog(LOG_FATAL, "NaClCondVarSignal returned %d\n", status);
      66                 : }
      67                 : 
      68            1162 : void NaClXCondVarBroadcast(struct NaClCondVar *cvp) {
      69                 :   NaClSyncStatus  status;
      70                 : 
      71            1162 :   if (NACL_SYNC_OK == (status = NaClCondVarBroadcast(cvp))) {
      72            2324 :     return;
      73                 :   }
      74               0 :   NaClLog(LOG_FATAL, "NaClCondVarBroadcast returned %d\n", status);
      75                 : }
      76                 : 
      77             589 : void NaClXCondVarWait(struct NaClCondVar *cvp,
      78                 :                       struct NaClMutex   *mp) {
      79                 :   NaClSyncStatus  status;
      80                 : 
      81             589 :   if (NACL_SYNC_OK == (status = NaClCondVarWait(cvp, mp))) {
      82            1110 :     return;
      83                 :   }
      84               0 :   NaClLog(LOG_FATAL, "NaClCondVarWait returned %d\n", status);
      85                 : }
      86                 : 
      87               0 : NaClSyncStatus NaClXCondVarTimedWaitAbsolute(
      88                 :     struct NaClCondVar              *cvp,
      89                 :     struct NaClMutex                *mp,
      90                 :     NACL_TIMESPEC_T const           *abstime) {
      91               0 :   NaClSyncStatus  status = NaClCondVarTimedWaitAbsolute(cvp, mp, abstime);
      92                 : 
      93               0 :   if (NACL_SYNC_OK == status || NACL_SYNC_CONDVAR_TIMEDOUT == status) {
      94               0 :     return status;
      95                 :   }
      96               0 :   NaClLog(LOG_FATAL, "NaClCondVarTimedWaitAbsolute returned %d\n", status);
      97                 :   /* NOTREACHED */
      98               0 :   return NACL_SYNC_INTERNAL_ERROR;
      99                 : }
     100                 : 
     101               0 : NaClSyncStatus NaClXCondVarTimedWaitRelative(
     102                 :     struct NaClCondVar              *cvp,
     103                 :     struct NaClMutex                *mp,
     104                 :     NACL_TIMESPEC_T const           *reltime) {
     105               0 :   NaClSyncStatus  status = NaClCondVarTimedWaitRelative(cvp, mp, reltime);
     106                 : 
     107               0 :   if (NACL_SYNC_OK == status || NACL_SYNC_CONDVAR_TIMEDOUT == status) {
     108               0 :       return status;
     109                 :   }
     110               0 :   NaClLog(LOG_FATAL, "NaClCondVarTimedWaitRelative returned %d\n", status);
     111                 :   /* NOTREACHED */
     112               0 :   return NACL_SYNC_INTERNAL_ERROR;
     113                 : }