posix/JackPosixMutex.cpp

   1 /*
   2  Copyright (C) 2006 Grame
   3
   4  This library is free software; you can redistribute it and/or
   5  modify it under the terms of the GNU Lesser General Public
   6  License as published by the Free Software Foundation; either
   7  version 2.1 of the License, or (at your option) any later version.
   8
   9  This library is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  Lesser General Public License for more details.
  13
  14  You should have received a copy of the GNU Lesser General Public
  15  License along with this library; if not, write to the Free Software
  16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17
  18  Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
  19  grame@grame.fr
  20 */
  21
  22 #include "JackPosixMutex.h"
  23 #include "JackError.h"
  24
  25 namespace Jack
  26 {
  27
  28     bool JackBasePosixMutex::Lock()
  29     {
  30         pthread_t current_thread = pthread_self();
  31
  32         if (!pthread_equal(current_thread, fOwner)) {
  33             int res = pthread_mutex_lock(&fMutex);
  34             if (res == 0) {
  35                 fOwner = current_thread;
  36                 return true;
  37             } else {
  38                 jack_error("JackBasePosixMutex::Lock res = %d", res);
  39                 return false;
  40             }
  41         } else {
  42             jack_error("JackBasePosixMutex::Lock mutex already locked by thread = %d", current_thread);
  43             return false;
  44         }
  45     }
  46
  47     bool JackBasePosixMutex::Trylock()
  48     {
  49         pthread_t current_thread = pthread_self();
  50
  51         if (!pthread_equal(current_thread, fOwner)) {
  52             int res = pthread_mutex_trylock(&fMutex);
  53             if (res == 0) {
  54                 fOwner = current_thread;
  55                 return true;
  56             } else {
  57                 return false;
  58             }
  59         } else {
  60             jack_error("JackBasePosixMutex::Trylock mutex already locked by thread = %d", current_thread);
  61             return false;
  62         }
  63     }
  64
  65     bool JackBasePosixMutex::Unlock()
  66     {
  67         if (pthread_equal(pthread_self(), fOwner)) {
  68             fOwner = 0;
  69             int res = pthread_mutex_unlock(&fMutex);
  70             if (res == 0) {
  71                 return true;
  72             } else {
  73                 jack_error("JackBasePosixMutex::Unlock res = %d", res);
  74                 return false;
  75             }
  76         } else {
  77             jack_error("JackBasePosixMutex::Unlock mutex not locked by thread = %d owner %d", pthread_self(), fOwner);
  78             return false;
  79         }
  80     }
  81
  82     bool JackPosixMutex::Lock()
  83     {
  84         int res = pthread_mutex_lock(&fMutex);
  85         if (res != 0) {
  86             jack_log("JackPosixMutex::Lock res = %d", res);
  87         }
  88         return (res == 0);
  89     }
  90
  91     bool JackPosixMutex::Trylock()
  92     {
  93         return (pthread_mutex_trylock(&fMutex) == 0);
  94     }
  95
  96     bool JackPosixMutex::Unlock()
  97     {
  98         int res = pthread_mutex_unlock(&fMutex);
  99         if (res != 0) {
 100             jack_log("JackPosixMutex::Unlock res = %d", res);
 101         }
 102         return (res == 0);
 103     }
 104
 105
 106 } // namespace