shm.c File Reference

Shared memory routines. More...

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/shm.h"

Go to the source code of this file.

Functions
int	shm_open (key_t key, size_t size, shm_mem_init_func_t mem_init, shm_t *pshm)
	Open shared memory segement. More...
int	shm_close (shm_t *pshm)
	Close shared memory segement. More...
static void	shm_mutex_create (key_t key, void *addr, size_t size)
	Create the share memory mutex. More...
int	shm_mutex_init (key_t key, shm_mutex_t *pshmmutex)
	Create and initialize a shared memory mutex. More...
int	shm_mutex_destroy (shm_mutex_t *pshmmutex)
	Destroy a shared memory mutex. More...
int	shm_mutex_lock (shm_mutex_t *pshmmutex)
	Lock the mutex. More...
int	shm_mutex_trylock (shm_mutex_t *pshmmutex)
	Try to lock the mutex. More...
int	shm_mutex_unlock (shm_mutex_t *pshmmutex)
	Unlock a lock the mutex. More...

Detailed Description

Shared memory routines.

LastChangedDate

2013-02-07 16:51:44 -0700 (Thu, 07 Feb 2013)

Rev

2675

• Basic convenience funtions.
• Shared memory implementation of the POSIX thread mutex. With shared memory, the mutex may span mutilple applications, not just threads within one application.
• Other functions as needed.

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2013-2018. RoadNarrows LLC..
http://www.roadnarrows.com
All Rights Reserved

Definition in file shm.c.

Function Documentation

int shm_close

(

shm_t *

pshm

)

Close shared memory segement.

The segment is marked for deletion, and is actually destroy after the last process detaches.

Parameters

[in,out]

pshm

Pointer to shared memory structure defined in caller's space.

Returns

On success, returns OK(0).
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 178 of file shm.c.

References LOGDIAG3, LOGERROR, LOGSYSERROR, shm_t::m_shmAddr, shm_t::m_shmId, shm_t::m_shmKey, shm_t::m_shmSize, NULL, OK, and RC_ERROR.

Referenced by shm_mutex_destroy().

{
  if( pshm == NULL )
  {
    LOGERROR("shm_t structure is NULL.");
    errno = EINVAL;
    return RC_ERROR;
  }

  // mark shared memory to be detroyed
  else if( shmctl(pshm->m_shmId, IPC_RMID, NULL) < 0 )
  {
    LOGSYSERROR("shmctl(%d, ...)", pshm->m_shmId);
    return RC_ERROR;
  }

  // detach shared memory from application address space
  else if( shmdt(pshm->m_shmAddr) < 0 )
  {
    LOGSYSERROR("shmdt(%p)", pshm->m_shmAddr);
    return RC_ERROR;
  }

  pshm->m_shmKey  = 0;
  pshm->m_shmId   = 0;
  pshm->m_shmSize = 0;
  pshm->m_shmAddr = NULL;

  LOGDIAG3("Closed shared memory (id=%d).", pshm->m_shmId);

  return OK;
}

static void shm_mutex_create ( key_t  key, void *  addr, size_t  size  )

static

Create the share memory mutex.

Parameters

key	Shared memory key.
addr	Starting address of attached shared memory.
size	Shared memory size.

Definition at line 223 of file shm.c.

References LOGDIAG4, and LOGSYSERROR.

Referenced by shm_mutex_init().

{
  pthread_mutex_t      *pmutex = (pthread_mutex_t *)addr;
  pthread_mutexattr_t   mutexAttr;

  pthread_mutexattr_init(&mutexAttr);

  //
  // Set the attribute to share between applications.
  //
  if(pthread_mutexattr_setpshared(&mutexAttr, PTHREAD_PROCESS_SHARED) < 0)
  {
    LOGSYSERROR("pthread_mutexattr_setpshared()");
  }

#ifndef ARCH_overo
  //
  // Set mutex robust attribute. If the owning thread or application terminates,
  // the next thread/application acquiring the mutex is notified by the 
  // return value EOWNERDEAD.
  //
  else if( pthread_mutexattr_setrobust(&mutexAttr, PTHREAD_MUTEX_ROBUST) < 0 )
  {
    LOGSYSERROR("pthread_mutexattr_setrobust()");
  }

  //
  // Allow recursive locks by the owning thread or application.
  //
  else if( pthread_mutexattr_settype(&mutexAttr, PTHREAD_MUTEX_RECURSIVE) < 0 )
  {
    LOGSYSERROR("pthread_mutexattr_settype()");
  }
#endif // ARCH_overo

  //
  // Initialize the pthread mutex with the give attributes
  //
  else if( pthread_mutex_init(pmutex, &mutexAttr) < 0 )
  {
    LOGSYSERROR("pthread_mutex_init()");
  }

  //
  // Success.
  //
  else
  {
    LOGDIAG4("Shared memory mutex created.");
  }

  pthread_mutexattr_destroy(&mutexAttr);
}

int shm_mutex_destroy

(

shm_mutex_t *

pshmmutex

)

Destroy a shared memory mutex.

The mutex is actually only destroyed when the last process attached to this mutex calls destroy.

Parameters

[in,out]

pshmmutex

Pointer to shared memory mutext structure defined in caller's space.

Returns

On success, returns 0.
On failure, errno is set and returned.

Definition at line 300 of file shm.c.

References shm_close().

Referenced by runExample().

{
  return shm_close(pshmmutex);
}

int shm_mutex_init	(	key_t	key,
		shm_mutex_t *	pshmmutex
	)

Create and initialize a shared memory mutex.

Parameters

	key	Shared memory key.
[in,out]	pshmmutex	Pointer to shared memory mutext structure defined in caller's space.

Returns

On success, returns 0.
On failure, errno is set and returned.

Definition at line 277 of file shm.c.

References LOGDIAG3, LOGERROR, LOGSYSERROR, NULL, OK, RC_ERROR, shm_mutex_create(), and shm_open().

Referenced by runExample().

{
  size_t  size = sizeof(pthread_mutex_t);

  if( pshmmutex == NULL )
  {
    LOGERROR("shm_mutex_t structure is NULL.");
    errno = EINVAL;
    return RC_ERROR;
  }

  // create/attach to shared memory mutex
  if( shm_open(key, size, shm_mutex_create, pshmmutex) < 0 )
  {
    LOGSYSERROR("shm_mutex_init(%d=0x%x, ...)", key, key);
    return RC_ERROR;
  }

  LOGDIAG3("Shared memory mutex initialized (key=%d=0x%x, ...)", key, key);

  return OK;
}

int shm_mutex_lock

(

shm_mutex_t *

pshmmutex

)

Lock the mutex.

Parameters

[in]

pshmmutex

Pointer to shared memory mutext structure defined in caller's space.

Returns

On success, returns 0.
On failure, errno is set and returned.

Definition at line 305 of file shm.c.

References LOGERROR, shm_t::m_shmAddr, NULL, OK, SHM_MUTEX_N_TRIES, and SHM_MUTEX_T_TRIES.

Referenced by lock().

{
  pthread_mutex_t  *pmutex;
  int               ntries;
  int               rc;

  if( pshmmutex == NULL )
  {
    LOGERROR("shm_mutex_t structure is NULL.");
    errno = EINVAL;
    return errno;
  }

  pmutex = (pthread_mutex_t *)(pshmmutex->m_shmAddr);

  for(ntries=0; ntries<SHM_MUTEX_N_TRIES; ++ntries)
  {
    if( (rc = pthread_mutex_lock(pmutex)) == 0 )
    {
      return OK;
    }

    switch( rc )
    {
      case EOWNERDEAD:  // owner of mutex went to a better place
#ifndef ARCH_overo
        pthread_mutex_consistent(pmutex);
#endif // ARCH_overo
        return OK;
      case EINVAL:      // mutex not initialized by creating thread/application
        usleep(SHM_MUTEX_T_TRIES);
        break;
      case EAGAIN:      // maximum recursive locks exceeded
        usleep(SHM_MUTEX_T_TRIES);
        break;
      default:          // other error
        errno = rc;
        return rc;
    }
  }

  errno = rc;
  return rc;
}

int shm_mutex_trylock

(

shm_mutex_t *

pshmmutex

)

Try to lock the mutex.

Parameters

[in]

pshmmutex

Pointer to shared memory mutext structure defined in caller's space.

Returns

On success, returns 0.
If the mutex is already locked, EBUSY is returned.
Otherwise, on failure, errno is set and returned.

Definition at line 350 of file shm.c.

References LOGERROR, shm_t::m_shmAddr, NULL, OK, SHM_MUTEX_N_TRIES, and SHM_MUTEX_T_TRIES.

{
  pthread_mutex_t  *pmutex;
  int               ntries;
  int               rc;

  if( pshmmutex == NULL )
  {
    LOGERROR("shm_mutex_t structure is NULL.");
    errno = EINVAL;
    return errno;
  }

  pmutex = (pthread_mutex_t *)(pshmmutex->m_shmAddr);

  for(ntries=0; ntries<SHM_MUTEX_N_TRIES; ++ntries)
  {
    if( (rc = pthread_mutex_trylock(pmutex)) == 0 )
    {
      return OK;
    }

    switch( rc )
    {
      case EOWNERDEAD:  // owner of mutex went to a better place
#ifndef ARCH_overo
        pthread_mutex_consistent(pmutex);
#endif // ARCH_overo
        return OK;
      case EINVAL:      // mutex not initialized by creating thread/application
        usleep(SHM_MUTEX_T_TRIES);
        break;
      case EAGAIN:      // maximum recursive locks exceeded
        usleep(SHM_MUTEX_T_TRIES);
        break;
      case EBUSY:       // already locked
      default:          // other error
        errno = rc;
        return rc;
    }
  }

  errno = rc;
  return rc;
}

int shm_mutex_unlock

(

shm_mutex_t *

pshmmutex

)

Unlock a lock the mutex.

Parameters

[in]

pshmmutex

Pointer to shared memory mutext structure defined in caller's space.

Returns

On success, returns 0.
On failure, errno is set and returned.

Definition at line 396 of file shm.c.

References LOGERROR, shm_t::m_shmAddr, main(), and NULL.

Referenced by unlock().

{
  pthread_mutex_t  *pmutex;

  if( pshmmutex == NULL )
  {
    LOGERROR("shm_mutex_t structure is NULL.");
    errno = EINVAL;
    return errno;
  }

  pmutex = (pthread_mutex_t *)(pshmmutex->m_shmAddr);

  return pthread_mutex_unlock(pmutex);
}

int shm_open	(	key_t	key,
		size_t	size,
		shm_mem_init_func_t	mem_init,
		shm_t *	pshm
	)

Open shared memory segement.

If the segment, associated by key, does not exist, then the shared memory is created and, optionally, initialized.

The shared memory segment is attached to the application address space.

Parameters

	key	Shared memory key.
	size	Shared memory size.
	mem_init	Optional memory initializer function. Set to NULL for no initialization.
[in,out]	pshm	Pointer to shared memory structure defined in caller's space.

Returns

On success, returns OK(0).
On failure, errno is set and RC_ERROR(-1) is returned.

Definition at line 74 of file shm.c.

References LOGDIAG3, LOGERROR, LOGSYSERROR, shm_t::m_shmAddr, shm_t::m_shmId, shm_t::m_shmKey, shm_t::m_shmSize, NULL, OK, and RC_ERROR.

Referenced by shm_mutex_init().

{
  int   perm = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
  int   shmId;
  void *addr;
  int   tmp;

  if( pshm == NULL )
  {
    LOGERROR("shm_t structure is NULL.");
    errno = EINVAL;
    return RC_ERROR;
  }

  // zzzsst
  pshm->m_shmKey  = 0;
  pshm->m_shmId   = 0;
  pshm->m_shmSize = 0;
  pshm->m_shmAddr = NULL;

  //
  // Try to create shared memory with the given key, returning the identifier.
  // Fails if already created.
  //
  shmId = shmget(key, size, IPC_CREAT | IPC_EXCL | perm);
  
  //
  // Created.
  //
  if( shmId >= 0 )
  {
    // attach shared memory to process address space
    addr = shmat(shmId, NULL, 0);
    
    if( addr == (void *)(-1) )
    {
      LOGSYSERROR("shmgat(%d, NULL, 0)",  shmId);
      tmp = errno;
      shmctl(shmId, IPC_RMID, NULL);
      errno = tmp;
      return RC_ERROR;
    }

    //
    // Initialize the shared memory. Only the caller that creates the shared
    // memory, initializes it, preventing race condition between caller
    // threads or applications.
    //
    if( mem_init != NULL )
    {
      mem_init(key, addr, size);
    }
  }

  // 
  // Already created, try to attach.
  //
  else if( errno == EEXIST )
  {
    // already exist, get the identifier
    shmId = shmget(key, size, perm);
      
    if( shmId < 0 )
    {
      LOGSYSERROR("shmget(%d=0x%x, %zu, ...)", key, key, size);
      return RC_ERROR;
    }

    // attach shared memory to process address space
    addr = shmat(shmId, NULL, 0);
    
    if( addr == (void *)(-1) )
    {
      LOGSYSERROR("shmgat(%d, NULL, 0)",  shmId);
      tmp = errno;
      shmctl(shmId, IPC_RMID, NULL);
      errno = tmp;
      return RC_ERROR;
    }
  }

  // 
  // Failed to create or get shared memory.
  //
  else
  {
    LOGSYSERROR("shmget(%d=0x%x, %zu, ...)", key, key, size);
    return RC_ERROR;
  }

  // set values
  pshm->m_shmKey  = key;
  pshm->m_shmId   = shmId;
  pshm->m_shmSize = size;
  pshm->m_shmAddr = addr;

  LOGDIAG3("Opened shared memory (id=%d, size=%zu).", key, size);

  return OK;
}