fixed size memory allocator interface without fragmentation on freeing the memory
Thoughts as I read through your post:


  On returning the memory there is no risk of memory fragmentation


I'm not sure what you mean.  Do you mean that all the memory will be free i.e. not leaked?  I don't see anything related to memory fragmentation.



char arr[4];


I don't know your use case, but 4 bytes is very small for a modern computer.  You could easily spend 100 times longer dereferencing a pointer than reading 4 bytes.  Are you sure a linked list is the right choice here?



struct mem_struct *head=NULL;


If someone else makes a global variable named head in another .c file, then you will get a linker error because of duplicate symbols.  If you have to use a global variable, you should name it something distinctive like

struct mem_struct *global_mem_struct_head=NULL;


But a better idea is not to use a global variable at all, and pass a mem_struct* argument to each function.



//max no. of fixed size memory blocks initialized at once in a pool
#define total 10


How about this:

static const int max_init_memory_blocks = 10;


Now you effectively get the comment every time you use the variable, you get type checking, and even though this is a global, it's invisible outside of this translation unit/this file.

That said, you've done a good job adding comments throughout your code.



int mem_pool_init()


This function does initialization a fixed number of times.  Can you use a for loop?



calloc


If calloc succeeds and then fails, you'll leak the first allocations.



void* mem_grant


Why does this return void*?!  How is the user supposed to know they can only use the first few bytes?!



   while(total_pool_size &lt; siz)   //insufficient memory in pool
       if(mem_pool_init())
          return NULL;


Isn't this an infinite loop?



I'm going to stop here.  I think you would find a lot of these mistakes with some very simple test cases.  Then you can post an improved version.