shm_arena.h

/* shm_arena.h is generated from the file shm_arena.h.in using configure */

/* 
 shm-arena    shared memory arena
 Copyright (C) 2006-2008 Lance Arsenault (LGPL v3)


    This file is part of shm-arena.

    shm-arena 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 (at your option) any later version.

    shm-arena 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 this program.  If not, see
    <http://www.gnu.org/licenses/>.
*/

#ifndef __SHM_ARENA_H__
#define __SHM_ARENA_H__

/*************************************************************
           system header files needed
*************************************************************/
#include <sys/stat.h>  /* for SHM_RW_MODE */
#include <fcntl.h>     /* for some macros */
#include <stdio.h>     /* defines NULL    */
#include <sys/types.h> /* for size_t      */

/**********************************************************
                  shm CPP MACROS
**********************************************************/

#define SHM_DEFAULT_SPEW_LEVEL      "WARN"

#define SHM_HOMEPAGE                 "http://shm-arena.sourceforge.net/"

#define SHM_PREFIX                   "/home/lanceman/installed/encap/shm_arena"

#define SHM_DEFAULT_ARENA_DIR        "/tmp/shm_arena"

#define SHM_DEFAULT_ARENA_FILE       "arena"


#define SHM_RW_MODE    (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)


/* The configure script makes sure that the last 8 bits (of 32)
 * in the open(2) flags are unused by any standard system flags
 * like O_CREAT and all the others in fcntl.h. */

#define SHM_WITH_SHM_OPEN            (01 << 24)

#define SHM_ARENA_HAVE_FLOCK         (01 << 25)

#define SHM_USE_GIVEN_PATH           (01 << 26)

#define SHM_ARENA_DEFAULT            (01 << 27)

#define SHM_WITHOUT_RWLOCK           (01 << 28)



#define SHM_TIMESTAMP                (01 << 29)

#define SHM_UNKNOWN_SIZE             ((size_t) -1)


/***********************************************************************/
#ifdef __cplusplus
extern "C"
{
#endif

/************************************************************************
                     shm data structures
************************************************************************/

  typedef struct shm_arena *shm_arena_t;

  typedef struct smq *smq_t;

/************************************************************************
                     shm library functions
************************************************************************/

  /* The shm_*() functions are doxygen documented in other .c source
   * files. */

  extern
  void *shm_get(shm_arena_t arena, size_t size,
        const char *name, int flags);

  extern
  ssize_t shm_size(shm_arena_t arena, const void *ptr);

  extern
  ssize_t shm_size_name(shm_arena_t arena, const char *name);

  extern
  int shm_remove(shm_arena_t arena, const void *ptr);

  extern
  int shm_remove_name(shm_arena_t arena, const char *name);

  extern
  char *shm_name(shm_arena_t arena, const void *ptr,
         char *name, size_t name_size);




  extern
  int shm_wrlock(shm_arena_t arena, const void *ptr);

  extern
  int shm_rdlock(shm_arena_t arena, const void *ptr);

  extern
  int shm_unlock(shm_arena_t arena, const void *ptr);


  extern
  int shm_rwlock_reset(shm_arena_t arena, const void *ptr);




  /* arena management functions */

  extern
  shm_arena_t shm_arena_create(const char *path, int flags,
                   mode_t mode, size_t min_size);


  extern
  int shm_arena_delete(shm_arena_t arena);

  extern
  int shm_arena_destroy(const char *path, int flags);

  extern
  int shm_arena_rwlock_reset(shm_arena_t arena);





  extern
  int shm_arena_wrlock(shm_arena_t arena);

  extern
  int shm_arena_rdlock(shm_arena_t arena);

  extern
  int shm_arena_unlock(shm_arena_t arena);



  extern
  int shm_arena_set_default(const shm_arena_t arena);




  extern
  int shm_arena_print(shm_arena_t arena);

  extern
  int shm_arena_print_dot(shm_arena_t arena);

  extern
  int shm_arena_print_list(shm_arena_t arena);




  /*******************************************************************
   * simpler interfaces which use the default arena which can be set
   * automatically or by using shm_arena_set_default()
   *******************************************************************/


  static inline
  void *sm_get(size_t size, const char *name)
  {
    return shm_get(NULL, size, name, O_CREAT);
  }

  static inline
  void *sm_create(size_t size, const char *name)
  {
    return shm_get(NULL, size, name, O_CREAT|O_EXCL);
  }
  
  static inline
  void *sm_connect(size_t size, const char *name)
  {
    return shm_get(NULL, size, name, 0);
  }

  static inline
  size_t sm_size(const void *ptr)
  {
    return shm_size(NULL, ptr);
  }

  static inline
  size_t sm_size_name(const char *name)
  {
    return shm_size_name(NULL, name);
  }

  
  static inline
  int sm_remove(const void *ptr)
  {
    return shm_remove(NULL, ptr);
  }

  static inline
  int sm_remove_name(const char *name)
  {
    return shm_remove_name(NULL, name);
  }

  static inline
  char *sm_name(const void *ptr, char *name, size_t name_size)
  {
    return shm_name(NULL, ptr, name, name_size);
  }

  static inline
  int sm_wrlock(const void *ptr)
  {
    return shm_wrlock(NULL, ptr);
  }

  static inline
  int sm_rdlock(const void *ptr)
  {
    return shm_rdlock(NULL, ptr);
  }

  static inline
  int sm_unlock(const void *ptr)
  {
    return shm_unlock(NULL, ptr);
  }



  static inline
  int sm_arena_wrlock(void)
  {
    return shm_arena_wrlock(NULL);
  }

  static inline
  int sm_arena_rdlock(void)
  {
    return shm_arena_rdlock(NULL);
  }

  static inline
  int sm_arena_unlock(void)
  {
    return shm_arena_unlock(NULL);
  }


  /****************************************************************
   *                      smq functions                           *
   ****************************************************************/
  extern
  smq_t smq_get(shm_arena_t arena, size_t element_size,
        int q_length, const char *name, int flags);
  extern
  size_t smq_element_size(smq_t q);
  extern
  int smq_remove(smq_t q);
  extern
  int smq_delete(smq_t q);
  extern
  int smq_rdlock(smq_t q, int num);
  extern
  int smq_unblock_rdlock(smq_t q);
  extern
  int smq_wrlock(smq_t q, int num);
  extern
  int smq_unlock(smq_t q);
  extern
  void *smq_write(smq_t q);
  extern
  void *smq_poll(smq_t q);
  extern
  void *smq_read(smq_t q);
  extern
  long double *smq_timestamp(smq_t q, const void *ptr);


/***********************************************************************/
#ifdef  __cplusplus
}
#endif
/***********************************************************************/

#endif /* #ifndef __SHM_ARENA_H__ */