Voici un aperçu de ces fonctionnalités :
L'utilisation est extrêmement simple puisqu'il suffit d'inclure le fichier sma.h en dernier et d'utiliser les fonctions préfixées sma_*. Si vous reprennez un projet volumineux afin de le débuguer, il n'ai pas utile de remplacer tous les appels, puisqu'il existe des macro afin de remplacer les appel à malloc et autres par les nouvelles fonctions.
#include <stdio.h> #include <stdlib.h> #include "sma.h" int main (void) { char *p[3] = { NULL }; // Initialisation sma_init (SMA_INFO, NULL); // Allocation p[1] = sma_malloc (10 * sizeof (*p[1])); // Ecriture en dehors de la zone allouée p[1][10] = 1; p[1][-1] = 1; // Réallocation p[1] = sma_realloc (p[1], 20); // Enregistrement d'une allocation externe p[2] = strdup ("sma"); sma_register (p[2]); // Affiche l'état du gestionnaire sma_profil (); // Fuite mémoire p[1]++; // Libération sma_free (p[1]); sma_free (p[2]); return 0; }
Compilation :
gcc `pkg-config --cflags --libs sma` main.c
Et le résultat sur la sortie standard :
===== malloc (10) dans main.c:14 ===== + 10 octects a 003E4EFC ===== realloc 20 dans main.c:20 ===== Warning : Underflow a 003E4EFC[-1] Warning : Overflow a 003E4EFC[10] - 10 octects a 003E4EFC dans main.c:14 + 20 octects dans 003E3EBC ===== Allocation externe dans main.c:24 ===== Enregistrement de 003E3EE0 dans main.c:24 |----------------------------------------------------------------| | Profile memoire | | main.c 27 | |----------------------------------------------------------------| | Taille | Addr | Ligne | Fichier | |----------------------------------------------------------------| | 20 | 003E3EBC | 20 | main.c | | x | 003E3EE0 | 24 | main.c | |----------------------------------------------------------------| ===== free dans main.c:33 ===== Warning : Adresse inconnue 003E3EBD dans main.c:33 ===== free dans main.c:34 ===== Liberation de 003E3EE0 dans main.c:34 enregistre dans main.c:24 ===== Fuites memoire ===== |----------------------------------------------------------------| | Profile memoire | | internal 0 | |----------------------------------------------------------------| | Taille | Addr | Ligne | Fichier | |----------------------------------------------------------------| | 20 | 003E3EBC | 20 | main.c | |----------------------------------------------------------------| ===== free dans internal:0 ===== Liberation de 003E3EBC (20 octects) dans internal:0 alloues dans main.c:20 Warning : Underflow a 003E3EBC[-1]
SMA - Secure Memory Allocator Copyright (C) 2006, 2007, 2008 Nicolas Joseph This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Si la surcharge est demandée, l'utilisateur doit définir une macro afin de vérifier qu'il est au courant de ce qu'il fait
Fichier .pc
Makefile
Macros | |
#define | sma_init(log_level, file_name) |
#define | sma_malloc(size) |
#define | malloc(size) |
#define | sma_calloc(nmemb, size) |
#define | calloc(nmemb, size) |
#define | sma_realloc(ptr, size) |
#define | realloc(ptr, size) |
#define | sma_register(ptr) |
#define | sma_free(ptr) |
#define | free(ptr) |
#define | sma_profil() |
#define | sma_is_register(ptr) |
#define | SMA_FILE__ |
#define | sma_end |
Énumérations | |
enum | debug_level_e { SMA_NONE, SMA_ERROR, SMA_WARNING, SMA_INFO } |
Fonctions | |
void | sma_set_malloc (void *(*foo)(size_t)) |
void | sma_set_calloc (void *(*foo)(size_t, size_t)) |
void | sma_set_realloc (void *(*foo)(void *, size_t)) |
void | sma_set_free (void(*foo)(void *)) |
#define sma_init | ( | log_level, | |||
file_name | ) |
Initialise le gestionnaire de mémoire.
[in] | log_level | : niveau d'information souhaitée. |
[in] | file_name | : chemin du fichier de log, ou NULL les informations seront alors écritent sur stdout. |
#define sma_malloc | ( | size | ) |
Alloue size octets, et renvoie un pointeur sur la mémoire allouée.
[in] | size | : taille de la zone mémoire souhaitée |
#define malloc | ( | size | ) |
#define sma_calloc | ( | nmemb, | |||
size | ) |
Alloue size octets, et renvoie un pointeur sur la mémoire allouée.
[in] | nmemb | : nombre d'objets |
[in] | size | : taille d'un objet |
#define calloc | ( | nmemb, | |||
size | ) |
#define sma_realloc | ( | ptr, | |||
size | ) |
Modifie la taille du bloc de mémoire pointé par ptr pour l'amener à une taille de size octets.
[in] | ptr | : pointeur sur la zone mémoire à modifier. |
[in] | size | : nouvelle taille. |
#define realloc | ( | ptr, | |||
size | ) |
#define sma_register | ( | ptr | ) |
Enregitre un pointeur sur une zone mémoire alloue en dehors du code, par exemple avec strdup.
[in] | ptr | : le pointeur à enregistrer. |
#define sma_free | ( | ptr | ) |
Libère l'espace mémoire pointé par p, qui a été obtenu lors d'un appel antérieur à malloc, calloc ou realloc.
[in] | ptr | : adresse de la zone mémoire à libérer. |
#define free | ( | ptr | ) |
#define sma_profil | ( | ) |
Affiche l'état de la mémoire.
#define sma_is_register | ( | ptr | ) |
Permet de savoir si une adresse est connue du gestionnaire.
[in] | ptr | : adresse a tester. |
#define SMA_FILE__ |
À usage interne uniquement.
#define sma_end |
Termine le gestionnaire de mémoire en vérifiant les fuites mémoire.
enum debug_level_e |
void sma_set_malloc | ( | void *(*)(size_t) | foo | ) |
Modifie la fonction à utiliser pour allouer la mémoire. Par défaut il s'agit de malloc.
[in] | foo | : fonction malloc like. |
void sma_set_calloc | ( | void *(*)(size_t, size_t) | foo | ) |
Modifie la fonction à utiliser pour allouer la mémoire en remplissant la zone allouée à zéro. Par défaut il s'agit de calloc.
[in] | foo | : fonction calloc like. |
void sma_set_realloc | ( | void *(*)(void *, size_t) | foo | ) |
Modifie la fonction à utiliser pour réallouer la mémoire. Par défaut il s'agit de realloc.
[in] | foo | : fonction realloc like. |
void sma_set_free | ( | void(*)(void *) | foo | ) |
Modifie la fonction à utiliser pour libérer la mémoire. Par défaut il s'agit de free.
[in] | foo | : fonction free like. |