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