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

#ifndef _SANITY_CHECK_H_
#define _SANITY_CHECK_H_

#ifdef SANITY_CHECK

#ifdef SANITY_CHECK
extern char *START_MB, *END_MB;
#endif


static inline int
check_range_ptr (char *ptr_TLSF, char *msg)
{
    if ((char *) ptr_TLSF < START_MB || (char *) ptr_TLSF > END_MB) {
	SANITY_PRINTF ("SANITY_CHECK error (ptr is out of range): %s\n", msg);
	return 1;
    }
    return 0;
}

static inline int
check_fl_sl (int fl, int sl, TLSF_t * ptr_TLSF, char *msg)
{
    if (fl < 0 || fl > ptr_TLSF->max_fl_index ||
	sl < 0 || sl > ptr_TLSF->max_sl_index) {
	SANITY_PRINTF ("SANITY_CHECK error ([fl] %d [sl] %d): %s\n", fl, sl,
		       msg);
	return 1;
    }
    return 0;
}

static inline int
check_fl_sl_2 (int fl, int sl, TLSF_t * ptr_TLSF, char *msg)
{
    if (fl < 0 || fl > ptr_TLSF->max_fl_index - MIN_LOG2_SIZE ||
	sl < 0 || sl > ptr_TLSF->max_sl_index) {
	SANITY_PRINTF ("SANITY_CHECK error ([fl] %d [sl] %d): %s\n", fl, sl,
		       msg);
	return 1;
    }
    return 0;
}

static inline int
check_mn (block_header_t * bh, char *msg)
{
    if (bh->mw != MAGIC_NUMBER) {
	SANITY_PRINTF ("SANITY_CHECK error (corrupted block): %s\n", msg);
	return 1;
    }
    return 0;
}

static inline int
check_range_bh (block_header_t * bh, char *msg)
{
    if ((char *) bh < START_MB || (char *) bh > END_MB) {
	SANITY_PRINTF ("SANITY_CHECK error (bh is out of range): %s\n", msg);
	SANITY_PRINTF ("S_C range: [0x%x - 0x%x] block 0x%x\n",
		       (int) START_MB, (int) END_MB, (int) bh);
	return 1;
    }

    if (((char *) bh) + TLSF_WORDS2BYTES (GET_BLOCK_SIZE (bh)) < START_MB ||
	((char *) bh) + TLSF_WORDS2BYTES (GET_BLOCK_SIZE (bh)) > END_MB) {
	SANITY_PRINTF ("S_C block size %d\n", GET_BLOCK_SIZE (bh));
	return 1;
    }
    return 0;
}

static inline int
checking_structure (TLSF_t * ptr, char *msg)
{
    int i, j;
    block_header_t *b;
    __u32 *ptr_following;
    int end;
    if (check_range_ptr ((char *) ptr, "checking structure\n")) {
	SANITY_PRINTF ("%s\n", msg);
	return 1;
    }
    for (i = 0; i < ptr->max_fl_index - MIN_LOG2_SIZE; i++)
	for (j = 0; j < ptr->max_sl_index; j++) {
	    if (check_range_ptr ((char *) ptr->fl_array[i].sl_array,
				 "checking_structure")) {
		SANITY_PRINTF ("%s\n", msg);
		return 1;
	    }
	    if (ptr->fl_array[i].sl_array[j] != NULL) {
		b = ptr->fl_array[i].sl_array[j];
		// First we check free blocks
		while (b != NULL) {
		    if (check_range_bh (b, "checking free blocks") ||
			check_mn (b, "checking free blocks")) {
			SANITY_PRINTF ("%s\n", msg);
			return 1;
		    }
		    b = b->ptr.free_ptr.next;
		}
	    }
	}

    // OK, now are checked physical contigous blocks
    ptr_following = ptr->following_non_cont_bh;
    b = (block_header_t *) (ptr_following + sizeof (__u32 *));
    end = 0;
    while (!end) {
	if (check_range_bh (b, "checking phys-cont blocks") ||
	    check_mn (b, "checking phys-cont blocks")) {
	    SANITY_PRINTF ("%s\n", msg);
	    return 1;
	}
	if (IS_LAST_BLOCK (b))
	    end = 1;
	else
	    b = (block_header_t *) (b->ptr.buffer +
				    TLSF_WORDS2BYTES (GET_BLOCK_SIZE (b)));
    }
    return 0;
}

#endif
#endif