From fd1c0872a4f83377de8c4b3e60e306e9170f87f8 Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Tue, 4 Nov 2025 15:27:56 +0100
Subject: [PATCH 01/13] '

---
 alignment/alignment.c | 10 ++++++++++
 alignment/alignment.h | 10 ++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 alignment/alignment.c
 create mode 100644 alignment/alignment.h

diff --git a/alignment/alignment.c b/alignment/alignment.c
new file mode 100644
index 0000000..72a063c
--- /dev/null
+++ b/alignment/alignment.c
@@ -0,0 +1,10 @@
+#include "alignment.h"
+
+size_t align(size_t size)
+{
+    size_t res;
+    if (__builtin_add_overflow(size, 8 - (size % 8), &res))
+        return 0;
+
+    return res;
+}
diff --git a/alignment/alignment.h b/alignment/alignment.h
new file mode 100644
index 0000000..582ce8d
--- /dev/null
+++ b/alignment/alignment.h
@@ -0,0 +1,10 @@
+#ifndef ALIGNMENT_H
+#define ALIGNMENT_H
+
+#define _GNU_SOURCE
+
+#include <stddef.h>
+
+size_t align(size_t size);
+
+#endif /* !ALIGNMENT_H */

From 1e895ef74a9759934413508aa04c726fdf186367 Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Tue, 4 Nov 2025 15:31:31 +0100
Subject: [PATCH 02/13] '

---
 alignment/alignment.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/alignment/alignment.c b/alignment/alignment.c
index 72a063c..e9332e5 100644
--- a/alignment/alignment.c
+++ b/alignment/alignment.c
@@ -3,7 +3,8 @@
 size_t align(size_t size)
 {
     size_t res;
-    if (__builtin_add_overflow(size, 8 - (size % 8), &res))
+    if (__builtin_add_overflow(
+            size, sizeof(long double) - (size % sizeof(long double)), &res))
         return 0;
 
     return res;

From ac1b94ebc1cfb881c137901683b08893d236b32f Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Tue, 4 Nov 2025 15:57:00 +0100
Subject: [PATCH 03/13] '

---
 .gitignore                   |   6 ++++++
 malloc/Makefile              |  18 ++++++++++++++++++
 malloc/src/malloc.c          |  19 +++++++++++++++++++
 malloc/tests/corruptionproof | Bin 0 -> 16632 bytes
 malloc/tests/memoryfootprint | Bin 0 -> 18064 bytes
 malloc/tests/speed           | Bin 0 -> 17280 bytes
 6 files changed, 43 insertions(+)
 create mode 100644 malloc/Makefile
 create mode 100644 malloc/src/malloc.c
 create mode 100755 malloc/tests/corruptionproof
 create mode 100755 malloc/tests/memoryfootprint
 create mode 100755 malloc/tests/speed

diff --git a/.gitignore b/.gitignore
index 7d45161..e8bcbb7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,9 @@
 a.out
+*~
+*.swp
 *.o
 *.a
+*.so
+*.class
+*.log
+*.core
diff --git a/malloc/Makefile b/malloc/Makefile
new file mode 100644
index 0000000..65f356b
--- /dev/null
+++ b/malloc/Makefile
@@ -0,0 +1,18 @@
+CC=gcc
+CFLAGS=
+LDFLAGS=
+
+SRCS=
+OBJS=${SRC:.c=.o}
+TARGET=libmalloc.so
+
+library: $(OBJS)
+	$(CC) -shared -o $(TARGET) $^
+
+debug:
+
+check:
+
+clean:
+	$(RM) *.o
+	$(RM) $(TARGET)
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
new file mode 100644
index 0000000..8b99ad9
--- /dev/null
+++ b/malloc/src/malloc.c
@@ -0,0 +1,19 @@
+#include <stddef.h>
+
+__attribute__((visibility("default"))) void *malloc(size_t size)
+{
+    return NULL;
+}
+
+__attribute__((visibility("default"))) void free(void *ptr)
+{}
+
+__attribute__((visibility("default"))) void *realloc(void *ptr, size_t size)
+{
+    return NULL;
+}
+
+__attribute__((visibility("default"))) void *calloc(size_t nmemb, size_t size)
+{
+    return NULL;
+}
diff --git a/malloc/tests/corruptionproof b/malloc/tests/corruptionproof
new file mode 100755
index 0000000000000000000000000000000000000000..26ebc81739cce73f44f543c2a26a2c17d6ebd564
GIT binary patch
literal 16632
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

literal 0
HcmV?d00001

diff --git a/malloc/tests/memoryfootprint b/malloc/tests/memoryfootprint
new file mode 100755
index 0000000000000000000000000000000000000000..1718375bbfa45852028af52036b9ee97d1651036
GIT binary patch
literal 18064
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

literal 0
HcmV?d00001

diff --git a/malloc/tests/speed b/malloc/tests/speed
new file mode 100755
index 0000000000000000000000000000000000000000..a1026c800bfa6503f70654b09ab54ae5a8588a4a
GIT binary patch
literal 17280
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

literal 0
HcmV?d00001


From 7629201717eb056823924eda00e291857026191f Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Tue, 4 Nov 2025 19:13:31 +0100
Subject: [PATCH 04/13] '

---
 malloc/Makefile              | 10 ++++++----
 malloc/src/helpers/helpers.c |  4 ++++
 malloc/src/helpers/helpers.h |  8 ++++++++
 malloc/src/malloc.c          |  3 ++-
 4 files changed, 20 insertions(+), 5 deletions(-)
 create mode 100644 malloc/src/helpers/helpers.c
 create mode 100644 malloc/src/helpers/helpers.h

diff --git a/malloc/Makefile b/malloc/Makefile
index 65f356b..6334b0d 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -1,15 +1,17 @@
 CC=gcc
-CFLAGS=
-LDFLAGS=
+CFLAGS=-std=c99 -pedantic -Werror -Wall -Wextra -Wvla -fvisibility=hidden -fPIC
+CPPFLAGS=D_DEFAULT_SOURCE
+LDFLAGS= -shared -Wl --no-undefined
 
 SRCS=
 OBJS=${SRC:.c=.o}
 TARGET=libmalloc.so
 
 library: $(OBJS)
-	$(CC) -shared -o $(TARGET) $^
+	$(CC) -o $(TARGET) $^
 
-debug:
+debug: $(OBJS) $(TST_OBJS)
+	$(CC) -o $(TST_TARGET) $^
 
 check:
 
diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
new file mode 100644
index 0000000..bba1bc1
--- /dev/null
+++ b/malloc/src/helpers/helpers.c
@@ -0,0 +1,4 @@
+#include "helpers.h"
+
+size_t get_next_2power(size_t n)
+{}
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
new file mode 100644
index 0000000..4d5b403
--- /dev/null
+++ b/malloc/src/helpers/helpers.h
@@ -0,0 +1,8 @@
+#ifndef HELPERS_H
+#define HELPERS_H
+
+#include <stddef.h>
+
+size_t get_next_2power(size_t n);
+
+#endif // ! HELPERS_H
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index 8b99ad9..26e8ab1 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -2,7 +2,8 @@
 
 __attribute__((visibility("default"))) void *malloc(size_t size)
 {
-    return NULL;
+    if (size == 0)
+        return NULL;
 }
 
 __attribute__((visibility("default"))) void free(void *ptr)

From ed8a843d3d34c3a7d7158521163032637b28d7d7 Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Wed, 5 Nov 2025 21:22:34 +0100
Subject: [PATCH 05/13] '

---
 malloc/src/helpers/helpers.c | 61 ++++++++++++++++++++++++++++++++++--
 malloc/src/helpers/helpers.h | 10 ++++++
 2 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index bba1bc1..52db459 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -1,4 +1,61 @@
 #include "helpers.h"
 
-size_t get_next_2power(size_t n)
-{}
+#include <sys/mman.h>
+
+// Returns the smallest power of 2 greater or equal to s
+size_t s2p(size_t s)
+{
+    // Trick I found on the internet but I don't completely understand it
+    // Quite amazing
+    // n--;           // 1101 1101 --> 1101 1100
+    // n |= n >> 1;   // 1101 1100 | 0110 1110 = 1111 1110
+    // n |= n >> 2;   // 1111 1110 | 0011 1111 = 1111 1111
+    // n |= n >> 4;   // ...
+    // n |= n >> 8;
+    // n |= n >> 16;  // 1111 1111 | 1111 1111 = 1111 1111
+    // n++;           // 1111 1111 --> 1 0000 0000
+
+    // There is also an x86 assembly instruction to do that in a single cycle:
+    // lzcnt
+    // Yeah... This one is definetely wild intel
+    // Now since asm{} is prohibited in the coding style it won't be useful
+    // Or maybe there is a builtin to do that ?
+    // (found __builtin_clzll but not sure of what it does)
+
+    // So here's the good old way
+    size_t n = 1;
+    while (n < s)
+    {
+        n <<= 1;
+    }
+
+    return n;
+}
+
+void *find_free_block(struct bucket *buck)
+{
+    unsigned maplength = buck->block_size / 8;
+    // for each block
+    for (unsigned i = 0; i < maplength; i++)
+    {
+        unsigned char map_byte = buck->free_list[i];
+        unsigned char bit = 1;
+        // Test byte
+        for (unsigned j = 0; j < 8; j <<= 1)
+        {
+            if (map_byte & bit) // Test if free
+                return buck->page + (buck->block_size * (i * 8 + j));
+
+            bit <<= 1;
+        }
+    }
+
+    return NULL;
+}
+
+struct bucket *create_bucket(size_t min_alloc_size)
+{
+    size_t alloc_size = s2p(min_alloc_size);
+    void *page =
+        mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0);
+}
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
index 4d5b403..51477f5 100644
--- a/malloc/src/helpers/helpers.h
+++ b/malloc/src/helpers/helpers.h
@@ -3,6 +3,16 @@
 
 #include <stddef.h>
 
+struct bucket
+{
+    unsigned block_size;
+    unsigned char free_list[64]; // 4096 / MIN_BLOCK_SIZE /
+                                 // sizeof(unsigned char) (in bits)
+    char *page;
+};
+
 size_t get_next_2power(size_t n);
+void *find_free_block(struct bucket *buck);
+struct bucket *create_bucket(size_t min_alloc_size);
 
 #endif // ! HELPERS_H

From 5aba0ff0c34fcd9a8fb91f78ee3587a23e6f8a9f Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Thu, 6 Nov 2025 19:56:55 +0100
Subject: [PATCH 06/13] backup

---
 malloc/src/helpers/helpers.c | 25 +++++++++++++++++++++++++
 malloc/src/helpers/helpers.h | 16 ++++++++++++++--
 malloc/src/malloc.c          | 11 +++++++++++
 3 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index 52db459..928234e 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -1,5 +1,6 @@
 #include "helpers.h"
 
+#include <string.h>
 #include <sys/mman.h>
 
 // Returns the smallest power of 2 greater or equal to s
@@ -55,7 +56,31 @@ void *find_free_block(struct bucket *buck)
 
 struct bucket *create_bucket(size_t min_alloc_size)
 {
+    // Round up
     size_t alloc_size = s2p(min_alloc_size);
+    // Get page
     void *page =
         mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0);
+
+    if (page == NULL)
+        return NULL;
+
+    // Init bucket
+    struct bucket *header = page;
+    header->page = page + sizeof(struct bucket);
+    header->block_size = alloc_size;
+    memset(header->free_list, 0, FREE_LIST_SIZE);
+
+    return header;
+}
+
+struct bucket *get_free_bucket(struct bucket *head, size_t size)
+{
+    while (head != NULL)
+    {
+        if (head->block_size >= size)
+            return head;
+    }
+
+    return NULL;
 }
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
index 51477f5..c6c622c 100644
--- a/malloc/src/helpers/helpers.h
+++ b/malloc/src/helpers/helpers.h
@@ -1,18 +1,30 @@
 #ifndef HELPERS_H
 #define HELPERS_H
 
+// #define PAGE_SIZE (size_t) sysconf(_SC_PAGE_SIZE)
+#define PAGE_SIZE 4096
+#define MIN_BLOCK_SIZE 8
+#define FREE_LIST_SIZE PAGE_SIZE / MIN_BLOCK_SIZE / sizeof(unsigned char)
+
 #include <stddef.h>
 
+// Header
+// Contains all informations about the concerned bucket
 struct bucket
 {
     unsigned block_size;
-    unsigned char free_list[64]; // 4096 / MIN_BLOCK_SIZE /
-                                 // sizeof(unsigned char) (in bits)
+    unsigned char free_list[FREE_LIST_SIZE]; // 4096 / MIN_BLOCK_SIZE /
+                                             // sizeof(unsigned char)
     char *page;
+    
+    struct bucket *next;
+
+    size_t checksum;
 };
 
 size_t get_next_2power(size_t n);
 void *find_free_block(struct bucket *buck);
 struct bucket *create_bucket(size_t min_alloc_size);
+struct bucket *get_free_bucket(struct bucket *head, size_t size);
 
 #endif // ! HELPERS_H
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index 26e8ab1..4419fdb 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -1,9 +1,20 @@
 #include <stddef.h>
 
+#include "helpers/helpers.h"
+
+struct bucket *head = NULL;
+
 __attribute__((visibility("default"))) void *malloc(size_t size)
 {
     if (size == 0)
         return NULL;
+
+    struct bucket *buck = get_free_bucket(head, size);
+    if (buck == NULL)
+    {
+        buck = create_bucket(size);
+        return ...;
+    }
 }
 
 __attribute__((visibility("default"))) void free(void *ptr)

From 06fac933c21d0cec60b977846b4bdf94c84e13c7 Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Thu, 6 Nov 2025 22:14:56 +0100
Subject: [PATCH 07/13] tuez-moi

---
 malloc/src/helpers/helpers.c | 36 +++++++++++++++++++++++++++++++++---
 malloc/src/helpers/helpers.h | 11 ++++++-----
 malloc/src/malloc.c          | 26 +++++++++++++++++++++-----
 3 files changed, 60 insertions(+), 13 deletions(-)

diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index 928234e..df0e7fa 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -45,7 +45,7 @@ void *find_free_block(struct bucket *buck)
         for (unsigned j = 0; j < 8; j <<= 1)
         {
             if (map_byte & bit) // Test if free
-                return buck->page + (buck->block_size * (i * 8 + j));
+                return get_data_begin(buck) + (buck->block_size * (i * 8 + j));
 
             bit <<= 1;
         }
@@ -67,14 +67,15 @@ struct bucket *create_bucket(size_t min_alloc_size)
 
     // Init bucket
     struct bucket *header = page;
-    header->page = page + sizeof(struct bucket);
     header->block_size = alloc_size;
     memset(header->free_list, 0, FREE_LIST_SIZE);
 
     return header;
 }
 
-struct bucket *get_free_bucket(struct bucket *head, size_t size)
+// Gets a bucket with at least a block_size of size
+// Returns NULL if nothing was found
+struct bucket *get_bucket(struct bucket *head, size_t size)
 {
     while (head != NULL)
     {
@@ -84,3 +85,32 @@ struct bucket *get_free_bucket(struct bucket *head, size_t size)
 
     return NULL;
 }
+
+void *get_data_begin(struct bucket *biquette)
+{
+    // TODO alignment
+    return biquette + sizeof(struct bucket);
+}
+
+void *get_page_begin(void *ptr)
+{
+    size_t quelenfer = ((size_t)ptr) & ~(PAGE_SIZE - 1);
+    char *pointeur_alacon = NULL;
+    return pointeur_alacon + quelenfer;
+}
+
+void bucket_append(struct bucket **head, struct bucket *elt)
+{
+    struct bucket *list_elt = *head;
+    if (list_elt == NULL)
+    {
+        *head = elt;
+        return;
+    }
+
+    while (list_elt->next != NULL)
+    {
+        list_elt = list_elt->next;
+    }
+    list_elt->next = elt;
+}
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
index c6c622c..217f7e9 100644
--- a/malloc/src/helpers/helpers.h
+++ b/malloc/src/helpers/helpers.h
@@ -14,17 +14,18 @@ struct bucket
 {
     unsigned block_size;
     unsigned char free_list[FREE_LIST_SIZE]; // 4096 / MIN_BLOCK_SIZE /
-                                             // sizeof(unsigned char)
-    char *page;
-    
+                                             // sizeof(unsigned char)    
     struct bucket *next;
 
     size_t checksum;
 };
 
-size_t get_next_2power(size_t n);
+size_t s2p(size_t n);
 void *find_free_block(struct bucket *buck);
 struct bucket *create_bucket(size_t min_alloc_size);
-struct bucket *get_free_bucket(struct bucket *head, size_t size);
+struct bucket *get_bucket(struct bucket *head, size_t size);
+void *get_data_begin(struct bucket *biquette);
+void *get_page_begin(void *ptr);
+void bucket_append(struct bucket **head, struct bucket *elt);
 
 #endif // ! HELPERS_H
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index 4419fdb..3f19f56 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -9,16 +9,32 @@ __attribute__((visibility("default"))) void *malloc(size_t size)
     if (size == 0)
         return NULL;
 
-    struct bucket *buck = get_free_bucket(head, size);
-    if (buck == NULL)
+    // Find adequate bucket
+    struct bucket *buck = get_bucket(head, size);
+    while (buck != NULL)
     {
-        buck = create_bucket(size);
-        return ...;
+        // Find adequate block
+        void *block = find_free_block(buck);
+        if (block != NULL)
+            return block;
+        else
+        {
+            // No free space -> loop
+            buck = get_bucket(buck->next, size);
+            continue;
+        }
     }
+
+    buck = create_bucket(size);
+    bucket_append(&head, buck);
+    return get_data_begin(buck);
 }
 
 __attribute__((visibility("default"))) void free(void *ptr)
-{}
+{
+    if (ptr == NULL)
+        return;
+}
 
 __attribute__((visibility("default"))) void *realloc(void *ptr, size_t size)
 {

From b4f942f678dc63a433ef2f2b774b8429a0d54e71 Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Fri, 7 Nov 2025 20:29:21 +0100
Subject: [PATCH 08/13] backup

---
 malloc/Makefile               |  6 +--
 malloc/src/helpers/allocate.c | 70 +++++++++++++++++++++++++++++++++++
 malloc/src/helpers/allocate.h | 13 +++++++
 malloc/src/helpers/helpers.c  | 68 +++++++++++++++++++++++-----------
 malloc/src/helpers/helpers.h  | 19 ++++++----
 malloc/src/malloc.c           | 35 +++++++++++++++---
 6 files changed, 174 insertions(+), 37 deletions(-)
 create mode 100644 malloc/src/helpers/allocate.c
 create mode 100644 malloc/src/helpers/allocate.h

diff --git a/malloc/Makefile b/malloc/Makefile
index 6334b0d..2ee592b 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -1,10 +1,10 @@
 CC=gcc
 CFLAGS=-std=c99 -pedantic -Werror -Wall -Wextra -Wvla -fvisibility=hidden -fPIC
-CPPFLAGS=D_DEFAULT_SOURCE
+CPPFLAGS= -D_DEFAULT_SOURCE
 LDFLAGS= -shared -Wl --no-undefined
 
-SRCS=
-OBJS=${SRC:.c=.o}
+SRCS=src/malloc.c src/helpers/helpers.c src/helpers/allocate.c
+OBJS=${SRCS:.c=.o}
 TARGET=libmalloc.so
 
 library: $(OBJS)
diff --git a/malloc/src/helpers/allocate.c b/malloc/src/helpers/allocate.c
new file mode 100644
index 0000000..9c8739f
--- /dev/null
+++ b/malloc/src/helpers/allocate.c
@@ -0,0 +1,70 @@
+#include "allocate.h"
+
+#include <string.h>
+#include <sys/mman.h>
+
+#include "helpers.h"
+
+void *allocate_block(struct bucket *biquette, int block_number)
+{
+    if (block_number == -1)
+        return NULL;
+
+    // Update header
+    unsigned char byte_mask = 1 << ((block_number % 8) - 1);
+    biquette->alloc_blk_cnt++;
+    biquette->free_map[block_number / 8] &= byte_mask;
+
+    // Compute block address
+    return get_block(biquette, block_number);
+}
+
+struct bucket *create_bucket(size_t min_alloc_size)
+{
+    // Round up
+    size_t alloc_size;
+    if (min_alloc_size > PAGE_SIZE - sizeof(struct bucket))
+        // Huge page
+        alloc_size = min_alloc_size;
+    else
+        // Regular page
+        alloc_size = s2p(min_alloc_size);
+
+    // Get page
+    void *page =
+        mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0);
+
+    if (page == NULL)
+        return NULL;
+
+    // Init bucket
+    struct bucket *header = page;
+    header->block_size = alloc_size;
+    header->alloc_blk_cnt = 0;
+    memset(header->free_map, 0, FREE_LIST_SIZE);
+
+    return header;
+}
+
+void free_block(void *ptr, struct bucket **list)
+{
+    // Compute header location and block number
+    struct bucket *header = get_page_begin(ptr);
+
+    // free in map and update size
+    int block_number; // ...
+    unsigned char byte_mask = 1 << ((block_number % 8) - 1);
+    header->free_map[block_number / 8] &= ~byte_mask;
+
+    // Huge page
+    if (header->block_size > BUCKET_SIZE)
+        // Delete bucket
+        header->alloc_blk_cnt = 0;
+
+    // free bucket if necessary
+    if (header->alloc_blk_cnt == 0)
+    {
+        bucket_list_remove(list, header);
+        munmap(ptr, 1);
+    }
+}
diff --git a/malloc/src/helpers/allocate.h b/malloc/src/helpers/allocate.h
new file mode 100644
index 0000000..3e91a0e
--- /dev/null
+++ b/malloc/src/helpers/allocate.h
@@ -0,0 +1,13 @@
+#ifndef ALLOCATE_H
+#define ALLOCATE_H
+
+#include "helpers.h"
+
+#include <stddef.h>
+
+void *allocate_block(struct bucket *biquette, int block_number);
+struct bucket *create_bucket(size_t min_alloc_size);
+void bucket_append(struct bucket **head, struct bucket *elt);
+void free_block(void *ptr, struct bucket **list);
+
+#endif // ! ALLOCATE_H
diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index df0e7fa..8091eda 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -1,8 +1,5 @@
 #include "helpers.h"
 
-#include <string.h>
-#include <sys/mman.h>
-
 // Returns the smallest power of 2 greater or equal to s
 size_t s2p(size_t s)
 {
@@ -33,44 +30,47 @@ size_t s2p(size_t s)
     return n;
 }
 
-void *find_free_block(struct bucket *buck)
+int find_free_block(struct bucket *buck)
 {
-    unsigned maplength = buck->block_size / 8;
+    unsigned maplength = PAGE_SIZE / buck->block_size / 8;
     // for each block
     for (unsigned i = 0; i < maplength; i++)
     {
-        unsigned char map_byte = buck->free_list[i];
+        unsigned char map_byte = buck->free_map[i];
         unsigned char bit = 1;
         // Test byte
         for (unsigned j = 0; j < 8; j <<= 1)
         {
             if (map_byte & bit) // Test if free
-                return get_data_begin(buck) + (buck->block_size * (i * 8 + j));
+                return i * 8 + j;
 
             bit <<= 1;
         }
     }
 
-    return NULL;
+    return -1;
 }
 
-struct bucket *create_bucket(size_t min_alloc_size)
+void *get_block(struct bucket *biquette, int block_number)
 {
-    // Round up
-    size_t alloc_size = s2p(min_alloc_size);
-    // Get page
-    void *page =
-        mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0);
-
-    if (page == NULL)
+    if (block_number == -1)
         return NULL;
 
-    // Init bucket
-    struct bucket *header = page;
-    header->block_size = alloc_size;
-    memset(header->free_list, 0, FREE_LIST_SIZE);
+    char *data_begin = get_data_begin(biquette);
+    return data_begin + (biquette->block_size * (block_number));
+}
 
-    return header;
+int get_block_number(struct bucket *biquette, void *block)
+{
+    if (block == NULL || biquette == NULL)
+        return -1;
+
+    char *block_nul = block;
+    void *biquetteounette = biquette;
+    char *biquette_cherie = biquetteounette;
+
+    return (block_nul - biquette_cherie - sizeof(struct bucket))
+        / biquette->block_size;
 }
 
 // Gets a bucket with at least a block_size of size
@@ -99,7 +99,7 @@ void *get_page_begin(void *ptr)
     return pointeur_alacon + quelenfer;
 }
 
-void bucket_append(struct bucket **head, struct bucket *elt)
+void bucket_list_append(struct bucket **head, struct bucket *elt)
 {
     struct bucket *list_elt = *head;
     if (list_elt == NULL)
@@ -114,3 +114,27 @@ void bucket_append(struct bucket **head, struct bucket *elt)
     }
     list_elt->next = elt;
 }
+
+// Removes a bucket from the list pointed by head
+void bucket_list_remove(struct bucket **head, struct bucket *elt)
+{
+    struct bucket *list_elt = *head;
+    if (list_elt == NULL)
+        return;
+
+    if (*head == elt)
+    {
+        *head = NULL;
+        return;
+    }
+
+    while (list_elt->next != NULL)
+    {
+        if (list_elt->next == elt)
+        {
+            list_elt->next = list_elt->next->next;
+            return;
+        }
+        list_elt = list_elt->next;
+    }
+}
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
index 217f7e9..ec8bd0b 100644
--- a/malloc/src/helpers/helpers.h
+++ b/malloc/src/helpers/helpers.h
@@ -1,7 +1,7 @@
 #ifndef HELPERS_H
 #define HELPERS_H
 
-// #define PAGE_SIZE (size_t) sysconf(_SC_PAGE_SIZE)
+// #define PAGE_SIZE sysconf(_SC_PAGE_SIZE)
 #define PAGE_SIZE 4096
 #define MIN_BLOCK_SIZE 8
 #define FREE_LIST_SIZE PAGE_SIZE / MIN_BLOCK_SIZE / sizeof(unsigned char)
@@ -13,19 +13,24 @@
 struct bucket
 {
     unsigned block_size;
-    unsigned char free_list[FREE_LIST_SIZE]; // 4096 / MIN_BLOCK_SIZE /
-                                             // sizeof(unsigned char)    
+    unsigned char free_map[FREE_LIST_SIZE]; // Keeps track of allocations   
+                                            // If block_size > MIN_BLOCK_SIZE
+                                            // It will use a consecutive
+                                            // representation
+    unsigned short alloc_blk_cnt; // Counts the number of allocated blocks
     struct bucket *next;
-
     size_t checksum;
 };
 
+#define BUCKET_SIZE PAGE_SIZE - sizeof(struct bucket)
+
 size_t s2p(size_t n);
-void *find_free_block(struct bucket *buck);
-struct bucket *create_bucket(size_t min_alloc_size);
+int find_free_block(struct bucket *buck);
 struct bucket *get_bucket(struct bucket *head, size_t size);
 void *get_data_begin(struct bucket *biquette);
 void *get_page_begin(void *ptr);
-void bucket_append(struct bucket **head, struct bucket *elt);
+void *get_block(struct bucket* biquette, int block_number);
+void bucket_list_append(struct bucket **head, struct bucket *elt);
+void bucket_list_remove(struct bucket **head, struct bucket *elt);
 
 #endif // ! HELPERS_H
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index 3f19f56..dfa093e 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -1,5 +1,7 @@
 #include <stddef.h>
+#include <string.h>
 
+#include "helpers/allocate.h"
 #include "helpers/helpers.h"
 
 struct bucket *head = NULL;
@@ -14,14 +16,13 @@ __attribute__((visibility("default"))) void *malloc(size_t size)
     while (buck != NULL)
     {
         // Find adequate block
-        void *block = find_free_block(buck);
-        if (block != NULL)
-            return block;
+        int block_number = find_free_block(buck);
+        if (block_number != -1)
+            return get_block(buck, block_number);
         else
         {
             // No free space -> loop
             buck = get_bucket(buck->next, size);
-            continue;
         }
     }
 
@@ -34,14 +35,38 @@ __attribute__((visibility("default"))) void free(void *ptr)
 {
     if (ptr == NULL)
         return;
+    free_block(ptr, &head);
 }
 
 __attribute__((visibility("default"))) void *realloc(void *ptr, size_t size)
 {
+    if (size == 0)
+        return NULL;
+    if (ptr == NULL)
+        return malloc(size);
+
+    struct bucket *header = get_page_begin(ptr);
+    if (header == NULL)
+        return NULL; // Shouldn't get here
+
+    if (header->block_size >= size)
+    {
+        return ptr;
+    }
+    else
+    {
+        void *new_ptr = malloc(size);
+        memcpy(new_ptr, ptr, header->block_size);
+        free(ptr);
+        return new_ptr;
+    }
+
     return NULL;
 }
 
 __attribute__((visibility("default"))) void *calloc(size_t nmemb, size_t size)
 {
-    return NULL;
+    char *res = malloc(nmemb * size);
+    memset(res, 0, nmemb * size);
+    return res;
 }

From a531db5e3a10ac9de1fac43710708475e9a3da3d Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Fri, 7 Nov 2025 23:29:21 +0100
Subject: [PATCH 09/13] backup

---
 malloc/Makefile               |  19 ++++++++++++++-----
 malloc/library                | Bin 0 -> 17152 bytes
 malloc/src/helpers/allocate.c |  34 +++++++++++++++++++++++++++-------
 malloc/src/helpers/allocate.h |   4 ++--
 malloc/src/helpers/helpers.c  |  12 +++++++++---
 malloc/src/helpers/helpers.h  |  12 ++++++++----
 malloc/src/malloc.c           |   6 +++---
 malloc/tests/test-cmd.sh      |   3 +++
 malloc/tests/test.c           |  25 +++++++++++++++++++++++++
 9 files changed, 91 insertions(+), 24 deletions(-)
 create mode 100755 malloc/library
 create mode 100755 malloc/tests/test-cmd.sh
 create mode 100644 malloc/tests/test.c

diff --git a/malloc/Makefile b/malloc/Makefile
index 2ee592b..6b16c91 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -1,20 +1,29 @@
 CC=gcc
 CFLAGS=-std=c99 -pedantic -Werror -Wall -Wextra -Wvla -fvisibility=hidden -fPIC
 CPPFLAGS= -D_DEFAULT_SOURCE
-LDFLAGS= -shared -Wl --no-undefined
+LDFLAGS= -shared -Wl,--no-undefined
+LDLIBS=
 
 SRCS=src/malloc.c src/helpers/helpers.c src/helpers/allocate.c
 OBJS=${SRCS:.c=.o}
+TST_OBJS = tests/test.o
 TARGET=libmalloc.so
 
 library: $(OBJS)
-	$(CC) -o $(TARGET) $^
+	$(CC) -o $(TARGET) $^ $(LDFLAGS)
 
-debug: $(OBJS) $(TST_OBJS)
-	$(CC) -o $(TST_TARGET) $^
+debug: CFLAGS += -g
+debug: $(OBJS)
+	$(CC) -o $(TARGET) $^ $(LDFLAGS)
+
+# test: LDLIBS += -lcriterion
+test: CFLAGS = -g -L. -lmalloc -fPIC -fvisibility=hidden
+test: library $(TST_OBJS)
+	$(CC) -o $(TST_TARGET) $^ $(LDLIBS)
 
 check:
+	dash tests/test-cmd.sh
 
 clean:
-	$(RM) *.o
+	$(RM) $(OBJS)
 	$(RM) $(TARGET)
diff --git a/malloc/library b/malloc/library
new file mode 100755
index 0000000000000000000000000000000000000000..9e8ed5c580f8adb3c2cbed4c385678806ead2765
GIT binary patch
literal 17152
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

literal 0
HcmV?d00001

diff --git a/malloc/src/helpers/allocate.c b/malloc/src/helpers/allocate.c
index 9c8739f..9bfef58 100644
--- a/malloc/src/helpers/allocate.c
+++ b/malloc/src/helpers/allocate.c
@@ -4,16 +4,17 @@
 #include <sys/mman.h>
 
 #include "helpers.h"
-
+// c'est dangereux de pas s'i3lock
+// coucou
 void *allocate_block(struct bucket *biquette, int block_number)
 {
     if (block_number == -1)
         return NULL;
 
     // Update header
-    unsigned char byte_mask = 1 << ((block_number % 8) - 1);
+    unsigned char byte_mask = 1 << (8 - 1 - (block_number % 8));
     biquette->alloc_blk_cnt++;
-    biquette->free_map[block_number / 8] &= byte_mask;
+    biquette->free_map[block_number / 8] |= byte_mask;
 
     // Compute block address
     return get_block(biquette, block_number);
@@ -31,8 +32,8 @@ struct bucket *create_bucket(size_t min_alloc_size)
         alloc_size = s2p(min_alloc_size);
 
     // Get page
-    void *page =
-        mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, -1, 0);
+    void *page = mmap(NULL, alloc_size, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
     if (page == NULL)
         return NULL;
@@ -41,6 +42,7 @@ struct bucket *create_bucket(size_t min_alloc_size)
     struct bucket *header = page;
     header->block_size = alloc_size;
     header->alloc_blk_cnt = 0;
+    header->alloc_size = alloc_size;
     memset(header->free_map, 0, FREE_LIST_SIZE);
 
     return header;
@@ -51,8 +53,26 @@ void free_block(void *ptr, struct bucket **list)
     // Compute header location and block number
     struct bucket *header = get_page_begin(ptr);
 
+    // Verify that header belongs to list
+    struct bucket *elt = *list;
+    int found = 0;
+    while (elt != NULL)
+    {
+        if (elt == header)
+        {
+            found = 1;
+            break;
+        }
+        elt = elt->next;
+    }
+    if (!found)
+        return;
+
     // free in map and update size
-    int block_number; // ...
+    int block_number = get_block_number(header, ptr);
+    if (block_number == -1)
+        return;
+
     unsigned char byte_mask = 1 << ((block_number % 8) - 1);
     header->free_map[block_number / 8] &= ~byte_mask;
 
@@ -65,6 +85,6 @@ void free_block(void *ptr, struct bucket **list)
     if (header->alloc_blk_cnt == 0)
     {
         bucket_list_remove(list, header);
-        munmap(ptr, 1);
+        munmap(header, header->alloc_size);
     }
 }
diff --git a/malloc/src/helpers/allocate.h b/malloc/src/helpers/allocate.h
index 3e91a0e..fdb723b 100644
--- a/malloc/src/helpers/allocate.h
+++ b/malloc/src/helpers/allocate.h
@@ -1,10 +1,10 @@
 #ifndef ALLOCATE_H
 #define ALLOCATE_H
 
-#include "helpers.h"
-
 #include <stddef.h>
 
+#include "helpers.h"
+
 void *allocate_block(struct bucket *biquette, int block_number);
 struct bucket *create_bucket(size_t min_alloc_size);
 void bucket_append(struct bucket **head, struct bucket *elt);
diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index 8091eda..8b37f4a 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -21,7 +21,7 @@ size_t s2p(size_t s)
     // (found __builtin_clzll but not sure of what it does)
 
     // So here's the good old way
-    size_t n = 1;
+    size_t n = MIN_BLOCK_SIZE;
     while (n < s)
     {
         n <<= 1;
@@ -41,7 +41,7 @@ int find_free_block(struct bucket *buck)
         // Test byte
         for (unsigned j = 0; j < 8; j <<= 1)
         {
-            if (map_byte & bit) // Test if free
+            if (map_byte ^ bit) // Test if free
                 return i * 8 + j;
 
             bit <<= 1;
@@ -51,6 +51,7 @@ int find_free_block(struct bucket *buck)
     return -1;
 }
 
+// Computes the block address based on its position in the freemap
 void *get_block(struct bucket *biquette, int block_number)
 {
     if (block_number == -1)
@@ -60,6 +61,7 @@ void *get_block(struct bucket *biquette, int block_number)
     return data_begin + (biquette->block_size * (block_number));
 }
 
+// Gets block position in the freemap based on its address
 int get_block_number(struct bucket *biquette, void *block)
 {
     if (block == NULL || biquette == NULL)
@@ -81,17 +83,20 @@ struct bucket *get_bucket(struct bucket *head, size_t size)
     {
         if (head->block_size >= size)
             return head;
+
+        head = head->next;
     }
 
     return NULL;
 }
 
+// Computes the buckets first block address
 void *get_data_begin(struct bucket *biquette)
 {
-    // TODO alignment
     return biquette + sizeof(struct bucket);
 }
 
+// Computes the beginning address of the page containing ptr
 void *get_page_begin(void *ptr)
 {
     size_t quelenfer = ((size_t)ptr) & ~(PAGE_SIZE - 1);
@@ -99,6 +104,7 @@ void *get_page_begin(void *ptr)
     return pointeur_alacon + quelenfer;
 }
 
+// Appends a bucket address to the list pointed by head
 void bucket_list_append(struct bucket **head, struct bucket *elt)
 {
     struct bucket *list_elt = *head;
diff --git a/malloc/src/helpers/helpers.h b/malloc/src/helpers/helpers.h
index ec8bd0b..8c64cfe 100644
--- a/malloc/src/helpers/helpers.h
+++ b/malloc/src/helpers/helpers.h
@@ -3,7 +3,7 @@
 
 // #define PAGE_SIZE sysconf(_SC_PAGE_SIZE)
 #define PAGE_SIZE 4096
-#define MIN_BLOCK_SIZE 8
+#define MIN_BLOCK_SIZE 16
 #define FREE_LIST_SIZE PAGE_SIZE / MIN_BLOCK_SIZE / sizeof(unsigned char)
 
 #include <stddef.h>
@@ -13,13 +13,16 @@
 struct bucket
 {
     unsigned block_size;
-    unsigned char free_map[FREE_LIST_SIZE]; // Keeps track of allocations   
+    unsigned char free_map[FREE_LIST_SIZE]; // Keeps track of allocations
                                             // If block_size > MIN_BLOCK_SIZE
                                             // It will use a consecutive
                                             // representation
     unsigned short alloc_blk_cnt; // Counts the number of allocated blocks
     struct bucket *next;
-    size_t checksum;
+    size_t alloc_size;
+
+    unsigned short space1; //
+    unsigned int space2; // -> Both are used to align data on 16 bytes
 };
 
 #define BUCKET_SIZE PAGE_SIZE - sizeof(struct bucket)
@@ -29,7 +32,8 @@ int find_free_block(struct bucket *buck);
 struct bucket *get_bucket(struct bucket *head, size_t size);
 void *get_data_begin(struct bucket *biquette);
 void *get_page_begin(void *ptr);
-void *get_block(struct bucket* biquette, int block_number);
+void *get_block(struct bucket *biquette, int block_number);
+int get_block_number(struct bucket *biquette, void *block);
 void bucket_list_append(struct bucket **head, struct bucket *elt);
 void bucket_list_remove(struct bucket **head, struct bucket *elt);
 
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index dfa093e..961d899 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -18,7 +18,7 @@ __attribute__((visibility("default"))) void *malloc(size_t size)
         // Find adequate block
         int block_number = find_free_block(buck);
         if (block_number != -1)
-            return get_block(buck, block_number);
+            return allocate_block(buck, block_number);
         else
         {
             // No free space -> loop
@@ -27,8 +27,8 @@ __attribute__((visibility("default"))) void *malloc(size_t size)
     }
 
     buck = create_bucket(size);
-    bucket_append(&head, buck);
-    return get_data_begin(buck);
+    bucket_list_append(&head, buck);
+    return allocate_block(buck, 1);
 }
 
 __attribute__((visibility("default"))) void free(void *ptr)
diff --git a/malloc/tests/test-cmd.sh b/malloc/tests/test-cmd.sh
new file mode 100755
index 0000000..e561d85
--- /dev/null
+++ b/malloc/tests/test-cmd.sh
@@ -0,0 +1,3 @@
+#!/bi/sh
+
+echo Hello world!
diff --git a/malloc/tests/test.c b/malloc/tests/test.c
new file mode 100644
index 0000000..51a4f94
--- /dev/null
+++ b/malloc/tests/test.c
@@ -0,0 +1,25 @@
+// #include <criterion/criterion.h>
+// #include <criterion/new/assert.h>
+
+// TestSuite(Main);
+
+// Test(Main, test1)
+// {
+//     int *i = malloc(16);
+//     cr_assert(i != NULL);
+// }
+
+#include <stdlib.h>
+
+int main(void)
+{
+    int *test = malloc(8);
+    void *tes2 = malloc(8);
+    void *tes3 = malloc(32);
+    void *tes4 = malloc(64);
+    void *tes5 = malloc(128);
+    void *tes6 = malloc(256);
+    void *tes7 = malloc(512);
+    void *tes8 = malloc(4096);
+    void *tes9 = malloc(95956);
+}

From 56636b54c4895296ffb6e50ab5e08ee77a03f81a Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Fri, 7 Nov 2025 23:30:27 +0100
Subject: [PATCH 10/13] backup

---
 malloc/library | Bin 17152 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100755 malloc/library

diff --git a/malloc/library b/malloc/library
deleted file mode 100755
index 9e8ed5c580f8adb3c2cbed4c385678806ead2765..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17152
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


From de0af4715b6af37ff849d01b14ec81079fa594bb Mon Sep 17 00:00:00 2001
From: Guillem George <guillem.george@epita.fr>
Date: Fri, 7 Nov 2025 23:38:51 +0100
Subject: [PATCH 11/13] nul

---
 malloc/tests/test-cmd.sh | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/malloc/tests/test-cmd.sh b/malloc/tests/test-cmd.sh
index e561d85..e633a4c 100755
--- a/malloc/tests/test-cmd.sh
+++ b/malloc/tests/test-cmd.sh
@@ -1,3 +1,24 @@
 #!/bi/sh
 
+RED='\033[0;31m'
+NC='\033[0m' # No color
+
 echo Hello world!
+
+check()
+{
+    if [ $? -ne 0 ]; then
+        echo $RED ERROR $NC
+    fi
+}
+LD_PRELOAD=./libmalloc.so ls 1> /dev/null
+check
+LD_PRELOAD=./libmalloc.so ip a 1> /dev/null
+check
+LD_PRELOAD=./libmalloc.so grep 1> /dev/null
+check
+LD_PRELOAD=./libmalloc.so find 1> /dev/null
+check
+LD_PRELOAD=./libmalloc.so tree 1> /dev/null
+check
+LD_PRELOAD=./libmalloc.so git status 1> /dev/null

From 4f8a0bb720e1d6668ba9cb7618e29b840019edee Mon Sep 17 00:00:00 2001
From: "Gu://em_" <guillem.george@epita.fr>
Date: Thu, 18 Dec 2025 18:06:44 +0100
Subject: [PATCH 12/13] malloc moi le fion

---
 malloc/src/helpers/allocate.c | 30 ++++++++++++---------
 malloc/src/helpers/helpers.c  | 51 ++++++++++++++++++++++++-----------
 malloc/src/malloc.c           | 14 ++++++++--
 malloc/tests/test-cmd.sh      |  2 +-
 4 files changed, 66 insertions(+), 31 deletions(-)

diff --git a/malloc/src/helpers/allocate.c b/malloc/src/helpers/allocate.c
index 9bfef58..350a38b 100644
--- a/malloc/src/helpers/allocate.c
+++ b/malloc/src/helpers/allocate.c
@@ -12,7 +12,7 @@ void *allocate_block(struct bucket *biquette, int block_number)
         return NULL;
 
     // Update header
-    unsigned char byte_mask = 1 << (8 - 1 - (block_number % 8));
+    unsigned char byte_mask = 1 << (block_number % 8);
     biquette->alloc_blk_cnt++;
     biquette->free_map[block_number / 8] |= byte_mask;
 
@@ -22,17 +22,24 @@ void *allocate_block(struct bucket *biquette, int block_number)
 
 struct bucket *create_bucket(size_t min_alloc_size)
 {
-    // Round up
-    size_t alloc_size;
+    size_t page_alloc_size;
+    size_t block_alloc_size;
+
     if (min_alloc_size > PAGE_SIZE - sizeof(struct bucket))
+    {
         // Huge page
-        alloc_size = min_alloc_size;
+        page_alloc_size = min_alloc_size + sizeof(struct bucket);
+        block_alloc_size = page_alloc_size;
+    }
     else
+    {
         // Regular page
-        alloc_size = s2p(min_alloc_size);
+        page_alloc_size = PAGE_SIZE;
+        block_alloc_size = s2p(min_alloc_size);
+    }
 
     // Get page
-    void *page = mmap(NULL, alloc_size, PROT_READ | PROT_WRITE,
+    void *page = mmap(NULL, page_alloc_size, PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
     if (page == NULL)
@@ -40,9 +47,9 @@ struct bucket *create_bucket(size_t min_alloc_size)
 
     // Init bucket
     struct bucket *header = page;
-    header->block_size = alloc_size;
+    header->block_size = block_alloc_size;
     header->alloc_blk_cnt = 0;
-    header->alloc_size = alloc_size;
+    header->alloc_size = page_alloc_size;
     memset(header->free_map, 0, FREE_LIST_SIZE);
 
     return header;
@@ -73,14 +80,11 @@ void free_block(void *ptr, struct bucket **list)
     if (block_number == -1)
         return;
 
-    unsigned char byte_mask = 1 << ((block_number % 8) - 1);
+    unsigned char byte_mask = 1 << ((block_number % 8));
     header->free_map[block_number / 8] &= ~byte_mask;
+    header->alloc_blk_cnt--;
 
     // Huge page
-    if (header->block_size > BUCKET_SIZE)
-        // Delete bucket
-        header->alloc_blk_cnt = 0;
-
     // free bucket if necessary
     if (header->alloc_blk_cnt == 0)
     {
diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index 8b37f4a..04ef038 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -32,19 +32,29 @@ size_t s2p(size_t s)
 
 int find_free_block(struct bucket *buck)
 {
-    unsigned maplength = PAGE_SIZE / buck->block_size / 8;
-    // for each block
+    // Huge pages
+    if (buck->block_size > BUCKET_SIZE)
+    {
+        // Check block 0
+        if (!(buck->free_map[0] & (1 << 0)))
+            return 0;
+        return -1;
+    }
+
+    size_t num_blocks_in_page = (PAGE_SIZE - sizeof(struct bucket)) / buck->block_size;
+    size_t maplength = (num_blocks_in_page + 7) / 8; // +7 for ceiling division (oui c'est moche mais ça marche)
+
+    // Foreach byte
     for (unsigned i = 0; i < maplength; i++)
     {
         unsigned char map_byte = buck->free_map[i];
-        unsigned char bit = 1;
-        // Test byte
-        for (unsigned j = 0; j < 8; j <<= 1)
-        {
-            if (map_byte ^ bit) // Test if free
-                return i * 8 + j;
+        if (map_byte == 0xFF) // Skip if used
+            continue;
 
-            bit <<= 1;
+        for (unsigned j = 0; j < 8; j++)
+        {   
+            if ((i * 8 + j) < num_blocks_in_page && !(map_byte & (1 << j))) // Check if free
+                return i * 8 + j;
         }
     }
 
@@ -68,11 +78,20 @@ int get_block_number(struct bucket *biquette, void *block)
         return -1;
 
     char *block_nul = block;
-    void *biquetteounette = biquette;
-    char *biquette_cherie = biquetteounette;
+    char* bibiche = get_data_begin(biquette); // Célèbre bar Capcinois, venez à l'occasion
+
+    return (block_nul - bibiche) / biquette->block_size;
+
+    // Au revoir mes belles
+    // Vous manquerez à papa
+    // (mais fallait marcher, là ça marche pas)
+
+    // void *biquetteounette = biquette;
+    // char *biquette_cherie = biquetteounette;
+
+    // return (block_nul - biquette_cherie - sizeof(struct bucket))
+    //     / biquette->block_size;
 
-    return (block_nul - biquette_cherie - sizeof(struct bucket))
-        / biquette->block_size;
 }
 
 // Gets a bucket with at least a block_size of size
@@ -93,7 +112,9 @@ struct bucket *get_bucket(struct bucket *head, size_t size)
 // Computes the buckets first block address
 void *get_data_begin(struct bucket *biquette)
 {
-    return biquette + sizeof(struct bucket);
+    void* maisqueltrucdemerde = biquette;
+    char* biquettas = maisqueltrucdemerde;
+    return biquettas + sizeof(struct bucket);
 }
 
 // Computes the beginning address of the page containing ptr
@@ -130,7 +151,7 @@ void bucket_list_remove(struct bucket **head, struct bucket *elt)
 
     if (*head == elt)
     {
-        *head = NULL;
+        *head = elt->next;
         return;
     }
 
diff --git a/malloc/src/malloc.c b/malloc/src/malloc.c
index 961d899..535c23e 100644
--- a/malloc/src/malloc.c
+++ b/malloc/src/malloc.c
@@ -28,7 +28,8 @@ __attribute__((visibility("default"))) void *malloc(size_t size)
 
     buck = create_bucket(size);
     bucket_list_append(&head, buck);
-    return allocate_block(buck, 1);
+    int first_free_buche = find_free_block(buck); // De noel (pas la mienne)
+    return allocate_block(buck, first_free_buche);
 }
 
 __attribute__((visibility("default"))) void free(void *ptr)
@@ -56,6 +57,8 @@ __attribute__((visibility("default"))) void *realloc(void *ptr, size_t size)
     else
     {
         void *new_ptr = malloc(size);
+        if (new_ptr == NULL)
+            return NULL;
         memcpy(new_ptr, ptr, header->block_size);
         free(ptr);
         return new_ptr;
@@ -66,7 +69,14 @@ __attribute__((visibility("default"))) void *realloc(void *ptr, size_t size)
 
 __attribute__((visibility("default"))) void *calloc(size_t nmemb, size_t size)
 {
-    char *res = malloc(nmemb * size);
+    // Check overflow
+    size_t c;
+    if (__builtin_mul_overflow(nmemb, size, &c))
+        return NULL;
+
+    char *res = malloc(c);
+    if (res == NULL)
+        return NULL;
     memset(res, 0, nmemb * size);
     return res;
 }
diff --git a/malloc/tests/test-cmd.sh b/malloc/tests/test-cmd.sh
index e633a4c..4ff60e6 100755
--- a/malloc/tests/test-cmd.sh
+++ b/malloc/tests/test-cmd.sh
@@ -15,7 +15,7 @@ LD_PRELOAD=./libmalloc.so ls 1> /dev/null
 check
 LD_PRELOAD=./libmalloc.so ip a 1> /dev/null
 check
-LD_PRELOAD=./libmalloc.so grep 1> /dev/null
+LD_PRELOAD=./libmalloc.so grep --help 1> /dev/null
 check
 LD_PRELOAD=./libmalloc.so find 1> /dev/null
 check

From a09cf2de17a909ac39b9c2fa33ef546669bd63a9 Mon Sep 17 00:00:00 2001
From: "Gu://em_" <guillem.george@epita.fr>
Date: Fri, 19 Dec 2025 19:02:50 +0100
Subject: [PATCH 13/13] masterclass le dementor

---
 malloc/src/helpers/helpers.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/malloc/src/helpers/helpers.c b/malloc/src/helpers/helpers.c
index 04ef038..bde2907 100644
--- a/malloc/src/helpers/helpers.c
+++ b/malloc/src/helpers/helpers.c
@@ -41,8 +41,10 @@ int find_free_block(struct bucket *buck)
         return -1;
     }
 
-    size_t num_blocks_in_page = (PAGE_SIZE - sizeof(struct bucket)) / buck->block_size;
-    size_t maplength = (num_blocks_in_page + 7) / 8; // +7 for ceiling division (oui c'est moche mais ça marche)
+    size_t num_blocks_in_page =
+        (PAGE_SIZE - sizeof(struct bucket)) / buck->block_size;
+    size_t maplength = (num_blocks_in_page + 7)
+        / 8; // +7 for ceiling division (oui c'est moche mais ça marche)
 
     // Foreach byte
     for (unsigned i = 0; i < maplength; i++)
@@ -52,8 +54,9 @@ int find_free_block(struct bucket *buck)
             continue;
 
         for (unsigned j = 0; j < 8; j++)
-        {   
-            if ((i * 8 + j) < num_blocks_in_page && !(map_byte & (1 << j))) // Check if free
+        {
+            if ((i * 8 + j) < num_blocks_in_page
+                && !(map_byte & (1 << j))) // Check if free
                 return i * 8 + j;
         }
     }
@@ -78,7 +81,8 @@ int get_block_number(struct bucket *biquette, void *block)
         return -1;
 
     char *block_nul = block;
-    char* bibiche = get_data_begin(biquette); // Célèbre bar Capcinois, venez à l'occasion
+    char *bibiche =
+        get_data_begin(biquette); // Célèbre bar Capcinois, venez à l'occasion
 
     return (block_nul - bibiche) / biquette->block_size;
 
@@ -91,7 +95,6 @@ int get_block_number(struct bucket *biquette, void *block)
 
     // return (block_nul - biquette_cherie - sizeof(struct bucket))
     //     / biquette->block_size;
-
 }
 
 // Gets a bucket with at least a block_size of size
@@ -112,8 +115,8 @@ struct bucket *get_bucket(struct bucket *head, size_t size)
 // Computes the buckets first block address
 void *get_data_begin(struct bucket *biquette)
 {
-    void* maisqueltrucdemerde = biquette;
-    char* biquettas = maisqueltrucdemerde;
+    void *maisqueltrucdemerde = biquette;
+    char *biquettas = maisqueltrucdemerde;
     return biquettas + sizeof(struct bucket);
 }