print.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"

int  shm_arena_print_list(shm_arena_t arena)
{
  int ret = 0;
  int i;
  int err;
  struct mapping_header * map_header;
  struct seg_header *seg;

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

  if(arena->header->magic != ARENA_MAGIC)
    {
      printf("Bad magic number 0x%X != 0x%X\n",
     arena->header->magic, ARENA_MAGIC);
      errno = EINVAL;
      goto print_error;
    }

  /* 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))
    {
      SPEW_SYS_ERR(_WARN, ret, "%s() failed", __func__);
      pthread_mutex_unlock(&arena->mapping_mutex);
      goto print_error;
    }
    }
  pthread_mutex_unlock(&arena->mapping_mutex);


  seg = (struct seg_header *)
    (arena->mapping[0].start +
     (CHUNKS(sizeof(struct arena_header)) + CHUNKS(sizeof(struct mapping_header))));

  for(i=0; i<arena->num_mappings;)
    {

      map_header = get_mapping_header(arena, i);

      while((uintptr_t)seg <
        (((uintptr_t)(arena->mapping[i].start)) + map_header->length_used*CHUNK))
    {
      struct seg_footer *footer;
      footer = get_seg_footer(seg);

      if(!(footer->flags & IS_FREE))
        printf("%zu %s\n", seg->user_length, get_seg_name(seg));

      

      if(seg->length == 0)
        {
          printf("***ERROR***** seg->length = 0\n");
          break;
        }
      else if((uintptr_t) (seg->length*CHUNK) >
          (((uintptr_t)(map_header->length_used*CHUNK)) -
           ((uintptr_t)(seg))-((uintptr_t)(arena->mapping[i].start))))
        {
          printf("***ERROR***** seg->length = "OFFSET_FORMAT
         " CHUNKS IS TOO LARGE for this mapping\n", seg->length);
          break;
        }

      /* Goto the next segment. */
      seg = (struct seg_header *)(((uint8_t *) seg) + seg->length*CHUNK);
    }

      i++;

      if(i<arena->num_mappings)
    {
      map_header = get_mapping_header(arena, i);
      seg = (struct seg_header *)(arena->mapping[i].start +
                      CHUNKS(sizeof(struct mapping_header)));
    }
    }

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      ret = -1;
    }

  return ret;

 print_error:

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      ret = -1;
    }

  return -1;
}


int  shm_arena_print(shm_arena_t arena)
{
  int ret = 0;
  int i;
  int err;
  struct mapping_header * map_header;
  struct seg_header *seg;
  size_t pagesize;

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

  pagesize = getpagesize();
  if(arena->header->magic != ARENA_MAGIC)
    {
      printf("Bad magic number 0x%X != 0x%X\n",
     arena->header->magic, ARENA_MAGIC);
      errno = EINVAL;
      goto print_error;
    }

  /* 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))
    {
      SPEW_SYS_ERR(_WARN, ret, "%s() failed", __func__);
      pthread_mutex_unlock(&arena->mapping_mutex);
      goto print_error;
    }
    }
  pthread_mutex_unlock(&arena->mapping_mutex);


  printf("-------------------------------------------------------------\n");

  printf("pagesize = %zu bytes    CHUNK = %zu bytes\n\n",
     pagesize, CHUNK);

  printf("  " MAPNUM_FORMAT " mapping(s)\n", arena->num_mappings);

  printf("--------------------------------------------------------------------\n"
     "-------------- MAPPING 0 at %p -------------------------\n"
     "--------------------------------------------------------------------\n"
     "  struct arena_header   size= %zu bytes = %zu CHUNKS\n",
     arena->header,
     sizeof(struct arena_header), CHUNKS(sizeof(struct arena_header))/CHUNK);

  map_header = get_mapping_header(arena, 0);
  printf("  ----------------------------------------------------------\n"
     "     struct mapping_header    size= %zu CHUNK(s) = %zu bytes \n"
     "     -------------------------------------------------------\n"
     "      map_length  = "OFFSET_FORMAT" CHUNKS = %zu bytes = %zu pages\n"
     "      length_used = "OFFSET_FORMAT" CHUNKS = %zu bytes\n"
     "     -------------------------------------------------------\n",
     CHUNKS(sizeof(struct mapping_header))/CHUNK, sizeof(struct mapping_header),
     map_header->map_length, map_header->map_length*CHUNK,
     map_header->map_length*CHUNK/pagesize,
     map_header->length_used, map_header->length_used*CHUNK);

  printf("      magic = 0x%X   ", arena->header->magic);

#define SHOW_FLAG(x,f)  (((x)&(f))?("|" #f):"")

  printf("   flags = 0");

  /* define a MACRO so that we may add and print lots of flags */
#define SHOW_FLAG(x,f)  (((x)&(f))?("|" #f):"")
  printf("%s    ",
     SHOW_FLAG(arena->header->flags, SHM_WITH_SHM_OPEN)
     );
#undef SHOW_FLAG

  printf("num_mappings = "MAPNUM_FORMAT"\n\n", arena->header->num_mappings);


  printf("                                    free_mapnum   = "MAPNUM_FORMAT"\r",
     arena->header->free_mapnum);
  printf("      alloc_mapnum  = "MAPNUM_FORMAT"\n", arena->header->alloc_mapnum);


  printf("                                    free_offset   = "OFFSET_FORMAT" CHUNKS\r",
     arena->header->free_offset);
  printf("      alloc_offset  = "OFFSET_FORMAT" CHUNKS\n",
     arena->header->alloc_offset);



  seg = (struct seg_header *)
    (arena->mapping[0].start +
     (CHUNKS(sizeof(struct arena_header)) + CHUNKS(sizeof(struct mapping_header))));

  for(i=0; i<arena->num_mappings;)
    {

      /* The next mapping header is in the mapping before */
      map_header = get_mapping_header(arena, i+1);

      printf("   ------------------------------------------------------------\n"
     "   details for next mapping (mapping %d)\n"
     "   struct mapping_header    size= %zu bytes = %zu CHUNK(S)\n"
     "   ------------------------------------------------------------\n"
     "      map_length  = "OFFSET_FORMAT" CHUNKS = %zu bytes = %zu pages\n"
     "      length_used = "OFFSET_FORMAT" CHUNKS = %zu bytes\n"
     "   ------------------------------------------------------------\n",
     i+1,
     sizeof(struct mapping_header),
     CHUNKS(sizeof(struct mapping_header))/CHUNK,
     map_header->map_length, map_header->map_length*CHUNK,
     map_header->map_length*CHUNK/pagesize,
     map_header->length_used, map_header->length_used*CHUNK);

      map_header = get_mapping_header(arena, i);

      while((uintptr_t)seg <
        (uintptr_t)(arena->mapping[i].start + map_header->length_used*CHUNK))
    {
      struct seg_footer *footer;
      footer = get_seg_footer(seg);

      printf("   -----------------------------------------------------------\n");

      if(!(footer->flags & IS_FREE))
        printf("    \"%s\"", get_seg_name(seg));
      else
        printf("    free");
      
      printf(" segment at %p %s read-write lock\n"
         "    %"PRIuPTR" CHUNKS from mapping %d start\n"
         "                                 right_mapnum = "MAPNUM_FORMAT"\r"
         "    left_mapnum = "MAPNUM_FORMAT"\n"
         "                                 right_offset = "OFFSET_FORMAT" CHUNKS\r"
         "    left_offset = "OFFSET_FORMAT" CHUNKS\n"
         
         "    length      = "OFFSET_FORMAT" CHUNKS = %zu bytes\n"
         "    user_length = %zu bytes %s %zu CHUNK(S)\n"
         "    height = "HEIGHT_FORMAT"\n",
         seg, (footer->flags & WITH_RWLOCK)?"with":"without",
         (((uintptr_t) seg) - ((uintptr_t) arena->mapping[i].start))/CHUNK,
         i,
         seg->right_mapnum, seg->left_mapnum,
         seg->right_offset, seg->left_offset,
         seg->length, seg->length*CHUNK,
         seg->user_length,
         (seg->user_length != (seg->user_length/CHUNK)*CHUNK)?"uses":"=",
         CHUNKS(seg->user_length)/CHUNK,
         seg->height);
         
      if(footer->length != seg->length)
        printf("***ERROR****THE FOOTER length ("OFFSET_FORMAT" CHUNKS) does not match "
           "the HEADER length\n", footer->length);
      
      printf("   -----------------------------------------------------------\n");

      if(seg->length == 0)
        {
          printf("***ERROR***** seg->length = 0\n");
          break;
        }
      else if((uintptr_t) (seg->length*CHUNK) >
          (((uintptr_t)(map_header->length_used*CHUNK)) -
           ((uintptr_t)(seg))-((uintptr_t)(arena->mapping[i].start))))
        {
          printf("***ERROR***** seg->length = "OFFSET_FORMAT
         " CHUNKS IS TOO LARGE for this mapping\n", seg->length);
          break;
        }

      /* Goto the next segment. */
      seg = (struct seg_header *)(((uint8_t *) seg) + seg->length*CHUNK);
    }

      i++;

      if(i<arena->num_mappings)
    {
      printf("--------------------------------------------------------------------\n"
         "-------------- MAPPING %d at %p -------------------------\n"
         "--------------------------------------------------------------------\n",
         i, arena->mapping[i].start);
      map_header = get_mapping_header(arena, i);
      seg = (struct seg_header *)(arena->mapping[i].start +
                      CHUNKS(sizeof(struct mapping_header)));
    }
    }
  printf("--------------------------------------------------------------------\n");



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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      ret = -1;
    }

  return ret;

 print_error:

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      ret = -1;
    }

  return -1;
}


static
void print_alloc_node(shm_arena_t arena, mapnum_t mapnum,
             offset_t offset)
{
  struct seg_header *seg;
  char *name;
  seg = get_seg_header(arena, mapnum, offset);

  ASSERT(seg);

  name = get_seg_name(seg);
  
  printf( " -> n"MAPNUM_FORMAT"x"OFFSET_FORMAT";\n",
      mapnum, offset);
  printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
      " [label=\"%s\\ns=%zu\\nh="HEIGHT_FORMAT"\"];\n",
      mapnum, offset, name, seg->user_length, seg->height);
  
  if(seg->left_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT,
          mapnum, offset);
      print_alloc_node(arena, seg->left_mapnum, seg->left_offset);
    }
  else if(seg->right_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
          " -> l"MAPNUM_FORMAT"x"OFFSET_FORMAT" [style=dotted,arrowhead=dot];\n",
          mapnum, offset, mapnum, offset);
      printf( "    l"MAPNUM_FORMAT"x"OFFSET_FORMAT" [label=\"\",color=white];\n",
          mapnum, offset);
    }

  if(seg->right_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT,
          mapnum, offset);
      print_alloc_node(arena, seg->right_mapnum, seg->right_offset);
    }
  else if(seg->left_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
          " -> r"MAPNUM_FORMAT"x"OFFSET_FORMAT" [style=dotted,arrowhead=dot];\n",
          mapnum, offset, mapnum, offset);
      printf( "    r"MAPNUM_FORMAT"x"OFFSET_FORMAT" [label=\"\",color=white];\n",
          mapnum, offset);
    }
}


static
void print_free_node(shm_arena_t arena, mapnum_t mapnum,
            offset_t offset)
{
  struct seg_header *seg;
  seg = get_seg_header(arena, mapnum, offset);

  ASSERT(seg);
 
  
  printf( " -> n"MAPNUM_FORMAT"x"OFFSET_FORMAT";\n",
      mapnum, offset);
  printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
      " [label=\"m="MAPNUM_FORMAT"\\ns="OFFSET_FORMAT"\\nof="
      OFFSET_FORMAT"\\nh="HEIGHT_FORMAT"\"];\n",
      mapnum, offset, mapnum, seg->length, offset, seg->height);
  
  if(seg->left_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT,
          mapnum, offset);
      print_free_node(arena, seg->left_mapnum, seg->left_offset);
    }
  else if(seg->right_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
          " -> l"MAPNUM_FORMAT"x"OFFSET_FORMAT" [style=dotted,arrowhead=dot];\n",
          mapnum, offset, mapnum, offset);
      printf( "    l"MAPNUM_FORMAT"x"OFFSET_FORMAT" [label=\"\",color=white];\n",
          mapnum, offset);
    }

  if(seg->right_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT,
          mapnum, offset);
      print_free_node(arena, seg->right_mapnum, seg->right_offset);
    }
  else if(seg->left_offset)
    {
      printf( "    n"MAPNUM_FORMAT"x"OFFSET_FORMAT
          " -> r"MAPNUM_FORMAT"x"OFFSET_FORMAT" [style=dotted,arrowhead=dot];\n",
          mapnum, offset, mapnum, offset);
      printf( "    r"MAPNUM_FORMAT"x"OFFSET_FORMAT" [label=\"\",color=white];\n",
          mapnum, offset);
    }
}


int shm_arena_print_dot(shm_arena_t arena)
{
  int ret = 0;
  int err;

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

  if(arena->header->magic != ARENA_MAGIC)
    {
      errno = EINVAL;
      SPEW_SYS_ERR(_WARN, ret, "Bad magic number 0x%X != 0x%X\n",
     arena->header->magic, ARENA_MAGIC);
      goto print_error;
    }

  /* 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))
    {
      SPEW_SYS_ERR(_WARN, ret, "%s() failed", __func__);
      pthread_mutex_unlock(&arena->mapping_mutex);
      goto print_error;
    }
    }
  pthread_mutex_unlock(&arena->mapping_mutex);

  printf("digraph G {\n\n");
  printf("bgcolor =\"transparent\";\n");
  printf("   node [style=filled,color=\"0.7 0.3 10\"]\n");

  printf("\"allocated\\nsegments\"");

  if(arena->header->alloc_offset)
    {
      print_alloc_node(arena, arena->header->alloc_mapnum,
               arena->header->alloc_offset);
    }
  else
    {
      printf(";\n");
    }

  printf("\n\n   node [color=\"0.4 0.8 10\"]\n");

  printf("\n \"free\\nsegments\"");

  if(arena->header->free_offset)
    {
      print_free_node(arena, arena->header->free_mapnum,
              arena->header->free_offset);
    }
  else
    {
      printf(";\n");
    }

  printf("\n}\n");

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      return -1;
    }

  return 0;

 print_error:

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
    }

  return -1;
}


int shm_arena_check(shm_arena_t arena)
{
  int ret = 0;
  int i, err;

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

  if(arena->header->magic != ARENA_MAGIC)
    {
      errno = EINVAL;
      SPEW_SYS_ERR(_WARN, ret, "Bad magic number 0x%X != 0x%X\n",
     arena->header->magic, ARENA_MAGIC);
      goto print_error;
    }

  /* 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))
    {
      SPEW_SYS_ERR(_WARN, ret, "%s() failed", __func__);
      pthread_mutex_unlock(&arena->mapping_mutex);
      goto print_error;
    }
    }
  pthread_mutex_unlock(&arena->mapping_mutex);

  for(i=0;i<arena->num_mappings;i++)
    {
      struct seg_header *seg;
      struct mapping_header * map_header;

      map_header = get_mapping_header(arena, i);
      seg = (struct seg_header *)
    (arena->mapping[i].start +
     (CHUNKS(sizeof(struct mapping_header)) +
      ((i==0)?CHUNKS(sizeof(struct arena_header)):0)));

      while((uintptr_t)seg <
        (uintptr_t)(arena->mapping[i].start +
          map_header->length_used*CHUNK))
    {
      struct seg_footer *f;
      int diff;

      f = get_seg_footer(seg);

      if(f->flags & IS_FREE)
        {
          if(seg != _shm_check_free_segment(arena, i,
            get_offset(arena, seg, i)))
        {
          ret = 1;
          printf("did not find free segment in AVL tree\n");
          printf("mapping=%d offset="OFFSET_FORMAT" CHUNKS\n",
             i, get_offset(arena, seg, i));
        }
        }
      else
        {
          mapnum_t mapnum;;
          if(seg != find_segment(arena, get_seg_name(seg), &mapnum))
        {
          ret = 1;
          printf("did not find allocated segment \"%s\" in AVL tree\n",
             get_seg_name(seg));
          printf("mapping=%d offset="OFFSET_FORMAT" CHUNKS\n",
             i, get_offset(arena, seg, i));
        }
        }

      if(seg->length == 0)
        {
          printf("***ERROR***** seg->length = 0\n");
          ret = 1;
        }
      else if((uintptr_t) (seg->length*CHUNK) >
          (((uintptr_t)(map_header->length_used*CHUNK)) -
           ((uintptr_t)(seg))-((uintptr_t)(arena->mapping[i].start))))
        {
          printf("***ERROR***** seg->length = "OFFSET_FORMAT
         " CHUNKS IS TOO LARGE for this mapping\n", seg->length);
          ret = 1;
        }

      diff = difference(arena, seg);

      if(diff > 1 || diff < -1)
        {
          ret = 1;
          printf("%s segment \"%s\" is not balanced: diff=%d "
          "%s child is higher\n",
             (f->flags & IS_FREE)?"free":"allocated",
             (f->flags & IS_FREE)?"":get_seg_name(seg), 
             diff, (diff>0)?"left":"right");
          printf("mapping=%d offset="OFFSET_FORMAT" CHUNKS\n",
             i, get_offset(arena, seg, i));
        }

      /* Goto the next segment. */
      seg = (struct seg_header *)(((uint8_t *) seg) + seg->length*CHUNK);
    }
    }

 print_error:

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

  ASSERT(err == 0);
  if(err)
    {
      SPEW(_WARN, "We're screwed");
      errno = err;
      /* don't give the user false hope. */
      ret = -1;
    }

  return ret;
}