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            2525 : void NaClXMutexCtor(struct NaClMutex *mp) {
      18            2525 :   if (!NaClMutexCtor(mp)) {
      19               0 :     NaClLog(LOG_FATAL, "NaClXMutexCtor failed\n");
      20               0 :   }
      21            2525 : }
      22                 : 
      23        12710191 : void NaClXMutexLock(struct NaClMutex *mp) {
      24        12710191 :   NaClSyncStatus  status;
      25                 : 
      26        12710191 :   if (NACL_SYNC_OK == (status = NaClMutexLock(mp))) {
      27        12710175 :     return;
      28                 :   }
      29               0 :   NaClLog(LOG_FATAL, "NaClMutexLock returned %d\n", status);
      30        12710174 : }
      31                 : 
      32               0 : NaClSyncStatus NaClXMutexTryLock(struct NaClMutex *mp) {
      33               0 :   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               0 : }
      43                 : 
      44        12710369 : void NaClXMutexUnlock(struct NaClMutex *mp) {
      45        12710369 :   NaClSyncStatus  status;
      46                 : 
      47        12710369 :   if (NACL_SYNC_OK == (status = NaClMutexUnlock(mp))) {
      48        12710369 :     return;
      49                 :   }
      50               0 :   NaClLog(LOG_FATAL, "NaClMutexUnlock returned %d\n", status);
      51        12710369 : }
      52                 : 
      53             231 : void NaClXCondVarCtor(struct NaClCondVar *cvp) {
      54             231 :   if (!NaClCondVarCtor(cvp)) {
      55               0 :     NaClLog(LOG_FATAL, "NaClCondVarCtor failed\n");
      56               0 :   }
      57             231 : }
      58                 : 
      59           43104 : void NaClXCondVarSignal(struct NaClCondVar *cvp) {
      60           43104 :   NaClSyncStatus  status;
      61                 : 
      62           43104 :   if (NACL_SYNC_OK == (status = NaClCondVarSignal(cvp))) {
      63           43104 :     return;
      64                 :   }
      65               0 :   NaClLog(LOG_FATAL, "NaClCondVarSignal returned %d\n", status);
      66           43104 : }
      67                 : 
      68            1086 : void NaClXCondVarBroadcast(struct NaClCondVar *cvp) {
      69            1086 :   NaClSyncStatus  status;
      70                 : 
      71            1086 :   if (NACL_SYNC_OK == (status = NaClCondVarBroadcast(cvp))) {
      72            1086 :     return;
      73                 :   }
      74               0 :   NaClLog(LOG_FATAL, "NaClCondVarBroadcast returned %d\n", status);
      75            1086 : }
      76                 : 
      77             540 : void NaClXCondVarWait(struct NaClCondVar *cvp,
      78             540 :                       struct NaClMutex   *mp) {
      79             540 :   NaClSyncStatus  status;
      80                 : 
      81             540 :   if (NACL_SYNC_OK == (status = NaClCondVarWait(cvp, mp))) {
      82             540 :     return;
      83                 :   }
      84               0 :   NaClLog(LOG_FATAL, "NaClCondVarWait returned %d\n", status);
      85             540 : }
      86                 : 
      87                 : NaClSyncStatus NaClXCondVarTimedWaitAbsolute(
      88               0 :     struct NaClCondVar              *cvp,
      89               0 :     struct NaClMutex                *mp,
      90               0 :     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               0 : }
     100                 : 
     101                 : NaClSyncStatus NaClXCondVarTimedWaitRelative(
     102               0 :     struct NaClCondVar              *cvp,
     103               0 :     struct NaClMutex                *mp,
     104               0 :     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               0 : }