Merge pull request #1 from ShadiBahaa/codex/conduct-code-review-for-repository

Use TOPDIR for recipe paths and harden HMM allocator (bounds, overflow, flags)

Author: ShadiBahaa

meta-dynamic/recipes-dynamic/build-dynamic/build-dynamic_0.1.bb

@@ -1,9 +1,7 @@
 DESCRIPTION = "Building the HMM library dynamically"
 PR = "r1"
 do_build () {
-    script_dir="$(dirname "$(realpath "$0")")"
-    
-    local dir="$script_dir/../../../../../project-files"
+    local dir="${TOPDIR}/../project-files"
 
     if [ ! -d "$dir" ]; then
         echo "Directory '$dir' does not exist."

meta-static/recipes-static/build-static/build-static_0.1.bb

@@ -1,9 +1,7 @@
 DESCRIPTION = "Building the HMM library statically"
 PR = "r1"
 do_build () {
-    log_dir="$(dirname "$(realpath "$0")")"
-    
-    local dir="$log_dir/../../../../../project-files"
+    local dir="${TOPDIR}/../project-files"
 
     if [ ! -d "$dir" ]; then
         echo "Directory '$dir' does not exist."

meta-test/recipes-test/test-dynamic/test-dynamic_1.0.bb

@@ -3,11 +3,11 @@ PR = "r1"
 
 do_build() {
     # Set the paths to the files
-    log_dir="$(dirname "$(realpath "$0")")"
-    local test_c_path="$log_dir/../../../../../project-files/test.c"
-    local lib_dir_path="$log_dir/../../../../../project-files"
-    local run_script_path="$log_dir/../../../../../project-files/run_executable.sh"
-    local output_executable="$log_dir/../../../../../project-files/test.exe"
+    local project_dir="${TOPDIR}/../project-files"
+    local test_c_path="$project_dir/test.c"
+    local lib_dir_path="$project_dir"
+    local run_script_path="$project_dir/run_executable.sh"
+    local output_executable="$project_dir/test.exe"
 
     # Compile the test.c with libhmm.a into test.exe statically
     gcc -o "$output_executable" "$test_c_path" -L"$lib_dir_path" -lhmm
@@ -27,4 +27,3 @@ do_build() {
         return 1
     fi
 }
-

meta-test/recipes-test/test-static/test-static_1.0.bb

@@ -3,11 +3,11 @@ PR = "r1"
 
 do_build() {
     # Set the paths to the files
-    log_dir="$(dirname "$(realpath "$0")")"
-    local test_c_path="$log_dir/../../../../../project-files/test.c"
-    local libhmm_path="$log_dir/../../../../../project-files/libhmm.a"
-    local run_script_path="$log_dir/../../../../../project-files/run_executable.sh"
-    local output_executable="$log_dir/../../../../../project-files/test.exe"
+    local project_dir="${TOPDIR}/../project-files"
+    local test_c_path="$project_dir/test.c"
+    local libhmm_path="$project_dir/libhmm.a"
+    local run_script_path="$project_dir/run_executable.sh"
+    local output_executable="$project_dir/test.exe"
 
     # Compile the test.c with libhmm.a into test.exe statically
     gcc "$test_c_path" "$libhmm_path" -o "$output_executable" --static
@@ -24,4 +24,3 @@ do_build() {
         return 1
     fi
 }
-

project-files/HMM.c

@@ -58,6 +58,10 @@ static mem_chunk_t *tail;
 
 static size_t current_free_size; 
 
+/**< Start and end addresses of memory acquired from sbrk. */
+static void *heap_start;
+static void *heap_end;
+
 /**
  * @brief Removes a free memory block from the list of free blocks in hash table.
  * 
@@ -73,6 +77,8 @@ static void HMMremove_free_block(mem_chunk_t *block)
         return;
     }
     size_t cur_size = block->size;
+    if (cur_size < ALIGNMENT)
+        return;
     size_t idx = (cur_size / ALIGNMENT) - 1;
         // If the index is within bounds, traverse the free list to remove the block.
 
@@ -102,16 +108,6 @@ static void HMMremove_free_block(mem_chunk_t *block)
         }
     }
 }
-/**
- * @brief Checks if a memory block is found in the list of free blocks in hash table.
- * 
- * @param block Pointer to the memory block to be checked.
- * @return 1 if the block is found, 0 otherwise.
- */
-static unsigned char HMMis_block_found(mem_chunk_t *block)
-{
-    return block->is_added;
-}
 /**
  * @brief Adds a free memory block to the list of free blocks in hash table.
  * 
@@ -123,6 +119,8 @@ static void HMMadd_free_block(mem_chunk_t *block)
         return;
 // Calculate the index for the block based on its size.
     size_t cur_size = block->size;
+    if (cur_size < ALIGNMENT)
+        return;
     size_t idx = (cur_size / ALIGNMENT) - 1;
         // If the index is within bounds and the block is not already added, add it to the free list.
 
@@ -152,6 +150,8 @@ static void HMMadd_free_block(mem_chunk_t *block)
  */
 static mem_chunk_t *HMMget_free_block(size_t size)
 {
+    if (size < ALIGNMENT)
+        return NULL;
     size_t idx = (size / ALIGNMENT) - 1;
     if (idx < MULTIPLES_MAX)
     {
@@ -247,6 +247,7 @@ static mem_chunk_t *HMMget_free_chunk(size_t size)
                 splitted->prev = current;
                 splitted->next = current_next;
                 splitted->is_free = 1;
+                splitted->is_added = 0;
                 if (current_next)
                     current_next->prev = splitted;
                 current->next = splitted;
@@ -270,7 +271,12 @@ static mem_chunk_t *HMMget_free_chunk(size_t size)
         // If no free block is large enough, allocate new memory from the system.
 
     size_t allocation_size = ALLOCATED_BYTES;
-    size_t num_allocated_bytes = ((size + sizeof(mem_chunk_t) + allocation_size) / allocation_size) * allocation_size;
+    if (size > (SIZE_MAX - sizeof(mem_chunk_t) - allocation_size))
+    {
+        return NULL;
+    }
+    size_t total_requested = size + sizeof(mem_chunk_t) + allocation_size;
+    size_t num_allocated_bytes = (total_requested / allocation_size) * allocation_size;
     void *new_free_space = sbrk(num_allocated_bytes);
     if (new_free_space == (void *)-1)
     {
@@ -289,6 +295,10 @@ static mem_chunk_t *HMMget_free_chunk(size_t size)
         // Initialize a new memory chunk and add it to the list.
 
     mem_chunk_t *new_chunk = (mem_chunk_t *)new_free_space;
+    if (heap_start == NULL)
+        heap_start = new_free_space;
+    heap_end = (unsigned char *)new_free_space + num_allocated_bytes;
+    new_chunk->is_added = 0;
     new_chunk->is_free = 1;
     new_chunk->size = num_allocated_bytes - sizeof(mem_chunk_t);
     new_chunk->prev = tail;
@@ -315,6 +325,15 @@ static void HMMfree(void *ptr)
     }
     // Get the memory chunk from the given pointer.
 
+    if (heap_start == NULL || heap_end == NULL)
+    {
+        return;
+    }
+    if ((unsigned char *)ptr < ((unsigned char *)heap_start + sizeof(mem_chunk_t)) ||
+        (unsigned char *)ptr >= (unsigned char *)heap_end)
+    {
+        return;
+    }
     mem_chunk_t *alloacted_member = (mem_chunk_t *)((unsigned char *)ptr - sizeof(mem_chunk_t)); 
         // Check if the memory is already free, if not, free it.
 
@@ -378,6 +397,7 @@ static void HMMfree(void *ptr)
             {
                 return;
             }
+            heap_end = new_break;
         }
     }
 }
@@ -536,8 +556,8 @@ void HMMtraverse(void)
     size_t cnt = 1;
     while (cur)
     {
-        printf("Node number: %d, Address: %10p, free: %lu, size: %lu\r\n", cnt, cur, cur->is_free, cur->size);
+        printf("Node number: %zu, Address: %10p, free: %u, size: %zu\r\n", cnt, (void *)cur, (unsigned int)cur->is_free, cur->size);
         cnt++;
         cur = cur->next;
     }
-}
+}

project-files/free_and_sbrk.c

@@ -1,20 +1,22 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <string.h>
-#include <math.h>
-#define _BSD_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
 
 int min(int a, int b){
     if (a < b)return a;
     return b;
 }
 
 #define MAX_ALLOCS 10000
-int
-main(int argc, char *argv[])
-{
-    srand(time(NULL));   
+int
+main(int argc, char *argv[])
+{
+    (void)argc;
+    (void)argv;
+    srand(time(NULL));   
     char *ptr[MAX_ALLOCS];
     int freeStep, freeMin, freeMax, blockSize, numAllocs, j;
 
@@ -50,4 +52,4 @@ main(int argc, char *argv[])
     printf("After free(), program break is: %10p\n", sbrk(0));
 
     exit(EXIT_SUCCESS);
-}
+}

project-files/test.c

@@ -37,7 +37,6 @@ void perform_random_operations()
         case CALLOC:
         {
             size_t num = rand() % MAX_SIZE + 1;
-            size_t size = rand() % MAX_SIZE + 1;
             allocated_blocks[i] = calloc(num, MAX_SIZE/num);
             //printf("Allocated block %p with %zu elements of size %zu\n", allocated_blocks[i], num, size);
             break;