common/JackShmMem.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2009 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "JackError.h"
  22 #include "JackShmMem.h"
  23 #include <stdio.h>
  24
  25 namespace Jack
  26 {
  27
  28 static unsigned int fSegmentNum = 0;
  29 static jack_shm_info_t gInfo;
  30 size_t JackMem::gSize = 0;
  31
  32 JackShmMem::JackShmMem()
  33 {
  34     JackShmMemAble::Init();
  35     LockMemory();
  36 }
  37
  38 JackShmMem::~JackShmMem()
  39 {
  40     UnlockMemory();
  41 }
  42
  43 void JackShmMemAble::Init()
  44 {
  45     fInfo.index = gInfo.index;
  46     fInfo.ptr.attached_at = gInfo.ptr.attached_at;
  47     fInfo.size = gInfo.size;
  48 }
  49
  50 void* JackShmMem::operator new(size_t size, void* memory)
  51 {
  52     jack_log("JackShmMem::new placement size = %ld", size);
  53     return memory;
  54 }
  55
  56 void* JackShmMem::operator new(size_t size)
  57 {
  58     jack_shm_info_t info;
  59     JackShmMem* obj;
  60     char name[64];
  61
  62     snprintf(name, sizeof(name), "/jack_shared%d", fSegmentNum++);
  63
  64     if (jack_shmalloc(name, size, &info)) {
  65         jack_error("cannot create shared memory segment of size = %d", size, strerror(errno));
  66         goto error;
  67     }
  68
  69     if (jack_attach_shm(&info)) {
  70         jack_error("cannot attach shared memory segment name = %s err = %s", name, strerror(errno));
  71         jack_destroy_shm(&info);
  72         goto error;
  73     }
  74
  75     obj = (JackShmMem*)jack_shm_addr(&info);
  76     // It is unsafe to set object fields directly (may be overwritten during object initialization),
  77     // so use an intermediate global data
  78     gInfo.index = info.index;
  79     gInfo.size = size;
  80     gInfo.ptr.attached_at = info.ptr.attached_at;
  81
  82     jack_log("JackShmMem::new index = %ld attached = %x size = %ld ", info.index, info.ptr.attached_at, size);
  83     return obj;
  84
  85 error:
  86     jack_error("JackShmMem::new bad alloc", size);
  87     throw std::bad_alloc();
  88 }
  89
  90 void JackShmMem::operator delete(void* p, size_t size)
  91 {
  92     jack_shm_info_t info;
  93     JackShmMem* obj = (JackShmMem*)p;
  94     info.index = obj->fInfo.index;
  95     info.ptr.attached_at = obj->fInfo.ptr.attached_at;
  96
  97     jack_log("JackShmMem::delete size = %ld index = %ld", size, info.index);
  98
  99     jack_release_shm(&info);
 100     jack_destroy_shm(&info);
 101 }
 102
 103 void JackShmMem::operator delete(void* obj)
 104 {
 105     if (obj) {
 106         JackShmMem::operator delete(obj, 0);
 107     }
 108 }
 109
 110 void LockMemoryImp(void* ptr, size_t size)
 111 {
 112     if (CHECK_MLOCK((char*)ptr, size)) {
 113         jack_log("Succeeded in locking %u byte memory area", size);
 114     } else {
 115         jack_error("Cannot lock down memory area (%s)", strerror(errno));
 116     }
 117 }
 118
 119 void InitLockMemoryImp(void* ptr, size_t size)
 120 {
 121     if (CHECK_MLOCK((char*)ptr, size)) {
 122         memset(ptr, 0, size);
 123         jack_log("Succeeded in locking %u byte memory area", size);
 124     } else {
 125         jack_error("Cannot lock down memory area (%s)", strerror(errno));
 126     }
 127 }
 128
 129 void UnlockMemoryImp(void* ptr, size_t size)
 130 {
 131     if (CHECK_MUNLOCK((char*)ptr, size)) {
 132         jack_log("Succeeded in unlocking %u byte memory area", size);
 133     } else {
 134         jack_error("Cannot unlock down memory area (%s)", strerror(errno));
 135     }
 136 }
 137
 138 void LockAllMemory()
 139 {
 140     if (CHECK_MLOCKALL()) {
 141         jack_log("Succeeded in locking all memory");
 142     } else {
 143         jack_error("Cannot lock all memory (%s)", strerror(errno));
 144     }
 145 }
 146
 147 void UnlockAllMemory()
 148 {
 149     if (CHECK_MUNLOCKALL()) {
 150         jack_log("Succeeded in unlocking all memory");
 151     } else {
 152         jack_error("Cannot unlock all memory (%s)", strerror(errno));
 153     }
 154 }
 155
 156
 157 } // end of namespace
 158