00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackPosixSemaphore.h"
00021 #include "JackTools.h"
00022 #include "JackConstants.h"
00023 #include "JackError.h"
00024 #include <fcntl.h>
00025 #include <stdio.h>
00026 #include <sys/time.h>
00027
00028 namespace Jack
00029 {
00030
00031 void JackPosixSemaphore::BuildName(const char* client_name, const char* server_name, char* res)
00032 {
00033 char ext_client_name[JACK_CLIENT_NAME_SIZE + 1];
00034 JackTools::RewriteName(client_name, ext_client_name);
00035 sprintf(res, "jack_sem.%d_%s_%s", JackTools::GetUID(), server_name, ext_client_name);
00036 }
00037
00038 bool JackPosixSemaphore::Signal()
00039 {
00040 int res;
00041
00042 if (!fSemaphore) {
00043 jack_error("JackPosixSemaphore::Signal name = %s already desallocated!!", fName);
00044 return false;
00045 }
00046
00047 if (fFlush)
00048 return true;
00049
00050 if ((res = sem_post(fSemaphore)) != 0) {
00051 jack_error("JackPosixSemaphore::Signal name = %s err = %s", fName, strerror(errno));
00052 }
00053 return (res == 0);
00054 }
00055
00056 bool JackPosixSemaphore::SignalAll()
00057 {
00058 int res;
00059
00060 if (!fSemaphore) {
00061 jack_error("JackPosixSemaphore::SignalAll name = %s already desallocated!!", fName);
00062 return false;
00063 }
00064
00065 if (fFlush)
00066 return true;
00067
00068 if ((res = sem_post(fSemaphore)) != 0) {
00069 jack_error("JackPosixSemaphore::SignalAll name = %s err = %s", fName, strerror(errno));
00070 }
00071 return (res == 0);
00072 }
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091 bool JackPosixSemaphore::Wait()
00092 {
00093 int res;
00094
00095 while ((res = sem_wait(fSemaphore) < 0)) {
00096 jack_error("JackPosixSemaphore::Wait name = %s err = %s", fName, strerror(errno));
00097 if (errno != EINTR)
00098 break;
00099 }
00100 return (res == 0);
00101 }
00102
00103 #if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) // glibc feature test
00104
00105 bool JackPosixSemaphore::TimedWait(long usec)
00106 {
00107 int res;
00108 struct timeval now;
00109 timespec time;
00110
00111 if (!fSemaphore) {
00112 jack_error("JackPosixSemaphore::TimedWait name = %s already desallocated!!", fName);
00113 return false;
00114 }
00115 gettimeofday(&now, 0);
00116 time.tv_sec = now.tv_sec + usec / 1000000;
00117 long tv_usec = (now.tv_usec + (usec % 1000000));
00118 time.tv_sec += tv_usec / 1000000;
00119 time.tv_nsec = (tv_usec % 1000000) * 1000;
00120
00121 if ((res = sem_timedwait(fSemaphore, &time)) != 0) {
00122 jack_error("JackPosixSemaphore::TimedWait err = %s", strerror(errno));
00123 jack_log("now %ld %ld ", now.tv_sec, now.tv_usec);
00124 jack_log("next %ld %ld ", time.tv_sec, time.tv_nsec/1000);
00125 }
00126 return (res == 0);
00127 }
00128
00129 #else
00130 #warning "JackPosixSemaphore::TimedWait is not supported: Jack in SYNC mode with JackPosixSemaphore will not run properly !!"
00131
00132 bool JackPosixSemaphore::TimedWait(long usec)
00133 {
00134 return Wait();
00135 }
00136 #endif
00137
00138
00139 bool JackPosixSemaphore::Allocate(const char* name, const char* server_name, int value)
00140 {
00141 BuildName(name, server_name, fName);
00142 jack_log("JackPosixSemaphore::Allocate name = %s val = %ld", fName, value);
00143
00144 if ((fSemaphore = sem_open(fName, O_CREAT, 0777, value)) == (sem_t*)SEM_FAILED) {
00145 jack_error("Allocate: can't check in named semaphore name = %s err = %s", fName, strerror(errno));
00146 return false;
00147 } else {
00148 return true;
00149 }
00150 }
00151
00152
00153 bool JackPosixSemaphore::ConnectInput(const char* name, const char* server_name)
00154 {
00155 BuildName(name, server_name, fName);
00156 jack_log("JackPosixSemaphore::Connect %s", fName);
00157
00158
00159 if (fSemaphore) {
00160 jack_log("Already connected name = %s", name);
00161 return true;
00162 }
00163
00164 if ((fSemaphore = sem_open(fName, O_CREAT)) == (sem_t*)SEM_FAILED) {
00165 jack_error("Connect: can't connect named semaphore name = %s err = %s", fName, strerror(errno));
00166 return false;
00167 } else {
00168 int val = 0;
00169 sem_getvalue(fSemaphore, &val);
00170 jack_log("JackPosixSemaphore::Connect sem_getvalue %ld", val);
00171 return true;
00172 }
00173 }
00174
00175 bool JackPosixSemaphore::Connect(const char* name, const char* server_name)
00176 {
00177 return ConnectInput(name, server_name);
00178 }
00179
00180 bool JackPosixSemaphore::ConnectOutput(const char* name, const char* server_name)
00181 {
00182 return ConnectInput(name, server_name);
00183 }
00184
00185 bool JackPosixSemaphore::Disconnect()
00186 {
00187 jack_log("JackPosixSemaphore::Disconnect %s", fName);
00188
00189 if (fSemaphore) {
00190 if (sem_close(fSemaphore) != 0) {
00191 jack_error("Disconnect: can't disconnect named semaphore name = %s err = %s", fName, strerror(errno));
00192 return false;
00193 } else {
00194 fSemaphore = NULL;
00195 return true;
00196 }
00197 } else {
00198 return true;
00199 }
00200 }
00201
00202
00203 void JackPosixSemaphore::Destroy()
00204 {
00205 if (fSemaphore != NULL) {
00206 jack_log("JackPosixSemaphore::Destroy");
00207 sem_unlink(fName);
00208 if (sem_close(fSemaphore) != 0) {
00209 jack_error("Destroy: can't destroy semaphore name = %s err = %s", fName, strerror(errno));
00210 }
00211 fSemaphore = NULL;
00212 } else {
00213 jack_error("JackPosixSemaphore::Destroy semaphore == NULL");
00214 }
00215 }
00216
00217 }
00218