size_name.c

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

#include "config.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <pthread.h>
#include <stdint.h>

#include <pthread.h>
#include "spew.h"
#include "assert.h"
#include "debug_lock.h"
#include "shm_arena.h"
#include "arena.h"
#include "arena_lock.h"
#include "avl.h"

ssize_t shm_size(shm_arena_t arena, const void *ptr)
{
  ssize_t ret = -1;
  int err;
  struct seg_header *seg;

  SPEW(_INFO, "%s(arena=%p, ptr=%p)", __func__, arena, ptr);

  if(!ptr)
    /* ptr is not set */
    return SPEW_SYS_ERR_RET(ret, _WARN, EINVAL,
                "%s(arena=%p, ptr=%p) failed: ptr=%p",
                __func__, arena, ptr, ptr);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      errno = err;
      return -1;
    }

  ASSERT(arena->header);

  /* Make sure that we have the current number of memory mappings for
   * this arena file, by comparing the local and arena file
   * change_count. */
  pthread_mutex_lock(&arena->mapping_mutex);
  if(arena->change_count != arena->header->change_count)
    if(_shm_arena_sync_mappings(IF_SPEW(__func__,) arena))
      {
    pthread_mutex_unlock(&arena->mapping_mutex);
    goto finish;
      }
  pthread_mutex_unlock(&arena->mapping_mutex);

  /*****************************************************************
   * shm_size()
   *****************************************************************/

#ifdef SHM_DEBUG

#endif

  /* Here we assume that the ptr is in one of the shared memory
   * regions. */

  seg = (struct seg_header *)(((uint8_t *) ptr) - CHUNKS(sizeof(struct seg_header)));
  ret = (ssize_t) (seg->user_length);


  /*****************************************************************/

 finish:

  err = arena_autounlock(arena IF_SPEW(, __func__));

  ASSERT(err == 0);
  if(err)
    {
      errno = err;
      ret = -1;
    }

  return ret;
}


ssize_t shm_size_name(shm_arena_t arena, const char *name)
{
  ssize_t ret = -1;
  size_t size;
  int err;

  SPEW(_INFO, "%s(arena=%p, name=\"%s\")",
       __func__, arena, name);

  if(!name || !name[0])
    /* name is not set */
    return SPEW_SYS_ERR_RET(ret, _WARN, EINVAL,
                "%s() failed: name is invalid", __func__);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      errno = err;
      return -1;
    }

  ASSERT(arena->header);

  /* Make sure that we have the current number of memory mappings for
   * this arena file, by comparing the local and arena file
   * change_count. */
  pthread_mutex_lock(&arena->mapping_mutex);
  if(arena->change_count != arena->header->change_count)
    if(_shm_arena_sync_mappings(IF_SPEW(__func__,) arena))
      {
      pthread_mutex_unlock(&arena->mapping_mutex);
      goto finish;
      }
  pthread_mutex_unlock(&arena->mapping_mutex);

  /*****************************************************************
   * shm_size_name()
   *****************************************************************/

  if(find_segment_name(arena, name, &size))
    ret = (ssize_t) size;

  /*****************************************************************/

 finish:

  err = arena_autounlock(arena IF_SPEW(, __func__));

  ASSERT(err == 0);
  if(err)
    {
      errno = err;
      ret = -1;
    }

  return ret;
}

char *shm_name(shm_arena_t arena, const void *ptr,
           char *name, size_t name_size)
{
  char *ret = NULL;
  struct seg_header *seg;
  int err;

  SPEW(_INFO, "%s(arena=%p, ptr=%p, name=%p, name_size=%zu)",
       __func__, arena, ptr, name, name_size);

  if(!ptr)
    /* ptr is not set */
    return SPEW_SYS_ERR_RET(ret, _WARN, EINVAL,
                "%s() failed: ptr=%p",
                __func__, ptr);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      errno = err;
      return NULL;
    }

  ASSERT(arena->header);

  /* Make sure that we have the current number of memory mappings for
   * this arena file, by comparing the local and arena file
   * change_count. */
  pthread_mutex_lock(&arena->mapping_mutex);
  if(arena->change_count != arena->header->change_count)
    if(_shm_arena_sync_mappings(IF_SPEW(__func__,) arena))
      {
    pthread_mutex_unlock(&arena->mapping_mutex);
    /* errno should be set */
    goto finish;
      }
  pthread_mutex_unlock(&arena->mapping_mutex);

  /*****************************************************************
   * shm_size()
   *****************************************************************/

#ifdef SHM_DEBUG

#endif

  /* Here we assume that the ptr is in one of the shared memory
   * regions. */

  seg = (struct seg_header *)(((uint8_t *) ptr) - CHUNKS(sizeof(struct seg_header)));
  ret = get_seg_name(seg);

  /* We should have a null terminated string here. */
  ASSERT(CHUNKS(sizeof(struct seg_header)) + CHUNKS(sizeof(struct seg_footer)) +
     CHUNKS(strlen(ret))  +
     ((get_seg_footer(seg)->flags & WITH_RWLOCK)?CHUNKS(sizeof(pthread_rwlock_t)):0)
     < seg->length*CHUNK);

  if(name_size > 0 && name)
    {
      size_t len;
      len = strlen(ret);
      if(len < name_size)
    {
      strcpy(name, ret);
      ret = name;
    }
      else
    {
      ret = NULL;
      SPEW(_WARN, "%s() failed: name_size=%zu is smaller than the"
           " segment name size=%zu with null terminator",
           __func__, name_size, len+1);
    }
    }
  else
    {
      name = strdup(ret);
#ifdef WITH_SPEW
      if(!name)
    SPEW(_WARN, "%s() failed: malloc() failed", __func__);
#endif
      ret = name;
    }

  /*****************************************************************/

 finish:

  err = arena_autounlock(arena IF_SPEW(, __func__));

  if(err)
    {
      errno = err;
      ret = NULL;
    }

  return ret;
}