remove.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 <inttypes.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"

static inline
int shrink_arena(struct shm_arena *a, struct seg_header *detached_seg)
/* This shrinks the arena until the last segment in the arena is an
 * allocated segment or we are left with the last mapping (mapping 0)
 * and the arena header data. */
{
  struct stat st;
  mapnum_t mapnum;

  /* This is the last segment and in the last mapping, so it will
   * not be inserted into the free AVL tree. */
  if(fstat(a->fd, &st)) /* Get the size of the arena file. */
    return /* error */
      SPEW_SYS_ERR_RET(-1, _WARN, errno,
               "fstat(fd=%d,) failed", a->fd);

  /* st.st_size is set to the current size of the arena file. */

  mapnum = a->num_mappings - 1;
  while(1)
    {
      struct mapping_header *m_hdr;
      struct seg_header *seg;
      struct seg_footer *footer;

      m_hdr = get_mapping_header(a, mapnum);
      ASSERT(m_hdr->map_length*CHUNK >= (uint32_t) getpagesize());

      /* get the last segment footer */
      footer = (struct seg_footer *)
    (a->mapping[mapnum].start +
     (m_hdr->length_used*CHUNK - CHUNKS(sizeof(struct seg_footer))));

      if(!(footer->flags & IS_FREE))
    return 0;

      /* get the last segment header from the footer */
      seg = (struct seg_header *)
    (((uint8_t *) footer) -
     (footer->length*CHUNK - CHUNKS(sizeof(struct seg_footer))));

      ASSERT(seg->length*CHUNK <= m_hdr->map_length*CHUNK -
         CHUNKS(sizeof(struct mapping_header)) -
         ((mapnum == 0)?CHUNKS(sizeof(struct arena_header)):0));

      if(seg != detached_seg)
    {
#ifdef SHM_DEBUG
      int ret;
      ret =
#endif
        _shm_detach_free_segment(a, seg, mapnum);
      ASSERT(ret == 0);
    }


      /* We have 2 cases:
       *
       *     Case 1  just remove part of the end of the mapping
       *     Case 2  remove the whole mapping
       */

      if((((uintptr_t)(a->mapping[mapnum].start +
               CHUNKS(sizeof(struct mapping_header)))) !=
      ((uintptr_t) seg)) || mapnum == 0)
    {
      /* Case 1  just remove the end of the mapping */

      /* seg will no longer point to valid memory after we
       * ftruncate the arena file, so we save the new_length_used
       * that is computed from it before ftruncate(). */
      offset_t new_length_used;

      new_length_used = m_hdr->length_used - seg->length;
      st.st_size -= seg->length*CHUNK;

      if(ftruncate(a->fd, st.st_size))
        return /* error */
          SPEW_SYS_ERR_RET(-1, _WARN, errno,
                   "ftruncate(fd=%d,) failed", a->fd);

      SPEW(_DEBUG, "Truncated arena file to %lu CHUNKS",
           (st.st_size)/CHUNK);

      m_hdr->length_used = new_length_used;

      return 0;
    }

      /* Case 2  remove the whole mapping */
      /* This is the last segment in the mapping and it's not the
       * first mapping. */

      st.st_size -= m_hdr->length_used*CHUNK;

      if(munmap(a->mapping[mapnum].start, m_hdr->map_length*CHUNK))
    return /* error */
      SPEW_SYS_ERR_RET(-1, _WARN, errno,
               "munmap() failed");

      if(ftruncate(a->fd, st.st_size))
    return /* error */
      SPEW_SYS_ERR_RET(-1, _WARN, errno,
                   "ftruncate(fd=%d,) failed", a->fd);

      SPEW(_DEBUG, "Unmapped mapping %d and truncated arena file to %lu CHUNKS",
       mapnum, (st.st_size)/CHUNK);

      
      (a->num_mappings)--;
      a->mapping = (struct shm_mapping *)
    realloc(a->mapping, a->num_mappings*sizeof(struct shm_mapping));
      if(!(a->mapping))
    return /* error */
      SPEW_SYS_ERR_RET(-1, _WARN, errno, "realloc() failed");

      a->change_count = ++(a->header->change_count);
      (a->header->num_mappings)--;

      m_hdr->map_length = 0;
      m_hdr->length_used = 0;

      /* We keep looping and see if we can shink the arena file
       * more. */

      mapnum--;
    }
}

static inline
int remove_segment(struct shm_arena *a, struct seg_header *seg,
           mapnum_t mapnum)
/* return 0 if it is found and removed
 *        1 if it is not found
 */
{
  struct mapping_header *m_hdr;
  struct seg_header *s;
  struct seg_footer *f;

  SPEW(_DEBUG, "%s(arena=%p, seg=%p, mapnum="MAPNUM_FORMAT")",
       __func__, a, seg, mapnum);

  SPEW(_DEBUG, "Removing segment \"%s\"", get_seg_name(seg));

  if(_shm_detach_alloc_segment(a, seg, mapnum)) return 1;

 /* Check for adjacent segments and merge them with seg. */

  m_hdr = get_mapping_header(a, mapnum);
  ASSERT(m_hdr);
  ASSERT(m_hdr->length_used*CHUNK > seg->length);

  /* seg is after all the header data */
  ASSERT((uintptr_t)(a->mapping[mapnum].start +
     (CHUNKS(sizeof(struct mapping_header)) +
       ((mapnum == 0)?CHUNKS(sizeof(struct arena_header)):0))) <=
     (uintptr_t) seg);

  /* seg is before the end of the of the mapping */
  ASSERT((uintptr_t)(((uint8_t *)(a->mapping[mapnum].start)) +
    m_hdr->length_used*CHUNK) >=
     (uintptr_t)(((uint8_t *) seg) + seg->length*CHUNK));

  if((uintptr_t)(a->mapping[mapnum].start +
          (CHUNKS(sizeof(struct mapping_header)) +
           ((mapnum == 0)?CHUNKS(sizeof(struct arena_header)):0))) !=
     (uintptr_t) seg)
    {
      /* This is not the first segment in the mapping */
      f = (struct seg_footer *)
    (((uint8_t *) seg) - CHUNKS(sizeof(struct seg_footer)));

      if(f->flags & IS_FREE)
    {
      /* merge seg and the previous segment */
#ifdef SHM_DEBUG
      int ret;
#endif
      s = (struct seg_header *)
        (((uint8_t *) f) - (f->length*CHUNK -
          CHUNKS(sizeof(struct seg_footer))));
#ifdef SHM_DEBUG
      ret =
#endif
        _shm_detach_free_segment(a, s, mapnum);
      ASSERT(ret == 0);

      /* merging it */
      s->length += seg->length;
      seg = s;
    }
    }

  if(((uintptr_t)(a->mapping[mapnum].start + m_hdr->length_used*CHUNK)) !=
     ((uintptr_t)(((uint8_t *) seg) + seg->length*CHUNK)))
    {
      /* there is a segment after this one */
      s = (struct seg_header *)(((uint8_t *) seg) + seg->length*CHUNK);
      f = (struct seg_footer *)
    (((uint8_t *) s) + (s->length*CHUNK -
      CHUNKS(sizeof(struct seg_footer))));
      if(f->flags & IS_FREE)
    {
      /* and it is free to merge it with seg */
#ifdef SHM_DEBUG
      int ret;
      ret =
#endif
        _shm_detach_free_segment(a, s, mapnum);
      ASSERT(ret == 0);

      /* merging it */
      seg->length += f->length;
    }
    }

  seg->user_length = 0;
  f = get_seg_footer(seg);
  f->flags = IS_FREE;
  f->length = seg->length;

  if(mapnum == a->num_mappings -1 &&
     ((uintptr_t)(a->mapping[mapnum].start + m_hdr->length_used*CHUNK)) ==
     ((uintptr_t)(((uint8_t *) seg) + seg->length*CHUNK)))
    {
      /* The segment will be removed from the arena file. */
      return shrink_arena(a, seg);
    }
  else
    {
      /* insert the free segment */
      insert_free_segment(a, seg, mapnum);
    }

  return 0; /* success */
}

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

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

  arena = get_arena_and_autolock(arena, 2, &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. */
  if(arena->change_count != arena->header->change_count)
    if(_shm_arena_sync_mappings(IF_SPEW(__func__,) arena))
      goto shm_remove_ret;

  /* Because we have arena file write lock and the mapping are in
   * sync, the mappings data will not change unless we change it in
   * this thread in this function. */

  /* Find the mapping that this segment is in */
  for(mapnum=0; mapnum < arena->num_mappings; mapnum++)
    {
      struct mapping_header *m_hdr;
      m_hdr = get_mapping_header(arena, mapnum);
      ASSERT(m_hdr);
      if((uintptr_t) ptr > (uintptr_t) arena->mapping[mapnum].start &&
     (uintptr_t) ptr < (uintptr_t)(arena->mapping[mapnum].start +
                       m_hdr->length_used*CHUNK))
    break;
    }


  if(mapnum == arena->num_mappings)
    {
      SPEW(_WARN, "A mapping was not found for this pointer=%p", ptr);
      goto shm_remove_ret;
    }

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

  ret = remove_segment(arena, seg, mapnum);

shm_remove_ret:


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

  ASSERT(err == 0);

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

  return ret;
}

int shm_remove_name(shm_arena_t arena, const char *name)
{
  struct seg_header *seg;
  mapnum_t mapnum;
  int ret = -1;
  int err;

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

  arena = get_arena_and_autolock(arena, 2, &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. */
  if(arena->change_count != arena->header->change_count)
    if(_shm_arena_sync_mappings(IF_SPEW(__func__,) arena))
      goto shm_remove_name_ret;

  /* Because we have arena file write lock and the mapping are in
   * sync, the mappings data will not change unless we change it in
   * this thread in this function. */

  seg = find_segment(arena, name, &mapnum);

  if(!seg)
    {
      SPEW(_INFO, "Segment \"%s\" not found", name);
      ret = 1;
      goto shm_remove_name_ret;
    }

  ret = remove_segment(arena, seg, mapnum);

shm_remove_name_ret:

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

  ASSERT(err == 0);

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

  return ret;
}