/*
 * Two Levels Segregate Fit memory allocator (TLSF)
 * Version 1.3
 *
 * Written by Miguel Masmano Tello <mmasmano@disca.upv.es>
 *
 * Thanks to Ismael Ripoll for his suggestions and reviews
 *
 * Copyright (C) April 2004 UPVLC, OCERA Consortium
 * 
 * This code is released using a dual license strategy: GPL/LGPL
 * You can choose the license that better fits your requirements.
 *
 * Released under the terms of the GNU General Public License Version 2.0
 * Released under the terms of the GNU Lesser General Public License Version 2.1
 *
 */

#include "TLSF_nondep.h"
#ifdef TLSF_DEBUG_FUNCTIONS

static void print_block (block_header_t *b){
  if (!b) return;

  PRINT_DBG_C (">>>> Address 0x");
  PRINT_DBG_H (b);
  
  if ((b -> size & USED_BLOCK) != USED_BLOCK)
    PRINT_DBG_C ("\n>>>> Status FREE");
  else
    PRINT_DBG_C ("\n>>>> Status USED");
  
  PRINT_DBG_C (" Block Size ");
  PRINT_DBG_D (TLSF_WORDS2BYTES(b -> size));
  PRINT_DBG_C (" bytes");
  
  if (!b -> prev_phys_block)
    PRINT_DBG_C ("\n>>>> FIRST BLOCK");
  else {
    PRINT_DBG_C ("\n>>>> PREV. PHYS. BLOCK 0x");
    PRINT_DBG_H (b -> prev_phys_block);
  }

  if ((b -> size & LAST_BLOCK) == LAST_BLOCK)
    PRINT_DBG_C (" LAST BLOCK");
  else
    PRINT_DBG_C (" NOT LAST BLOCK");
  
  if ((b -> size & FREE_BLOCK) == FREE_BLOCK){
    PRINT_DBG_C ("\n---- Prev Free 0x");
    PRINT_DBG_H (b -> ptr.free_ptr.prev);
    PRINT_DBG_C (" Next Free 0x");
    PRINT_DBG_H (b -> ptr.free_ptr.next);
  }
  PRINT_DBG_C ("\n\n");
}

/*
 * structure_status () shows the status of all the blocks
 */
void structure_status (char *block_ptr) {
  block_header_t *b;
  TLSF_t *ptr_TLSF;
  int end = 0, end2 = 0;
  __u32 *ptr_following;
  
  ptr_TLSF = (TLSF_t *) block_ptr; 
  if (!ptr_TLSF || ptr_TLSF -> magic_number != MAGIC_NUMBER) {
    PRINT_MSG 
      ("structure_status() error: TLSF structure is not initialized\n");
    PRINT_MSG 
      ("Hint: Execute init_memory_pool() before calling structure_status()");
      return;
  }

  PRINT_DBG_C ("\nTLSF structure address 0x");
  PRINT_DBG_H (ptr_TLSF);
  PRINT_DBG_C ("\nMax. first level index: ");
  PRINT_DBG_D (ptr_TLSF -> max_fl_index);
  PRINT_DBG_C ("\nMax. second level index: ");
  PRINT_DBG_D (ptr_TLSF -> max_sl_index);
  PRINT_DBG_C ("\n\nALL BLOCKS\n");
  
  ptr_following = ptr_TLSF -> following_non_cont_bh;
  while (!end2) {
    end = 0;
    b = (block_header_t *) (ptr_following + sizeof (__u32 *));
    
    while (!end) {
      print_block (b);
      if (IS_LAST_BLOCK(b))
	end = 1;
      else
	b = (block_header_t *) (b -> ptr.buffer + 
			        TLSF_WORDS2BYTES (GET_BLOCK_SIZE(b)));
    }
    if (!(__u32 *) *ptr_following) 
      end2 = 1;
    else {
      ptr_following = (__u32 *) *ptr_following;
    }    
  }
}

/*
 * free_blocks_status () only shows the status
 * of the free blocks
 */
void free_blocks_status (char *block_ptr){
  int i, j;
  block_header_t *b;

  TLSF_t *ptr_TLSF;
  
  ptr_TLSF = (TLSF_t *) block_ptr; 
  if (!ptr_TLSF || ptr_TLSF -> magic_number != MAGIC_NUMBER) {
    PRINT_MSG 
      ("free_blocks_status() error: TLSF structure is not initialized\n");
    PRINT_MSG 
      ("Hint: Execute init_memory_pool() before calling free_blocks_status()");

    return;
  }

  PRINT_DBG_C ("\nTLSF structure address 0x");
  PRINT_DBG_H (ptr_TLSF);
  PRINT_DBG_C ("\nFREE BLOCKS\n\n");
  for (i = ptr_TLSF -> max_fl_index  - 1 - MIN_LOG2_SIZE; i >= 0; i--) {
    if (ptr_TLSF -> fl_array [i].bitmapSL > 0)
      for (j = ptr_TLSF -> max_sl_index - 1; j >= 0; j--) {
        if (ptr_TLSF -> fl_array [i].sl_array[j]) {
          b = ptr_TLSF -> fl_array [i].sl_array [j];
          PRINT_DBG_C ("[");
          PRINT_DBG_D (i + MIN_LOG2_SIZE);
          PRINT_DBG_C ("] ");
          PRINT_DBG_D (TLSF_WORDS2BYTES(1 << (i + MIN_LOG2_SIZE)));
	  PRINT_DBG_C (" bytes -> Free blocks: 0x");
	  PRINT_DBG_H (ptr_TLSF -> fl_array [i].bitmapSL);
          PRINT_DBG_C ("\n");
	  
          while (b) {
	    PRINT_DBG_C (">>>> First_Level [");
	    PRINT_DBG_D (i + MIN_LOG2_SIZE);
	    PRINT_DBG_C ("] Second Level [");
	    PRINT_DBG_D (j);
	    PRINT_DBG_C ("] -> ");
	    PRINT_DBG_D (TLSF_WORDS2BYTES((1 << (i + MIN_LOG2_SIZE)) + 
			  ( ((1 << (i + MIN_LOG2_SIZE)) / 
			     ptr_TLSF -> max_sl_index) * j)));

            PRINT_DBG_C (" bytes\n");
            print_block (b);
            b = b -> ptr.free_ptr.next;
          }
        }
      }
  }
}

void dump_memory_region (unsigned char *mem_ptr, unsigned int size) {
  
  unsigned int begin = (unsigned int) mem_ptr;
  unsigned int end = (unsigned int) mem_ptr + size;
  int column = 0;

  begin >>= 2;
  begin <<= 2;
  
  end >>= 2;
  end ++;
  end <<= 2;
  
  PRINT_DBG_C ("\nMemory region dumped: 0x");
  PRINT_DBG_H (begin);
  PRINT_DBG_C (" - ");
  PRINT_DBG_H (end);
  PRINT_DBG_C ("\n\n");
  
  column = 0;
  PRINT_DBG_C ("\t\t+0");
  PRINT_DBG_C ("\t+1");
  PRINT_DBG_C ("\t+2");
  PRINT_DBG_C ("\t+3");
  PRINT_DBG_C ("\t+4");
  PRINT_DBG_C ("\t+5");
  PRINT_DBG_C ("\n0x");
  PRINT_DBG_H (begin);
  PRINT_DBG_C ("\t");

  while (begin < end) {
    if (((unsigned char *) begin) [0] == 0)
      PRINT_DBG_C ("00");
    else
      PRINT_DBG_H (((unsigned char *) begin) [0]);
    if (((unsigned char *) begin) [1] == 0)
      PRINT_DBG_C ("00");
    else
      PRINT_DBG_H (((unsigned char *) begin) [1]);
    PRINT_DBG_C ("\t");
    begin += 2;
    column ++;
    if (column == 6) {
      PRINT_DBG_C ("\n0x");
      PRINT_DBG_H (begin);
      PRINT_DBG_C ("\t");
      column = 0;
    }

  }
  PRINT_DBG_C ("\n\n"); 
}

#endif