arena.h

/* 
 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/>.
*/

/* extra 32 bit prime number: 0xBE2CEE45 */

/* the max string length including the '\0' of the generated segment
 * name made in get.c and refered to in smq.c. */ 
#define GEN_NAME_SIZE         32

#define ARENA_MAGIC   0xCB35CC0D

#define IS_FREE         (01 << 0)

#define WITH_RWLOCK     (01 << 1)


#define PLUS_SIZE(x,s)   ((((x)+(s)-1)/(s))*(s))

#define PAGES(x, pagesize)         PLUS_SIZE((x), (pagesize))

#define CHUNKS(x)        PLUS_SIZE((x), CHUNK)


typedef int16_t mapnum_t;

#define MAPNUM_FORMAT  "%"PRId16  /* for printing */

typedef uint32_t offset_t;

#define OFFSET_FORMAT  "%"PRIu32 /* for printing */


typedef int32_t height_t;

#define HEIGHT_FORMAT  "%"PRId32 /* for printing */


struct seg_header
{
  mapnum_t left_mapnum, right_mapnum ;
  offset_t left_offset, right_offset ;
  height_t height;
  offset_t length;
  size_t user_length;
};


struct seg_footer
{
  offset_t length;
  uint32_t flags;
};

struct mapping_header
{
  offset_t map_length;
  offset_t length_used;
};

struct arena_header
{
  uint32_t magic;

  uint32_t flags;

  pthread_rwlock_t rwlock;

  struct mapping_header map_header;

  uint32_t name_count;

  uint32_t change_count;

  mapnum_t num_mappings;

  mapnum_t free_mapnum;
  mapnum_t alloc_mapnum;
  offset_t free_offset;
  offset_t alloc_offset;
};

struct shm_mapping
{
  uint8_t *start;

  offset_t map_length;
};

struct rwlock_attr
{
  int rdlock_count;
  int wrlock_count;
};

struct shm_arena
{
  int fd;

  struct arena_header *header; /* not changing after arena creation. */

  struct shm_mapping *mapping;

  int num_mappings;

  uint32_t change_count;

  pthread_mutex_t mapping_mutex;

  pthread_mutex_t rwlock_mutex;

  pthread_key_t rwlock_key;

  void *user_shm_address;
 };


/* Oh the shit we do to be thread-safe. */
static inline
struct rwlock_attr *get_rwlock_attr(struct shm_arena *a)
/* We have the two counters rdlock_count and wrlock_count for each
 * thread so that each thread may have recursive arena read-write
 * locks.  So if the user calls shm_get() the user will automatically
 * get a read or write arena lock.  Or they may get the arena read or
 * write lock explicitly with shm_arena_rdlock() or
 * shm_arena_wrlock(). */
{
  struct rwlock_attr *attr;
  int err;

  ASSERT(a);

  /* We make sure that just one thread will initialize the per-thread
   * flags in the struct rwlock_attr for each thread per arena. */
  pthread_mutex_lock(&a->rwlock_mutex);
  attr = (struct rwlock_attr *) pthread_getspecific(a->rwlock_key);
  if(attr)
    {
      pthread_mutex_unlock(&a->rwlock_mutex);
      return attr;
    }

  attr = (struct rwlock_attr *) malloc(sizeof(struct rwlock_attr));
  if(!attr)/* pretty well screwed. */
    {
      pthread_mutex_unlock(&a->rwlock_mutex);
      return attr;
    }

  if((err = pthread_setspecific(a->rwlock_key, attr)))
    {
      free(attr);
      pthread_mutex_unlock(&a->rwlock_mutex);
      return /* pretty well screwed. */
    SPEW_SYS_ERR_RET(NULL, _WARN, err,
             "pthread_setspecific() failed");
    }
  pthread_mutex_unlock(&a->rwlock_mutex);

  /* initialize it */
  attr->rdlock_count = 0;
  attr->wrlock_count = 0;

  SPEW(_DEBUG, "Initialized thread arena recursive read-write lock flags");
  return attr;
}

static inline
struct seg_footer *get_seg_footer(const struct seg_header *seg)
{
  return (struct seg_footer *)
    (((uint8_t *) seg +
      (seg->length*CHUNK - CHUNKS(sizeof(struct seg_footer)))));
}

/* seg_header and seg_footer must be set up to call this. */
static inline
char *get_seg_name(const struct seg_header *seg)
{
  return (char *)
    (((uint8_t *) seg +
      (CHUNKS(sizeof(struct seg_header)) +
       CHUNKS(seg->user_length) +
       ((get_seg_footer(seg)->flags & WITH_RWLOCK)?
    CHUNKS(sizeof(pthread_rwlock_t)):0))));
}

/* get a pointer to the user data -- assumes that seg_header and
 * seg_footer are set up. */
static inline
void *get_seg_ptr(struct seg_header *seg)
{
  return (void *)
    (((uint8_t *) seg +
      CHUNKS(sizeof(struct seg_header))));
}



/* returns the offset from the top of the mapping to the top of struct
 * seg_header *seg in CHUNKs. Offset in bytes is CHUNK times this. */
static inline
offset_t get_offset(const struct shm_arena *a,
            struct seg_header *seg, mapnum_t seg_mapnum)
{
  return (offset_t)
    (
     (((uintptr_t) seg) - ((uintptr_t)(a->mapping[seg_mapnum].start)))/CHUNK
     );
}

static inline
struct seg_header *get_seg_header(const struct shm_arena *a,
                  mapnum_t map_num, offset_t offset)
{
  if(offset)
    return (struct seg_header *)
      (((uint8_t *) (a->mapping[map_num].start)) + (offset*CHUNK));
  else
    return NULL;
}

static inline
struct mapping_header *get_mapping_header(const struct shm_arena *a,
                      mapnum_t mapnum)
{
  /* For Debug builds */
  ASSERT(a);
  ASSERT(a->mapping);
  ASSERT(a->change_count > 0);
  ASSERT(a->num_mappings > 0);
  ASSERT(mapnum <= a->num_mappings && mapnum >= -1);

  if(mapnum == -1 || mapnum >= a->num_mappings + 1)
    return NULL;

  if(mapnum != 0 && mapnum != 1)
    return (struct mapping_header *)(a->mapping[mapnum-1].start);

  if(mapnum == 0)
    return &(a->header->map_header);

  /* mapnum == 1 */
  return (struct mapping_header *) (((uint8_t *)(a->mapping[0].start)) +
                    CHUNKS(sizeof(struct arena_header)));
}

/* returns segment read-write lock or NULL is there are no segment
 * read-write lock */
static inline
pthread_rwlock_t *ptr_rwlock(const void *ptr)
{
  struct seg_header *seg;
  seg = (struct seg_header *)
     (((uint8_t *) ptr) - CHUNKS(sizeof(struct seg_header)));

  if(get_seg_footer(seg)->flags & WITH_RWLOCK)
    return (pthread_rwlock_t *)
      (((uint8_t *) ptr) + CHUNKS(seg->user_length));
  return NULL;
}

static inline
pthread_rwlock_t *get_seg_rwlock(const struct seg_header *seg)
{
  ASSERT(get_seg_footer(seg)->flags & WITH_RWLOCK);

  return 
    (pthread_rwlock_t *)
    (((uint8_t *) seg) +
     CHUNKS(sizeof(struct seg_header)) +
     CHUNKS(seg->user_length));
}

/* return non-zero is there is an error. */
extern int
_shm_arena_sync_mappings(IF_SPEW(const char *func,)
             struct shm_arena *arena);