malloc_dbg.c File Reference

This file contains malloc_dbg, calloc_dbg, free_dbg and printLeaks implementations. More...

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "malloc_dbg.h"

Include dependency graph for malloc_dbg.c:

Data Structures
struct	MEMORY_INFORMATION
	For the malloc, calloc and free functions. More...

Typedefs
typedef struct MEMORY_INFORMATION	mem_info
	For the malloc, calloc and free functions.

Functions
mem_info *	addMemInfo (mem_info *memoryInfo, void *ptrToReturn, size_t bytes, int line, const char *filename, const char *functionName)
	addMemInfo function add a memory allocation in the memoryInfo list.
int	inList (const char *filename, int line)
	inList function is used to know if an element is already in the memoryInfo list.
void	editInfo (int elemPos, size_t bytes)
	editInfo function is used to edit an element in the memoryInfo list.
void *	malloc_dbg (size_t bytes, int line, const char *filename, const char *functionName)
	malloc_dbg function is a wrapper around the malloc function.
void *	calloc_dbg (size_t elementCount, size_t elementSize, int line, const char *filename, const char *functionName)
	calloc_dbg function is a wrapper around the calloc function.
void	free_dbg (void *ptrToFree)
	free_dbg function is used to free the memory allocated to a pointer.
void	printLeaks ()
	printLeaks function is used to print all the memory leaks.

Variables
mem_info *	memoryInformation = NULL
	We use a global variable for the list so we can use it at any time.
int	atexitCalled = 0
	Another global variable.

Detailed Description

This file contains malloc_dbg, calloc_dbg, free_dbg and printLeaks implementations.

Author

tinouduart33

Typedef Documentation

mem_info

typedef struct MEMORY_INFORMATION mem_info

For the malloc, calloc and free functions.

For IO operations (printf). For the memcmp function. Header file which contains the prototypes of malloc_dbg, calloc_dbg and fre_dbg.

Structure used to save an allocated pointer

Function Documentation

addMemInfo()

mem_info * addMemInfo	(	mem_info *	memoryInfo,
		void *	ptrToReturn,
		size_t	bytes,
		int	line,
		const char *	filename,
		const char *	functionName
	)

addMemInfo function add a memory allocation in the memoryInfo list.

This function creates a new element and add it on top of the list

Parameters

memoryInfo	Pointer to the doubly linked list used to store all of the allocations
ptrToreturn	Pointer returned by malloc or calloc
bytes	Size in bytes of the allocation
line	Line where the allocation has been called
filename	File where the allocation has been called
functionName	Name of the function where the allocation has been called

Returns

mem_info pointer if it succeeds, NULL otherwise

{
    mem_info* newMemInfo = (mem_info*)malloc(sizeof(mem_info));
    if (!newMemInfo)
    {
        return NULL;
    }
 
    newMemInfo->ptr = ptrToReturn;
    newMemInfo->bytes = bytes;
    newMemInfo->line = line;
    newMemInfo->fileName = filename;
    newMemInfo->functionName = functionName;
    newMemInfo->next = memoryInfo;
    newMemInfo->previous = NULL;
    if (memoryInformation)
        memoryInformation->previous = newMemInfo;
 
    return newMemInfo;
}

calloc_dbg()

void * calloc_dbg	(	size_t	elementCount,
		size_t	elementSize,
		int	line,
		const char *	filename,
		const char *	functionName
	)

calloc_dbg function is a wrapper around the calloc function.

This function calls calloc and allocates the number of bytes passed in the parameters. If the allocation succeeds then it add the pointer returned by malloc in the mem_info list.

Parameters

elementCount	number of element to allocate
elementSize	Size of each element
line	Line number in the caller file
filename	Caller file
functionName	Caller function

Returns

Pointer returned by calloc if it's valid, NULL otherwhise.

{
    void* ptrToReturn = calloc(elementCount, elementSize);
    if (!ptrToReturn)
    {
        return NULL;
    }
 
    // We must check atexitCalled value to know if we already called the function
    if (!atexitCalled)
    {
        atexit(printLeaks); // Used to call printLeaks when the program exit
        atexitCalled = 1;
    }
 
    // Add a new element in the mem_info list
    memoryInformation = addMemInfo(memoryInformation, ptrToReturn, elementCount * elementSize, line, filename, functionName);
    if (!memoryInformation)
    {
        free(ptrToReturn);
        return NULL;
    }
 
    return ptrToReturn;
}

Here is the call graph for this function:

editInfo()

void editInfo	(	int	elemPos,
		size_t	bytes
	)

editInfo function is used to edit an element in the memoryInfo list.

This function is used to edit the number of bytes allocated at a specific line.

Parameters

elemPos	Position of an element in the doubly linked list memoryInfo
bytes	Size of the allocation in bytes

Returns

Nothing.

{
    int counter = 0;
    mem_info* tmp = memoryInformation;
 
    while (counter != elemPos)
    {
        tmp = tmp->next;
        counter++;
    }
    tmp->bytes += bytes;
}

free_dbg()

void free_dbg

(

void *

ptrToFree

)

free_dbg function is used to free the memory allocated to a pointer.

This function free the memory pointed by the pointer passed in parameter. To free this pointer, we loop through the mem_info list and check if we find the pointer. Once it's found, the pointer is freed and the element is deleted from the list.

Parameters

ptrToFree

Pointer that must be freed

Returns

Nothing.

{
    mem_info* tmp = memoryInformation;
    mem_info* toFree = NULL;
    mem_info* previous = NULL;
 
    // Check if the head contains the pointer to free
    if (tmp->ptr == ptrToFree)
    {
        toFree = tmp;
        memoryInformation = tmp->next;
        free(toFree->ptr);
        free(toFree);
        if (memoryInformation)
        {
            memoryInformation->previous = NULL;
        }
        return;
    }
 
    // We can loop through the list without any problems, the head is not the pointer
    while (tmp)
    {
        if (tmp->ptr == ptrToFree) // If we found the pointer that must be freed
        {
            toFree = tmp;
            tmp = tmp->next;
            previous = toFree->previous;
 
            if (previous)
            {
                previous->next = tmp;
            }
            if (tmp)
            {
                tmp->previous = previous;
            }
 
            free(toFree->ptr);
            if (toFree == memoryInformation)
            {
                memoryInformation = NULL;
            }
            free(toFree);
            return;
        }
        tmp = tmp->next;
    }
}

inList()

int inList	(	const char *	filename,
		int	line
	)

inList function is used to know if an element is already in the memoryInfo list.

This function is used to know if an allocation in a specific file at a specific line already exists in the list.

Parameters

filename	File in which malloc or calloc has been called
line	Line number in the file in which malloc or calloc has been called

Returns

Position of the element in the list if the element is found, -1 otherwise.

{
    mem_info* tmp = memoryInformation;
    int counter = 0;
    int len = strlen(filename);
 
    while (tmp)
    {
        if (len == strlen(tmp->fileName))
        {
            if (!memcmp(filename, tmp->fileName, len) && tmp->line == line)
            {
                return counter;
            }
        }
        tmp = tmp->next;
        counter++;
    }
    return -1;
}

malloc_dbg()

void * malloc_dbg	(	size_t	bytes,
		int	line,
		const char *	filename,
		const char *	functionName
	)

malloc_dbg function is a wrapper around the malloc function.

This function calls malloc and allocates the number of bytes passed in the parameters. If the allocation succeeds then it add the pointer returned by malloc in the mem_info list.

Parameters

bytes	Size of the allocation in bytes
filename	Caller file
functionName	Caller function

Returns

Pointer returned by malloc if it's valid, NULL otherwhise.

{
    void* ptrToReturn = malloc(bytes);
    int pos = 0;
    if (!ptrToReturn)
    {
        return NULL;
    }
 
    // We must check atexitCalled value to know if we already called the function
    if (!atexitCalled)
    {
        atexit(printLeaks); // Used to call printLeaks when the program exit
        atexitCalled = 1;
    }
 
    pos = inList(filename, line);
    if (pos == -1)
    {
        // Add a new element in the mem_info list
        memoryInformation = addMemInfo(memoryInformation, ptrToReturn, bytes, line, filename, functionName);
        if (!memoryInformation)
        {
            free(ptrToReturn);
            return NULL;
        }
    }
    else
    {
        editInfo(pos, bytes);
    }
    return ptrToReturn;
}

Here is the call graph for this function:

printLeaks()

void printLeaks

(

void

)

printLeaks function is used to print all the memory leaks.

This function is called when the program exits. It loop through the mem_info list and if it's not empty, it prints the memory leaks.

Returns

Nothing.

{
    mem_info* tmp = memoryInformation;
    mem_info* previous = NULL;
    size_t sum = 0;
    int nbBlocks = 0;
 
    if (tmp)
    {
        printf("Memory Leaks detected.\n");
    }
 
    while (tmp)
    {
        previous = tmp;
        printf("\n%ld bytes lost\n", tmp->bytes);
        printf("address : 0x%p in %s\t%s:%d\n", tmp->ptr, tmp->functionName, tmp->fileName, tmp->line);
        printf("\n====================================\n");
        sum += tmp->bytes;
        tmp = tmp->next;
        free(previous);
        nbBlocks++;
    }
 
    printf("SUMMARY :\n%ld bytes lost in %d blocks\n", sum, nbBlocks);
}

Variable Documentation

atexitCalled

int atexitCalled = 0

Another global variable.

This one is used to know if we already call the atexit function.