macosx/JackMachSemaphore.mm

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU Lesser General Public License as published by
   6 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #include "JackMachSemaphore.h"
  21 #include "JackConstants.h"
  22 #include "JackTools.h"
  23 #include "JackError.h"
  24 #include <stdio.h>
  25
  26 namespace Jack
  27 {
  28
  29 void JackMachSemaphore::BuildName(const char* client_name, const char* server_name, char* res, int size)
  30 {
  31     char ext_client_name[SYNC_MAX_NAME_SIZE + 1];
  32     JackTools::RewriteName(client_name, ext_client_name);
  33     snprintf(res, size, "jacksem.%d_%s_%s", JackTools::GetUID(), server_name, ext_client_name);
  34 }
  35
  36 bool JackMachSemaphore::Signal()
  37 {
  38     if (!fSemaphore) {
  39         jack_error("JackMachSemaphore::Signal name = %s already deallocated!!", fName);
  40         return false;
  41     }
  42
  43     if (fFlush) {
  44         return true;
  45     }
  46
  47     kern_return_t res;
  48     if ((res = semaphore_signal(fSemaphore)) != KERN_SUCCESS) {
  49         jack_error("JackMachSemaphore::Signal name = %s err = %s", fName, mach_error_string(res));
  50     }
  51     return (res == KERN_SUCCESS);
  52 }
  53
  54 bool JackMachSemaphore::SignalAll()
  55 {
  56     if (!fSemaphore) {
  57         jack_error("JackMachSemaphore::SignalAll name = %s already deallocated!!", fName);
  58         return false;
  59     }
  60
  61     if (fFlush) {
  62         return true;
  63     }
  64
  65     kern_return_t res;
  66     // When signaled several times, do not accumulate signals...
  67     if ((res = semaphore_signal_all(fSemaphore)) != KERN_SUCCESS) {
  68         jack_error("JackMachSemaphore::SignalAll name = %s err = %s", fName, mach_error_string(res));
  69     }
  70     return (res == KERN_SUCCESS);
  71 }
  72
  73 bool JackMachSemaphore::Wait()
  74 {
  75     if (!fSemaphore) {
  76         jack_error("JackMachSemaphore::Wait name = %s already deallocated!!", fName);
  77         return false;
  78     }
  79
  80     kern_return_t res;
  81     if ((res = semaphore_wait(fSemaphore)) != KERN_SUCCESS) {
  82         jack_error("JackMachSemaphore::Wait name = %s err = %s", fName, mach_error_string(res));
  83     }
  84     return (res == KERN_SUCCESS);
  85 }
  86
  87 bool JackMachSemaphore::TimedWait(long usec)
  88 {
  89     if (!fSemaphore) {
  90         jack_error("JackMachSemaphore::TimedWait name = %s already deallocated!!", fName);
  91         return false;
  92     }
  93
  94     kern_return_t res;
  95     mach_timespec time;
  96     time.tv_sec = usec / 1000000;
  97     time.tv_nsec = (usec % 1000000) * 1000;
  98
  99     if ((res = semaphore_timedwait(fSemaphore, time)) != KERN_SUCCESS) {
 100         jack_error("JackMachSemaphore::TimedWait name = %s usec = %ld err = %s", fName, usec, mach_error_string(res));
 101     }
 102     return (res == KERN_SUCCESS);
 103 }
 104
 105 // Server side : publish the semaphore in the global namespace
 106 bool JackMachSemaphore::Allocate(const char* name, const char* server_name, int value)
 107 {
 108     BuildName(name, server_name, fName, sizeof(fName));
 109     mach_port_t task = mach_task_self();
 110     kern_return_t res;
 111
 112     if (fBootPort == 0) {
 113         if ((res = task_get_bootstrap_port(task, &fBootPort)) != KERN_SUCCESS) {
 114             jack_error("Allocate: Can't find bootstrap mach port err = %s", mach_error_string(res));
 115             return false;
 116         }
 117     }
 118
 119     if ((res = semaphore_create(task, &fSemaphore, SYNC_POLICY_FIFO, value)) != KERN_SUCCESS) {
 120         jack_error("Allocate: can create semaphore err = %i:%s", res, mach_error_string(res));
 121         return false;
 122     }
 123
 124     if ((res = bootstrap_register(fBootPort, fName, fSemaphore)) != KERN_SUCCESS) {
 125         switch (res) {
 126             case BOOTSTRAP_SUCCESS :
 127                 jack_log("bootstrap_register(): bootstrap success");
 128                 /* service not currently registered, "a good thing" (tm) */
 129                 break;
 130
 131             case BOOTSTRAP_NOT_PRIVILEGED :
 132                 jack_log("bootstrap_register(): bootstrap not privileged");
 133                 /* might belong to a previously running jack process that crashed, let's try to connect */
 134                 {
 135                     semaphore_t sem;
 136                     if (semaphore_create(task, &sem, SYNC_POLICY_FIFO, value) == KERN_SUCCESS)
 137                     {
 138                         const bool ok = (bootstrap_look_up(fBootPort, fName, &sem) == KERN_SUCCESS);
 139                         semaphore_destroy(mach_task_self(), sem);
 140
 141                         if (ok)
 142                         {
 143                             jack_error("bootstrap_register(): forced connection");
 144                             return true;
 145                         }
 146                     }
 147                 }
 148                 break;
 149
 150             case BOOTSTRAP_SERVICE_ACTIVE :
 151                 jack_log("bootstrap_register(): bootstrap service active");
 152                 break;
 153
 154             default :
 155                 jack_log("bootstrap_register() err = %i:%s", res, mach_error_string(res));
 156                 break;
 157         }
 158
 159         jack_error("Allocate: can't check in mach semaphore name = %s err = %i:%s", fName, res, mach_error_string(res));
 160         return false;
 161     }
 162
 163     jack_log("JackMachSemaphore::Allocate name = %s", fName);
 164     return true;
 165 }
 166
 167 // Client side : get the published semaphore from server
 168 bool JackMachSemaphore::ConnectInput(const char* name, const char* server_name)
 169 {
 170     BuildName(name, server_name, fName, sizeof(fName));
 171     kern_return_t res;
 172
 173     if (fBootPort == 0) {
 174         if ((res = task_get_bootstrap_port(mach_task_self(), &fBootPort)) != KERN_SUCCESS) {
 175             jack_error("Connect: can't find bootstrap port err = %s", mach_error_string(res));
 176             return false;
 177         }
 178     }
 179
 180     if ((res = bootstrap_look_up(fBootPort, fName, &fSemaphore)) != KERN_SUCCESS) {
 181         jack_error("Connect: can't find mach semaphore name = %s err = %s", fName, mach_error_string(res));
 182         return false;
 183     }
 184
 185     jack_log("JackMachSemaphore::Connect name = %s ", fName);
 186     return true;
 187 }
 188
 189 bool JackMachSemaphore::Connect(const char* name, const char* server_name)
 190 {
 191     return ConnectInput(name, server_name);
 192 }
 193
 194 bool JackMachSemaphore::ConnectOutput(const char* name, const char* server_name)
 195 {
 196     return ConnectInput(name, server_name);
 197 }
 198
 199 bool JackMachSemaphore::Disconnect()
 200 {
 201     if (fSemaphore > 0) {
 202         jack_log("JackMachSemaphore::Disconnect name = %s", fName);
 203         fSemaphore = 0;
 204     }
 205     // Nothing to do
 206     return true;
 207 }
 208
 209 // Server side : destroy the JackGlobals
 210 void JackMachSemaphore::Destroy()
 211 {
 212     kern_return_t res;
 213
 214     if (fSemaphore > 0) {
 215         jack_log("JackMachSemaphore::Destroy name = %s", fName);
 216         if ((res = semaphore_destroy(mach_task_self(), fSemaphore)) != KERN_SUCCESS) {
 217             jack_error("JackMachSemaphore::Destroy can't destroy semaphore err = %s", mach_error_string(res));
 218         }
 219         fSemaphore = 0;
 220     } else {
 221         jack_error("JackMachSemaphore::Destroy semaphore < 0");
 222     }
 223 }
 224
 225 } // end of namespace
 226