linux/JackLinuxFutex.cpp

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3 Copyright (C) 2016 Filipe Coelho
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #include "JackLinuxFutex.h"
  22 #include "JackTools.h"
  23 #include "JackConstants.h"
  24 #include "JackError.h"
  25 #include "promiscuous.h"
  26 #include <fcntl.h>
  27 #include <stdio.h>
  28 #include <sys/mman.h>
  29 #include <syscall.h>
  30 #include <linux/futex.h>
  31
  32 namespace Jack
  33 {
  34
  35 JackLinuxFutex::JackLinuxFutex() : JackSynchro(), fSharedMem(-1), fFutex(NULL), fPrivate(false)
  36 {
  37     const char* promiscuous = getenv("JACK_PROMISCUOUS_SERVER");
  38     fPromiscuous = (promiscuous != NULL);
  39     fPromiscuousGid = jack_group2gid(promiscuous);
  40 }
  41
  42 void JackLinuxFutex::BuildName(const char* client_name, const char* server_name, char* res, int size)
  43 {
  44     char ext_client_name[SYNC_MAX_NAME_SIZE + 1];
  45     JackTools::RewriteName(client_name, ext_client_name);
  46     if (fPromiscuous) {
  47         snprintf(res, size, "jack_sem.%s_%s", server_name, ext_client_name);
  48     } else {
  49         snprintf(res, size, "jack_sem.%d_%s_%s", JackTools::GetUID(), server_name, ext_client_name);
  50     }
  51 }
  52
  53 bool JackLinuxFutex::Signal()
  54 {
  55     if (!fFutex) {
  56         jack_error("JackLinuxFutex::Signal name = %s already deallocated!!", fName);
  57         return false;
  58     }
  59
  60     if (fFlush) {
  61         return true;
  62     }
  63
  64     if (! __sync_bool_compare_and_swap(&fFutex->futex, 0, 1))
  65     {
  66         // already unlocked, do not wake futex
  67         if (! fFutex->internal) return true;
  68     }
  69
  70     ::syscall(__NR_futex, fFutex, fFutex->internal ? FUTEX_WAKE_PRIVATE : FUTEX_WAKE, 1, NULL, NULL, 0);
  71     return true;
  72 }
  73
  74 bool JackLinuxFutex::SignalAll()
  75 {
  76     return Signal();
  77 }
  78
  79 bool JackLinuxFutex::Wait()
  80 {
  81     if (!fFutex) {
  82         jack_error("JackLinuxFutex::Wait name = %s already deallocated!!", fName);
  83         return false;
  84     }
  85
  86     if (fFutex->needsChange)
  87     {
  88         fFutex->needsChange = false;
  89         fFutex->internal = !fFutex->internal;
  90     }
  91
  92     for (;;)
  93     {
  94         if (__sync_bool_compare_and_swap(&fFutex->futex, 1, 0))
  95             return true;
  96
  97         if (::syscall(__NR_futex, fFutex, fFutex->internal ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT, 0, NULL, NULL, 0) != 0 && errno != EWOULDBLOCK)
  98             return false;
  99     }
 100 }
 101
 102 bool JackLinuxFutex::TimedWait(long usec)
 103 {
 104     if (!fFutex) {
 105         jack_error("JackLinuxFutex::TimedWait name = %s already deallocated!!", fName);
 106         return false;
 107      }
 108
 109     if (fFutex->needsChange)
 110     {
 111         fFutex->needsChange = false;
 112         fFutex->internal = !fFutex->internal;
 113     }
 114
 115     const uint secs  =  usec / 1000000;
 116     const int  nsecs = (usec % 1000000) * 1000;
 117
 118     const timespec timeout = { static_cast<time_t>(secs), nsecs };
 119
 120     for (;;)
 121     {
 122         if (__sync_bool_compare_and_swap(&fFutex->futex, 1, 0))
 123             return true;
 124
 125         if (::syscall(__NR_futex, fFutex, fFutex->internal ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT, 0, &timeout, NULL, 0) != 0 && errno != EWOULDBLOCK)
 126             return false;
 127     }
 128 }
 129
 130 // Server side : publish the futex in the global namespace
 131 bool JackLinuxFutex::Allocate(const char* name, const char* server_name, int value, bool internal)
 132 {
 133     BuildName(name, server_name, fName, sizeof(fName));
 134     jack_log("JackLinuxFutex::Allocate name = %s val = %ld", fName, value);
 135
 136     if ((fSharedMem = shm_open(fName, O_CREAT | O_RDWR, 0777)) < 0) {
 137         jack_error("Allocate: can't check in named futex name = %s err = %s", fName, strerror(errno));
 138         return false;
 139     }
 140
 141     if (ftruncate(fSharedMem, sizeof(FutexData)) != 0) {
 142         jack_error("Allocate: can't set shared memory size in named futex name = %s err = %s", fName, strerror(errno));
 143         return false;
 144     }
 145
 146     if (fPromiscuous && (jack_promiscuous_perms(fSharedMem, fName, fPromiscuousGid) < 0)) {
 147         close(fSharedMem);
 148         fSharedMem = -1;
 149         shm_unlink(fName);
 150         return false;
 151     }
 152
 153     FutexData* futex = (FutexData*)mmap(NULL, sizeof(FutexData), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_LOCKED, fSharedMem, 0);
 154
 155     if (futex == NULL || futex == MAP_FAILED) {
 156         jack_error("Allocate: can't check in named futex name = %s err = %s", fName, strerror(errno));
 157         close(fSharedMem);
 158         fSharedMem = -1;
 159         shm_unlink(fName);
 160         return false;
 161     }
 162
 163     fPrivate = internal;
 164
 165     futex->futex = value;
 166     futex->internal = internal;
 167     futex->wasInternal = internal;
 168     futex->needsChange = false;
 169     futex->externalCount = 0;
 170     fFutex = futex;
 171     return true;
 172 }
 173
 174 // Client side : get the published futex from server
 175 bool JackLinuxFutex::Connect(const char* name, const char* server_name)
 176 {
 177     BuildName(name, server_name, fName, sizeof(fName));
 178     jack_log("JackLinuxFutex::Connect name = %s", fName);
 179
 180     // Temporary...
 181     if (fFutex) {
 182         jack_log("Already connected name = %s", name);
 183         return true;
 184     }
 185
 186     if ((fSharedMem = shm_open(fName, O_RDWR, 0)) < 0) {
 187         jack_error("Connect: can't connect named futex name = %s err = %s", fName, strerror(errno));
 188         return false;
 189     }
 190
 191     FutexData* futex = (FutexData*)mmap(NULL, sizeof(FutexData), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_LOCKED, fSharedMem, 0);
 192
 193     if (futex == NULL || futex == MAP_FAILED) {
 194         jack_error("Connect: can't connect named futex name = %s err = %s", fName, strerror(errno));
 195         close(fSharedMem);
 196         fSharedMem = -1;
 197         return false;
 198     }
 199
 200     if (! fPrivate && futex->wasInternal)
 201     {
 202         const char* externalSync = getenv("JACK_INTERNAL_CLIENT_SYNC");
 203
 204         if (externalSync != NULL && strstr(fName, externalSync) != NULL && ++futex->externalCount == 1)
 205         {
 206             jack_error("Note: client %s running as external client temporarily", fName);
 207             futex->needsChange = true;
 208         }
 209     }
 210
 211     fFutex = futex;
 212     return true;
 213 }
 214
 215 bool JackLinuxFutex::ConnectInput(const char* name, const char* server_name)
 216 {
 217     return Connect(name, server_name);
 218 }
 219
 220 bool JackLinuxFutex::ConnectOutput(const char* name, const char* server_name)
 221 {
 222     return Connect(name, server_name);
 223 }
 224
 225 bool JackLinuxFutex::Disconnect()
 226 {
 227     if (!fFutex) {
 228         return true;
 229     }
 230
 231     if (! fPrivate && fFutex->wasInternal)
 232     {
 233         const char* externalSync = getenv("JACK_INTERNAL_CLIENT_SYNC");
 234
 235         if (externalSync != NULL && strstr(fName, externalSync) != NULL && --fFutex->externalCount == 0)
 236         {
 237             jack_error("Note: client %s now running as internal client again", fName);
 238             fFutex->needsChange = true;
 239         }
 240     }
 241
 242     munmap(fFutex, sizeof(FutexData));
 243     fFutex = NULL;
 244
 245     close(fSharedMem);
 246     fSharedMem = -1;
 247     return true;
 248 }
 249
 250 // Server side : destroy the futex
 251 void JackLinuxFutex::Destroy()
 252 {
 253     if (!fFutex) {
 254         return;
 255     }
 256
 257     munmap(fFutex, sizeof(FutexData));
 258     fFutex = NULL;
 259
 260     close(fSharedMem);
 261     fSharedMem = -1;
 262
 263     shm_unlink(fName);
 264 }
 265
 266 } // end of namespace
 267