/* -*- c++ -*- */
/*
* Copyright 2003,2011,2013 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* GNU Radio 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "vmcircbuf_mmap_shm_open.h"
#include <stdexcept>
#include <assert.h>
#include <unistd.h>
#include <fcntl.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include <errno.h>
#include <stdio.h>
#include "pagesize.h"
#include <gnuradio/sys_paths.h>
namespace gr {
vmcircbuf_mmap_shm_open::vmcircbuf_mmap_shm_open(int size)
: gr::vmcircbuf(size)
{
#if !defined(HAVE_MMAP) || !defined(HAVE_SHM_OPEN)
fprintf(stderr, "gr::vmcircbuf_mmap_shm_open: mmap or shm_open is not available\n");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
#else
gr::thread::scoped_lock guard(s_vm_mutex);
static int s_seg_counter = 0;
if(size <= 0 || (size % gr::pagesize ()) != 0) {
fprintf(stderr, "gr::vmcircbuf_mmap_shm_open: invalid size = %d\n", size);
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
int shm_fd = -1;
char seg_name[1024];
static bool portable_format = true;
// open a new named shared memory segment
while(1) {
if(portable_format) {
// This is the POSIX recommended "portable format".
// Of course the "portable format" doesn't work on some systems...
snprintf(seg_name, sizeof(seg_name),
"/gnuradio-%d-%d", getpid(), s_seg_counter);
}
else {
// Where the "portable format" doesn't work, we try building
// a full filesystem pathname pointing into a suitable temporary directory.
snprintf(seg_name, sizeof(seg_name),
"%s/gnuradio-%d-%d", gr::tmp_path(), getpid(), s_seg_counter);
}
shm_fd = shm_open(seg_name, O_RDWR | O_CREAT | O_EXCL, 0600);
if(shm_fd == -1 && errno == EACCES && portable_format) {
portable_format = false;
continue; // try again using "non-portable format"
}
s_seg_counter++;
if(shm_fd == -1) {
if(errno == EEXIST) // Named segment already exists (shouldn't happen). Try again
continue;
char msg[1024];
snprintf(msg, sizeof(msg), "gr::vmcircbuf_mmap_shm_open: shm_open [%s]", seg_name);
perror(msg);
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
break;
}
// We've got a new shared memory segment fd open.
// Now set it's length to 2x what we really want and mmap it in.
if(ftruncate(shm_fd, (off_t)2 * size) == -1) {
close(shm_fd); // cleanup
perror("gr::vmcircbuf_mmap_shm_open: ftruncate (1)");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
void *first_copy = mmap(0, 2 * size,
PROT_READ | PROT_WRITE, MAP_SHARED,
shm_fd, (off_t) 0);
if(first_copy == MAP_FAILED) {
close(shm_fd); // cleanup
perror("gr::vmcircbuf_mmap_shm_open: mmap (1)");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
// unmap the 2nd half
if(munmap ((char *) first_copy + size, size) == -1) {
close(shm_fd); // cleanup
perror("gr::vmcircbuf_mmap_shm_open: munmap (1)");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
// map the first half into the now available hole where the
// second half used to be.
void *second_copy = mmap((char*)first_copy + size, size,
PROT_READ | PROT_WRITE, MAP_SHARED,
shm_fd, (off_t)0);
if(second_copy == MAP_FAILED) {
close(shm_fd); // cleanup
perror("gr::vmcircbuf_mmap_shm_open: mmap (2)");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
#if 0 // OS/X doesn't allow you to resize the segment
// cut the shared memory segment down to size
if(ftruncate(shm_fd, (off_t)size) == -1) {
close(shm_fd); // cleanup
perror("gr::vmcircbuf_mmap_shm_open: ftruncate (2)");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
#endif
close(shm_fd); // fd no longer needed. The mapping is retained.
if(shm_unlink(seg_name) == -1) { // unlink the seg_name.
perror("gr::vmcircbuf_mmap_shm_open: shm_unlink");
throw std::runtime_error("gr::vmcircbuf_mmap_shm_open");
}
// Now remember the important stuff
d_base = (char*)first_copy;
d_size = size;
#endif
}
vmcircbuf_mmap_shm_open::~vmcircbuf_mmap_shm_open()
{
#if defined(HAVE_MMAP)
gr::thread::scoped_lock guard(s_vm_mutex);
if(munmap (d_base, 2 * d_size) == -1) {
perror("gr::vmcircbuf_mmap_shm_open: munmap (2)");
}
#endif
}
// ----------------------------------------------------------------
// The factory interface
// ----------------------------------------------------------------
gr::vmcircbuf_factory *vmcircbuf_mmap_shm_open_factory::s_the_factory = 0;
gr::vmcircbuf_factory *
vmcircbuf_mmap_shm_open_factory::singleton()
{
if(s_the_factory)
return s_the_factory;
s_the_factory = new gr::vmcircbuf_mmap_shm_open_factory();
return s_the_factory;
}
int
vmcircbuf_mmap_shm_open_factory::granularity()
{
return gr::pagesize();
}
gr::vmcircbuf *
vmcircbuf_mmap_shm_open_factory::make(int size)
{
try {
return new vmcircbuf_mmap_shm_open(size);
}
catch (...) {
return 0;
}
}
} /* namespace gr */