Implementing Dynamic Memory Management Functions - c

Question

I tryed to implement dynamic memory managemet functions and succeed. However when I try to implement another function that prints some information about memory with the exact same way, I got segmentation fault. I am using Ubuntu, gcc.
Here is my related code:
In mm_alloc.c: (Other functions malloc, free etc. are also here)
#include "mm_alloc.h"
#include "stdlib.h"
#include "stdio.h"
#include "unistd.h"
#include "string.h"
void mm_print_mem() {
printf( "\nstart_addr\tsize\tfree\tprev\tnext\n");
printf("=============================\n");
printf("HEAD OF LL %p\n", metadata);
METADATA *currentPtr = metadata;
int i = 0;
while (currentPtr!= NULL && i <= 10) {
printf("%p\t%d\t%d\t%p\t%p\n", currentPtr, (int)currentPtr-
>size, currentPtr->free,currentPtr->prev,currentPtr->next);
if (currentPtr->next == NULL) break;
currentPtr = currentPtr->next;
i++;
}
return;
}
mm_alloc.h:
#pragma once
#include <stdlib.h>
typedef struct METADATA{
struct METADATA *next;
struct METADATA *prev;
int free;
size_t size;
}METADATA;
METADATA *metadata;
void *mm_malloc(size_t size);
void *mm_realloc(void *ptr, size_t size);
void mm_free(void *ptr);
void mm_print_mem();
And the test function. Here, I got segmentation fault when I call mm_print_mem function, others work well.
int main() {
load_alloc_functions();
int *dizi = (int *)mm_malloc(5 * sizeof(int));
dizi[4] = 5;
dizi[2] = 10;
printf("%d - %d\n", dizi[4], dizi[2]);
mm_print_mem();
return 0;
}
I use these commands on Ubuntu in order to link files and run the test file.
gcc -c -Wall -Werror -fpic mm_alloc.c
gcc -shared -o libfoo.so 14011085.so
gcc mm_test.c -o try -ldl
./try
Notice that even the inside of mm_print_mem was empty, it gives segmentation fault as well. Where am I doing wrong?

Answer 1

You have at least a problem in the declaration of the global variable metadata. It is declared as METADATA *metadata; in an included file. So it has correctly external linkage, but is defined in every translation unit, when one single definition should exist in a full program. Not doing so is explicitely undefined behaviour, with no diagnostic required.
There are different ways to fix that problem:
declare it extern in the include file
extern METADATA *metadata;
and define it in only one translation unit without the extern specifier:
#include "mm_alloc.h" // extern declaration
...
METADATA * metadata; // single definition in whole program
put all the library functions in one single translation unit (if it makes sense), define metadata in that file and remove any reference to it from the mm_alloc.h file. After all, it is private data for the library...
remove the reference to metadata from the mm_alloc.h include file which should only declare the external interface for the library, define it in one single file of the library (at file level without the extern specifier) and declare it in all other files from the library as extern METADATA *metadata;
Without seeing the source for the other functions I cannot say whether there are other problems...

Answer 2

You make things a bit difficult by not providing a A Minimal, Complete, and Verifiable example, but a short example will help. Without seeing your load and alloc functions, you leave us guessing a bit at exactly where your problem is located or the extent of you problems.
That said a short example illustrating your mm_print_mem(); function should at least get that part straightened out. (note: the example uses a cirular linked list where the last node points to the first and first->prev points to the last. You can adjust the test and assignments for metadata->prev and last->next if you want NULL at both ends)
While you can use #pragma once, you will find greater portability just using traditional header-guards to prevent multiple includes, e.g. #ifndef HEADERNAME, then #define it, e.g.
#ifndef __mm_alloc_h__
#define __mm_alloc_h__ 1
#include <stdlib.h>
typedef struct METADATA {
struct METADATA *next;
struct METADATA *prev;
int free;
size_t size;
} METADATA;
METADATA *metadata;
// void *mm_malloc(size_t size);
// void *mm_realloc(void *ptr, size_t size);
// void mm_free(void *ptr);
void mm_print_mem();
#endif
Your mm_alloc.c is fine, but your loop control was a bit strange with the magic number 10 included as a condition. With the example list, you simply iterate and increment nodes until currentPtr->next (e.g. currentPtr after assignment) is equal to metadata (completing the circle)
#include "mm_alloc.h"
#include <stdio.h>
void mm_print_mem() {
METADATA *currentPtr = metadata;
printf ("\nstart_addr\tsize\tfree\tprev\t\tnext\n"
"=========================================================\n"
"HEAD OF LL %p\n", metadata);
for (;;) {
printf ("%p\t%d\t%d\t%p\t%p\n", currentPtr, (int)currentPtr->size,
currentPtr->free,currentPtr->prev,currentPtr->next);
currentPtr = currentPtr->next;
if (currentPtr == metadata)
break;
}
}
I wrote a simple test program that allocates and fills 20 nodes for you showing the independent handling of the 1st and remaining nodes, e.g,
#include "mm_alloc.h"
#include <stdio.h>
#define MAX 20
int main (void) {
int i;
for (i = 0; i < MAX; i++) {
METADATA *node = malloc (sizeof *node);
if (!node) {
perror ("malloc node");
return 1;
}
node->next = node->prev = NULL;
node->free = MAX - i - 1;
node->size = i;
if (!metadata) { /* 1st node is self-referencing */
node->prev = node; /* in circular linked-list */
node->next = node;
metadata = node;
}
else { /* add rest at end as metadata->prev */
node->prev = metadata->prev;
node->next = metadata;
metadata->prev->next = node;
metadata->prev = node;
}
}
mm_print_mem();
return 0;
}
(note: you should free the node when you are done with them)
Compile Shared Object Library & Test Program
$ gcc -Wall -Werror -fPIC -o mm_alloc.o -c mm_alloc.c
$ gcc -shared -o libmm_alloc.so mm_alloc.o
When compiling the test program, make sure your program can find your shared library. using the linker option -rpath is a good way to specify the location for a custom library if not in the standard library search path locations. (just note it must be in the same place on any system you copy it too)
(line-continuation are used below to allow the compile string to fit)
$ gcc -L"/path/to/your/lib/dir" \
-Wl,-rpath="/path/to/your/lib/dir" \
-Wall -o mm_alloc_tst mm_alloc_tst.c -lmm_alloc
Example Use/Output
$ ./mm_alloc_tst
start_addr size free prev next
=========================================================
HEAD OF LL 0x208d010
0x208d010 0 19 0x208d3a0 0x208d040
0x208d040 1 18 0x208d010 0x208d070
0x208d070 2 17 0x208d040 0x208d0a0
0x208d0a0 3 16 0x208d070 0x208d0d0
0x208d0d0 4 15 0x208d0a0 0x208d100
0x208d100 5 14 0x208d0d0 0x208d130
0x208d130 6 13 0x208d100 0x208d160
0x208d160 7 12 0x208d130 0x208d190
0x208d190 8 11 0x208d160 0x208d1c0
0x208d1c0 9 10 0x208d190 0x208d1f0
0x208d1f0 10 9 0x208d1c0 0x208d220
0x208d220 11 8 0x208d1f0 0x208d250
0x208d250 12 7 0x208d220 0x208d280
0x208d280 13 6 0x208d250 0x208d2b0
0x208d2b0 14 5 0x208d280 0x208d2e0
0x208d2e0 15 4 0x208d2b0 0x208d310
0x208d310 16 3 0x208d2e0 0x208d340
0x208d340 17 2 0x208d310 0x208d370
0x208d370 18 1 0x208d340 0x208d3a0
0x208d3a0 19 0 0x208d370 0x208d010
Look things over and let me know if you have further questions.