Edge cases for simulated malloc function
Not sure if it's just a result from copy-and-pasting the code here but the code formatting needs improvement.


Inconsistent indentation
Inconsistent use of spaces
Random empty lines


Clearly formatted code is a lot easier to read, maintain and is less prone to contain bugs.
Naming is inconsistent as well, e.g. allocated_list vs freelist vs tempBlock.
There is no need to place braces around the return value like this: return(0);. It should simply be return 0;. return is not a function call.
In order to append blocks to the end of each of the lists you currently iterate to find the end. It would pay off to keep a tail pointer pointing to the last element of each of the lists which avoids that.
I think there is a bug when calling sfree on the last block allocated. Example:


First call to smalloc allocates a new struct block and assigns it to allocated_list

This means allocated_list-&gt;next == NULL.

Call to sfree

cur points to allocated_list
cur != NULL
But cur-&gt;next-&gt;addr is invalid because cur-&gt;next == NULL


I think the cleaning up is technically broken. When initializing the structure you perform a single call to mmap to obtain a set of mapped memory pages. However on clean up you munmap every single block allocated by the user of smalloc. As per munmap man page:


  The implementation  will require that addr be a multiple of the page size {PAGESIZE}. 


This can't be guaranteed because the passed in addr is not aligned at all as it is purely dependent on what was allocated by the user.

However I suspect it "simply works" because the first call to munmap unmaps the entire space mapped in originally with mmap because that's what the first addr of freelist is. Nevertheless the implementation is incorrect and works by pure coincidence.
You should check the return values of malloc and munmap as well.
Multiple calls to mem_init will leak memory. While it would certainly count as user error detecting this and notifying the user is good defensive programming.