/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 21 апр. 2024 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef PLATFORM_WINDOWS
#include
#include
#include
// Windows headers define macro for a type (sick)... We need to avoid it.
#ifdef uuid_t
#undef uuid_t
#endif /* uuid_t */
#else
#include
#include
#include
#include
#include
#include
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace ipc
{
struct shared_context_t
{
uatomic_t nReferences; // Number of references to this object
void *pData; // Pointer to the mapped memory buffer
wsize_t nSize; // Original segment size
size_t nMapOffset; // Mapping offset
size_t nMapSize; // Mapping size
size_t nMode; // Open mode
LSPString sPath; // Path to the shared memory segment
// System-specific data
#ifdef PLATFORM_WINDOWS
LSPString sLock; // Lock name
HANDLE hFD; // File descriptor
HANDLE hMapping; // File mapping
#else
int hFD; // File descriptor
#endif /* PLATFORM_WINDOWS */
};
SharedMem::SharedMem()
{
pContext = NULL;
}
SharedMem::SharedMem(const SharedMem & src)
{
pContext = src.pContext;
if (pContext != NULL)
atomic_add(&pContext->nReferences, 1);
}
SharedMem::SharedMem(SharedMem && src)
{
pContext = src.pContext;
src.pContext = NULL;
}
SharedMem::~SharedMem()
{
release_context();
}
void SharedMem::release_context()
{
if (pContext == NULL)
return;
if (atomic_add(&pContext->nReferences, -1) != 1)
return;
close_context(pContext);
delete pContext;
pContext = NULL;
}
SharedMem & SharedMem::operator = (const SharedMem & src)
{
release_context();
pContext = src.pContext;
if (pContext != NULL)
atomic_add(&pContext->nReferences, 1);
return *this;
}
SharedMem & SharedMem::operator = (SharedMem && src)
{
release_context();
pContext = src.pContext;
src.pContext = NULL;
return *this;
}
bool SharedMem::allocate_context()
{
if (pContext != NULL)
return true;
shared_context_t *ctx = new shared_context_t;
if (ctx == NULL)
return false;
ctx->nReferences = 1;
ctx->pData = NULL;
ctx->nSize = 0;
ctx->nMapOffset = 0;
ctx->nMapSize = 0;
ctx->nMode = 0;
#ifdef PLATFORM_WINDOWS
ctx->hFD = INVALID_HANDLE_VALUE;
ctx->hMapping = INVALID_HANDLE_VALUE;
#else
ctx->hFD = -1;
#endif /* PLATFORM_WINDOWS */
pContext = ctx;
return true;
}
status_t SharedMem::create(LSPString *name, const LSPString *postfix, size_t mode, size_t size)
{
LSPString tmp;
lsp::uuid_t uuid;
char utext[48];
if (opened())
return STATUS_OPENED;
if ((mode & (SHM_READ | SHM_WRITE)) == 0)
return STATUS_BAD_ARGUMENTS;
mode |= SHM_CREATE;
const size_t postfix_len = (postfix != NULL) ? postfix->length() : 0;
if (!tmp.reserve(36 + postfix_len))
return STATUS_NO_MEM;
while (true)
{
// Form the name of the shared segment
generate_uuid(&uuid);
format_uuid_dashed(utext, &uuid, false);
if (!tmp.set_ascii(utext))
return STATUS_NO_MEM;
if (postfix_len > 0)
{
if (!tmp.append(postfix))
return STATUS_NO_MEM;
}
// Try to create new shared segment
status_t res = open(&tmp, mode, size);
if (res == STATUS_OK)
break;
else if (res != STATUS_ALREADY_EXISTS)
return res;
}
tmp.swap(name);
return STATUS_OK;
}
status_t SharedMem::create(LSPString *name, const char *postfix, size_t mode, size_t size)
{
LSPString tmp;
lsp::uuid_t uuid;
char utext[48];
if (opened())
return STATUS_OPENED;
if ((mode & (SHM_READ | SHM_WRITE)) == 0)
return STATUS_BAD_ARGUMENTS;
mode |= SHM_CREATE;
const size_t postfix_len = (postfix != NULL) ? strlen(postfix) : 0;
if (!tmp.reserve(36 + postfix_len))
return STATUS_NO_MEM;
while (true)
{
// Form the name of the shared segment
// For MacOS there is a serious limitation on the shared memory
// segment name, so we use Base64 with custom table instead.
generate_uuid(&uuid);
#ifdef PLATFORM_MACOSX
format_uuid_base64(utext, &uuid);
#else
format_uuid_dashed(utext, &uuid, false);
#endif /* PLATFORM_MACOSX */
if (!tmp.set_ascii(utext))
return STATUS_NO_MEM;
if (postfix_len > 0)
{
if (!tmp.append_utf8(postfix))
return STATUS_NO_MEM;
}
// Try to create new shared segment
status_t res = open(&tmp, mode, size);
if (res == STATUS_OK)
break;
else if (res != STATUS_ALREADY_EXISTS)
return res;
}
tmp.swap(name);
return STATUS_OK;
}
status_t SharedMem::open(const char *name, size_t mode, size_t size)
{
if (name == NULL)
return STATUS_BAD_ARGUMENTS;
if ((mode & (SHM_READ | SHM_WRITE)) == 0)
return STATUS_BAD_ARGUMENTS;
if (opened())
return STATUS_OPENED;
if (!allocate_context())
return STATUS_NO_MEM;
#ifdef PLATFORM_WINDOWS
// Form the name of the temporary file
status_t res = system::get_system_temporary_dir(&pContext->sPath);
if (res != STATUS_OK)
return res;
if (!pContext->sPath.append(FILE_SEPARATOR_C))
return STATUS_NO_MEM;
if (!pContext->sPath.append_utf8(name))
return STATUS_NO_MEM;
// Form the name of shared mapping
if (!pContext->sLock.set_ascii("Local" FILE_SEPARATOR_S))
return STATUS_NO_MEM;
if (!pContext->sLock.append_utf8(name))
return STATUS_NO_MEM;
#else
// For portable use, a shared memory object should be identified by a name of the form /somename;
// that is, a null-terminated string of up to NAME_MAX (i.e., 255) characters consisting of an initial
// slash, followed by one or more characters, none of which are slashes.
pContext->sPath.clear();
if (!pContext->sPath.append(FILE_SEPARATOR_C))
return STATUS_NO_MEM;
if (!pContext->sPath.append_utf8(name))
return STATUS_NO_MEM;
#endif /* PLATFORM_WINDOWS */
return open_context(pContext, mode, size);
}
status_t SharedMem::open(const LSPString *name, size_t mode, size_t size)
{
if (name == NULL)
return STATUS_BAD_ARGUMENTS;
if ((mode & (SHM_READ | SHM_WRITE)) == 0)
return STATUS_BAD_ARGUMENTS;
if (opened())
return STATUS_OPENED;
if (!allocate_context())
return STATUS_NO_MEM;
#ifdef PLATFORM_WINDOWS
// Form the name of the temporary file
status_t res = system::get_system_temporary_dir(&pContext->sPath);
if (res != STATUS_OK)
return res;
if (!pContext->sPath.append(FILE_SEPARATOR_C))
return STATUS_NO_MEM;
if (!pContext->sPath.append(name))
return STATUS_NO_MEM;
// Form the name of shared mapping
if (!pContext->sLock.set_ascii("Local" FILE_SEPARATOR_S))
return STATUS_NO_MEM;
if (!pContext->sLock.append(name))
return STATUS_NO_MEM;
#else
// For portable use, a shared memory object should be identified by a name of the form /somename;
// that is, a null-terminated string of up to NAME_MAX (i.e., 255) characters consisting of an initial
// slash, followed by one or more characters, none of which are slashes.
pContext->sPath.clear();
if (!pContext->sPath.append(FILE_SEPARATOR_C))
return STATUS_NO_MEM;
if (!pContext->sPath.append(name))
return STATUS_NO_MEM;
#endif /* PLATFORM_WINDOWS */
return open_context(pContext, mode, size);
}
status_t SharedMem::close_context(shared_context_t *ctx)
{
status_t res = STATUS_OK;
if (ctx == NULL)
return res;
res = update_status(res, unmap_context(ctx));
res = update_status(res, close_file(ctx));
return res;
}
status_t SharedMem::close_file(shared_context_t *ctx)
{
status_t res = STATUS_OK;
#ifdef PLATFORM_WINDOWS
lsp_finally {
ctx->sPath.truncate();
ctx->sLock.truncate();
};
if (ctx->hMapping != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(ctx->hMapping))
res = update_status(res, STATUS_IO_ERROR);
ctx->hMapping = INVALID_HANDLE_VALUE;
}
const bool is_open = (ctx->hFD != INVALID_HANDLE_VALUE);
if (is_open)
{
if (!CloseHandle(ctx->hFD))
res = update_status(res, STATUS_IO_ERROR);
ctx->hFD = INVALID_HANDLE_VALUE;
}
// Need to release system structures?
// For windows, last one who closed the shared resource can unlink it
if ((is_open) && (!(ctx->nMode & SHM_PERSIST)))
unlink_file(ctx);
#else
lsp_finally {
ctx->sPath.truncate();
};
// Close file handle and remove it if persistent mode was specified
const bool is_open = (ctx->hFD >= 0);
if (is_open)
{
if (::close(ctx->hFD) < 0)
res = STATUS_IO_ERROR;
ctx->hFD = -1;
}
// Need to release system structures?
// For POSIX, those who created the shared resource
if ((is_open) && ((ctx->nMode & (SHM_CREATE | SHM_PERSIST)) == SHM_CREATE))
res = update_status(res, unlink_file(ctx));
#endif /* PLATFORM_WINDOWS */
return res;
}
status_t SharedMem::unmap_context(shared_context_t *ctx)
{
if (ctx->pData == NULL)
return STATUS_OK;
lsp_finally { ctx->pData = NULL; };
#ifdef PLATFORM_WINDOWS
if (!FlushViewOfFile(ctx->pData, ctx->nMapSize))
return STATUS_IO_ERROR;
if (!UnmapViewOfFile(ctx->pData))
return STATUS_IO_ERROR;
return STATUS_OK;
#else
if (munmap(ctx->pData, ctx->nMapSize) >= 0)
return STATUS_OK;
const int error = errno;
switch (error)
{
case EACCES: return STATUS_PERMISSION_DENIED;
case EAGAIN: return STATUS_RETRY;
case EPERM: return STATUS_PERMISSION_DENIED;
case EFBIG: return STATUS_TOO_BIG;
case EEXIST: return STATUS_ALREADY_EXISTS;
case ENOMEM: return STATUS_NO_MEM;
case EOVERFLOW: return STATUS_OVERFLOW;
default: break;
}
return STATUS_IO_ERROR;
#endif /* PLATFORM_WINDOWS */
}
status_t SharedMem::unlink_file(shared_context_t *ctx)
{
#ifdef PLATFORM_WINDOWS
const WCHAR *path = ctx->sPath.get_utf16();
if (path == NULL)
return STATUS_NO_MEM;
if (!DeleteFileW(path))
return STATUS_IO_ERROR;
#else
const char *path = ctx->sPath.get_native();
if (path == NULL)
return STATUS_NO_MEM;
if (shm_unlink(path) < 0)
return STATUS_IO_ERROR;
#endif /* PLATFORM_WINDOWS */
return STATUS_OK;
}
status_t SharedMem::open_context(shared_context_t *ctx, size_t mode, size_t size)
{
lsp_finally {
close_context(ctx);
};
#ifdef PLATFORM_WINDOWS
const WCHAR *path = ctx->sPath.get_utf16();
if (path == NULL)
return STATUS_NO_MEM;
const WCHAR *lock = ctx->sLock.get_utf16();
if (lock == NULL)
return STATUS_NO_MEM;
DWORD prot_flags = ((mode & SHM_EXEC) != 0) ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
DWORD file_access = 0;
if ((mode & SHM_READ) != 0)
file_access |= GENERIC_READ;
if ((mode & SHM_WRITE) != 0)
file_access |= GENERIC_READ | GENERIC_WRITE;
if ((mode & SHM_EXEC) != 0)
file_access |= GENERIC_EXECUTE;
LARGE_INTEGER l_size;
l_size.QuadPart = size;
if (mode & SHM_CREATE)
{
if (mode & SHM_PERSIST)
{
// lsp_trace("CreateFileW(access=0x%x, CREATE_NEW)", file_access);
ctx->hFD = CreateFileW(
path, // lpFileName
file_access, // dwDesiredAccess
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, // dwShareMode
NULL, // lpSecurityAttributes
CREATE_NEW, // dwCreationDisposition
FILE_ATTRIBUTE_ARCHIVE, // dwFlagsAndAttributes
NULL); // hTemplateFile
if (ctx->hFD == INVALID_HANDLE_VALUE)
{
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ALREADY_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_FILE_NOT_FOUND: return STATUS_NOT_FOUND;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
default: break;
}
return STATUS_IO_ERROR;
}
// Resize the file
if (!SetFilePointerEx(ctx->hFD, l_size, NULL, FILE_BEGIN))
return STATUS_IO_ERROR;
if (!SetEndOfFile(ctx->hFD))
return STATUS_IO_ERROR;
}
else
ctx->hFD = INVALID_HANDLE_VALUE;
// lsp_trace("CreateFileMappingW(fd=%p, access=0x%x, size=%d)", ctx->hFD, prot_flags, l_size.LowPart);
ctx->hMapping = CreateFileMappingW(
ctx->hFD, // hFile
NULL, // lpFileMappingAttributes
prot_flags, // flProtect
l_size.HighPart, // dwMaximumSizeHigh
l_size.LowPart, // dwMaximumSizeLow
lock); // lpName
if ((ctx->hMapping == INVALID_HANDLE_VALUE) || (ctx->hMapping == NULL))
{
ctx->hMapping = INVALID_HANDLE_VALUE;
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
default: break;
}
return STATUS_IO_ERROR;
}
}
else
{
// Try to open file mapping
// lsp_trace("OpenFileMappingW(access=0x%x, size=%d)", FILE_MAP_ALL_ACCESS, l_size.LowPart);
ctx->hMapping = OpenFileMappingW(FILE_MAP_ALL_ACCESS, TRUE, lock);
if ((ctx->hMapping == INVALID_HANDLE_VALUE) || (ctx->hMapping == NULL))
{
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
case ERROR_FILE_NOT_FOUND:
if (!(mode & SHM_PERSIST))
return STATUS_NOT_FOUND;
break;
default: return STATUS_IO_ERROR;
}
// There is no file mapping to open, try to create it
if (mode & SHM_PERSIST)
{
// lsp_trace("CreateFileW(access=0x%x, OPEN_EXISTING)", file_access);
ctx->hFD = CreateFileW(
path, // lpFileName
file_access, // dwDesiredAccess
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, // dwShareMode
NULL, // lpSecurityAttributes
OPEN_EXISTING, // dwCreationDisposition
FILE_ATTRIBUTE_ARCHIVE, // dwFlagsAndAttributes
NULL); // hTemplateFile
if (ctx->hFD == INVALID_HANDLE_VALUE)
{
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ALREADY_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_FILE_NOT_FOUND: return STATUS_NOT_FOUND;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
default: break;
}
return STATUS_IO_ERROR;
}
// Determine file size
if (!GetFileSizeEx(ctx->hFD, &l_size))
return STATUS_IO_ERROR;
size = l_size.QuadPart;
}
else
ctx->hFD = INVALID_HANDLE_VALUE;
// lsp_trace("CreateFileMappingW(fd=%p, access=0x%x, size=%d)", ctx->hFD, prot_flags, l_size.LowPart);
ctx->hMapping = CreateFileMappingW(
ctx->hFD, // hFile
NULL, // lpFileMappingAttributes
prot_flags, // flProtect
l_size.HighPart, // dwMaximumSizeHigh
l_size.LowPart, // dwMaximumSizeLow
lock); // lpName
if ((ctx->hMapping == INVALID_HANDLE_VALUE) || (ctx->hMapping == NULL))
{
ctx->hMapping = INVALID_HANDLE_VALUE;
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
default: break;
}
return STATUS_IO_ERROR;
}
}
}
#else
// Form the open mode
int o_flags = 0;
if ((mode & (SHM_READ | SHM_WRITE)) == 0)
return STATUS_BAD_ARGUMENTS;
if ((mode & SHM_WRITE) != 0)
o_flags = O_RDWR;
else
o_flags = O_RDONLY;
if (mode & SHM_CREATE)
o_flags |= O_CREAT | O_EXCL;
// Get the path
const char *path = ctx->sPath.get_native();
if (path == NULL)
return STATUS_NO_MEM;
// Create and initialize context
ctx->nMode = mode & (~SHM_PERSIST);
static constexpr int open_mode =
S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP |
S_IROTH | S_IWOTH;
// Open/create shared memory segment
const int fd = shm_open(path, o_flags, open_mode);
if (fd < 0)
{
const int error = errno;
switch (error)
{
case EACCES: return STATUS_PERMISSION_DENIED;
case EEXIST: return STATUS_ALREADY_EXISTS;
case EINVAL: return STATUS_INVALID_VALUE;
case EMFILE: return STATUS_OVERFLOW;
case ENAMETOOLONG: return STATUS_OVERFLOW;
case ENFILE: return STATUS_OVERFLOW;
case ENOENT: return STATUS_NOT_FOUND;
default: break;
}
return STATUS_IO_ERROR;
}
ctx->hFD = fd;
// Resize memory segment if it was created
if (mode & SHM_CREATE)
{
if (ftruncate(ctx->hFD, size) < 0)
{
const int error = errno;
switch (error)
{
case EACCES: return STATUS_PERMISSION_DENIED;
case EPERM: return STATUS_PERMISSION_DENIED;
case EFBIG: return STATUS_TOO_BIG;
default: break;
}
return STATUS_IO_ERROR;
}
}
else
{
io::fattr_t attr;
status_t res = io::File::stat(fd, &attr);
if (res != STATUS_OK)
return res;
size = attr.size;
}
#endif /* PLATFORM_WINDOWS */
// Now we are ready to deploy new context
ctx->nMode = mode;
ctx->nSize = size;
// Prevent context from being closed
ctx = NULL;
return STATUS_OK;
}
status_t SharedMem::close()
{
status_t res = close_context(pContext);
return res;
}
status_t SharedMem::map_context(shared_context_t *ctx, size_t offset, size_t size)
{
#ifdef PLATFORM_WINDOWS
DWORD map_access = 0;
if ((ctx->nMode & SHM_READ) != 0)
map_access |= FILE_MAP_READ;
if ((ctx->nMode & SHM_WRITE) != 0)
map_access |= FILE_MAP_WRITE;
if ((ctx->nMode & SHM_EXEC) != 0)
map_access |= FILE_MAP_EXECUTE;
LARGE_INTEGER l_offset;
l_offset.QuadPart = offset;
// lsp_trace("MapViewOfFile(%p, 0x%x, %d, %d)", ctx->hMapping, map_access, l_offset.LowPart, size);
void *addr = MapViewOfFile(
ctx->hMapping, // hFileMappingObject,
map_access, // dwDesiredAccess,
l_offset.HighPart, // dwFileOffsetHigh,
l_offset.LowPart, // dwFileOffsetLow,
size); // dwNumberOfBytesToMap
if (addr == NULL)
{
DWORD error = GetLastError();
switch (error)
{
case ERROR_FILE_EXISTS: return STATUS_ALREADY_EXISTS;
case ERROR_ACCESS_DENIED: return STATUS_PERMISSION_DENIED;
default: break;
}
return STATUS_IO_ERROR;
}
// Unmap previously mapped address
if (ctx->pData != NULL)
UnmapViewOfFile(ctx->pData);
#else
int prot_flags = 0;
if ((ctx->nMode & SHM_READ) != 0)
prot_flags |= PROT_READ;
if ((ctx->nMode & SHM_WRITE) != 0)
prot_flags |= PROT_WRITE;
if ((ctx->nMode & SHM_EXEC) != 0)
prot_flags |= PROT_EXEC;
// Map new memory address
void *addr = mmap(0, size, prot_flags, MAP_SHARED, ctx->hFD, offset);
if (addr == MAP_FAILED)
{
const int error = errno;
switch (error)
{
case EACCES: return STATUS_PERMISSION_DENIED;
case EAGAIN: return STATUS_RETRY;
case EPERM: return STATUS_PERMISSION_DENIED;
case EFBIG: return STATUS_TOO_BIG;
case EEXIST: return STATUS_ALREADY_EXISTS;
case ENOMEM: return STATUS_NO_MEM;
case EOVERFLOW: return STATUS_OVERFLOW;
default: break;
}
return STATUS_IO_ERROR;
}
// Unmap previously mapped address
if (ctx->pData != NULL)
munmap(ctx->pData, ctx->nMapSize);
#endif /* PLATFORM_WINDOWS */
// Commit new state
ctx->pData = addr;
ctx->nMapOffset = offset;
ctx->nMapSize = size;
return STATUS_OK;
}
status_t SharedMem::map(size_t offset, size_t size)
{
if (!opened())
return STATUS_CLOSED;
return map_context(pContext, offset, size);
}
status_t SharedMem::unmap()
{
// Check state
if (!opened())
return STATUS_CLOSED;
if (!mapped())
return STATUS_NOT_MAPPED;
// Unmap memory
return unmap_context(pContext);
}
void *SharedMem::data()
{
return (pContext != NULL) ? pContext->pData : NULL;
}
const void *SharedMem::data() const
{
return (pContext != NULL) ? pContext->pData : NULL;
}
ssize_t SharedMem::map_offset() const
{
if (!opened())
return -STATUS_CLOSED;
if (!mapped())
return -STATUS_NOT_MAPPED;
return pContext->nMapOffset;
}
ssize_t SharedMem::map_size() const
{
if (!opened())
return -STATUS_CLOSED;
if (!mapped())
return -STATUS_NOT_MAPPED;
return pContext->nMapSize;
}
wssize_t SharedMem::size() const
{
if (!opened())
return -STATUS_CLOSED;
return pContext->nSize;
}
bool SharedMem::opened() const
{
if (pContext == NULL)
return false;
#ifdef PLATFORM_WINDOWS
if ((pContext->hFD == INVALID_HANDLE_VALUE) && (pContext->hMapping == INVALID_HANDLE_VALUE))
return false;
#else
if (pContext->hFD < 0)
return false;
#endif /* PLATFORM_WINDOWS */
return true;
}
bool SharedMem::mapped() const
{
return (pContext != NULL) ? pContext->pData != NULL : false;
}
} /* namespace ipc */
} /* namespace lsp */