common/JackPosixSemaphore.cpp

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8
   9   This program 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
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackPosixSemaphore.h"
  21 #include "JackChannel.h"
  22 #include "JackError.h"
  23 #include <fcntl.h>
  24 #include <sys/time.h>
  25
  26 namespace Jack
  27 {
  28
  29 void JackPosixSemaphore::BuildName(const char* name, char* res)
  30 {
  31     sprintf(res, "%s/jack_sem.%s", jack_client_dir, name);
  32 }
  33
  34 bool JackPosixSemaphore::Signal()
  35 {
  36     int res;
  37     assert(fSemaphore);
  38
  39     if (fFlush)
  40         return true;
  41
  42     if ((res = sem_post(fSemaphore)) != 0) {
  43         jack_error("JackPosixSemaphore::Signal name = %s err = %s", fName, strerror(errno));
  44     }
  45     return (res == 0);
  46 }
  47
  48 bool JackPosixSemaphore::SignalAll()
  49 {
  50     int res;
  51     assert(fSemaphore);
  52
  53     if (fFlush)
  54         return true;
  55
  56     if ((res = sem_post(fSemaphore)) != 0) {
  57         jack_error("JackPosixSemaphore::SignalAll name = %s err = %s", fName, strerror(errno));
  58     }
  59     return (res == 0);
  60 }
  61
  62 /*
  63 bool JackPosixSemaphore::Wait()
  64 {
  65     int res;
  66         assert(fSemaphore);
  67     if ((res = sem_wait(fSemaphore)) != 0) {
  68         jack_error("JackPosixSemaphore::Wait name = %s err = %s", fName, strerror(errno));
  69     }
  70     return (res == 0);
  71 }
  72 */
  73
  74 bool JackPosixSemaphore::Wait()
  75 {
  76     int res;
  77
  78     while ((res = sem_wait(fSemaphore) < 0)) {
  79         jack_error("JackPosixSemaphore::Wait name = %s err = %s", fName, strerror(errno));
  80         if (errno != EINTR)
  81             break;
  82     }
  83     return (res == 0);
  84 }
  85
  86
  87 /*
  88 #ifdef __linux__
  89
  90 bool JackPosixSemaphore::TimedWait(long usec) // unusable semantic !!
  91 {
  92         int res;
  93         struct timeval now;
  94         timespec time;
  95         assert(fSemaphore);
  96         gettimeofday(&now, 0);
  97         time.tv_sec = now.tv_sec + usec / 1000000;
  98         time.tv_nsec = (now.tv_usec + (usec % 1000000)) * 1000;
  99
 100     if ((res = sem_timedwait(fSemaphore, &time)) != 0) {
 101         jack_error("JackPosixSemaphore::TimedWait err = %s", strerror(errno));
 102                 JackLog("now %ld %ld \n", now.tv_sec, now.tv_usec);
 103                 JackLog("next %ld %ld \n", time.tv_sec, time.tv_nsec/1000);
 104         }
 105     return (res == 0);
 106 }
 107
 108 #else
 109 #warning "JackPosixSemaphore::TimedWait is not supported: Jack in SYNC mode with JackPosixSemaphore will not run properly !!"
 110
 111 bool JackPosixSemaphore::TimedWait(long usec)
 112 {
 113         return Wait();
 114 }
 115 #endif
 116 */
 117
 118 #warning JackPosixSemaphore::TimedWait not available : synchronous mode may not work correctly if POSIX semaphore are used
 119
 120 bool JackPosixSemaphore::TimedWait(long usec)
 121 {
 122     return Wait();
 123 }
 124
 125 // Server side : publish the semaphore in the global namespace
 126 bool JackPosixSemaphore::Allocate(const char* name, int value)
 127 {
 128     BuildName(name, fName);
 129     JackLog("JackPosixSemaphore::Allocate name = %s val = %ld\n", fName, value);
 130
 131     if ((fSemaphore = sem_open(fName, O_CREAT, 0777, value)) == (sem_t*)SEM_FAILED) {
 132         jack_error("Allocate: can't check in named semaphore name = %s err = %s", fName, strerror(errno));
 133         return false;
 134     } else {
 135         return true;
 136     }
 137 }
 138
 139 // Client side : get the published semaphore from server
 140 bool JackPosixSemaphore::ConnectInput(const char* name)
 141 {
 142     BuildName(name, fName);
 143     JackLog("JackPosixSemaphore::Connect %s\n", fName);
 144
 145     // Temporary...
 146     if (fSemaphore) {
 147         JackLog("Already connected name = %s\n", name);
 148         return true;
 149     }
 150
 151     if ((fSemaphore = sem_open(fName, O_CREAT)) == (sem_t*)SEM_FAILED) {
 152         jack_error("Connect: can't connect named semaphore name = %s err = %s", fName, strerror(errno));
 153         return false;
 154     } else {
 155         int val = 0;
 156         sem_getvalue(fSemaphore, &val);
 157         JackLog("JackPosixSemaphore::Connect sem_getvalue %ld\n", val);
 158         return true;
 159     }
 160 }
 161
 162 bool JackPosixSemaphore::Connect(const char* name)
 163 {
 164     return ConnectInput(name);
 165 }
 166
 167 bool JackPosixSemaphore::ConnectOutput(const char* name)
 168 {
 169     return ConnectInput(name);
 170 }
 171
 172 bool JackPosixSemaphore::Disconnect()
 173 {
 174     JackLog("JackPosixSemaphore::Disconnect %s\n", fName);
 175
 176     if (fSemaphore) {
 177         if (sem_close(fSemaphore) != 0) {
 178             jack_error("Disconnect: can't disconnect named semaphore name = %s err = %s", fName, strerror(errno));
 179             return false;
 180         } else {
 181             fSemaphore = NULL;
 182             return true;
 183         }
 184     } else {
 185         return true;
 186     }
 187 }
 188
 189 // Server side : destroy the semaphore
 190 void JackPosixSemaphore::Destroy()
 191 {
 192     if (fSemaphore != NULL) {
 193         JackLog("JackPosixSemaphore::Destroy\n");
 194         sem_unlink(fName);
 195         if (sem_close(fSemaphore) != 0) {
 196             jack_error("Destroy: can't destroy semaphore name = %s err = %s", fName, strerror(errno));
 197         }
 198         fSemaphore = NULL;
 199     } else {
 200         jack_error("JackPosixSemaphore::Destroy semaphore == NULL");
 201     }
 202 }
 203
 204 } // end of namespace
 205