sync_mappings.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 <inttypes.h>

#include <sys/mman.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"


DLL_LOCAL
int _shm_arena_sync_mappings( IF_SPEW(const char *func,)
                  struct shm_arena *arena)
{
  int i;
  int mapping_changed = 0; /* bool: has a mapping changed size? */
  struct mapping_header *map_header;
  struct arena_header *header;
  off_t offset = 0; /* offset into the arena file for each mapping */

  SPEW(_DEBUG, "%s(from func=\"%s\",,)", __func__, func);

  ASSERT(arena->header);

  header = arena->header;

  if(header->map_header.map_length < 1)
    return SPEW_SYS_RET(1, _WARN,
    "There are no mappings in the arena file");

  if(arena->num_mappings != header->num_mappings)
    {
      if(arena->num_mappings > header->num_mappings)
    {
      /* we have mappings that are no longer in the arena file */
      int min;
      min = arena->header->num_mappings;
      for(i=arena->num_mappings-1; i>=min; i--)
        {
          if(munmap(arena->mapping[i].start,
            arena->mapping[i].map_length))
        return SPEW_SYS_RET(1, _WARN, "%s() failed: "
            "munmap() failed: mapping %d", func, i);
          (arena->num_mappings)--;
        }
    }
      arena->mapping = (struct shm_mapping *)
    realloc(arena->mapping,
        arena->num_mappings*sizeof(struct shm_mapping));

      if(!(arena->mapping))
    return SPEW_SYS_RET(1, _WARN, "%s() failed: realloc() failed",
                func);

      /* Initialize any mappings that are being added. */
      while(arena->num_mappings < header->num_mappings)
    {
      arena->mapping[arena->num_mappings].start = MAP_FAILED;
      arena->mapping[arena->num_mappings].map_length = 0;
      (arena->num_mappings)++;
    }
    }

  /* Any mappings could have changed so we must check them all. */

  /* check 1st (0) mapping */
  if(arena->mapping[0].map_length != header->map_header.map_length)
    {
      if(munmap(arena->mapping[0].start,
        arena->mapping[0].map_length*CHUNK))
    return SPEW_SYS_RET(1, _WARN,
        "%s() failed: mumap() failed: remapping %d",
        func, 0);
      arena->mapping[0].map_length = header->map_header.map_length;
      arena->mapping[0].start =
    mmap(arena->user_shm_address, arena->mapping[0].map_length*CHUNK,
        PROT_READ|PROT_WRITE, MAP_SHARED, arena->fd, offset);
      if(arena->mapping[0].start == MAP_FAILED)
    return SPEW_SYS_RET(1, _WARN,
        "%s() failed: mmap() failed: remapping %d",
        func, 0);
      if(arena->user_shm_address &&
      arena->mapping[0].start != arena->user_shm_address)
    return SPEW_SYS_RET(1, _WARN, "%s() failed: mmap() failed"
        " with SHM_ADDRESS set: remapping %d",
        func, 0);

      /* Once one mapping changes the offset into the file may change
       * and so all the mappings are questionable. */
      mapping_changed = 1;
    }

  /* compute the offset to the next mapping */
  offset = (arena->mapping[0].map_length)*CHUNK;

  /* check all other mappings */
  map_header = get_mapping_header(arena, 1);

  for(i=1;i<header->num_mappings; i++)
    {
      /* Once one mapping changes the offset into the file may change
       * and so all the mappings are questionable. */
      if(arena->mapping[i].map_length != map_header->map_length
      || mapping_changed)
    {
      void *map_start = NULL;

      if(munmap(arena->mapping[i].start,
        arena->mapping[i].map_length*CHUNK))
        return SPEW_SYS_RET(1, _WARN,
        "%s() failed: mumap() failed: remapping %d",
        func, i);

          arena->mapping[i].map_length = map_header->map_length;

      if(arena->user_shm_address)
        map_start = (void*)(((uintptr_t) arena->mapping[i-1].start) +
        arena->mapping[i-1].map_length*CHUNK);
      arena->mapping[i].start =
        mmap(map_start, arena->mapping[i].map_length*CHUNK,
         PROT_READ|PROT_WRITE, MAP_SHARED, arena->fd, offset);
      if(arena->mapping[i].start == MAP_FAILED)
        return SPEW_SYS_RET(1, _WARN,
        "%s() failed: mmap() failed:"
        " remapping %d", func, i);
      if(map_start && arena->mapping[i].start != map_start)
        return SPEW_SYS_RET(1, _WARN,
        "%s() failed: mmap() failed with SHM_ADDRESS set:"
        " remapping %d", func, i);

      mapping_changed = 1;
    }
      /* go to the next mapping header */
      map_header = get_mapping_header(arena, i);
      /* compute the offset to the next mapping */
      offset += (arena->mapping[i].map_length)*CHUNK;
    }

  arena->num_mappings = header->num_mappings;
  arena->change_count = header->change_count;

  return 0; /* no error */
}