SharedMem Class Reference

Inheritance diagram for SharedMem:

Public Member Functions
	SharedMem (const char *name, int size)
	SharedMem (int shm_id, int sem_id, int size)
	~SharedMem (void)
void *	ptr (void)
int	shmid (void)
bool	IsCreated (void)
void	lock (void)
void	unlock (void)
bool	isLocked (void)

Static Public Member Functions
static std::string	getTmpFileName (std::string user, std::string name)
static bool	getIdFromTmpFileName (std::string filename, int &shmid, int &semid)

Private Attributes
bool	m_new {false}
	True if we created the ring buffer ourselves (and need to clean it).
key_t	m_shmkey
	SHM key, see shmget(2).
key_t	m_semkey
	Semaphore key.
int	m_shmid {-1}
	shared memory id
int	m_semid {-1}
	semaphore id
void *	m_shmadr {nullptr}

Detailed Description

Definition at line 19 of file SharedMem.h.

Constructor & Destructor Documentation

SharedMem() [1/2]

SharedMem	(	const char *	name,
		int	size
	)

Definition at line 25 of file SharedMem.cc.

{
  bool hasFile = false;
  std::string tmpPathName;
  // 0. Determine shared memory type
  if (strcmp(name, "private") != 0) {      // Global
    int tmpFilefd = -1;
    hasFile = true;
    tmpPathName = getTmpFileName(getenv("USER"), name);
    tmpFilefd = open(tmpPathName.c_str(), O_CREAT | O_EXCL | O_RDWR, 0644);
    // existance of file does not really imply shared mem is existing.
    // -> better we do not rely and update the content anyway!
    if (tmpFilefd > 0) {   // a new shared memory file created
      printf("SharedMem: Creating a new tmp file %s\n", name);
      m_new = true;
      close(tmpFilefd); // will open again later
    } else if (tmpFilefd == -1 && errno == EEXIST) { // shm already there
      printf("SharedMem: Found existing tmp file %s\n", name);
      m_new = false;
    } else {
      printf("SharedMem: error to open tmp file %s\n", tmpPathName.c_str());
      return;
    }
    m_shmkey = ftok(tmpPathName.c_str(), 1);
    m_semkey = ftok(tmpPathName.c_str(), 2);
  } else { // Private
    hasFile = false;
    m_new = true;
    m_shmkey = IPC_PRIVATE;
    m_semkey = IPC_PRIVATE;
    printf("SharedMem: Opening private shared memory\n");
  }
 
  printf("Shared memory/Semaphore Keys: $%X $%X\n", m_shmkey, m_semkey);
  // Behavior:
  // - IPC_CREATE will open existing or create new one
  // - IPC_CREATE|IPC_EXCL will create new one and fail is existing
  // - 0 will open existing one and fails if not existing
 
  // 1. Open shared memory
  m_shmid = shmget(m_shmkey, size * 4, IPC_CREAT | 0644);
  if (m_shmid < 0) {
    perror("SharedMem::shmget");
    return;
  }
  m_shmadr = (int*) shmat(m_shmid, 0, 0);
  if (m_shmadr == (int*) - 1) {
    perror("SharedMem::shmat");
    return;
  }
 
  // 2. Open semaphore
 
  // Behavior:
  // - IPC_CREATE will open existing or create new one
  // - IPC_CREATE|IPC_EXCL will create new one and fail is existing
  // - 0 will open existing one and fails if not existing
  m_semid = semget(m_semkey, 1, IPC_CREAT | IPC_EXCL | 0666);
  if (m_semid >= 0) {
    // POSIX doesn't guarantee any particular state of our fresh semaphore
    int semval = 1; //unlocked state
    printf("Semaphore ID %d created for key $%X\n", m_semid, m_semkey);
    if (semctl(m_semid, 0, SETVAL, semval) == -1) { //set 0th semaphore to semval
      perror("Initializing semaphore with semctl() failed.");
      return;
    }
  } else if (errno == EEXIST) {
    m_semid = semget(m_semkey, 1, 0); // obtain existing one
    printf("Found existing Semaphore ID %d for key $%X\n", m_semid, m_semkey);
  }
  if (m_semid < 0) {
    perror("SharedMem::shmget");
    return;
  }
 
  // 3. Put id of shm and semaphore in tmp file
  if (hasFile) {
    // private shm dont have a file, thus need to skip
    bool updateneeded = m_new;
    // 3.1 check if id of shm and semaphore in tmp file need update
    if (!m_new) {
      int shmid = 0, semid = 0;
      if (getIdFromTmpFileName(tmpPathName.c_str(), shmid, semid)) {
        updateneeded = (shmid != m_shmid || semid != m_semid);
        printf("tmp file %s content still uptodate\n", tmpPathName.c_str());
      } else {
        updateneeded = true; // could not open file or empty
      }
    }
    // 3.2 put id of shm and semaphore in tmp file
    if (updateneeded) {
      char shminfo[256];
      int tmpFilefd = open(tmpPathName.c_str(), O_RDWR, 0644);
      if (tmpFilefd < 0) {
        printf("SharedMem: error to reopen tmp file %s\n", tmpPathName.c_str());
        return;
      }
      snprintf(shminfo, sizeof(shminfo), "%d %d\n", m_shmid, m_semid);
      int is = write(tmpFilefd, shminfo, strlen(shminfo));
      if (is < 0) perror("write");
      close(tmpFilefd);
      printf("tmp file %s has been updated with shminfo \"%s\"\n", tmpPathName.c_str(), shminfo);
    }
  }
  printf("SharedMem: created. shmid = %d, semid = %d\n", m_shmid, m_semid);
 
}

SharedMem() [2/2]

SharedMem	(	int	shm_id,
		int	sem_id,
		int	size
	)

Definition at line 133 of file SharedMem.cc.

{
  m_shmid = shm_id;
  m_shmadr = (int*) shmat(m_shmid, 0, SHM_RDONLY);
  if (m_shmadr == (int*) - 1) {
    perror("SharedMem::shmat");
    return;
  }
  m_semid = sem_id;
  printf("SharedMem: open shmid = %d, semid = %d\n", m_shmid, m_semid);
}

~SharedMem()

~SharedMem

(

void

)

this killed the shared mems if the b2hlt... utils are run, thus commented!

Definition at line 145 of file SharedMem.cc.

{
 
  //shmdt((const void*) m_shmadr);
  //shmctl(m_shmid, IPC_RMID, NULL);
  //printf("SharedMem: destructor called for ID %d\n", m_shmid);
  // TODO: problem, neither semaphore nor tmp file are deleted if they exist
  // TODO: there is no guarantee that the destructor is called (e.g. on exit(), crash)
  // printf("SharedMem: destructor called for %s\n", m_strbuf);
}

Member Function Documentation

getIdFromTmpFileName()

bool getIdFromTmpFileName ( std::string  filename, int &  shmid, int &  semid  )

static

Definition at line 177 of file SharedMem.cc.

{
  char shminfo[256];
  int fd = open(filename.c_str(), O_RDONLY);
  if (fd < 0) {
    printf("SharedMem: error to reopen tmp file %s\n", filename.c_str());
    return false;
  }
  shmid = -1;
  semid = -1;
  memset(shminfo, 0, sizeof(shminfo));
  int n = read(fd, shminfo, sizeof(shminfo));
  close(fd);
  sscanf(shminfo, "%d %d", &shmid, &semid);
  return (n >= 3 && shmid >= 0 && semid >= 0);
}

getTmpFileName()

std::string getTmpFileName ( std::string  user, std::string  name  )

static

Definition at line 172 of file SharedMem.cc.

{
  return string("/tmp/") + user + string("_SHM_") + name;
}

IsCreated()

bool IsCreated

(

void

)

Definition at line 167 of file SharedMem.cc.

{
  return m_new;
}

isLocked()

bool isLocked

(

void

)

Definition at line 228 of file SharedMem.cc.

{
  int ignored = 0;
  return (semctl(m_semid, 0, GETVAL, ignored) == 0); //0: locked, 1: unlocked
}

lock()

void lock

(

void

)

Definition at line 194 of file SharedMem.cc.

{
  struct sembuf sb;
  sb.sem_num = 0;
  sb.sem_op = -1;
  sb.sem_flg = 0;
  while (semop(m_semid, &sb, 1) == -1) {
    if (errno == EINTR) {
      //interrupted by signal (e.g. window size changed), try again
      continue;
    } else {
      perror("lock:semop");
      exit(-1);
    }
  }
}

ptr()

void * ptr

(

void

)

Definition at line 157 of file SharedMem.cc.

{
  return (void*) m_shmadr;
}

shmid()

int shmid

(

void

)

Definition at line 162 of file SharedMem.cc.

{
  return m_shmid;
}

unlock()

void unlock

(

void

)

Definition at line 211 of file SharedMem.cc.

{
  struct sembuf sb;
  sb.sem_num = 0;
  sb.sem_op = 1;
  sb.sem_flg = 0;
  while (semop(m_semid, &sb, 1) == -1) {
    if (errno == EINTR) {
      //interrupted by signal (e.g. window size changed), try again
      continue;
    } else {
      perror("unlock:semop");
      exit(-1);
    }
  }
}

Member Data Documentation

m_new

bool m_new {false}

private

True if we created the ring buffer ourselves (and need to clean it).

Definition at line 38 of file SharedMem.h.

m_semid

int m_semid {-1}

private

semaphore id

Definition at line 43 of file SharedMem.h.

m_semkey

key_t m_semkey

private

Semaphore key.

Definition at line 40 of file SharedMem.h.

m_shmadr

void* m_shmadr {nullptr}

private

Definition at line 44 of file SharedMem.h.

m_shmid

int m_shmid {-1}

private

shared memory id

Definition at line 42 of file SharedMem.h.

m_shmkey

key_t m_shmkey

private

SHM key, see shmget(2).

Definition at line 39 of file SharedMem.h.

---

The documentation for this class was generated from the following files:

• daq/rfarm/manager/include/SharedMem.h
• daq/rfarm/manager/src/SharedMem.cc