diff --git a/README.md b/README.md
index 3aa9830d..73651032 100644
--- a/README.md
+++ b/README.md
@@ -78,20 +78,24 @@ Follows the list of implemented features:
 **Filesystem**
  - [x] Virtual Filesystem (VFS);
  - [x] Initramfs;
- - [x] EXT2;
+ - [x] Second Extended File System (EXT2);
  - [x] Procfs;
 
 **Input/Output**
  - [x] Programmable Interrupt Controller (PIC) drivers;
+ - [x] PS/2 drivers;
+ - [x] Advanced Technology Attachment (ATA) drivers;
+ - [x] Real Time Clock (RTC) drivers;
  - [x] Keyboard drivers (IT/ENG layouts);
  - [x] Video drivers;
  - [ ] VGA drivers;
 
 **Inter-Process Communication (IPC)**
  - [X] Semaphore
- - [ ] Message queue
- - [ ] Shared memory
- - [ ] Named pipe
+ - [X] Message queue
+ - [X] Shared memory
+ - [ ] PIPE
+ - [ ] Named PIPE
 
 I will try to keep it updated...
 
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index d128b5ab..3b32fa94 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -105,6 +105,7 @@ if (DOXYGEN_FOUND)
         ${CMAKE_SOURCE_DIR}/mentos/inc/version.h
 
         ${CMAKE_SOURCE_DIR}/mentos/src/boot.c
+        ${CMAKE_SOURCE_DIR}/mentos/src/crypt/sha256.c
         ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/exception.c
         ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/gdt.c
         ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/idt.c
@@ -193,6 +194,7 @@ if (DOXYGEN_FOUND)
         ${CMAKE_SOURCE_DIR}/libc/inc/bits/ioctls.h
         ${CMAKE_SOURCE_DIR}/libc/inc/bits/stat.h
         ${CMAKE_SOURCE_DIR}/libc/inc/bits/termios-struct.h
+        ${CMAKE_SOURCE_DIR}/libc/inc/crypt/sha256.h
         ${CMAKE_SOURCE_DIR}/libc/inc/ctype.h
         ${CMAKE_SOURCE_DIR}/libc/inc/fcntl.h
         ${CMAKE_SOURCE_DIR}/libc/inc/fcvt.h
@@ -259,6 +261,7 @@ if (DOXYGEN_FOUND)
         ${CMAKE_SOURCE_DIR}/libc/src/sys/utsname.c
         ${CMAKE_SOURCE_DIR}/libc/src/termios.c
         ${CMAKE_SOURCE_DIR}/libc/src/time.c
+        ${CMAKE_SOURCE_DIR}/libc/src/crypt/sha256.c
         ${CMAKE_SOURCE_DIR}/libc/src/unistd/chdir.c
         ${CMAKE_SOURCE_DIR}/libc/src/unistd/close.c
         ${CMAKE_SOURCE_DIR}/libc/src/unistd/creat.c
diff --git a/libc/inc/bits/stat.h b/libc/inc/bits/stat.h
index 155d32d2..e8513c5b 100644
--- a/libc/inc/bits/stat.h
+++ b/libc/inc/bits/stat.h
@@ -13,7 +13,7 @@
 #include "time.h"
 
 /// @brief Data structure which contains information about a file.
-typedef struct stat_t {
+typedef struct stat {
     /// ID of device containing file.
     dev_t st_dev;
     /// File serial number.
diff --git a/libc/inc/crypt/sha256.h b/libc/inc/crypt/sha256.h
index f0a098c9..6225f6df 100644
--- a/libc/inc/crypt/sha256.h
+++ b/libc/inc/crypt/sha256.h
@@ -1,9 +1,8 @@
-/// @file sha256.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
+/// @file sha256.h
 /// @brief Implementation of the SHA-256 hashing algorithm.
 /// @details The original code was written by Brad Conte, and is available at:
 ///     https://github.com/B-Con/crypto-algorithms
-/// 
+///
 /// SHA-256 is one of the three algorithms in the SHA2
 /// specification. The others, SHA-384 and SHA-512, are not
 /// offered in this implementation.
@@ -19,14 +18,33 @@
 /// @brief SHA256 outputs a 32 byte digest.
 #define SHA256_BLOCK_SIZE 32
 
+/// @brief Structure that holds context information for SHA-256 operations.
 typedef struct {
-    uint8_t data[64];
-    uint32_t datalen;
-    unsigned long long bitlen;
-    uint32_t state[8];
+    uint8_t data[64];          ///< Input data block being processed (512 bits / 64 bytes).
+    uint32_t datalen;          ///< Length of the current data in the buffer (in bytes).
+    unsigned long long bitlen; ///< Total length of the input in bits (for padding).
+    uint32_t state[8];         ///< Current hash state (256 bits / 8 * 32-bit words).
 } SHA256_ctx_t;
 
+/// @brief Initializes the SHA-256 context.
+/// @param ctx Pointer to the SHA-256 context to initialize.
 void sha256_init(SHA256_ctx_t *ctx);
+
+/// @brief Adds data to the SHA-256 context for hashing.
+/// @param ctx Pointer to the SHA-256 context.
+/// @param data Pointer to the data to be hashed.
+/// @param len Length of the data to hash, in bytes.
 void sha256_update(SHA256_ctx_t *ctx, const uint8_t data[], size_t len);
+
+/// @brief Finalizes the hashing and produces the final SHA-256 digest.
+/// @param ctx Pointer to the SHA-256 context.
+/// @param hash Pointer to a buffer where the final hash will be stored (must be at least 32 bytes long).
 void sha256_final(SHA256_ctx_t *ctx, uint8_t hash[]);
+
+/// @brief Converts a byte array to its hexadecimal string representation.
+/// @param src Pointer to the source byte array.
+/// @param src_length Length of the source byte array.
+/// @param out Pointer to the output buffer for the hexadecimal string.
+/// @param out_length Length of the output buffer (must be at least 2 * src_length + 1).
+/// @details The output string will be null-terminated if the buffer is large enough.
 void sha256_bytes_to_hex(uint8_t *src, size_t src_length, char *out, size_t out_length);
diff --git a/libc/inc/readline.h b/libc/inc/readline.h
index aeeda1d5..5fa3cb62 100644
--- a/libc/inc/readline.h
+++ b/libc/inc/readline.h
@@ -5,10 +5,12 @@
 
 #include "stddef.h"
 
-/// @brief Reads a line from the file.
-/// @param fd the file descriptor.
-/// @param buffer the buffer where we place the line.
-/// @param buflen the length of the buffer.
-/// @param readlen the amount we read, if negative, we did not encounter a newline.
-/// @return 0 if we are done reading, 1 if we encountered a newline, -1 if otherwise.
+/// @brief Reads a line from the given file descriptor into the buffer.
+/// @param fd The file descriptor to read from.
+/// @param buffer The buffer where the read line will be stored. Must not be NULL.
+/// @param buflen The size of the buffer.
+/// @param read_len A pointer to store the length of the read line. Can be NULL if not needed.
+/// @return 1 if a newline was found and the line was read successfully, 
+///         0 if the end of the file was reached, 
+///        -1 if no newline was found and partial data was read.
 int readline(int fd, char *buffer, size_t buflen, ssize_t *read_len);
diff --git a/libc/inc/sched.h b/libc/inc/sched.h
index 924c8d86..a0443d4d 100644
--- a/libc/inc/sched.h
+++ b/libc/inc/sched.h
@@ -8,7 +8,7 @@
 #include "stdbool.h"
 
 /// @brief Structure that describes scheduling parameters.
-typedef struct sched_param_t {
+typedef struct sched_param {
     /// Static execution priority.
     int sched_priority;
     /// Expected period of the task
diff --git a/libc/inc/signal.h b/libc/inc/signal.h
index eb68861f..72d58a5d 100644
--- a/libc/inc/signal.h
+++ b/libc/inc/signal.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "sys/types.h"
+#include "stddef.h"
 
 /// @brief List of signals.
 typedef enum {
@@ -161,13 +162,13 @@ typedef void (*sighandler_t)(int);
 /// Signals are divided into two cathegories, identified by the two unsigned longs:
 ///     [ 1, 31] corresponds to normal signals;
 ///     [32, 64] corresponds to real-time signals.
-typedef struct sigset_t {
+typedef struct sigset {
     /// Signals divided into two cathegories.
     unsigned long sig[2];
 } sigset_t;
 
 /// @brief Holds the information on how to handle a specific signal.
-typedef struct sigaction_t {
+typedef struct sigaction {
     /// This field specifies the type of action to be performed; its value can be a pointer
     /// to the signal handler, SIG_DFL (that is, the value 0) to specify that the default
     /// action is performed, or SIG_IGN (that is, the value 1) to specify that the signal is
@@ -186,7 +187,7 @@ typedef union sigval {
 } sigval_t;
 
 /// @brief Stores information about an occurrence of a specific signal.
-typedef struct siginfo_t {
+typedef struct siginfo {
     /// The signal number.
     int si_signo;
     /// A code identifying who raised the signal (see signal_sender_code_t).
diff --git a/libc/inc/sys/list_head.h b/libc/inc/sys/list_head.h
index f13244a3..7c956041 100644
--- a/libc/inc/sys/list_head.h
+++ b/libc/inc/sys/list_head.h
@@ -10,10 +10,8 @@
 
 /// @brief Structure used to implement the list_head data structure.
 typedef struct list_head {
-    /// @brief The previous element.
-    struct list_head *prev;
-    /// @brief The subsequent element.
-    struct list_head *next;
+    struct list_head *prev; ///< The previous element.
+    struct list_head *next; ///< The subsequent element.
 } list_head;
 
 /// @brief Get the struct for this entry.
@@ -66,6 +64,7 @@ typedef struct list_head {
 /// @param head The head of your list.
 static inline void list_head_init(list_head *head)
 {
+    assert(head && "Variable head is NULL."); // Ensure head is not NULL
     head->next = head->prev = head;
 }
 
@@ -74,7 +73,7 @@ static inline void list_head_init(list_head *head)
 /// @return 1 if empty, 0 otherwise.
 static inline int list_head_empty(const list_head *head)
 {
-    assert(head && "Variable head is NULL.");
+    assert(head && "Variable head is NULL."); // Ensure head is not NULL
     return head->next == head;
 }
 
@@ -83,6 +82,8 @@ static inline int list_head_empty(const list_head *head)
 /// @return the size of the list.
 static inline unsigned list_head_size(const list_head *head)
 {
+    assert(head && "Variable head is NULL."); // Ensure head is not NULL
+
     unsigned size = 0;
     if (!list_head_empty(head)) {
         list_for_each_decl(it, head) size += 1;
@@ -91,12 +92,15 @@ static inline unsigned list_head_size(const list_head *head)
 }
 
 /// @brief Insert the new entry after the given location.
-/// @param new_entry the new element we want to insert.
-/// @param location the element after which we insert.
+/// @param new_entry The new element we want to insert.
+/// @param location The element after which we insert.
 static inline void list_head_insert_after(list_head *new_entry, list_head *location)
 {
-    assert(new_entry && "Variable new_entry is NULL.");
-    assert(location && "Variable location is NULL.");
+    assert(new_entry && "Variable new_entry is NULL.");           // Check for NULL new_entry
+    assert(location && "Variable location is NULL.");             // Check for NULL location
+    assert(location->prev && "Variable location->prev is NULL."); // Check location is valid
+    assert(location->next && "Variable location->next is NULL."); // Check location is valid
+
     // We store the old `next` element.
     list_head *old_next = location->next;
     // We insert our element.
@@ -132,10 +136,12 @@ static inline void list_head_insert_before(list_head *new_entry, list_head *loca
 /// @param entry the entry we want to remove.
 static inline void list_head_remove(list_head *entry)
 {
+    assert(entry && "Variable entry is NULL.");              // Check for NULL entry
+    assert(entry->prev && "Attribute entry->prev is NULL."); // Check previous pointer
+    assert(entry->next && "Attribute entry->next is NULL."); // Check next pointer
+
     // Check if the element is actually in a list.
     if (!list_head_empty(entry)) {
-        assert(entry->prev && "Attribute entry->prev is NULL.");
-        assert(entry->next && "Attribute entry->next is NULL.");
         // We link the `previous` element to the `next` one.
         entry->prev->next = entry->next;
         // We link the `next` element to the `previous` one.
@@ -151,6 +157,8 @@ static inline void list_head_remove(list_head *entry)
 /// @return a list_head pointing to the element we removed, NULL on failure.
 static inline list_head *list_head_pop(list_head *head)
 {
+    assert(head && "Variable head is NULL."); // Check for NULL head
+
     // Check if the list is not empty.
     if (!list_head_empty(head)) {
         // Store the pointer.
@@ -168,11 +176,14 @@ static inline list_head *list_head_pop(list_head *head)
 /// @param secondary the secondary list, which gets appended, and re-initialized as empty.
 static inline void list_head_append(list_head *main, list_head *secondary)
 {
+    assert(main && "Variable main is NULL.");           // Check for NULL main
+    assert(secondary && "Variable secondary is NULL."); // Check for NULL secondary
+
     // Check that both lists are actually filled with entries.
     if (!list_head_empty(main) && !list_head_empty(secondary)) {
-        assert(main->prev && "Attribute main->prev is NULL.");
-        assert(secondary->next && "Attribute secondary->next is NULL.");
-        assert(secondary->prev && "Attribute secondary->prev is NULL.");
+        assert(main->prev && "Attribute main->prev is NULL.");           // Check main's previous pointer
+        assert(secondary->next && "Attribute secondary->next is NULL."); // Check secondary's next pointer
+        assert(secondary->prev && "Attribute secondary->prev is NULL."); // Check secondary's previous pointer
         // Connect the last element of the main list to the first one of the secondary list.
         main->prev->next = secondary->next;
         // Connect the first element of the secondary list to the last one of the main list.
@@ -191,11 +202,15 @@ static inline void list_head_append(list_head *main, list_head *secondary)
 /// @param entry2 the second entry which will take the place of the first entry.
 static inline void list_head_replace(list_head *entry1, list_head *entry2)
 {
+    assert(entry1 && "Variable entry1 is NULL."); // Check for NULL entry1
+    assert(entry2 && "Variable entry2 is NULL."); // Check for NULL entry2
+
     // First we need to remove the second entry.
     list_head_remove(entry2);
-    assert(entry2->next && "Attribute entry2->next is NULL.");
-    assert(entry2->prev && "Attribute entry2->prev is NULL.");
-    // Then, we can place second entry where the first entry is.
+    assert(entry2->next && "Attribute entry2->next is NULL."); // Check entry2's next pointer
+    assert(entry2->prev && "Attribute entry2->prev is NULL."); // Check entry2's previous pointer
+
+    // Then, we can place the second entry where the first entry is.
     entry2->next       = entry1->next;
     entry2->next->prev = entry2;
     entry2->prev       = entry1->prev;
@@ -209,6 +224,9 @@ static inline void list_head_replace(list_head *entry1, list_head *entry2)
 /// @param entry2 the second entry.
 static inline void list_head_swap(list_head *entry1, list_head *entry2)
 {
+    assert(entry1 && "Variable entry1 is NULL."); // Check for NULL entry1
+    assert(entry2 && "Variable entry2 is NULL."); // Check for NULL entry2
+
     list_head *pos = entry2->prev;
     list_head_replace(entry1, entry2);
     if (pos == entry1) {
diff --git a/libc/inc/sys/list_head_algorithm.h b/libc/inc/sys/list_head_algorithm.h
index e604f6db..e2dd8890 100644
--- a/libc/inc/sys/list_head_algorithm.h
+++ b/libc/inc/sys/list_head_algorithm.h
@@ -1,5 +1,4 @@
 /// @file list_head_algorithm.h
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
 /// @brief Some general algorithm that might come in handy while using list_head.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
diff --git a/libc/inc/sys/mman.h b/libc/inc/sys/mman.h
index 15772d96..0dc897f0 100644
--- a/libc/inc/sys/mman.h
+++ b/libc/inc/sys/mman.h
@@ -1,5 +1,4 @@
 /// @file mman.h
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
 /// @brief Functions for managing mappings in virtual address space.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
diff --git a/libc/inc/sys/stat.h b/libc/inc/sys/stat.h
index 691d49f6..55375539 100644
--- a/libc/inc/sys/stat.h
+++ b/libc/inc/sys/stat.h
@@ -4,6 +4,8 @@
 /// See LICENSE.md for details.
 
 #pragma once
+
+/// Prevents the error when inlcuding <bits/stat.h>.
 #define __SYS_STAT_H
 
 #include "bits/stat.h"
@@ -26,14 +28,14 @@
 /// @defgroup FileTypeTest File Type Test Macros
 /// @brief These macros allows to easily identify file types.
 /// @{
-#define S_ISTYPE(mode, mask) (((mode) & S_IFMT) == (mask))
-#define S_ISSOCK(mode)       (S_ISTYPE(mode, S_IFSOCK)) ///< Check if a socket.
-#define S_ISLNK(mode)        (S_ISTYPE(mode, S_IFLNK))  ///< Check if a symbolic link.
-#define S_ISREG(mode)        (S_ISTYPE(mode, S_IFREG))  ///< Check if a regular file.
-#define S_ISBLK(mode)        (S_ISTYPE(mode, S_IFBLK))  ///< Check if a block special.
-#define S_ISDIR(mode)        (S_ISTYPE(mode, S_IFDIR))  ///< Check if a directory.
-#define S_ISCHR(mode)        (S_ISTYPE(mode, S_IFCHR))  ///< Check if a char special.
-#define S_ISFIFO(mode)       (S_ISTYPE(mode, S_IFIFO))  ///< Check if a fifo.
+#define S_ISTYPE(mode, mask) (((mode) & S_IFMT) == (mask)) ///< Easy macro for checking the type.
+#define S_ISSOCK(mode)       (S_ISTYPE(mode, S_IFSOCK))    ///< Check if a socket.
+#define S_ISLNK(mode)        (S_ISTYPE(mode, S_IFLNK))     ///< Check if a symbolic link.
+#define S_ISREG(mode)        (S_ISTYPE(mode, S_IFREG))     ///< Check if a regular file.
+#define S_ISBLK(mode)        (S_ISTYPE(mode, S_IFBLK))     ///< Check if a block special.
+#define S_ISDIR(mode)        (S_ISTYPE(mode, S_IFDIR))     ///< Check if a directory.
+#define S_ISCHR(mode)        (S_ISTYPE(mode, S_IFCHR))     ///< Check if a char special.
+#define S_ISFIFO(mode)       (S_ISTYPE(mode, S_IFIFO))     ///< Check if a fifo.
 /// @}
 
 /// @defgroup ModeBitsAccessPermission Mode Bits for Access Permission
diff --git a/libc/inc/sys/unistd.h b/libc/inc/sys/unistd.h
index bde20028..a45b5418 100644
--- a/libc/inc/sys/unistd.h
+++ b/libc/inc/sys/unistd.h
@@ -9,9 +9,13 @@
 #include "stddef.h"
 #include "sys/dirent.h"
 
-#define STDIN_FILENO  0 ///< Standard input.
-#define STDOUT_FILENO 1 ///< Standard output.
-#define STDERR_FILENO 2 ///< Standard error output.
+#define STDIN_FILENO  0 ///< Standard input file descriptor.
+#define STDOUT_FILENO 1 ///< Standard output file descriptor.
+#define STDERR_FILENO 2 ///< Standard error file descriptor.
+
+#define stdin  STDIN_FILENO  ///< Standard input file descriptor.
+#define stdout STDOUT_FILENO ///< Standard output file descriptor.
+#define stderr STDERR_FILENO ///< Standard error file descriptor.
 
 /// @brief        Read data from a file descriptor.
 /// @param fd     The file descriptor.
@@ -80,7 +84,7 @@ extern pid_t getpid(void);
 ///        If pid != 0 return the SID corresponding to the process having identifier == pid
 ///@param pid process identifier from wich we want the SID
 ///@return On success return SID of the session
-///        Otherwise return -1 with errno set on: EPERM or ESRCH  
+///        Otherwise return -1 with errno set on: EPERM or ESRCH
 extern pid_t getsid(pid_t pid);
 
 ///@brief creates a new session if the calling process is not a
@@ -90,7 +94,7 @@ extern pid_t getsid(pid_t pid);
 ///       of a new process group in the session (i.e., its process group ID
 ///       is made the same as its process ID).
 ///@return On success return SID of the session just created
-///        Otherwise return -1 with errno : EPERM 
+///        Otherwise return -1 with errno : EPERM
 extern pid_t setsid(void);
 
 ///@brief returns the Process Group ID (PGID) of the process specified by pid.
@@ -117,7 +121,7 @@ extern gid_t getegid(void);
 ///@brief sets the group IDs of the calling process.
 ///@param gid the Group ID to set
 ///@return On success, zero is returned.
-///        Otherwise returns -1 with errno set to :EINVAL or EPERM  
+///        Otherwise returns -1 with errno set to :EINVAL or EPERM
 extern int setgid(gid_t gid);
 
 ///@brief sets the real and effective group IDs of the calling process.
@@ -138,7 +142,7 @@ extern uid_t geteuid(void);
 ///@brief Sets the User IDs of the calling process.
 ///@param uid the new User ID.
 ///@return On success, zero is returned.
-///        Otherwise returns -1 with errno set to :EINVAL or EPERM  
+///        Otherwise returns -1 with errno set to :EINVAL or EPERM
 extern int setuid(uid_t uid);
 
 ///@brief Sets the effective and real User IDs of the calling process.
diff --git a/libc/inc/time.h b/libc/inc/time.h
index ac75e397..eb7d3dcc 100644
--- a/libc/inc/time.h
+++ b/libc/inc/time.h
@@ -22,7 +22,7 @@
 typedef unsigned int time_t;
 
 /// Used to get information about the current time.
-typedef struct tm_t {
+typedef struct tm {
     /// Seconds [0 to 59]
     int tm_sec;
     /// Minutes [0 to 59]
@@ -44,22 +44,22 @@ typedef struct tm_t {
 } tm_t;
 
 /// Rappresents time.
-typedef struct _timeval {
+typedef struct timeval {
     time_t tv_sec;  ///< Seconds.
     time_t tv_usec; ///< Microseconds.
-} timeval;
+} timeval_t;
 
 /// Rappresents a time interval.
-typedef struct _itimerval {
-    timeval it_interval; ///< Next value.
-    timeval it_value;    ///< Current value.
-} itimerval;
+typedef struct itimerval {
+    struct timeval it_interval; ///< Next value.
+    struct timeval it_value;    ///< Current value.
+} itimerval_t;
 
 /// @brief Specify intervals of time with nanosecond precision.
 typedef struct timespec {
     time_t tv_sec; ///< Seconds.
     long tv_nsec;  ///< Nanoseconds.
-} timespec;
+} timespec_t;
 
 /// @brief Returns the current time.
 /// @param t Where the time should be stored.
@@ -97,7 +97,7 @@ size_t strftime(char *s, size_t max, const char *format, const tm_t *tm);
 /// in *req has elapsed, or the delivery of a signal that triggers the
 /// invocation of a handler in the calling thread or that terminates
 /// the process.
-int nanosleep(const timespec *req, timespec *rem);
+int nanosleep(const struct timespec *req, struct timespec *rem);
 
 /// @brief Causes the calling thread to sleep either until the number of
 ///        real-time seconds specified in seconds have elapsed or
@@ -112,7 +112,7 @@ unsigned int sleep(unsigned int seconds);
 /// @param which which timer.
 /// @param curr_value where we place the timer value.
 /// @return 0 on success, -1 on failure and errno is set to indicate the error.
-int getitimer(int which, itimerval *curr_value);
+int getitimer(int which, struct itimerval *curr_value);
 
 /// @brief The system provides each process with three interval timers, each
 /// decrementing in a distinct time domain. When any timer expires, a signal is
@@ -121,4 +121,4 @@ int getitimer(int which, itimerval *curr_value);
 /// @param new_value the new value for the timer.
 /// @param old_value output variable where the function places the previous value.
 /// @return 0 on success, -1 on failure and errno is set to indicate the error.
-int setitimer(int which, const itimerval *new_value, itimerval *old_value);
+int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
diff --git a/libc/src/crypt/sha256.c b/libc/src/crypt/sha256.c
index 8293fd0c..28e02f38 100644
--- a/libc/src/crypt/sha256.c
+++ b/libc/src/crypt/sha256.c
@@ -1,5 +1,4 @@
 /// @file sha256.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
 /// @brief Implementation of the SHA-256 hashing algorithm.
 /// @details The original code was written by Brad Conte, and is available at:
 ///     https://github.com/B-Con/crypto-algorithms
@@ -11,25 +10,65 @@
 ///     http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
 /// This implementation uses little endian byte order.
 
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[SHA256]"      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
+
 #include "crypt/sha256.h"
 
 #include <stdlib.h>
 #include <string.h>
 
-/****************************** MACROS ******************************/
-#define ROTLEFT(a, b)  (((a) << (b)) | ((a) >> (32 - (b))))
+/// @brief Rotate left operation on a 32-bit unsigned integer.
+/// @param a The value to rotate.
+/// @param b The number of positions to rotate.
+/// @return The rotated value.
+#define ROTLEFT(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
+
+/// @brief Rotate right operation on a 32-bit unsigned integer.
+/// @param a The value to rotate.
+/// @param b The number of positions to rotate.
+/// @return The rotated value.
 #define ROTRIGHT(a, b) (((a) >> (b)) | ((a) << (32 - (b))))
 
-#define CH(x, y, z)  (((x) & (y)) ^ (~(x) & (z)))
+/// @brief Chooses bits from y if x is set, otherwise from z.
+/// @param x, y, z Input values.
+/// @return Result of CH function.
+#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
+
+/// @brief Majority function used in SHA-256.
+/// @param x, y, z Input values.
+/// @return Result of the majority function.
 #define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
-#define EP0(x)       (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22))
-#define EP1(x)       (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25))
-#define SIG0(x)      (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3))
-#define SIG1(x)      (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10))
 
+/// @brief First expansion function for the working variables.
+/// @param x Input value.
+/// @return Result of EP0.
+#define EP0(x) (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22))
+
+/// @brief Second expansion function for the working variables.
+/// @param x Input value.
+/// @return Result of EP1.
+#define EP1(x) (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25))
+
+/// @brief First Sigma function for message scheduling.
+/// @param x Input value.
+/// @return Result of SIG0.
+#define SIG0(x) (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3))
+
+/// @brief Second Sigma function for message scheduling.
+/// @param x Input value.
+/// @return Result of SIG1.
+#define SIG1(x) (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10))
+
+/// Max data length for message scheduling expansion.
 #define SHA256_MAX_DATA_LENGTH (SHA256_BLOCK_SIZE * 2)
 
-/**************************** VARIABLES *****************************/
+/// @brief The constants used in the SHA-256 algorithm, as defined by the
+/// specification. These are the first 32 bits of the fractional parts of the
+/// cube roots of the first 64 primes (2..311).
 static const uint32_t k[SHA256_MAX_DATA_LENGTH] = {
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
     0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -44,35 +83,43 @@ static const uint32_t k[SHA256_MAX_DATA_LENGTH] = {
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 
-/*********************** FUNCTION DEFINITIONS ***********************/
-
-void sha256_bytes_to_hex(uint8_t *src, size_t src_length, char *out, size_t out_length)
+/// @brief Transforms the state of the SHA-256 context based on a block of input data.
+/// @param ctx Pointer to the SHA-256 context. Must not be NULL.
+/// @param data Input data block to process (64 bytes). Must not be NULL.
+static inline void __sha256_transform(SHA256_ctx_t *ctx, const uint8_t data[])
 {
-    if (out_length >= (src_length * 2 + 1)) {
-        static const char look_up[] = "0123456789abcdef";
-        for (size_t i = 0; i < src_length; ++i) {
-            *out++ = look_up[*src >> 4];
-            *out++ = look_up[*src & 0x0F];
-            src++;
-        }
-        *out = 0;
+    // Error checks: Ensure the input parameters are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return;
+    }
+    if (!data) {
+        pr_err("Input data is NULL.\n");
+        return;
     }
-}
 
-void sha256_transform(SHA256_ctx_t *ctx, const uint8_t data[])
-{
-    uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2, m[SHA256_MAX_DATA_LENGTH];
+    uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2;
+    uint32_t m[SHA256_MAX_DATA_LENGTH]; // Message schedule array.
 
+    // Step 1: Prepare the message schedule (first 16 words are directly from
+    // the input data).
     for (i = 0, j = 0; i < 16; ++i, j += 4) {
+        // Each 32-bit word is constructed from 4 consecutive 8-bit bytes from
+        // the input data.
         m[i] = (uint32_t)(data[j] << 24) |
                (uint32_t)(data[j + 1] << 16) |
                (uint32_t)(data[j + 2] << 8) |
                (uint32_t)(data[j + 3]);
     }
+
+    // Step 2: Extend the first 16 words into the remaining 48 words of the
+    // message schedule. Each word is computed based on the previous words using
+    // the SIG1 and SIG0 functions.
     for (; i < SHA256_MAX_DATA_LENGTH; ++i) {
         m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
     }
 
+    // Step 3: Initialize the working variables with the current state values.
     a = ctx->state[0];
     b = ctx->state[1];
     c = ctx->state[2];
@@ -82,19 +129,24 @@ void sha256_transform(SHA256_ctx_t *ctx, const uint8_t data[])
     g = ctx->state[6];
     h = ctx->state[7];
 
+    // Step 4: Perform the main hash computation (64 rounds).
     for (i = 0; i < SHA256_MAX_DATA_LENGTH; ++i) {
+        // Calculate the temporary values.
         t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
         t2 = EP0(a) + MAJ(a, b, c);
-        h  = g;
-        g  = f;
-        f  = e;
-        e  = d + t1;
-        d  = c;
-        c  = b;
-        b  = a;
-        a  = t1 + t2;
+
+        // Rotate the working variables for the next round.
+        h = g;
+        g = f;
+        f = e;
+        e = d + t1;
+        d = c;
+        c = b;
+        b = a;
+        a = t1 + t2;
     }
 
+    // Step 5: Add the resulting values back into the current state.
     ctx->state[0] += a;
     ctx->state[1] += b;
     ctx->state[2] += c;
@@ -105,10 +157,47 @@ void sha256_transform(SHA256_ctx_t *ctx, const uint8_t data[])
     ctx->state[7] += h;
 }
 
+/// @brief Converts a byte array into its hexadecimal string representation.
+/// @param src Pointer to the source byte array.
+/// @param src_length Length of the source byte array.
+/// @param out Pointer to the output buffer for the hexadecimal string.
+/// @param out_length Length of the output buffer (must be at least 2 * src_length + 1).
+/// @details The output string will be null-terminated if the buffer is large enough.
+void sha256_bytes_to_hex(uint8_t *src, size_t src_length, char *out, size_t out_length)
+{
+    // Check if the output buffer is large enough to hold the hex string
+    if (out_length < (src_length * 2 + 1)) {
+        pr_err("Output buffer is too small for the hex representation.\n");
+        return; // Return early if the buffer is insufficient.
+    }
+
+    // Lookup table for converting bytes to hex
+    static const char look_up[] = "0123456789abcdef";
+
+    // Convert each byte to its hex representation
+    for (size_t i = 0; i < src_length; ++i) {
+        *out++ = look_up[*src >> 4];   // Upper nibble
+        *out++ = look_up[*src & 0x0F]; // Lower nibble
+        src++;
+    }
+    *out = 0; // Null-terminate the output string
+}
+
 void sha256_init(SHA256_ctx_t *ctx)
 {
-    ctx->datalen  = 0;
-    ctx->bitlen   = 0;
+    // Error check: Ensure the input context is not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
+
+    // Initialize the length of the data (in bytes) to 0.
+    ctx->datalen = 0;
+
+    // Initialize the total length of the input data (in bits) to 0.
+    ctx->bitlen = 0;
+
+    // Initialize the state variables (hash values) to the SHA-256 initial constants.
     ctx->state[0] = 0x6a09e667;
     ctx->state[1] = 0xbb67ae85;
     ctx->state[2] = 0x3c6ef372;
@@ -121,14 +210,32 @@ void sha256_init(SHA256_ctx_t *ctx)
 
 void sha256_update(SHA256_ctx_t *ctx, const uint8_t data[], size_t len)
 {
-    uint32_t i;
+    // Error check: Ensure the input context and data are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
 
-    for (i = 0; i < len; ++i) {
+    if (!data) {
+        pr_err("Input data is NULL.\n");
+        return; // Return early if the data is NULL to prevent errors.
+    }
+
+    // Iterate over the input data, processing it in chunks.
+    for (uint32_t i = 0; i < len; ++i) {
+        // Add data to the context's buffer.
         ctx->data[ctx->datalen] = data[i];
         ctx->datalen++;
+
+        // If the buffer is full, process the data and reset the buffer.
         if (ctx->datalen == SHA256_MAX_DATA_LENGTH) {
-            sha256_transform(ctx, ctx->data);
+            // Perform the SHA-256 transformation on the full data block.
+            __sha256_transform(ctx, ctx->data);
+
+            // Update the total length of the data processed so far in bits.
             ctx->bitlen += 512;
+
+            // Reset the buffer length to 0 for the next chunk of data.
             ctx->datalen = 0;
         }
     }
@@ -136,28 +243,56 @@ void sha256_update(SHA256_ctx_t *ctx, const uint8_t data[], size_t len)
 
 void sha256_final(SHA256_ctx_t *ctx, uint8_t hash[])
 {
-    uint32_t i;
+    // Error check: Ensure the input context and hash are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
+    if (!hash) {
+        pr_err("Output hash buffer is NULL.\n");
+        return; // Return early if the output buffer is NULL to prevent errors.
+    }
+
+    // Get the current length of the data buffer.
+    uint32_t i = ctx->datalen;
 
-    i = ctx->datalen;
+    // Step 1: Pad whatever data is left in the buffer.
 
-    // Pad whatever data is left in the buffer.
+    // If there's enough space in the buffer (less than 56 bytes used), pad
+    // with 0x80 followed by zeros.
     if (ctx->datalen < 56) {
+        // Append the padding byte (0x80).
         ctx->data[i++] = 0x80;
+
+        // Pad the buffer with zeros until we reach 56 bytes.
         while (i < 56) {
             ctx->data[i++] = 0x00;
         }
-    } else {
+    }
+    // If there's not enough space, pad the remaining buffer and process it.
+    else {
+        // Append the padding byte (0x80).
         ctx->data[i++] = 0x80;
+
+        // Fill the rest of the buffer with zeros.
         while (i < SHA256_MAX_DATA_LENGTH) {
             ctx->data[i++] = 0x00;
         }
-        sha256_transform(ctx, ctx->data);
-        memset(ctx->data, 0, 56);
+
+        // Process the full buffer.
+        __sha256_transform(ctx, ctx->data); 
+
+        // Reset the buffer for the next padding.
+        memset(ctx->data, 0, 56);           
     }
 
-    // Append to the padding the total message's length in bits and transform.
-    ctx->bitlen += ctx->datalen * 8;
-    ctx->data[63] = ctx->bitlen;
+    // Step 2: Append the total message length in bits and process the final block.
+    
+    // Convert the total length from bytes to bits.
+    ctx->bitlen += ctx->datalen * 8; 
+
+    // Append the lower 8 bits of the length.
+    ctx->data[63] = ctx->bitlen;     
     ctx->data[62] = ctx->bitlen >> 8;
     ctx->data[61] = ctx->bitlen >> 16;
     ctx->data[60] = ctx->bitlen >> 24;
@@ -165,11 +300,14 @@ void sha256_final(SHA256_ctx_t *ctx, uint8_t hash[])
     ctx->data[58] = ctx->bitlen >> 40;
     ctx->data[57] = ctx->bitlen >> 48;
     ctx->data[56] = ctx->bitlen >> 56;
-    sha256_transform(ctx, ctx->data);
 
-    // Since this implementation uses little endian byte ordering and SHA uses big
-    // endian, reverse all the bytes when copying the final state to the output
-    // hash.
+    // Process the final block.
+    __sha256_transform(ctx, ctx->data);
+
+    // Step 3: Copy the final state (hash) to the output buffer.
+
+    // SHA-256 uses big-endian byte order, so we reverse the byte order when
+    // copying.
     for (i = 0; i < 4; ++i) {
         hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
         hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
diff --git a/libc/src/readline.c b/libc/src/readline.c
index b66ce2b4..ae5286f2 100644
--- a/libc/src/readline.c
+++ b/libc/src/readline.c
@@ -1,11 +1,13 @@
 /// @file readline.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
-/// @brief
-/// @version 0.1
-/// @date 2023-08-30
-///
-/// @copyright Copyright (c) 2023
-///
+/// @brief Implementation of a function that reads a line from a file descriptor.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
+/// See LICENSE.md for details.
+
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[RDLINE]"      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
 
 #include "readline.h"
 
@@ -15,43 +17,73 @@
 
 int readline(int fd, char *buffer, size_t buflen, ssize_t *read_len)
 {
+    // Error check: Ensure the buffer is not NULL and has sufficient length.
+    if (!buffer || buflen == 0) {
+        pr_err("Invalid buffer or buffer length.\n");
+        return 0; // Invalid input, cannot proceed.
+    }
+
     ssize_t length, rollback, num_read;
-    memset(buffer, 0, buflen);
     unsigned char found_newline = 1;
-    // Read from the file.
+
+    // Initialize the buffer to ensure it starts empty.
+    memset(buffer, 0, buflen);
+
+    // Read from the file descriptor into the buffer.
     num_read = read(fd, buffer, buflen);
+
+    // Error check: If read() fails, return -1 to indicate an error.
+    if (num_read < 0) {
+        pr_err("Failed to read from file descriptor.\n");
+        return -1;
+    }
+
+    // If nothing was read, return 0 to indicate the end of the file.
     if (num_read == 0) {
         return 0;
     }
-    // Search for termination character.
+
+    // Search for newline or termination character.
     char *newline = strchr(buffer, '\n');
     if (newline == NULL) {
         found_newline = 0;
-        newline       = strchr(buffer, EOF);
+        // Search for EOF.
+        newline = strchr(buffer, EOF);
         if (newline == NULL) {
-            newline = strchr(buffer, 0);
+            // Search for null terminator.
+            newline = strchr(buffer, '\0');
             if (newline == NULL) {
+                // No termination character found.
                 return 0;
             }
         }
     }
-    // Compute the length of the string.
+
+    // Compute the length of the string up to the newline or termination
+    // character.
     length = (newline - buffer);
     if (length <= 0) {
         return 0;
     }
-    // Close the string.
-    buffer[length] = 0;
-    // Compute how much we need to rollback.
+
+    // Close the string by adding a null terminator.
+    buffer[length] = '\0';
+
+    // Compute how much we need to rollback the file position after reading.
     rollback = length - num_read + 1;
     if (rollback > 1) {
-        return 0;
+        return 0; // Rollback value seems invalid.
     }
-    // Rollback the reading position in the file.
+
+    // Adjust the file's read position using lseek to undo the extra read
+    // characters.
     lseek(fd, rollback, SEEK_CUR);
-    // Set how much we were able to read from the file.
+
+    // Set the number of bytes read if the caller provided a pointer.
     if (read_len) {
         *read_len = length;
     }
+
+    // Return 1 if a newline was found, -1 otherwise (partial data read).
     return (found_newline) ? 1 : -1;
 }
diff --git a/libc/src/stdio.c b/libc/src/stdio.c
index 74d638d3..fd8be745 100644
--- a/libc/src/stdio.c
+++ b/libc/src/stdio.c
@@ -13,7 +13,7 @@
 
 void putchar(int character)
 {
-    write(STDOUT_FILENO, &character, 1);
+    write(STDOUT_FILENO, &character, 1U);
 }
 
 void puts(const char *str)
@@ -188,35 +188,57 @@ long strtol(const char *str, char **endptr, int base)
 
 int fgetc(int fd)
 {
-    unsigned char c;
-    if (read(fd, &c, 1) <= 0) {
-        return EOF;
+    char c;
+    ssize_t bytes_read;
+
+    // Read a single character from the file descriptor.
+    bytes_read = read(fd, &c, 1);
+
+    // Check for errors or EOF.
+    if (bytes_read == -1) {
+        perror("Error reading from file descriptor");
+        return EOF; // Return EOF on error.
+    } else if (bytes_read == 0) {
+        return EOF; // Return EOF if no bytes were read (end of file).
     }
-    return c;
+
+    // Return the character as an unsigned char.
+    return (unsigned char)c;
 }
 
 char *fgets(char *buf, int n, int fd)
 {
     int c;
-    char *p;
+    char *p = buf;
+    int count = n - 1; // Leave space for null terminator
+
+    // Read characters until reaching the limit or newline
+    while (count > 0) {
+        ssize_t bytes_read = read(fd, &c, 1); // Read one character
 
-    /* get max bytes or upto a newline */
-    for (p = buf, n--; n > 0; n--) {
-        // Get the character.
-        c = fgetc(fd);
-        if (c == EOF) {
+        if (bytes_read < 0) {
+            perror("Error reading from file descriptor");
+            return NULL; // Return NULL on error
+        } else if (bytes_read == 0) {
+            // End of file
             break;
         }
-        *p++ = (char)c;
+
+        *p++ = (char)c; // Store the character in the buffer
+
         if (c == '\n') {
-            break;
+            break; // Stop if we reach a newline
         }
+        count--;
     }
-    *p = 0;
+
+    *p = '\0'; // Null-terminate the string
+
     if (p == buf || c == EOF) {
-        return NULL;
+        return NULL; // Return NULL if no characters were read or EOF was reached
     }
-    return (p);
+
+    return buf; // Return the buffer
 }
 
 void perror(const char *s)
diff --git a/libc/src/sys/ipc.c b/libc/src/sys/ipc.c
index 98be4c49..2ac03097 100644
--- a/libc/src/sys/ipc.c
+++ b/libc/src/sys/ipc.c
@@ -114,7 +114,7 @@ key_t ftok(char *path, int id)
 {
     // Create a struct containing the serial number and the device number of the
     // file we use to generate the key.
-    struct stat_t st;
+    struct stat st;
     if (stat(path, &st) < 0) {
         pr_err("Cannot stat the file `%s`...\n", path);
         errno = ENOENT;
diff --git a/libc/src/sys/mman.c b/libc/src/sys/mman.c
index 17e7add8..f6433783 100644
--- a/libc/src/sys/mman.c
+++ b/libc/src/sys/mman.c
@@ -1,5 +1,4 @@
 /// @file mman.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
 /// @brief Functions for managing mappings in virtual address space.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
diff --git a/libc/src/time.c b/libc/src/time.c
index de83029d..4f2fc1f9 100644
--- a/libc/src/time.c
+++ b/libc/src/time.c
@@ -116,49 +116,49 @@ size_t strftime(char *str, size_t maxsize, const char *format, const tm_t *timep
                     break;
 #endif
             case 'b': // Abbreviated month name
-            {
-                strncat(s, months[timeptr->tm_mon], 3);
-                break;
-            }
+                {
+                    strncat(s, months[timeptr->tm_mon], 3);
+                    break;
+                }
             case 'B': // Full month name
-            {
-                unsigned int i = (unsigned int)timeptr->tm_mon;
-                strcat(s, months[i]);
-                break;
-            }
+                {
+                    unsigned int i = (unsigned int)timeptr->tm_mon;
+                    strcat(s, months[i]);
+                    break;
+                }
             case 'd': /* day of month as decimal number (01-31) */
-            {
-                value  = timeptr->tm_mday;
-                (*s++) = (char)('0' + ((value / 10) % 10));
-                (*s++) = (char)('0' + (value % 10));
-                break;
-            }
+                {
+                    value  = timeptr->tm_mday;
+                    (*s++) = (char)('0' + ((value / 10) % 10));
+                    (*s++) = (char)('0' + (value % 10));
+                    break;
+                }
             case 'H': /* hour (24-hour clock) as decimal (00-23) */
-            {
-                value  = timeptr->tm_hour;
-                (*s++) = (char)('0' + ((value / 10) % 10));
-                (*s++) = (char)('0' + (value % 10));
-                break;
-            }
+                {
+                    value  = timeptr->tm_hour;
+                    (*s++) = (char)('0' + ((value / 10) % 10));
+                    (*s++) = (char)('0' + (value % 10));
+                    break;
+                }
 #if 0
                 case 'I':    /* hour (12-hour clock) as decimal (01-12) */
                     SPRINTF("%02d", ((timeptr->tm_hour + 11) % 12) + 1);
                     break;
 #endif
             case 'j': // Day of year as decimal number (001-366)
-            {
-                value  = timeptr->tm_yday;
-                (*s++) = (char)('0' + ((value / 10) % 10));
-                (*s++) = (char)('0' + (value % 10));
-                break;
-            }
+                {
+                    value  = timeptr->tm_yday;
+                    (*s++) = (char)('0' + ((value / 10) % 10));
+                    (*s++) = (char)('0' + (value % 10));
+                    break;
+                }
             case 'm': // Month as decimal number (01-12)
-            {
-                value  = timeptr->tm_mon;
-                (*s++) = (char)('0' + ((value / 10) % 10));
-                (*s++) = (char)('0' + (value % 10));
-                break;
-            }
+                {
+                    value  = timeptr->tm_mon;
+                    (*s++) = (char)('0' + ((value / 10) % 10));
+                    (*s++) = (char)('0' + (value % 10));
+                    break;
+                }
 #if 0
                 case 'M':    /* month as decimal number (00-59) */
                     SPRINTF("%02d", timeptr->tm_min);
@@ -381,11 +381,11 @@ size_t strftime(char *str, size_t maxsize, const char *format, const tm_t *timep
 }
 
 /// @brief nanosleep function.
-_syscall2(int, nanosleep, const timespec *, req, timespec *, rem)
+_syscall2(int, nanosleep, const struct timespec *, req, struct timespec *, rem)
 
-    unsigned int sleep(unsigned int seconds)
+unsigned int sleep(unsigned int seconds)
 {
-    timespec req, rem;
+    struct timespec req, rem;
     req.tv_sec = seconds;
     // Call the nanosleep.
     int __ret = nanosleep(&req, &rem);
@@ -397,6 +397,6 @@ _syscall2(int, nanosleep, const timespec *, req, timespec *, rem)
     return 0;
 }
 
-_syscall2(int, getitimer, int, which, itimerval *, curr_value)
+_syscall2(int, getitimer, int, which, struct itimerval *, curr_value)
 
-    _syscall3(int, setitimer, int, which, const itimerval *, new_value, itimerval *, old_value)
+_syscall3(int, setitimer, int, which, const struct itimerval *, new_value, struct itimerval *, old_value)
diff --git a/libc/src/vsprintf.c b/libc/src/vsprintf.c
index 30a44df2..1443ff78 100644
--- a/libc/src/vsprintf.c
+++ b/libc/src/vsprintf.c
@@ -3,6 +3,12 @@
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[PRINTF]"      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
+
 #include "sys/bitops.h"
 #include "ctype.h"
 #include "fcvt.h"
@@ -29,249 +35,347 @@ static char *_digits = "0123456789abcdefghijklmnopqrstuvwxyz";
 /// The list of uppercase digits.
 static char *_upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
-/// @brief Returns the index of the first non-integer character.
+/// @brief Returns the integer value parsed from the beginning of the string
+/// until a non-integer character is found.
 /// @param s the string we need to analyze.
-/// @return the index of the first non-integer character.
+/// @return the integer value represented by the initial digits in the string.
+/// @note This function assumes that `s` points to a valid string and will stop
+/// parsing at the first non-integer character.
 static inline int skip_atoi(const char **s)
 {
+    // Error check to ensure that the string pointer is valid.
+    if (s == NULL || *s == NULL) {
+        pr_crit("skip_atoi: Invalid string pointer.\n");
+        return -1;
+    }
+
     int i = 0;
+
+    // Iterate through the string as long as we encounter digits.
     while (isdigit(**s)) {
+        // Convert the current digit character to its integer value.
         i = i * 10 + *((*s)++) - '0';
     }
-    return i;
+
+    return i; // Return the parsed integer value.
 }
 
 /// @brief Transforms the number into a string.
 /// @param str the output string.
 /// @param num the number to transform to string.
-/// @param base the base to use for number transformation.
-/// @param size the size of the output string.
-/// @param precision the precision for floating point numbers.
-/// @param flags control flags.
-/// @return the number turned into a string.
+/// @param base the base to use for number transformation (e.g., 10 for decimal, 16 for hex).
+/// @param size the minimum size of the output string (pads with '0' or spaces if necessary).
+/// @param precision the precision for number conversion (affects floating point numbers and zero padding).
+/// @param flags control flags (e.g., for padding, sign, and case sensitivity).
+/// @return the resulting string after number transformation.
 static char *number(char *str, long num, int base, int size, int32_t precision, unsigned flags)
 {
-    char c, tmp[66] = { 0 };
-    char *dig = _digits;
+    char tmp[66] = { 0 };   // Temporary buffer to hold the number in reverse order
+    char *dig    = _digits; // Default digits for base conversion (lowercase)
 
+    // Check for uppercase conversion flag.
     if (bitmask_check(flags, FLAGS_UPPERCASE)) {
-        dig = _upper_digits;
+        dig = _upper_digits; // Use uppercase digits if the flag is set
     }
+
+    // Disable zero padding if left alignment is specified.
     if (bitmask_check(flags, FLAGS_LEFT)) {
         bitmask_clear_assign(flags, FLAGS_ZEROPAD);
     }
+
+    // Error handling: base must be between 2 and 36.
     if (base < 2 || base > 36) {
-        return 0;
+        pr_crit("number: Unsupported base %d.\n", base);
+        return 0; // Return NULL if the base is invalid.
     }
 
-    c = bitmask_check(flags, FLAGS_ZEROPAD) ? '0' : ' ';
+    // Set padding character based on the FLAGS_ZEROPAD flag (either '0' or ' ').
+    const int paddingc = bitmask_check(flags, FLAGS_ZEROPAD) ? '0' : ' ';
 
-    // --------------------------------
-    // Set the sign.
-    // --------------------------------
+    // Set the sign (for signed numbers).
     char sign = 0;
     if (bitmask_check(flags, FLAGS_SIGN)) {
         if (num < 0) {
-            sign = '-';
-            num  = -num;
-            size--;
+            sign = '-';  // Negative sign for negative numbers
+            num  = -num; // Make number positive
+            size--;      // Reduce size for the sign
         } else if (bitmask_check(flags, FLAGS_PLUS)) {
-            sign = '+';
+            sign = '+'; // Positive sign for positive numbers
             size--;
         } else if (bitmask_check(flags, FLAGS_SPACE)) {
-            sign = ' ';
+            sign = ' '; // Space for positive numbers
             size--;
         }
     }
-    // Sice I've removed the sign (if negative), i can transform it to unsigned.
+
+    // Convert the number to unsigned for further processing.
     uint32_t uns_num = (uint32_t)num;
+
+    // Handle the FLAGS_HASH for octal (base 8) and hexadecimal (base 16).
     if (bitmask_check(flags, FLAGS_HASH)) {
         if (base == 16) {
-            size -= 2;
+            size -= 2; // Hexadecimal prefix "0x" or "0X" uses 2 characters.
         } else if (base == 8) {
-            size--;
+            size--; // Octal prefix "0" uses 1 character.
         }
     }
 
+    // Convert the number to the target base.
     int32_t i = 0;
     if (uns_num == 0) {
-        tmp[i++] = '0';
+        tmp[i++] = '0'; // Handle zero case explicitly.
     } else {
         while (uns_num != 0) {
-            tmp[i++] = dig[((unsigned long)uns_num) % (unsigned)base];
-            uns_num  = ((unsigned long)uns_num) / (unsigned)base;
+            tmp[i++] = dig[((unsigned long)uns_num) % (unsigned)base]; // Convert to base
+            uns_num  = ((unsigned long)uns_num) / (unsigned)base;      // Divide by base
         }
     }
+
+    // Ensure precision is at least as large as the number's length.
     if (i > precision) {
         precision = i;
     }
+
+    // Adjust the size based on the precision.
     size -= precision;
+
+    // Write padding spaces if right-aligned and no zero padding.
     if (!bitmask_check(flags, FLAGS_ZEROPAD | FLAGS_LEFT)) {
         while (size-- > 0) {
             *str++ = ' ';
         }
     }
+
+    // Write the sign character if necessary.
     if (sign) {
         *str++ = sign;
     }
+
+    // Write the prefix for octal and hexadecimal if the FLAGS_HASH is set.
     if (bitmask_check(flags, FLAGS_HASH)) {
         if (base == 8) {
-            *str++ = '0';
+            *str++ = '0'; // Octal prefix.
         } else if (base == 16) {
-            *str++ = '0';
-            *str++ = _digits[33];
+            *str++ = '0';         // Hexadecimal prefix "0x".
+            *str++ = _digits[33]; // 'x' or 'X' based on FLAGS_UPPERCASE.
         }
     }
+
+    // Write zero-padding if necessary.
     if (!bitmask_check(flags, FLAGS_LEFT)) {
         while (size-- > 0) {
-            *str++ = c;
+            *str++ = paddingc; // Pad with '0' or ' '.
         }
     }
+
+    // Write any additional zeros required by the precision.
     while (i < precision--) {
         *str++ = '0';
     }
+
+    // Write the number in reverse order (tmp array holds the reversed digits).
     while (i-- > 0) {
         *str++ = tmp[i];
     }
+
+    // If the number is left-aligned, pad remaining space with spaces.
     while (size-- > 0) {
         *str++ = ' ';
     }
-    return str;
+
+    return str; // Return the resulting string pointer.
 }
 
+/// @brief Converts a MAC address into a human-readable string format.
+/// @param str The output string where the MAC address will be written.
+/// @param addr The 6-byte MAC address to be formatted.
+/// @param size The minimum field width for the output (pads with spaces if necessary).
+/// @param precision Unused in this function (for compatibility with similar functions).
+/// @param flags Control flags that affect the format (e.g., uppercase and left alignment).
+/// @return Pointer to the end of the output string.
 static char *eaddr(char *str, unsigned char *addr, int size, int precision, unsigned flags)
 {
-    (void)precision;
-    char tmp[24];
-    char *dig = _digits;
-    int i, len;
+    (void)precision; // Precision is unused in this function.
 
+    char tmp[24];        // Temporary buffer to hold the formatted MAC address.
+    char *dig = _digits; // Default digits for hex conversion (lowercase by default).
+    int i, len = 0;
+
+    // Use uppercase hex digits if the FLAGS_UPPERCASE flag is set.
     if (bitmask_check(flags, FLAGS_UPPERCASE)) {
         dig = _upper_digits;
     }
 
-    len = 0;
+    // Convert each byte of the MAC address to hex format.
     for (i = 0; i < 6; i++) {
+        // Add colon separator between address bytes.
         if (i != 0) {
             tmp[len++] = ':';
         }
-        tmp[len++] = dig[addr[i] >> 4];
-        tmp[len++] = dig[addr[i] & 0x0F];
+
+        tmp[len++] = dig[addr[i] >> 4];   // Convert upper nibble to hex.
+        tmp[len++] = dig[addr[i] & 0x0F]; // Convert lower nibble to hex.
     }
 
+    // Handle right alignment if the FLAGS_LEFT flag is not set.
     if (!bitmask_check(flags, FLAGS_LEFT)) {
         while (len < size--) {
-            *str++ = ' ';
+            *str++ = ' '; // Pad with spaces on the left if needed.
         }
     }
 
+    // Copy the formatted MAC address from tmp buffer to the output string.
     for (i = 0; i < len; ++i) {
         *str++ = tmp[i];
     }
 
+    // Handle left padding if the FLAGS_LEFT flag is set.
     while (len < size--) {
-        *str++ = ' ';
+        *str++ = ' '; // Pad with spaces on the right if needed.
     }
 
-    return str;
+    return str; // Return the pointer to the end of the output string.
 }
 
+/// @brief Converts an IPv4 address into a human-readable string format.
+/// @param str The output string where the IPv4 address will be written.
+/// @param addr The 4-byte IPv4 address to be formatted.
+/// @param size The minimum field width for the output (pads with spaces if necessary).
+/// @param precision Unused in this function (for compatibility with similar functions).
+/// @param flags Control flags that affect the format (e.g., left alignment).
+/// @return Pointer to the end of the output string.
 static char *iaddr(char *str, unsigned char *addr, int size, int precision, unsigned flags)
 {
-    (void)precision;
+    (void)precision; // Precision is unused in this function.
+
+    // Temporary buffer to hold the formatted IP address.
     char tmp[24];
-    int i, n, len;
+    int i, n, len = 0;
 
-    len = 0;
+    // Convert each byte of the IP address to decimal format.
     for (i = 0; i < 4; i++) {
+        // Add a dot between each octet.
         if (i != 0) {
             tmp[len++] = '.';
         }
+
+        // Current octet of the IP address.
         n = addr[i];
 
+        // Convert the current octet to decimal digits.
         if (n == 0) {
+            // Handle the case where the octet is zero.
             tmp[len++] = _digits[0];
         } else {
+            // If the number is greater than or equal to 100, we need to extract
+            // hundreds, tens, and units.
             if (n >= 100) {
-                tmp[len++] = _digits[n / 100];
+                tmp[len++] = _digits[n / 100]; // Hundreds place.
                 n          = n % 100;
-                tmp[len++] = _digits[n / 10];
+                tmp[len++] = _digits[n / 10]; // Tens place.
                 n          = n % 10;
             } else if (n >= 10) {
-                tmp[len++] = _digits[n / 10];
+                // If the number is between 10 and 99, we only need tens and units.
+                tmp[len++] = _digits[n / 10]; // Tens place.
                 n          = n % 10;
             }
 
+            // Finally, add the unit digit.
             tmp[len++] = _digits[n];
         }
     }
 
+    // Handle right alignment if the FLAGS_LEFT flag is not set.
     if (!bitmask_check(flags, FLAGS_LEFT)) {
+        // Pad with spaces on the left if needed.
         while (len < size--) {
             *str++ = ' ';
         }
     }
 
+    // Copy the formatted IP address from tmp buffer to the output string.
     for (i = 0; i < len; ++i) {
         *str++ = tmp[i];
     }
 
+    // Handle left padding if the FLAGS_LEFT flag is set. Pad with spaces on the
+    // right if needed.
     while (len < size--) {
         *str++ = ' ';
     }
 
-    return str;
+    return str; // Return the pointer to the end of the output string.
 }
 
+/// @brief Converts a floating-point number to a string with a specified format.
+/// @param value The floating-point value to be converted.
+/// @param buffer The output buffer to store the resulting string.
+/// @param fmt The format specifier ('e', 'f', or 'g').
+/// @param precision The number of digits to be displayed after the decimal
+/// point.
 static void cfltcvt(double value, char *buffer, char fmt, int precision)
 {
     int decpt, sign, exp, pos;
-    char cvtbuf[CVTBUFSIZE];
-    char *digits = cvtbuf;
-    int capexp   = 0;
+    char cvtbuf[CVTBUFSIZE]; // Temporary buffer to store the digits.
+    char *digits = cvtbuf;   // Pointer to the digit buffer.
+    int capexp   = 0;        // Flag to check for uppercase exponent.
     int magnitude;
 
+    // Handle uppercase 'G' or 'E' format specifier.
+    // Convert them to lowercase 'g' or 'e' for uniform processing.
     if (fmt == 'G' || fmt == 'E') {
-        capexp = 1;
-        fmt += 'a' - 'A';
+        capexp = 1;       // Set capexp to handle uppercase exponent.
+        fmt += 'a' - 'A'; // Convert to lowercase.
     }
 
+    // Handle 'g' format: choose between 'e' or 'f' based on magnitude.
     if (fmt == 'g') {
         ecvtbuf(value, precision, &decpt, &sign, cvtbuf, CVTBUFSIZE);
-        magnitude = decpt - 1;
+        magnitude = decpt - 1; // Calculate magnitude of the number.
+
+        // If magnitude is out of range for 'f', use scientific notation 'e'.
         if (magnitude < -4 || magnitude > precision - 1) {
             fmt = 'e';
-            precision -= 1;
+            precision -= 1; // Adjust precision for 'e' format.
         } else {
             fmt = 'f';
-            precision -= decpt;
+            precision -= decpt; // Adjust precision for 'f' format.
         }
     }
 
+    // Handle scientific notation ('e' format).
     if (fmt == 'e') {
+        // Convert the number to scientific format.
         ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf, CVTBUFSIZE);
 
+        // Add the sign to the output buffer if necessary.
         if (sign) {
             *buffer++ = '-';
         }
+
+        // Add the first digit.
         *buffer++ = *digits;
+
+        // Add the decimal point and remaining digits.
         if (precision > 0) {
             *buffer++ = '.';
         }
+
+        // Copy the remaining digits.
         memcpy(buffer, digits + 1, precision);
         buffer += precision;
+
+        // Add the exponent character ('e' or 'E').
         *buffer++ = capexp ? 'E' : 'e';
 
+        // Calculate the exponent.
         if (decpt == 0) {
-            if (value == 0.0) {
-                exp = 0;
-            } else {
-                exp = -1;
-            }
+            exp = (value == 0.0) ? 0 : -1;
         } else {
             exp = decpt - 1;
         }
 
+        // Add the sign of the exponent.
         if (exp < 0) {
             *buffer++ = '-';
             exp       = -exp;
@@ -279,28 +383,44 @@ static void cfltcvt(double value, char *buffer, char fmt, int precision)
             *buffer++ = '+';
         }
 
+        // Add the exponent digits (e.g., '01', '02').
         buffer[2] = (char)((exp % 10) + '0');
-        exp       = exp / 10;
+        exp /= 10;
         buffer[1] = (char)((exp % 10) + '0');
-        exp       = exp / 10;
+        exp /= 10;
         buffer[0] = (char)((exp % 10) + '0');
         buffer += 3;
-    } else if (fmt == 'f') {
+    }
+    // Handle fixed-point notation ('f' format).
+    else if (fmt == 'f') {
+        // Convert the number to fixed-point format.
         fcvtbuf(value, precision, &decpt, &sign, cvtbuf, CVTBUFSIZE);
+
+        // Add the sign to the output buffer if necessary.
         if (sign) {
             *buffer++ = '-';
         }
+
+        // If digits exist, process them.
         if (*digits) {
+            // Handle the case where the decimal point is before the first
+            // digit.
             if (decpt <= 0) {
                 *buffer++ = '0';
                 *buffer++ = '.';
+
+                // Add leading zeros before the first significant digit.
                 for (pos = 0; pos < -decpt; pos++) {
                     *buffer++ = '0';
                 }
+
+                // Copy the digits.
                 while (*digits) {
                     *buffer++ = *digits++;
                 }
-            } else {
+            }
+            // Handle normal case where decimal point is after some digits.
+            else {
                 pos = 0;
                 while (*digits) {
                     if (pos++ == decpt) {
@@ -309,7 +429,9 @@ static void cfltcvt(double value, char *buffer, char fmt, int precision)
                     *buffer++ = *digits++;
                 }
             }
-        } else {
+        }
+        // Handle case where the value is zero.
+        else {
             *buffer++ = '0';
             if (precision > 0) {
                 *buffer++ = '.';
@@ -320,163 +442,227 @@ static void cfltcvt(double value, char *buffer, char fmt, int precision)
         }
     }
 
-    *buffer = '\0';
+    *buffer = '\0'; // Null-terminate the string.
 }
 
+/// @brief Ensures that a decimal point is present in the given number string.
+/// @param buffer The string representation of a number.
 static void forcdecpt(char *buffer)
 {
+    // Traverse the buffer to check if there is already a decimal point or an
+    // exponent ('e' or 'E').
     while (*buffer) {
         if (*buffer == '.') {
-            return;
+            return; // Decimal point found, no need to modify.
         }
         if (*buffer == 'e' || *buffer == 'E') {
-            break;
+            break; // Reached exponent part of the number, stop checking.
         }
-
-        buffer++;
+        buffer++; // Move to the next character.
     }
 
+    // If an exponent ('e' or 'E') is found, shift the exponent part to make
+    // space for the decimal point.
     if (*buffer) {
+        // Get the length of the exponent part.
         long n = (long)strlen(buffer);
+
+        // Shift the buffer contents one position to the right to make space for
+        // the decimal point.
         while (n > 0) {
             buffer[n + 1] = buffer[n];
             n--;
         }
+
+        // Insert the decimal point.
         *buffer = '.';
-    } else {
-        *buffer++ = '.';
-        *buffer   = '\0';
+    }
+    // If no exponent is found, append the decimal point at the end of the string.
+    else {
+        *buffer++ = '.';  // Add decimal point at the current end.
+        *buffer   = '\0'; // Null-terminate the string.
     }
 }
 
+/// @brief Removes trailing zeros after the decimal point in a number string.
+/// @param buffer The string representation of a number.
 static void cropzeros(char *buffer)
 {
     char *stop;
 
+    // Traverse until a decimal point is found or the end of the string is
+    // reached.
     while (*buffer && *buffer != '.') {
         buffer++;
     }
 
-    if (*buffer++) {
+    // If there is a decimal point, find the position of the exponent or the end
+    // of the number.
+    if (*buffer++) { // Move past the decimal point.
+        // Continue until 'e', 'E', or end of string is found.
         while (*buffer && *buffer != 'e' && *buffer != 'E') {
             buffer++;
         }
+
+        // Store position of 'e', 'E', or end of the string, and backtrack one
+        // step.
         stop = buffer--;
+
+        // Backtrack over trailing zeros.
         while (*buffer == '0') {
             buffer--;
         }
+
+        // If a decimal point is found with no significant digits after,
+        // backtrack to remove it.
         if (*buffer == '.') {
             buffer--;
         }
+
+        // Shift the string forward to overwrite any unnecessary characters
+        // (trailing zeros or decimal point).
         while ((*++buffer = *stop++)) {}
     }
 }
 
+/// @brief Formats a floating-point number into a string with specified options.
+///
+/// @details This function converts a floating-point number into a string
+/// representation based on the specified format, precision, and flags. It
+/// handles alignment, padding, and sign appropriately.
+///
+/// @param str Pointer to the output string where the formatted number will be stored.
+/// @param num The floating-point number to format.
+/// @param size The total size of the output string, including padding.
+/// @param precision The number of digits to display after the decimal point.
+/// @param fmt The format specifier for the output ('f', 'g', 'e', etc.).
+/// @param flags Control flags that modify the output format (e.g., left alignment, zero padding).
+///
+/// @return Pointer to the next position in the output string after the formatted number.
 static char *flt(char *str, double num, int size, int precision, char fmt, unsigned flags)
 {
-    char tmp[80];
+    char workbuf[80];
     char c, sign;
     int n, i;
 
-    // Left align means no zero padding.
+    /// If the `FLAGS_LEFT` is set, clear the `FLAGS_ZEROPAD` flag.
+    /// Left alignment implies no zero padding.
     if (bitmask_check(flags, FLAGS_LEFT)) {
         bitmask_clear_assign(flags, FLAGS_ZEROPAD);
     }
 
-    // Determine padding and sign char.
+    /// Determine the padding character (`c`) and the sign of the number.
+    /// If `FLAGS_ZEROPAD` is set, the padding will be '0', otherwise it will be
+    /// a space (' ').
     c    = bitmask_check(flags, FLAGS_ZEROPAD) ? '0' : ' ';
     sign = 0;
+
+    /// Check the `FLAGS_SIGN` flag to determine if the sign should be added.
     if (bitmask_check(flags, FLAGS_SIGN)) {
         if (num < 0.0) {
+            /// If the number is negative, set `sign` to '-' and make the number
+            /// positive.
             sign = '-';
             num  = -num;
-            size--;
+            size--; // Reduce size for the sign character.
         } else if (bitmask_check(flags, FLAGS_PLUS)) {
+            /// If `FLAGS_PLUS` is set, prepend a '+' to positive numbers.
             sign = '+';
             size--;
         } else if (bitmask_check(flags, FLAGS_SPACE)) {
+            /// If `FLAGS_SPACE` is set, prepend a space to positive numbers.
             sign = ' ';
             size--;
         }
     }
 
-    // Compute the precision value.
+    /// Set the default precision if no precision is provided.
     if (precision < 0) {
-        // Default precision: 6.
-        precision = 6;
+        precision = 6; // Default precision is 6 decimal places.
     } else if (precision == 0 && fmt == 'g') {
-        // ANSI specified.
-        precision = 1;
+        precision = 1; // For format 'g', default precision is 1.
     }
 
-    // Convert floating point number to text.
-    cfltcvt(num, tmp, fmt, precision);
+    /// Convert the floating-point number `num` into a string `workbuf` using the
+    /// given format `fmt`.
+    cfltcvt(num, workbuf, fmt, precision);
 
-    // '#' and precision == 0 means force a decimal point.
+    /// If the `FLAGS_HASH` is set and precision is 0, force a decimal point in
+    /// the output.
     if (bitmask_check(flags, FLAGS_HASH) && (precision == 0)) {
-        forcdecpt(tmp);
+        forcdecpt(workbuf);
     }
 
-    // 'g' format means crop zero unless '#' given.
+    /// For format 'g', remove trailing zeros unless `FLAGS_HASH` is set.
     if ((fmt == 'g') && !bitmask_check(flags, FLAGS_HASH)) {
-        cropzeros(tmp);
+        cropzeros(workbuf);
     }
 
-    n = strlen(tmp);
+    /// Calculate the length of the resulting string `workbuf`.
+    n = strnlen(workbuf, 80);
 
-    // Output number with alignment and padding.
+    /// Adjust size to account for the length of the output string.
     size -= n;
+
+    /// Add padding spaces before the number if neither `FLAGS_ZEROPAD` nor `FLAGS_LEFT` are set.
     if (!bitmask_check(flags, FLAGS_ZEROPAD | FLAGS_LEFT)) {
         while (size-- > 0) {
             *str++ = ' ';
         }
     }
 
+    /// Add the sign character (if any) before the number.
     if (sign) {
         *str++ = sign;
     }
 
+    /// Add padding characters (either '0' or spaces) before the number if `FLAGS_ZEROPAD` is set.
     if (!bitmask_check(flags, FLAGS_LEFT)) {
         while (size-- > 0) {
             *str++ = c;
         }
     }
 
+    /// Copy the formatted number string to the output `str`.
     for (i = 0; i < n; i++) {
-        *str++ = tmp[i];
+        *str++ = workbuf[i];
     }
 
+    /// Add padding spaces after the number if `FLAGS_LEFT` is set (left-aligned output).
     while (size-- > 0) {
         *str++ = ' ';
     }
 
-    return str;
+    return str; /// Return the resulting string after formatting the number.
 }
 
 int vsprintf(char *str, const char *fmt, va_list args)
 {
-    int base;
-    char *tmp;
-    char *s;
+    int base;       // Base for number formatting.
+    char *tmp;      // Pointer to current position in the output buffer.
+    char *s;        // Pointer for string formatting.
+    unsigned flags; // Flags for number formatting.
+    char qualifier; // Character qualifier for integer fields ('h', 'l', or 'L').
 
-    // Flags to number().
-    unsigned flags;
-
-    // 'h', 'l', or 'L' for integer fields.
-    char qualifier;
+    // Check for null input buffer or format string.
+    if (str == NULL || fmt == NULL) {
+        return -1; // Error: null pointer provided.
+    }
 
     for (tmp = str; *fmt; fmt++) {
         if (*fmt != '%') {
-            *tmp++ = *fmt;
-
+            *tmp++ = *fmt; // Directly copy non-format characters.
             continue;
         }
 
-        // Process flags-
+        // Reset flags for each new format specifier.
         flags = 0;
+
     repeat:
-        // This also skips first '%'.
+
+        // Process format flags (skips first '%').
         fmt++;
+
         switch (*fmt) {
         case '-':
             bitmask_set_assign(flags, FLAGS_LEFT);
@@ -496,8 +682,7 @@ int vsprintf(char *str, const char *fmt, va_list args)
         }
 
         // Get the width of the output field.
-        int32_t field_width;
-        field_width = -1;
+        int32_t field_width = -1;
 
         if (isdigit(*fmt)) {
             field_width = skip_atoi(&fmt);
@@ -510,9 +695,8 @@ int vsprintf(char *str, const char *fmt, va_list args)
             }
         }
 
-        /* Get the precision, thus the minimum number of digits for
-         * integers; max number of chars for from string.
-         */
+        // Get the precision, thus the minimum number of digits for integers;
+        // max number of chars for from string.
         int32_t precision = -1;
         if (*fmt == '.') {
             ++fmt;
@@ -534,52 +718,62 @@ int vsprintf(char *str, const char *fmt, va_list args)
             fmt++;
         }
 
-        // Default base.
+        // Default base for integer conversion.
         base = 10;
 
         switch (*fmt) {
         case 'c':
+            // Handle left padding.
             if (!bitmask_check(flags, FLAGS_LEFT)) {
                 while (--field_width > 0) {
                     *tmp++ = ' ';
                 }
             }
+            // Add the character.
             *tmp++ = va_arg(args, char);
+            // Handle right padding.
             while (--field_width > 0) {
                 *tmp++ = ' ';
             }
             continue;
 
         case 's':
+            // Handle string formatting.
             s = va_arg(args, char *);
             if (!s) {
                 s = "<NULL>";
             }
-
+            // Get the length of the string.
             int32_t len = (int32_t)strnlen(s, (uint32_t)precision);
+            // Handle left padding.
             if (!bitmask_check(flags, FLAGS_LEFT)) {
                 while (len < field_width--) {
                     *tmp++ = ' ';
                 }
             }
-
-            int32_t it;
-            for (it = 0; it < len; ++it) {
+            // Add the string.
+            for (int32_t it = 0; it < len; ++it) {
                 *tmp++ = *s++;
             }
+            // Handle right padding.
             while (len < field_width--) {
                 *tmp++ = ' ';
             }
             continue;
 
         case 'p':
+
+            // Handle pointer formatting.
             if (field_width == -1) {
                 field_width = 2 * sizeof(void *);
+                // Zero pad for pointers.
                 bitmask_set_assign(flags, FLAGS_ZEROPAD);
             }
             tmp = number(tmp, (unsigned long)va_arg(args, void *), 16, field_width, precision, flags);
             continue;
+
         case 'n':
+            // Handle writing the number of characters written.
             if (qualifier == 'l') {
                 long *ip = va_arg(args, long *);
                 *ip      = (tmp - str);
@@ -588,79 +782,84 @@ int vsprintf(char *str, const char *fmt, va_list args)
                 *ip     = (tmp - str);
             }
             continue;
+
         case 'A':
+            // Handle hexadecimal formatting with uppercase.
             bitmask_set_assign(flags, FLAGS_UPPERCASE);
             break;
+
         case 'a':
+            // Handle address formatting (either Ethernet or IP).
             if (qualifier == 'l') {
                 tmp = eaddr(tmp, va_arg(args, unsigned char *), field_width, precision, flags);
             } else {
                 tmp = iaddr(tmp, va_arg(args, unsigned char *), field_width, precision, flags);
             }
             continue;
-            // Integer number formats - set up the flags and "break".
+
         case 'o':
+            // Integer number formats.
             base = 8;
             break;
 
         case 'X':
+            // Handle hexadecimal formatting with uppercase.
             bitmask_set_assign(flags, FLAGS_UPPERCASE);
             break;
 
         case 'x':
+            // Handle hexadecimal formatting.
             base = 16;
             break;
 
         case 'd':
         case 'i':
+            // Handle signed integer formatting.
             bitmask_set_assign(flags, FLAGS_SIGN);
 
         case 'u':
+            // Handle unsigned integer formatting.
             break;
+
         case 'E':
         case 'G':
         case 'e':
         case 'f':
         case 'g':
+            // Handle floating-point formatting.
             tmp = flt(tmp, va_arg(args, double), field_width, precision, *fmt, bitmask_set(flags, FLAGS_SIGN));
             continue;
+
         default:
             if (*fmt != '%') {
-                *tmp++ = '%';
+                *tmp++ = '%'; // Output '%' if not a format specifier.
             }
             if (*fmt) {
-                *tmp++ = *fmt;
+                *tmp++ = *fmt; // Output the current character.
             } else {
-                --fmt;
+                --fmt; // Handle the case of trailing '%'.
             }
             continue;
         }
 
+        // Process the integer value.
         if (bitmask_check(flags, FLAGS_SIGN)) {
-            long num;
-            if (qualifier == 'l') {
-                num = va_arg(args, long);
-            } else if (qualifier == 'h') {
-                num = va_arg(args, short);
-            } else {
-                num = va_arg(args, int);
-            }
+            long num = (qualifier == 'l') ? va_arg(args, long) :
+                       (qualifier == 'h') ? va_arg(args, short) :
+                                            va_arg(args, int);
+            // Add the number.
             tmp = number(tmp, num, base, field_width, precision, flags);
         } else {
-            unsigned long num;
-            if (qualifier == 'l') {
-                num = va_arg(args, unsigned long);
-            } else if (qualifier == 'h') {
-                num = va_arg(args, unsigned short);
-            } else {
-                num = va_arg(args, unsigned int);
-            }
+            unsigned long num = (qualifier == 'l') ? va_arg(args, unsigned long) :
+                                (qualifier == 'h') ? va_arg(args, unsigned short) :
+                                                     va_arg(args, unsigned int);
+            // Add the number.
             tmp = number(tmp, num, base, field_width, precision, flags);
         }
     }
 
-    *tmp = '\0';
-    return tmp - str;
+    *tmp = '\0';             // Null-terminate the output string.
+    return (int)(tmp - str); // Return the number of characters written.
 }
 
 int printf(const char *fmt, ...)
diff --git a/mentos/CMakeLists.txt b/mentos/CMakeLists.txt
index 18f9974c..280bca16 100644
--- a/mentos/CMakeLists.txt
+++ b/mentos/CMakeLists.txt
@@ -89,6 +89,7 @@ set(KERNEL_SOURCES
     ${CMAKE_SOURCE_DIR}/mentos/src/mem/vmem_map.c
     ${CMAKE_SOURCE_DIR}/mentos/src/mem/zone_allocator.c
     ${CMAKE_SOURCE_DIR}/mentos/src/elf/elf.c
+    ${CMAKE_SOURCE_DIR}/mentos/src/crypt/sha256.c
     ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/gdt.c
     ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/gdt.S
     ${CMAKE_SOURCE_DIR}/mentos/src/descriptor_tables/interrupt.c
diff --git a/mentos/inc/drivers/ps2.h b/mentos/inc/drivers/ps2.h
index f06a50df..381319a5 100644
--- a/mentos/inc/drivers/ps2.h
+++ b/mentos/inc/drivers/ps2.h
@@ -9,10 +9,21 @@
 /// @return 0 on success, 1 on failure.
 int ps2_initialize(void);
 
-/// @brief Writes data to the PS/2 port.
-/// @param data the data to write.
-void ps2_write(unsigned char data);
+/// @brief Writes a byte of data to the PS/2 device.
+/// @details This function waits until the input buffer of the PS/2 controller
+/// is empty before sending the specified data byte to the PS/2 data register.
+/// @param data The byte of data to be sent to the PS/2 device.
+void ps2_write_data(unsigned char data);
 
-/// @brief Reads data from the PS/2 port.
-/// @return the data coming from the PS/2 port.
-unsigned char ps2_read(void);
+/// @brief Sends a command to the PS/2 controller.
+/// @details This function waits until the input buffer of the PS/2 controller
+/// is empty before writing the specified command to the PS/2 command register.
+/// @param command The command byte to be sent to the PS/2 controller.
+void ps2_write_command(unsigned char command);
+
+/// @brief Reads a byte of data from the PS/2 device.
+/// @details This function waits until data is available in the output buffer of
+/// the PS/2 controller. Once data is available, it reads and returns the byte
+/// from the PS/2 data register.
+/// @return The byte of data read from the PS/2 device.
+unsigned char ps2_read_data(void);
diff --git a/mentos/inc/fs/namei.h b/mentos/inc/fs/namei.h
index 3a89d3aa..116ade9b 100644
--- a/mentos/inc/fs/namei.h
+++ b/mentos/inc/fs/namei.h
@@ -11,10 +11,10 @@
 #define FOLLOW_LINKS          1 << 1
 #define CREAT_LAST_COMPONENT  1 << 2
 
-/// @brief Resolve the path by following all symbolic links.
-/// @param path The path to resolve.
-/// @param buffer The buffer where the resolved path is stored.
-/// @param buflen The size of the provided resolved_path buffer.
-/// @param flags The flags controlling how the path is resolved.
-/// @return -errno on fail, 1 on success.
+/// @brief Resolve the given path by following all symbolic links.
+/// @param path The path to resolve, can include symbolic links.
+/// @param buffer The buffer where the resolved absolute path will be stored.
+/// @param buflen The size of the buffer, which should be large enough to hold the resolved path.
+/// @param flags The flags controlling the behavior of path resolution (e.g., following symlinks, relative/absolute paths).
+/// @return 1 on success, negative errno on failure (e.g., -ENOENT if the path is not found).
 int resolve_path(const char *path, char *buffer, size_t buflen, int flags);
diff --git a/mentos/inc/fs/vfs.h b/mentos/inc/fs/vfs.h
index 4faef2b5..67271927 100644
--- a/mentos/inc/fs/vfs.h
+++ b/mentos/inc/fs/vfs.h
@@ -8,18 +8,19 @@
 #include "fs/vfs_types.h"
 #include "mem/slab.h"
 
-#define MAX_OPEN_FD 16 ///< Maximum number of opened file.
-
-#define STDIN_FILENO  0 ///< Standard input.
-#define STDOUT_FILENO 1 ///< Standard output.
-#define STDERR_FILENO 2 ///< Standard error output.
+/// Maximum number of opened file.
+#define MAX_OPEN_FD 16
 
+/// Cache for file structures in the VFS.
 extern kmem_cache_t *vfs_file_cache;
 
 /// @brief Forward declaration of task_struct.
+/// Used for task management in the VFS.
 struct task_struct;
 
 /// @brief Initialize the Virtual File System (VFS).
+/// This function sets up necessary resources and structures for the VFS. It
+/// must be called before any other VFS functions.
 void vfs_init(void);
 
 /// @brief Register a new filesystem.
@@ -32,20 +33,29 @@ int vfs_register_filesystem(file_system_type *fs);
 /// @return The outcome of the operation, 0 if fails.
 int vfs_unregister_filesystem(file_system_type *fs);
 
+/// @brief Register a superblock for the filesystem.
+/// @param name The name of the superblock.
+/// @param path The path associated with the superblock.
+/// @param type A pointer to the filesystem type.
+/// @param root A pointer to the root file of the filesystem.
+/// @return 1 on success, 0 on failure.
 int vfs_register_superblock(const char *name, const char *path, file_system_type *type, vfs_file_t *root);
 
+/// @brief Unregister a superblock.
+/// @param sb A pointer to the superblock to unregister.
+/// @return 1 on success, 0 on failure.
 int vfs_unregister_superblock(super_block_t *sb);
 
 /// @brief Searches for the mountpoint of the given path.
 /// @param absolute_path Path for which we want to search the mountpoint.
-/// @return Pointer to the vfs_file of the mountpoint.
+/// @return Pointer to the super_block_t of the mountpoint, or NULL if not found.
 super_block_t *vfs_get_superblock(const char *absolute_path);
 
-/// @brief Given an absolute path to a file, vfs_open_abspath() returns a file struct, used to access the file.
-/// @param absolute_path An absolute path to a file.
-/// @param flags Used to set the file status flags and file access modes of the open file description.
-/// @param mode Specifies the file mode bits be applied when a new file is created.
-/// @return Returns a file struct, or NULL.
+/// @brief Open a file given its absolute path.
+/// @param absolute_path An absolute path to the file.
+/// @param flags Used to set the file status flags and access modes.
+/// @param mode Specifies the file mode bits to apply when creating a new file.
+/// @return Pointer to the opened vfs_file_t structure, or NULL on error.
 vfs_file_t *vfs_open_abspath(const char *absolute_path, int flags, mode_t mode);
 
 /// @brief Given a pathname for a file, vfs_open() returns a file struct, used to access the file.
diff --git a/mentos/inc/hardware/timer.h b/mentos/inc/hardware/timer.h
index 8e6219f2..f390c9fb 100644
--- a/mentos/inc/hardware/timer.h
+++ b/mentos/inc/hardware/timer.h
@@ -154,7 +154,7 @@ void remove_timer(struct timer_list *timer);
 /// in *req has elapsed, or the delivery of a signal that triggers the
 /// invocation of a handler in the calling thread or that terminates
 /// the process.
-int sys_nanosleep(const timespec *req, timespec *rem);
+int sys_nanosleep(const struct timespec *req, struct timespec *rem);
 
 /// @brief Send signal to calling thread after desired seconds.
 /// @param seconds The number of seconds in the interval
@@ -163,18 +163,6 @@ int sys_nanosleep(const timespec *req, timespec *rem);
 ///         scheduled alarm.
 unsigned sys_alarm(int seconds);
 
-/// @brief Rappresents a time value.
-struct timeval {
-    time_t tv_sec;  ///< Seconds.
-    time_t tv_usec; ///< Microseconds.
-};
-
-/// @brief Rappresents a time interval.
-struct itimerval {
-    struct timeval it_interval; ///< Next value.
-    struct timeval it_value;    ///< Current value.
-};
-
 /// @brief Fills the structure pointed to by curr_value with the current setting for the timer specified by which.
 /// @param which      The time domain (i.e., ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF)
 /// @param curr_value There the values must be stored.
diff --git a/mentos/inc/mem/paging.h b/mentos/inc/mem/paging.h
index 58c03b4b..2d23334d 100644
--- a/mentos/inc/mem/paging.h
+++ b/mentos/inc/mem/paging.h
@@ -12,125 +12,134 @@
 #include "boot.h"
 #include "stdint.h"
 
-/// Size of a page.
-#define PAGE_SIZE 4096U
+/// 4KB pages (2^12 = 4096 bytes)
+#define PAGE_SHIFT 12
+/// Size of a page (4096 bytes).
+#define PAGE_SIZE (1 << PAGE_SHIFT)
+/// Maximum number of physical page frame numbers (PFNs).
+#define MAX_PHY_PFN (1UL << (32 - PAGE_SHIFT))
+
 /// The start of the process area.
 #define PROCAREA_START_ADDR 0x00000000
 /// The end of the process area (and start of the kernel area).
 #define PROCAREA_END_ADDR 0xC0000000
 
+/// For a single page table in a 32-bit system.
+#define MAX_PAGE_TABLE_ENTRIES 1024
+/// For a page directory with 1024 entries.
+#define MAX_PAGE_DIR_ENTRIES 1024
+
 /// @brief An entry of a page directory.
 typedef struct page_dir_entry_t {
-    unsigned int present : 1;   ///< TODO: Comment.
-    unsigned int rw : 1;        ///< TODO: Comment.
-    unsigned int user : 1;      ///< TODO: Comment.
-    unsigned int w_through : 1; ///< TODO: Comment.
-    unsigned int cache : 1;     ///< TODO: Comment.
-    unsigned int accessed : 1;  ///< TODO: Comment.
-    unsigned int reserved : 1;  ///< TODO: Comment.
-    unsigned int page_size : 1; ///< TODO: Comment.
-    unsigned int global : 1;    ///< TODO: Comment.
-    unsigned int available : 3; ///< TODO: Comment.
-    unsigned int frame : 20;    ///< TODO: Comment.
+    unsigned int present : 1;   ///< Page is present in memory.
+    unsigned int rw : 1;        ///< Read/write permission (0 = read-only, 1 = read/write).
+    unsigned int user : 1;      ///< User/supervisor (0 = supervisor, 1 = user).
+    unsigned int w_through : 1; ///< Write-through caching enabled.
+    unsigned int cache : 1;     ///< Cache disabled.
+    unsigned int accessed : 1;  ///< Page has been accessed.
+    unsigned int reserved : 1;  ///< Reserved.
+    unsigned int page_size : 1; ///< Page size (0 = 4 KB, 1 = 4 MB).
+    unsigned int global : 1;    ///< Global page (not flushed by TLB).
+    unsigned int available : 3; ///< Available for system use.
+    unsigned int frame : 20;    ///< Frame address (shifted right 12 bits).
 } page_dir_entry_t;
 
 /// @brief An entry of a page table.
 typedef struct page_table_entry_t {
-    unsigned int present : 1;    ///< TODO: Comment.
-    unsigned int rw : 1;         ///< TODO: Comment.
-    unsigned int user : 1;       ///< TODO: Comment.
-    unsigned int w_through : 1;  ///< TODO: Comment.
-    unsigned int cache : 1;      ///< TODO: Comment.
-    unsigned int accessed : 1;   ///< TODO: Comment.
-    unsigned int dirty : 1;      ///< TODO: Comment.
-    unsigned int zero : 1;       ///< TODO: Comment.
-    unsigned int global : 1;     ///< TODO: Comment.
-    unsigned int kernel_cow : 1; ///< TODO: Comment.
-    unsigned int available : 2;  ///< TODO: Comment.
-    unsigned int frame : 20;     ///< TODO: Comment.
+    unsigned int present : 1;    ///< Page is present in memory.
+    unsigned int rw : 1;         ///< Read/write permission (0 = read-only, 1 = read/write).
+    unsigned int user : 1;       ///< User/supervisor (0 = supervisor, 1 = user).
+    unsigned int w_through : 1;  ///< Write-through caching enabled.
+    unsigned int cache : 1;      ///< Cache disabled.
+    unsigned int accessed : 1;   ///< Page has been accessed.
+    unsigned int dirty : 1;      ///< Page has been written to.
+    unsigned int zero : 1;       ///< Reserved (set to 0).
+    unsigned int global : 1;     ///< Global page (not flushed by TLB).
+    unsigned int kernel_cow : 1; ///< Kernel copy-on-write.
+    unsigned int available : 2;  ///< Available for system use.
+    unsigned int frame : 20;     ///< Frame address (shifted right 12 bits).
 } page_table_entry_t;
 
 /// @brief Flags associated with virtual memory areas.
 enum MEMMAP_FLAGS {
-    MM_USER    = 0x1, ///< Area belongs to user.
-    MM_GLOBAL  = 0x2, ///< Area is global.
-    MM_RW      = 0x4, ///< Area has user read/write perm.
-    MM_PRESENT = 0x8, ///< Area is valid.
+    MM_USER    = 0x1, ///< Area belongs to user mode (accessible by user-level processes).
+    MM_GLOBAL  = 0x2, ///< Area is global (not flushed from TLB on context switch).
+    MM_RW      = 0x4, ///< Area has read/write permissions.
+    MM_PRESENT = 0x8, ///< Area is present in memory.
     // Kernel flags
-    MM_COW     = 0x10, ///< Area is copy on write.
-    MM_UPDADDR = 0x20, ///< Check?
+    MM_COW     = 0x10, ///< Area is copy-on-write (used for forked processes).
+    MM_UPDADDR = 0x20, ///< Update address (used for special memory mappings).
 };
 
 /// @brief A page table.
 /// @details
 /// It contains 1024 entries which can be addressed by 10 bits (log_2(1024)).
 typedef struct page_table_t {
-    page_table_entry_t pages[1024]; ///< Array of pages.
+    /// @brief Array of page table entries.
+    page_table_entry_t pages[MAX_PAGE_TABLE_ENTRIES];
 } __attribute__((aligned(PAGE_SIZE))) page_table_t;
 
 /// @brief A page directory.
 /// @details In the two-level paging, this is the first level.
 typedef struct page_directory_t {
-    /// We need a table that contains virtual address, so that we can
-    /// actually get to the tables (size: 1024 * 4 = 4096 byte).
-    page_dir_entry_t entries[1024];
+    /// @brief Array of page directory entries.
+    /// @details
+    /// We need a table that contains virtual addresses, so that we can actually
+    /// get to the tables (size: 1024 * 4 = 4096 bytes).
+    page_dir_entry_t entries[MAX_PAGE_DIR_ENTRIES];
 } __attribute__((aligned(PAGE_SIZE))) page_directory_t;
 
 /// @brief Virtual Memory Area, used to store details of a process segment.
 typedef struct vm_area_struct_t {
-    /// Memory descriptor associated.
+    /// Pointer to the memory descriptor associated with this area.
     struct mm_struct_t *vm_mm;
     /// Start address of the segment, inclusive.
     uint32_t vm_start;
     /// End address of the segment, exclusive.
     uint32_t vm_end;
-    /// List of memory areas.
+    /// Linked list of memory areas.
     list_head vm_list;
-    /// Permissions.
+    /// Page protection flags (permissions).
     pgprot_t vm_page_prot;
-    /// Flags.
+    /// Flags indicating attributes of the memory area.
     unsigned short vm_flags;
-    /// rbtree node.
-    // struct rb_node vm_rb;
 } vm_area_struct_t;
 
 /// @brief Memory Descriptor, used to store details about the memory of a user process.
 typedef struct mm_struct_t {
-    /// List of memory area (vm_area_struct reference).
+    /// List of memory areas (vm_area_struct references).
     list_head mmap_list;
-    // /// rbtree of memory area.
-    // struct rb_root mm_rb;
-    /// Last memory area used.
+    /// Pointer to the last used memory area.
     vm_area_struct_t *mmap_cache;
-    /// Process page directory.
+    /// Pointer to the process's page directory.
     page_directory_t *pgd;
-    /// Number of memory area.
+    /// Number of memory areas.
     int map_count;
-    /// List of mm_struct.
+    /// List of mm_structs.
     list_head mm_list;
-    /// CODE start.
+    /// Start address of the code segment.
     uint32_t start_code;
-    /// CODE end.
+    /// End address of the code segment.
     uint32_t end_code;
-    /// DATA start.
+    /// Start address of the data segment.
     uint32_t start_data;
-    /// DATA end.
+    /// End address of the data segment.
     uint32_t end_data;
-    /// HEAP start.
+    /// Start address of the heap.
     uint32_t start_brk;
-    /// HEAP end.
+    /// End address of the heap.
     uint32_t brk;
-    /// STACK start.
+    /// Start address of the stack.
     uint32_t start_stack;
-    /// ARGS start.
+    /// Start address of the arguments.
     uint32_t arg_start;
-    /// ARGS end.
+    /// End address of the arguments.
     uint32_t arg_end;
-    /// ENVIRONMENT start.
+    /// Start address of the environment variables.
     uint32_t env_start;
-    /// ENVIRONMENT end.
+    /// End address of the environment variables.
     uint32_t env_end;
-    /// Number of mapped pages.
+    /// Total number of mapped pages.
     unsigned int total_vm;
 } mm_struct_t;
 
@@ -138,22 +147,28 @@ typedef struct mm_struct_t {
 extern kmem_cache_t *pgtbl_cache;
 
 /// @brief Comparison function between virtual memory areas.
-/// @param vma0 the first vm_area.
-/// @param vma1 the second vm_area.
-/// @return true if vma0 is after vma1.
+/// @param vma0 Pointer to the first vm_area_struct's list_head.
+/// @param vma1 Pointer to the second vm_area_struct's list_head.
+/// @return 1 if vma0 starts after vma1 ends, 0 otherwise.
 static inline int vm_area_compare(const list_head *vma0, const list_head *vma1)
 {
+    // Retrieve the vm_area_struct from the list_head for vma0.
     vm_area_struct_t *_vma0 = list_entry(vma0, vm_area_struct_t, vm_list);
+    // Retrieve the vm_area_struct from the list_head for vma1.
     vm_area_struct_t *_vma1 = list_entry(vma1, vm_area_struct_t, vm_list);
+    // Compare the start address of vma0 with the end address of vma1.
     return _vma0->vm_start > _vma1->vm_end;
 }
 
-/// @brief Initializes paging
-/// @param info Information coming from bootloader.
-void paging_init(boot_info_t *info);
+/// @brief Initializes the paging system, sets up memory caches, page
+/// directories, and maps important memory regions.
+/// @param info   Pointer to the boot information structure, containing kernel
+/// addresses and other details.
+/// @return 0 on success, -1 on error.
+int paging_init(boot_info_t *info);
 
 /// @brief Provide access to the main page directory.
-/// @return A pointer to the main page directory.
+/// @return A pointer to the main page directory, or NULL if main_mm is not initialized.
 page_directory_t *paging_get_main_directory(void);
 
 /// @brief Provide access to the current paging directory.
@@ -170,9 +185,15 @@ static inline void paging_switch_directory(page_directory_t *dir)
     set_cr3((uintptr_t)dir);
 }
 
+/// @brief Checks if the given page directory is the current one.
+/// @param pgd A pointer to the page directory to check.
+/// @return 1 if the given page directory is the current one, 0 otherwise.
+int is_current_pgd(page_directory_t *pgd);
+
 /// @brief Switches paging directory, the pointer can be a lowmem address.
 /// @param dir A pointer to the new page directory.
-void paging_switch_directory_va(page_directory_t *dir);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int paging_switch_directory_va(page_directory_t *dir);
 
 /// @brief Invalidate a single tlb page (the one that maps the specified virtual address)
 /// @param addr The address of the page table.
@@ -198,20 +219,21 @@ static inline int paging_is_enabled(void)
 /// @param f The interrupt stack frame.
 void page_fault_handler(pt_regs *f);
 
-/// @brief Gets a page from a virtual address
-/// @param pgdir      The target page directory.
-/// @param virt_start The virtual address to query
-/// @param size       A pointer to the requested size of the data, size is updated if physical memory is not contiguous
-/// @return Pointer to the page.
+/// @brief Maps a virtual address to a corresponding physical page.
+/// @param pgdir The page directory.
+/// @param virt_start The starting virtual address to map.
+/// @param size Pointer to a size_t variable to store the size of the mapped memory.
+/// @return A pointer to the physical page corresponding to the virtual address, or NULL on error.
 page_t *mem_virtual_to_page(page_directory_t *pgdir, uint32_t virt_start, size_t *size);
 
-/// @brief Creates a virtual to physical mapping, incrementing pages usage counters.
-/// @param pgd        The target page directory.
-/// @param virt_start The virtual address to map to.
-/// @param phy_start  The physical address to map.
-/// @param size       The size of the segment.
-/// @param flags      The flags for the memory range.
-void mem_upd_vm_area(page_directory_t *pgd, uint32_t virt_start, uint32_t phy_start, size_t size, uint32_t flags);
+/// @brief Updates the virtual memory area in a page directory.
+/// @param pgd The page directory to update.
+/// @param virt_start The starting virtual address to update.
+/// @param phy_start The starting physical address to map to the virtual addresses.
+/// @param size The size of the memory area to update.
+/// @param flags Flags to set for the page table entries.
+/// @return 0 on success, or -1 on failure.
+int mem_upd_vm_area(page_directory_t *pgd, uint32_t virt_start, uint32_t phy_start, size_t size, uint32_t flags);
 
 /// @brief Clones a range of pages between two distinct page tables
 /// @param src_pgd   The source page directory.
@@ -220,12 +242,13 @@ void mem_upd_vm_area(page_directory_t *pgd, uint32_t virt_start, uint32_t phy_st
 /// @param dst_start The destination virtual address for the clone.
 /// @param size      The size of the segment.
 /// @param flags     The flags for the new dst memory range.
-void mem_clone_vm_area(page_directory_t *src_pgd,
-                       page_directory_t *dst_pgd,
-                       uint32_t src_start,
-                       uint32_t dst_start,
-                       size_t size,
-                       uint32_t flags);
+/// @return 0 on success, -1 on failure.
+int mem_clone_vm_area(page_directory_t *src_pgd,
+                      page_directory_t *dst_pgd,
+                      uint32_t src_start,
+                      uint32_t dst_start,
+                      size_t size,
+                      uint32_t flags);
 
 /// @brief Create a virtual memory area.
 /// @param mm         The memory descriptor which will contain the new segment.
@@ -254,7 +277,7 @@ uint32_t clone_vm_area(mm_struct_t *mm,
 /// @brief Destroys a virtual memory area.
 /// @param mm the memory descriptor from which we will destroy the area.
 /// @param area the are we want to destroy.
-/// @return 0 if the area was destroyed, or 1 if the operation failed.
+/// @return 0 if the area was destroyed, or -1 if the operation failed.
 int destroy_vm_area(mm_struct_t *mm, vm_area_struct_t *area);
 
 /// @brief Searches for the virtual memory area at the given address.
@@ -274,7 +297,7 @@ int is_valid_vm_area(mm_struct_t *mm, uintptr_t vm_start, uintptr_t vm_end);
 /// @param mm the memory descriptor which should contain the new area.
 /// @param length the size of the empty spot.
 /// @param vm_start where we save the starting address for the new area.
-/// @return 0 on success, 1 on failure.
+/// @return 0 on success, -1 on error, or 1 if no free area is found.
 int find_free_vm_area(mm_struct_t *mm, size_t length, uintptr_t *vm_start);
 
 /// @brief Creates the main memory descriptor.
@@ -289,4 +312,5 @@ mm_struct_t *clone_process_image(mm_struct_t *mmp);
 
 /// @brief Free Memory Descriptor with all the memory segment contained.
 /// @param mm The Memory Descriptor to free.
-void destroy_process_image(mm_struct_t *mm);
+/// @return Returns -1 on error, otherwise 0.
+int destroy_process_image(mm_struct_t *mm);
diff --git a/mentos/inc/mem/slab.h b/mentos/inc/mem/slab.h
index 4157df0d..a08a1787 100644
--- a/mentos/inc/mem/slab.h
+++ b/mentos/inc/mem/slab.h
@@ -55,17 +55,26 @@ typedef struct kmem_cache_t {
     list_head slabs_free;
 } kmem_cache_t;
 
-/// Initialize the slab system
-void kmem_cache_init(void);
-
-/// @brief Creates a new slab cache.
-/// @param name  Name of the cache.
-/// @param size  Size of the objects contained inside the cache.
-/// @param align Memory alignment for the objects inside the cache.
-/// @param flags Flags used to define the properties of the cache.
-/// @param ctor  Constructor for initializing the cache elements.
-/// @param dtor  Destructor for finalizing the cache elements.
-/// @return Pointer to the object used to manage the cache.
+/// @brief Initializes the kernel memory cache system.
+/// @details This function initializes the global cache list and creates the
+/// main cache for managing kmem_cache_t structures. It also creates caches for
+/// different order sizes for kmalloc allocations.
+/// @note This function should be called during system initialization.
+/// @return Returns 0 on success, or -1 if an error occurs.
+int kmem_cache_init(void);
+
+/// @brief Creates a new kmem_cache structure.
+/// @details This function allocates memory for a new cache and initializes it
+/// with the provided parameters. The cache is ready for use after this function
+/// returns.
+/// @param name Name of the cache.
+/// @param size Size of each object in the cache.
+/// @param align Alignment requirement for objects in the cache.
+/// @param flags Flags for slab allocation.
+/// @param ctor Constructor function for initializing objects (can be NULL).
+/// @param dtor Destructor function for cleaning up objects (can be NULL).
+/// @return Pointer to the newly created kmem_cache_t, or NULL if allocation
+/// fails.
 kmem_cache_t *kmem_cache_create(
     const char *name,
     unsigned int size,
@@ -74,9 +83,13 @@ kmem_cache_t *kmem_cache_create(
     kmem_fun_t ctor,
     kmem_fun_t dtor);
 
-/// @brief Deletes the given cache.
-/// @param cachep Pointer to the cache.
-void kmem_cache_destroy(kmem_cache_t *cachep);
+/// @brief Destroys a specified kmem_cache structure.
+/// @details This function cleans up and frees all memory associated with the
+/// specified cache, including all associated slab pages. After calling this
+/// function, the cache should no longer be used.
+/// @param cachep Pointer to the kmem_cache_t structure to destroy.
+/// @return Returns 0 on success, or -1 if an error occurs.
+int kmem_cache_destroy(kmem_cache_t *cachep);
 
 #ifdef ENABLE_CACHE_TRACE
 
@@ -103,14 +116,15 @@ void pr_kmem_cache_free(const char *file, const char *fun, int line, void *addr)
 #define kmem_cache_free(...) pr_kmem_cache_free(__FILE__, __func__, __LINE__, __VA_ARGS__)
 
 #else
-/// @brief Allocs a new object using the provided cache.
-/// @param cachep The cache used to allocate the object.
-/// @param flags  Flags used to define where we are going to Get Free Pages (GFP).
-/// @return Pointer to the allocated space.
+
+/// @brief Allocates an object from the specified kmem_cache_t.
+/// @param cachep Pointer to the cache from which to allocate the object.
+/// @param flags Flags for the allocation (e.g., GFP_KERNEL).
+/// @return Pointer to the allocated object, or NULL if allocation fails.
 void *kmem_cache_alloc(kmem_cache_t *cachep, gfp_t flags);
 
-/// @brief Frees an cache allocated object.
-/// @param addr Address of the object.
+/// @brief Frees an object previously allocated from a kmem_cache_t.
+/// @param addr Pointer to the object to free.
 void kmem_cache_free(void *addr);
 
 #endif
@@ -140,13 +154,13 @@ void pr_kfree(const char *file, const char *fun, int line, void *addr);
 
 #else
 
-/// @brief Provides dynamically allocated memory in kernel space.
-/// @param size The amount of memory to allocate.
-/// @return A pointer to the allocated memory.
+/// @brief Allocates memory of the specified size using kmalloc.
+/// @param size Size of the memory to allocate.
+/// @return Pointer to the allocated memory, or NULL if allocation fails.
 void *kmalloc(unsigned int size);
 
-/// @brief Frees dynamically allocated memory in kernel space.
-/// @param ptr The pointer to the allocated memory.
+/// @brief Frees memory allocated by kmalloc or kmem_cache_alloc.
+/// @param ptr Pointer to the memory to free.
 void kfree(void *ptr);
 
 #endif
diff --git a/mentos/inc/mem/vmem_map.h b/mentos/inc/mem/vmem_map.h
index 45ff225c..4b420d2f 100644
--- a/mentos/inc/mem/vmem_map.h
+++ b/mentos/inc/mem/vmem_map.h
@@ -24,43 +24,43 @@ typedef struct virt_map_page_t {
     bb_page_t bbpage;
 } virt_map_page_t;
 
-/// @brief Initialize the virtual memory mapper
-void virt_init(void);
+/// @brief Initialize the virtual memory mapper.
+/// @return Returns 0 on success, or -1 if an error occurs.
+int virt_init(void);
 
-/// @brief Map a page range to virtual memory
-/// @param page The start page of the mapping
-/// @param pfn_count The number of pages to map
-/// @return The virtual address of the mapping
+/// @brief Maps physical pages to virtual memory.
+/// @param page Pointer to the physical page.
+/// @param pfn_count The number of page frames to map.
+/// @return The virtual address of the mapped pages, or 0 on failure.
 uint32_t virt_map_physical_pages(page_t *page, int pfn_count);
 
-/// @brief Allocate a virtual page range of the specified size.
-/// @param size The required amount.
-/// @return Pointer to the allocated memory.
+/// @brief Allocates virtual pages for a given size.
+/// @param size The size in bytes to allocate.
+/// @return Pointer to the allocated virtual pages, or NULL on failure.
 virt_map_page_t *virt_map_alloc(uint32_t size);
 
-/// @brief Map a page to a memory area portion.
-/// @param mm    The memory descriptor.
-/// @param vpage Pointer to the virtual page.
-/// @param vaddr The starting address of the are.
-/// @param size  The size of the area.
-/// @return Address of the mapped area.
-uint32_t virt_map_vaddress(mm_struct_t *mm,
-                           virt_map_page_t *vpage,
-                           uint32_t vaddr,
-                           uint32_t size);
+/// @brief Maps a virtual address to a virtual memory area.
+/// @param mm Pointer to the memory management structure.
+/// @param vpage Pointer to the virtual map page.
+/// @param vaddr The virtual address to map.
+/// @param size The size of the memory area to map.
+/// @return The starting virtual address of the mapped area, or 0 on failure.
+uint32_t virt_map_vaddress(mm_struct_t *mm, virt_map_page_t *vpage, uint32_t vaddr, uint32_t size);
 
 /// @brief Checks if an address belongs to the virtual memory mapping.
 /// @param addr The address to check.
 /// @return 1 if it belongs to the virtual memory mapping, 0 otherwise.
 int virtual_check_address(uint32_t addr);
 
-/// @brief Unmap an address.
-/// @param addr The address to unmap.
-void virt_unmap(uint32_t addr);
+/// @brief Unmaps a virtual address from the virtual memory.
+/// @param addr The virtual address to unmap.
+/// @return Returns 0 on success, or -1 if an error occurs.
+int virt_unmap(uint32_t addr);
 
 /// @brief Unmap a page.
 /// @param page Pointer to the page to unmap.
-void virt_unmap_pg(virt_map_page_t *page);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int virt_unmap_pg(virt_map_page_t *page);
 
 /// @brief Memcpy from different processes virtual addresses
 /// @param dst_mm The destination memory struct
diff --git a/mentos/inc/mem/zone_allocator.h b/mentos/inc/mem/zone_allocator.h
index fdbfb1fb..7c3a869b 100644
--- a/mentos/inc/mem/zone_allocator.h
+++ b/mentos/inc/mem/zone_allocator.h
@@ -32,7 +32,6 @@ typedef struct page_t {
     bb_page_t bbpage;
     /// @brief Contains pointers to the slabs doubly linked list of pages.
     list_head slabs;
-
     /// @brief Slab allocator variables / Contains the total number of objects
     /// in this page, 0 if not managed by the slub.
     unsigned int slab_objcnt;
@@ -113,12 +112,13 @@ typedef struct pg_data_t {
 extern page_t *mem_map;
 extern pg_data_t *contig_page_data;
 
-/// @brief Find the nearest block's order of size greater than the amount of
-/// byte.
-/// @param base_addr The start address, used to handle extra page calculation in
-/// case of not page aligned addresses.
-/// @param amount    The amount of byte which we want to calculate order.
-/// @return The block's order greater and nearest than amount.
+/// @brief Finds the nearest order of memory allocation that can accommodate a
+/// given amount of memory.
+/// @param base_addr the base address from which to calculate the number of
+/// pages.
+/// @param amount the amount of memory (in bytes) to allocate.
+/// @return The nearest order (power of two) that is greater than or equal to
+/// the number of pages required.
 uint32_t find_nearest_order_greater(uint32_t base_addr, uint32_t amount);
 
 /// @brief Physical memory manager initialization.
@@ -126,24 +126,26 @@ uint32_t find_nearest_order_greater(uint32_t base_addr, uint32_t amount);
 /// @return Outcome of the operation.
 int pmmngr_init(boot_info_t *boot_info);
 
-/// @brief Alloc a single cached page.
-/// @param gfp_mask The GetFreePage mask.
-/// @return Pointer to the page.
+/// @brief Allocates a cached page based on the given GFP mask.
+/// @param gfp_mask The GFP mask specifying the allocation constraints.
+/// @return A pointer to the allocated page, or NULL if allocation fails.
 page_t *alloc_page_cached(gfp_t gfp_mask);
 
 /// @brief Free a page allocated with alloc_page_cached.
 /// @param page Pointer to the page to free.
-void free_page_cached(page_t *page);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int free_page_cached(page_t *page);
 
 /// @brief Find the first free page frame, set it allocated and return the
 /// memory address of the page frame.
 /// @param gfp_mask GFP_FLAGS to decide the zone allocation.
-/// @return Memory address of the first free block.
+/// @return The low memory address of the allocated page, or 0 if allocation fails.
 uint32_t __alloc_page_lowmem(gfp_t gfp_mask);
 
 /// @brief Frees the given page frame address.
 /// @param addr The block address.
-void free_page_lowmem(uint32_t addr);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int free_page_lowmem(uint32_t addr);
 
 /// @brief Find the first free 2^order amount of page frames, set it allocated
 /// and return the memory address of the first page frame allocated.
@@ -156,52 +158,57 @@ uint32_t __alloc_pages_lowmem(gfp_t gfp_mask, uint32_t order);
 /// and return the memory address of the first page frame allocated.
 /// @param gfp_mask GFP_FLAGS to decide the zone allocation.
 /// @param order    The logarithm of the size of the page frame.
-/// @return Memory address of the first free page frame allocated.
+/// @return Memory address of the first free page frame allocated, or NULL if
+/// allocation fails.
 page_t *_alloc_pages(gfp_t gfp_mask, uint32_t order);
 
-/// @brief Get the start address of the corresponding page.
-/// @param page A page structure.
-/// @return The address that corresponds to the page.
-uint32_t get_lowmem_address_from_page(page_t *page);
+/// @brief Converts a page structure to its corresponding low memory virtual address.
+/// @param page Pointer to the page structure.
+/// @return The low memory virtual address corresponding to the specified page,
+/// or 0 if the input page pointer is invalid.
+uint32_t get_virtual_address_from_page(page_t *page);
 
-/// @brief Get the start physical address of the corresponding page.
-/// @param page A page structure
-/// @return The physical address that corresponds to the page.
+/// @brief Converts a page structure to its corresponding physical address.
+/// @param page Pointer to the page structure.
+/// @return The physical address corresponding to the specified page, or 0 if
+/// the input page pointer is invalid.
 uint32_t get_physical_address_from_page(page_t *page);
 
-/// @brief Get the page from it's physical address.
-/// @param phy_addr The physical address
-/// @return The page that corresponds to the physical address.
-page_t *get_page_from_physical_address(uint32_t phy_addr);
+/// @brief Retrieves the page structure corresponding to a given physical address.
+/// @param paddr The physical address for which the page structure is requested.
+/// @return A pointer to the corresponding page structure, or NULL if the address is invalid.
+page_t *get_page_from_physical_address(uint32_t paddr);
 
-/// @brief Get the page that contains the specified address.
-/// @param addr A phisical address.
-/// @return The page that corresponds to the address.
-page_t *get_lowmem_page_from_address(uint32_t addr);
+/// @brief Retrieves the low memory page corresponding to the given virtual address.
+/// @param vaddr the virtual address to convert.
+/// @return A pointer to the corresponding page, or NULL if the address is out of range.
+page_t *get_page_from_virtual_address(uint32_t vaddr);
 
 /// @brief Frees from the given page frame address up to 2^order amount of page
 /// frames.
 /// @param addr The page frame address.
-void free_pages_lowmem(uint32_t addr);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int free_pages_lowmem(uint32_t addr);
 
 /// @brief Frees from the given page frame address up to 2^order amount of page
 /// frames.
 /// @param page The page.
-void __free_pages(page_t *page);
+/// @return Returns 0 on success, or -1 if an error occurs.
+int __free_pages(page_t *page);
 
-/// @brief Returns the total space for the given zone.
-/// @param gfp_mask GFP_FLAGS to decide the zone.
-/// @return Total space of the given zone.
+/// @brief Retrieves the total space of the zone corresponding to the given GFP mask.
+/// @param gfp_mask The GFP mask specifying the allocation constraints.
+/// @return The total space of the zone, or 0 if the zone cannot be retrieved.
 unsigned long get_zone_total_space(gfp_t gfp_mask);
 
-/// @brief Returns the total free space for the given zone.
-/// @param gfp_mask GFP_FLAGS to decide the zone.
-/// @return Total free space of the given zone.
+/// @brief Retrieves the free space of the zone corresponding to the given GFP mask.
+/// @param gfp_mask The GFP mask specifying the allocation constraints.
+/// @return The free space of the zone, or 0 if the zone cannot be retrieved.
 unsigned long get_zone_free_space(gfp_t gfp_mask);
 
-/// @brief Returns the total cached space for the given zone.
-/// @param gfp_mask GFP_FLAGS to decide the zone.
-/// @return Total cached space of the given zone.
+/// @brief Retrieves the cached space of the zone corresponding to the given GFP mask.
+/// @param gfp_mask The GFP mask specifying the allocation constraints.
+/// @return The cached space of the zone, or 0 if the zone cannot be retrieved.
 unsigned long get_zone_cached_space(gfp_t gfp_mask);
 
 /// @brief Checks if the specified address points to a page_t (or field) that
diff --git a/mentos/inc/proc_access.h b/mentos/inc/proc_access.h
index 92dce200..cd002f59 100644
--- a/mentos/inc/proc_access.h
+++ b/mentos/inc/proc_access.h
@@ -148,6 +148,26 @@ static inline void set_cr0(uintptr_t cr0)
                          : "r"(cr0));
 }
 
+
+/// @brief Reads the current cr2 value.
+/// @return the value we read.
+static inline uintptr_t get_cr2(void)
+{
+    uintptr_t cr2;
+    __asm__ __volatile__("mov %%cr2, %0"
+                         : "=r"(cr2));
+    return (cr2);
+}
+
+/// @brief Sets the cr2 value.
+/// @param cr2 the value we want to set.
+static inline void set_cr2(uintptr_t cr2)
+{
+    __asm__ __volatile__("mov %0, %%cr2"
+                         :
+                         : "r"(cr2));
+}
+
 /// @brief Reads the current cr3 value.
 /// @return the value we read.
 static inline uintptr_t get_cr3(void)
diff --git a/mentos/inc/process/scheduler_feedback.h b/mentos/inc/process/scheduler_feedback.h
index 99d1938a..aa477d34 100644
--- a/mentos/inc/process/scheduler_feedback.h
+++ b/mentos/inc/process/scheduler_feedback.h
@@ -1,6 +1,7 @@
 /// @file scheduler_feedback.h
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
-/// @brief
+/// @brief Scheduler feedback system for managing tasks and updating scheduling statistics.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
+/// See LICENSE.md for details.
 
 #pragma once
 
@@ -8,21 +9,33 @@
 #include "process/process.h"
 
 /// @brief Initialize the scheduler feedback system.
+/// @details This function sets up the necessary data structures and mechanisms
+/// for the scheduler feedback system. It must be called before any other
+/// scheduler feedback operations are performed.
 /// @return 1 on success, 0 on failure.
 int scheduler_feedback_init(void);
 
 /// @brief Add the given task to the feedback system.
-/// @param task the task we need to add.
+/// @param task A pointer to the task_struct representing the task to be added.
+/// @details This function adds a task to the scheduler feedback system for
+/// monitoring and updating its scheduling statistics.
 void scheduler_feedback_task_add(task_struct *task);
 
 /// @brief Removes the given task from the feedback system.
-/// @param pid the pid of the task we need to remove.
+/// @param pid The process ID of the task to remove.
+/// @details This function removes the task identified by the given pid from the
+/// scheduler feedback system. It should be called when a task is terminated or
+/// no longer needs to be monitored.
 void scheduler_feedback_task_remove(pid_t pid);
 
 /// @brief Updates the scheduling statistics for the given task.
-/// @param task the task for which we update the statistics.
+/// @param task A pointer to the task_struct representing the task to update.
+/// @details This function updates the scheduling statistics for the given task
+/// based on its recent behavior (e.g., execution time, priority changes).
 void scheduler_feedback_task_update(task_struct *task);
 
-/// @brief Updates the scheduling statistics for the given task.
-/// @param task the task for which we update the statistics.
+/// @brief Updates the global scheduler feedback statistics.
+/// @details This function is periodically called to update the overall
+/// statistics of the scheduler feedback system, adjusting task priorities and
+/// managing scheduling decisions for all tasks.
 void scheduler_feedback_update(void);
diff --git a/mentos/inc/version.h b/mentos/inc/version.h
index 5b8be03d..a1ae5185 100644
--- a/mentos/inc/version.h
+++ b/mentos/inc/version.h
@@ -18,10 +18,10 @@
 #define OS_MAJOR_VERSION 0
 
 /// Minor version of the operating system.
-#define OS_MINOR_VERSION 7
+#define OS_MINOR_VERSION 8
 
 /// Micro version of the operating system.
-#define OS_MICRO_VERSION 3
+#define OS_MICRO_VERSION 0
 
 /// Helper to transform the given argument into a string.
 #define OS_STR_HELPER(x) #x
diff --git a/mentos/src/crypt/sha256.c b/mentos/src/crypt/sha256.c
new file mode 100644
index 00000000..a6530ae3
--- /dev/null
+++ b/mentos/src/crypt/sha256.c
@@ -0,0 +1,321 @@
+/// @file sha256.c
+/// @brief Implementation of the SHA-256 hashing algorithm.
+/// @details The original code was written by Brad Conte, and is available at:
+///     https://github.com/B-Con/crypto-algorithms
+///
+/// SHA-256 is one of the three algorithms in the SHA2
+/// specification. The others, SHA-384 and SHA-512, are not
+/// offered in this implementation.
+/// Algorithm specification can be found here:
+///     http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
+/// This implementation uses little endian byte order.
+
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[SHA256]"      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
+
+#include "crypt/sha256.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+/// @brief Rotate left operation on a 32-bit unsigned integer.
+/// @param a The value to rotate.
+/// @param b The number of positions to rotate.
+/// @return The rotated value.
+#define ROTLEFT(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
+
+/// @brief Rotate right operation on a 32-bit unsigned integer.
+/// @param a The value to rotate.
+/// @param b The number of positions to rotate.
+/// @return The rotated value.
+#define ROTRIGHT(a, b) (((a) >> (b)) | ((a) << (32 - (b))))
+
+/// @brief Chooses bits from y if x is set, otherwise from z.
+/// @param x, y, z Input values.
+/// @return Result of CH function.
+#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
+
+/// @brief Majority function used in SHA-256.
+/// @param x, y, z Input values.
+/// @return Result of the majority function.
+#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+/// @brief First expansion function for the working variables.
+/// @param x Input value.
+/// @return Result of EP0.
+#define EP0(x) (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22))
+
+/// @brief Second expansion function for the working variables.
+/// @param x Input value.
+/// @return Result of EP1.
+#define EP1(x) (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25))
+
+/// @brief First Sigma function for message scheduling.
+/// @param x Input value.
+/// @return Result of SIG0.
+#define SIG0(x) (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3))
+
+/// @brief Second Sigma function for message scheduling.
+/// @param x Input value.
+/// @return Result of SIG1.
+#define SIG1(x) (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10))
+
+/// Max data length for message scheduling expansion.
+#define SHA256_MAX_DATA_LENGTH (SHA256_BLOCK_SIZE * 2)
+
+/// @brief The constants used in the SHA-256 algorithm, as defined by the
+/// specification. These are the first 32 bits of the fractional parts of the
+/// cube roots of the first 64 primes (2..311).
+static const uint32_t k[SHA256_MAX_DATA_LENGTH] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+/// @brief Transforms the state of the SHA-256 context based on a block of input data.
+/// @param ctx Pointer to the SHA-256 context. Must not be NULL.
+/// @param data Input data block to process (64 bytes). Must not be NULL.
+static inline void __sha256_transform(SHA256_ctx_t *ctx, const uint8_t data[])
+{
+    // Error checks: Ensure the input parameters are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return;
+    }
+    if (!data) {
+        pr_err("Input data is NULL.\n");
+        return;
+    }
+
+    uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2;
+    uint32_t m[SHA256_MAX_DATA_LENGTH]; // Message schedule array.
+
+    // Step 1: Prepare the message schedule (first 16 words are directly from
+    // the input data).
+    for (i = 0, j = 0; i < 16; ++i, j += 4) {
+        // Each 32-bit word is constructed from 4 consecutive 8-bit bytes from
+        // the input data.
+        m[i] = (uint32_t)(data[j] << 24) |
+               (uint32_t)(data[j + 1] << 16) |
+               (uint32_t)(data[j + 2] << 8) |
+               (uint32_t)(data[j + 3]);
+    }
+
+    // Step 2: Extend the first 16 words into the remaining 48 words of the
+    // message schedule. Each word is computed based on the previous words using
+    // the SIG1 and SIG0 functions.
+    for (; i < SHA256_MAX_DATA_LENGTH; ++i) {
+        m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
+    }
+
+    // Step 3: Initialize the working variables with the current state values.
+    a = ctx->state[0];
+    b = ctx->state[1];
+    c = ctx->state[2];
+    d = ctx->state[3];
+    e = ctx->state[4];
+    f = ctx->state[5];
+    g = ctx->state[6];
+    h = ctx->state[7];
+
+    // Step 4: Perform the main hash computation (64 rounds).
+    for (i = 0; i < SHA256_MAX_DATA_LENGTH; ++i) {
+        // Calculate the temporary values.
+        t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
+        t2 = EP0(a) + MAJ(a, b, c);
+
+        // Rotate the working variables for the next round.
+        h = g;
+        g = f;
+        f = e;
+        e = d + t1;
+        d = c;
+        c = b;
+        b = a;
+        a = t1 + t2;
+    }
+
+    // Step 5: Add the resulting values back into the current state.
+    ctx->state[0] += a;
+    ctx->state[1] += b;
+    ctx->state[2] += c;
+    ctx->state[3] += d;
+    ctx->state[4] += e;
+    ctx->state[5] += f;
+    ctx->state[6] += g;
+    ctx->state[7] += h;
+}
+
+/// @brief Converts a byte array into its hexadecimal string representation.
+/// @param src Pointer to the source byte array.
+/// @param src_length Length of the source byte array.
+/// @param out Pointer to the output buffer for the hexadecimal string.
+/// @param out_length Length of the output buffer (must be at least 2 * src_length + 1).
+/// @details The output string will be null-terminated if the buffer is large enough.
+void sha256_bytes_to_hex(uint8_t *src, size_t src_length, char *out, size_t out_length)
+{
+    // Check if the output buffer is large enough to hold the hex string
+    if (out_length < (src_length * 2 + 1)) {
+        pr_err("Output buffer is too small for the hex representation.\n");
+        return; // Return early if the buffer is insufficient.
+    }
+
+    // Lookup table for converting bytes to hex
+    static const char look_up[] = "0123456789abcdef";
+
+    // Convert each byte to its hex representation
+    for (size_t i = 0; i < src_length; ++i) {
+        *out++ = look_up[*src >> 4];   // Upper nibble
+        *out++ = look_up[*src & 0x0F]; // Lower nibble
+        src++;
+    }
+    *out = 0; // Null-terminate the output string
+}
+
+void sha256_init(SHA256_ctx_t *ctx)
+{
+    // Error check: Ensure the input context is not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
+
+    // Initialize the length of the data (in bytes) to 0.
+    ctx->datalen = 0;
+
+    // Initialize the total length of the input data (in bits) to 0.
+    ctx->bitlen = 0;
+
+    // Initialize the state variables (hash values) to the SHA-256 initial constants.
+    ctx->state[0] = 0x6a09e667;
+    ctx->state[1] = 0xbb67ae85;
+    ctx->state[2] = 0x3c6ef372;
+    ctx->state[3] = 0xa54ff53a;
+    ctx->state[4] = 0x510e527f;
+    ctx->state[5] = 0x9b05688c;
+    ctx->state[6] = 0x1f83d9ab;
+    ctx->state[7] = 0x5be0cd19;
+}
+
+void sha256_update(SHA256_ctx_t *ctx, const uint8_t data[], size_t len)
+{
+    // Error check: Ensure the input context and data are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
+
+    if (!data) {
+        pr_err("Input data is NULL.\n");
+        return; // Return early if the data is NULL to prevent errors.
+    }
+
+    // Iterate over the input data, processing it in chunks.
+    for (uint32_t i = 0; i < len; ++i) {
+        // Add data to the context's buffer.
+        ctx->data[ctx->datalen] = data[i];
+        ctx->datalen++;
+
+        // If the buffer is full, process the data and reset the buffer.
+        if (ctx->datalen == SHA256_MAX_DATA_LENGTH) {
+            // Perform the SHA-256 transformation on the full data block.
+            __sha256_transform(ctx, ctx->data);
+
+            // Update the total length of the data processed so far in bits.
+            ctx->bitlen += 512;
+
+            // Reset the buffer length to 0 for the next chunk of data.
+            ctx->datalen = 0;
+        }
+    }
+}
+
+void sha256_final(SHA256_ctx_t *ctx, uint8_t hash[])
+{
+    // Error check: Ensure the input context and hash are not NULL.
+    if (!ctx) {
+        pr_err("SHA256 context is NULL.\n");
+        return; // Return early if the context is NULL to prevent crashes.
+    }
+    if (!hash) {
+        pr_err("Output hash buffer is NULL.\n");
+        return; // Return early if the output buffer is NULL to prevent errors.
+    }
+
+    // Get the current length of the data buffer.
+    uint32_t i = ctx->datalen;
+
+    // Step 1: Pad whatever data is left in the buffer.
+
+    // If there's enough space in the buffer (less than 56 bytes used), pad
+    // with 0x80 followed by zeros.
+    if (ctx->datalen < 56) {
+        // Append the padding byte (0x80).
+        ctx->data[i++] = 0x80;
+
+        // Pad the buffer with zeros until we reach 56 bytes.
+        while (i < 56) {
+            ctx->data[i++] = 0x00;
+        }
+    }
+    // If there's not enough space, pad the remaining buffer and process it.
+    else {
+        // Append the padding byte (0x80).
+        ctx->data[i++] = 0x80;
+
+        // Fill the rest of the buffer with zeros.
+        while (i < SHA256_MAX_DATA_LENGTH) {
+            ctx->data[i++] = 0x00;
+        }
+
+        // Process the full buffer.
+        __sha256_transform(ctx, ctx->data);
+
+        // Reset the buffer for the next padding.
+        memset(ctx->data, 0, 56);
+    }
+
+    // Step 2: Append the total message length in bits and process the final block.
+
+    // Convert the total length from bytes to bits.
+    ctx->bitlen += ctx->datalen * 8;
+
+    // Append the lower 8 bits of the length.
+    ctx->data[63] = ctx->bitlen;
+    ctx->data[62] = ctx->bitlen >> 8;
+    ctx->data[61] = ctx->bitlen >> 16;
+    ctx->data[60] = ctx->bitlen >> 24;
+    ctx->data[59] = ctx->bitlen >> 32;
+    ctx->data[58] = ctx->bitlen >> 40;
+    ctx->data[57] = ctx->bitlen >> 48;
+    ctx->data[56] = ctx->bitlen >> 56;
+
+    // Process the final block.
+    __sha256_transform(ctx, ctx->data);
+
+    // Step 3: Copy the final state (hash) to the output buffer.
+
+    // SHA-256 uses big-endian byte order, so we reverse the byte order when
+    // copying.
+    for (i = 0; i < 4; ++i) {
+        hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
+        hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
+    }
+}
diff --git a/mentos/src/drivers/ata.c b/mentos/src/drivers/ata.c
index 741382a1..301354b1 100644
--- a/mentos/src/drivers/ata.c
+++ b/mentos/src/drivers/ata.c
@@ -424,21 +424,21 @@ static inline const char *ata_get_device_settings_str(ata_device_t *dev)
 static inline const char *ata_get_device_type_str(ata_device_type_t type)
 {
     if (type == ata_dev_type_pata) {
-        return "pata";
+        return "PATA";
     }
     if (type == ata_dev_type_sata) {
-        return "sata";
+        return "SATA";
     }
     if (type == ata_dev_type_patapi) {
-        return "patapi";
+        return "PATAPI";
     }
     if (type == ata_dev_type_satapi) {
-        return "satapi";
+        return "SATAPI";
     }
     if (type == ata_dev_type_unknown) {
-        return "unknown";
+        return "UNKNOWN";
     }
-    return "no_device";
+    return "NONE";
 }
 
 /// @brief Dumps on debugging output the device data.
@@ -501,20 +501,21 @@ static inline void ata_dump_device(ata_device_t *dev)
     pr_debug("    }\n");
 }
 
-/// @brief Waits for 400 nanoseconds.
-/// @param dev the device on which we wait.
+/// @brief Waits for approximately 400 nanoseconds by performing four I/O reads.
+/// @param dev The device on which we wait.
 static inline void ata_io_wait(ata_device_t *dev)
 {
+    // Perform four reads from the control register to wait for 400 ns.
     inportb(dev->io_control);
     inportb(dev->io_control);
     inportb(dev->io_control);
     inportb(dev->io_control);
 }
 
-/// @brief Wait until the status bits selected through the mask are zero.
-/// @param dev the device we need to wait for.
-/// @param mask the mask we use to access those bits.
-/// @param timeout the maximum number of cycles we are going to wait.
+/// @brief Waits until the status bits selected through the mask are zero.
+/// @param dev The device we need to wait for.
+/// @param mask The mask used to check the status bits.
+/// @param timeout The maximum number of cycles to wait before timing out.
 /// @return 1 on success, 0 if it times out.
 static inline int ata_status_wait_not(ata_device_t *dev, long mask, long timeout)
 {
@@ -522,16 +523,14 @@ static inline int ata_status_wait_not(ata_device_t *dev, long mask, long timeout
     do {
         status = inportb(dev->io_reg.status);
     } while (((status & mask) == mask) && (--timeout > 0));
-    if (timeout > 0) {
-        return 0;
-    }
-    return 1;
+    // Return 1 on success (bits cleared), 0 on timeout.
+    return timeout <= 0;
 }
 
-/// @brief Wait until the status bits selected through the mask are one.
-/// @param dev the device we need to wait for.
-/// @param mask the mask we use to access those bits.
-/// @param timeout the maximum number of cycles we are going to wait.
+/// @brief Waits until the status bits selected through the mask are set.
+/// @param dev The device we need to wait for.
+/// @param mask The mask used to check the status bits.
+/// @param timeout The maximum number of cycles to wait before timing out.
 /// @return 1 on success, 0 if it times out.
 static inline int ata_status_wait_for(ata_device_t *dev, long mask, long timeout)
 {
@@ -539,10 +538,8 @@ static inline int ata_status_wait_for(ata_device_t *dev, long mask, long timeout
     do {
         status = inportb(dev->io_reg.status);
     } while (((status & mask) != mask) && (--timeout > 0));
-    if (timeout > 0) {
-        return 0;
-    }
-    return 1;
+    // Return 1 on success (bits set), 0 on timeout.
+    return timeout <= 0;
 }
 
 /// @brief Prints the status and error information about the device.
@@ -588,119 +585,289 @@ static inline void ata_fix_string(char *str, size_t len)
 }
 
 /// @brief Performs a soft reset of the device.
-/// @details "For non-ATAPI drives, the only method a driver has of resetting a
+/// @details For non-ATAPI drives, the only method a driver has of resetting a
 /// drive after a major error is to do a "software reset" on the bus. Set bit 2
 /// (SRST, value = 4) in the proper Control Register for the bus. This will
-/// reset both ATA devices on the bus."
+/// reset both ATA devices on the bus.
 /// @param dev the device on which we perform the soft reset.
 static inline void ata_soft_reset(ata_device_t *dev)
 {
     pr_debug("[%s] Performing ATA soft reset...\n", ata_get_device_settings_str(dev));
     ata_print_status_error(dev);
-    // Write reset.
+
+    // Setting the SRST bit
+    // Writes the SRST (software reset) bit to the control register, initiating
+    // the reset. This bit should be set to 1 to start the reset.
     outportb(dev->io_control, ata_control_srst);
-    // Flush.
+
+    // Flushing the I/O
+    // Flushes to ensure that the write to the control register is completed.
+    // This is necessary to avoid issues due to out-of-order execution or
+    // caching, which is standard practice.
     inportb(dev->io_control);
-    // Wait for the soft reset to complete.
+
+    // Waiting for the reset to complete
+    // Ensures that the system waits for 400ns, which is a typical delay needed
+    // after issuing the reset to give the device time to process it.
     ata_io_wait(dev);
-    // Reset the bus to normal operation.
+
+    // Clearing the SRST bit
+    // After the delay, resets the control register to its normal state by
+    // clearing the SRST bit (0), allowing normal operations to resume on the
+    // device.
     outportb(dev->io_control, ata_control_zero);
-    // Flush.
+
+    // Flushing the I/O again.
     inportb(dev->io_control);
-    // Wait until master drive is ready again.
-    ata_status_wait_not(dev, ata_status_bsy | ata_status_drq, 100000);
+
+    // Waiting until the device is ready
+    // Waits until the device is no longer busy (BSY bit cleared) and no data
+    // request (DRQ bit cleared), indicating the reset is complete and the
+    // device is ready.
+    if (ata_status_wait_not(dev, ata_status_bsy | ata_status_drq, 100000)) {
+        pr_err("Soft reset failed. Device did not become ready.");
+        return;
+    }
 }
 
 /// @brief Creates the DMA memory area used to write and read on the device.
 /// @param size the size of the DMA memory area.
 /// @param physical the physical address of the DMA memory area.
-/// @return the logical address of the DMA memory area.
-static inline uintptr_t ata_dma_malloc(size_t size, uintptr_t *physical)
+/// @return the logical address of the DMA memory area, or 0 on failure.
+static inline uintptr_t ata_dma_alloc(size_t size, uintptr_t *physical)
 {
-    // Get the page order to accomodate the size.
-    uint32_t order           = find_nearest_order_greater(0, size);
-    page_t *page             = _alloc_pages(GFP_KERNEL, order);
-    *physical                = get_physical_address_from_page(page);
-    uintptr_t lowmem_address = get_lowmem_address_from_page(page);
+    // Sanity check the requested size.
+    if (size == 0 || !physical) {
+        pr_crit("Invalid size or physical address pointer provided.\n");
+        return 0;
+    }
+
+    // Get the page order to accommodate the requested size. This finds the
+    // nearest order (power of two) greater than or equal to the size. DMA
+    // allocations typically need to be a power of two, and the size should be
+    // aligned to ensure proper DMA operation, as DMA engines often require
+    // memory to be aligned to specific boundaries (e.g., 4KB or 64KB).
+    uint32_t order = find_nearest_order_greater(0, size);
+
+    // Allocate a contiguous block of memory pages. Ensure that _alloc_pages
+    // returns physically contiguous pages suitable for DMA, as DMA transfers
+    // usually require physically contiguous memory.
+    page_t *page = _alloc_pages(GFP_KERNEL, order);
+    if (!page) {
+        pr_crit("Failed to allocate pages for DMA memory (order = %d).\n", order);
+        return 0;
+    }
+
+    // Extract the physical address from the allocated page. This physical
+    // address will be passed to the DMA engine, which uses it to directly
+    // transfer data.
+    *physical = get_physical_address_from_page(page);
+    if (*physical == 0) {
+        pr_crit("Failed to retrieve a valid physical address.\n");
+        return 0;
+    }
+
+    // Retrieve the low-memory address (logical address) that the CPU can use to
+    // access the allocated memory. The CPU will use this address to interact
+    // with the DMA memory region.
+    uintptr_t lowmem_address = get_virtual_address_from_page(page);
+    if (lowmem_address == 0) {
+        pr_crit("Failed to retrieve a valid low-memory address.\n");
+        return 0;
+    }
+
     pr_debug("Size requirement is %d, which results in an order %d\n", size, order);
     pr_debug("Allocated page is at       : 0x%p\n", page);
-    pr_debug("The physical address is at : 0x%p\n", physical);
-    pr_debug("The lowmem address is at   : 0x%p\n", lowmem_address);
+    pr_debug("The physical address is at : 0x%lx\n", *physical);
+    pr_debug("The lowmem address is at   : 0x%lx\n", lowmem_address);
+
+    // Return the logical (low-memory) address for CPU access.
     return lowmem_address;
 }
 
-/// @brief Emables bus mastering, allowing Direct Memory Access (DMA) transactions.
-static inline void ata_dma_enable_bus_mastering(void)
+/// @brief Frees the DMA memory area previously allocated.
+/// @param logical_addr the logical (low-memory) address to free.
+/// @return 0 on success, 1 on failure.
+static inline int ata_dma_free(uintptr_t logical_addr)
+{
+    // Sanity check the input.
+    if (!logical_addr) {
+        pr_debug("Invalid logical address or size for freeing DMA memory.\n");
+        return 1;
+    }
+
+    // Retrieve the page structure from the logical address.
+    page_t *page = get_page_from_virtual_address(logical_addr);
+    if (!page) {
+        pr_debug("Failed to retrieve the page structure from logical address 0x%lx.\n", logical_addr);
+        return 1;
+    }
+
+    // Free the allocated pages.
+    if (__free_pages(page) < 0) {
+        pr_debug("Failed to free allocated pages 0x%p with order %d.\n", page, order);
+        return 1;
+    }
+
+    // Debugging information.
+    pr_debug("Successfully freed DMA memory at logical address 0x%lx with order %d.\n", logical_addr, order);
+
+    return 0; // Success.
+}
+
+/// @brief Enables bus mastering, allowing Direct Memory Access (DMA)
+/// transactions.
+/// @details This function reads the PCI command register and enables bus
+/// mastering if not already enabled. It checks if the bus mastering bit is
+/// already set, and if not, sets it and verifies the change. If bus mastering
+/// cannot be enabled, it signals an error.
+/// @return 0 on success, 1 on failure.
+static inline int ata_dma_enable_bus_mastering(void)
 {
+    // Ensure that the ata_pci device handle is valid.
+    if (!ata_pci) {
+        pr_crit("Invalid PCI device handle.\n");
+        return 1;
+    }
+
+    // Read the PCI command register.
     uint32_t pci_cmd = pci_read_32(ata_pci, PCI_COMMAND);
+
+    // Check if bus mastering is already enabled.
     if (bit_check(pci_cmd, pci_command_bus_master)) {
-        pr_warning("Bus mastering already enabled.\n");
-    } else {
-        // Set the bit for bus mastering.
-        bit_set_assign(pci_cmd, pci_command_bus_master);
-        // Write the PCI command field.
-        pci_write_32(ata_pci, PCI_COMMAND, pci_cmd);
-        // Check that the bus mastering is enabled.
-        pci_cmd = pci_read_32(ata_pci, PCI_COMMAND);
-        if (!bit_check(pci_cmd, pci_command_bus_master)) {
-            pr_warning("Bus mastering is not correctly set.\n");
-            kernel_panic("Failed ATA initialization.");
-        }
+        pr_crit("Bus mastering already enabled.\n");
+        return 0;
+    }
+
+    // Enable bus mastering by setting the corresponding bit.
+    bit_set_assign(pci_cmd, pci_command_bus_master);
+    // Write the updated PCI command register back to the device.
+    pci_write_32(ata_pci, PCI_COMMAND, pci_cmd);
+
+    // Verify that bus mastering is enabled.
+    pci_cmd = pci_read_32(ata_pci, PCI_COMMAND);
+    if (!bit_check(pci_cmd, pci_command_bus_master)) {
+        pr_crit("Bus mastering is not correctly set.\n");
+        return 1;
     }
+
+    // Successfully enabled bus mastering.
+    return 0;
 }
 
-/// @brief Initialize the bmr field of the ATA device.
-/// @param dev the device to initialize.
+/// @brief Disables bus mastering, preventing Direct Memory Access (DMA)
+/// transactions.
+/// @details This function reads the PCI command register and clears the bus
+/// mastering bit. If bus mastering is already disabled, it logs a warning.
+/// @return 0 on success, 1 on failure.
+static inline int ata_dma_disable_bus_mastering(void)
+{
+    // Ensure that the ata_pci device handle is valid.
+    if (!ata_pci) {
+        pr_crit("Invalid PCI device handle.\n");
+        return 1;
+    }
+
+    // Read the current PCI command register.
+    uint32_t pci_cmd = pci_read_32(ata_pci, PCI_COMMAND);
+
+    // Check if bus mastering is currently enabled.
+    if (!bit_check(pci_cmd, pci_command_bus_master)) {
+        pr_crit("Bus mastering already disabled.\n");
+        return 0;
+    }
+
+    // Clear the bus mastering bit to disable it.
+    bit_clear_assign(pci_cmd, pci_command_bus_master);
+    // Write the updated PCI command register back to the device.
+    pci_write_32(ata_pci, PCI_COMMAND, pci_cmd);
+
+    // Verify that bus mastering is disabled.
+    pci_cmd = pci_read_32(ata_pci, PCI_COMMAND);
+    if (bit_check(pci_cmd, pci_command_bus_master)) {
+        pr_crit("Bus mastering is not correctly cleared.\n");
+        return 1;
+    }
+
+    // Successfully disabled bus mastering.
+    return 0;
+}
+
+/// @brief Initializes the bus mastering register (BMR) fields of the ATA
+/// device.
+/// @param dev The device to initialize.
 /// @details
-/// When you want to retrieve the actual base address of a BAR, be sure to mask
-/// the lower bits.
-/// For 16-bit Memory Space BARs, you calculate (BAR[x] & 0xFFF0).
-/// For 32-bit Memory Space BARs, you calculate (BAR[x] & 0xFFFFFFF0).
-static inline void ata_dma_initialize_bus_mastering_address(ata_device_t *dev)
+/// When retrieving the actual base address of a Base Address Register (BAR),
+/// it's essential to mask the lower bits to ensure you're working with the
+/// correct address space.
+/// - For 16-bit Memory Space BARs, the address should be masked with 0xFFF0.
+/// - For 32-bit Memory Space BARs, the address should be masked with 0xFFFFFFF0.
+/// @return 0 on success, 1 on failure.
+static inline int ata_dma_initialize_bus_mastering_address(ata_device_t *dev)
 {
+    // Read the value of the PCI Base Address Register (BAR) for bus mastering.
     uint32_t address = pci_read_32(ata_pci, PCI_BASE_ADDRESS_4);
-    // To distinguish between memory space BARs and I/O space BARs, you can
-    // check the value of the lowest bit. memory space BARs has always a 0,
-    // while I/O space BARs has always a 1.
+
+    // Check if the lowest bit is set to distinguish between memory space and
+    // I/O space BARs. Memory space BARs have the lowest bit as 0, while I/O
+    // space BARs have it as 1.
     if (!bit_check(address, 0)) {
-        pr_warning("[%s] Failed to initialize BUS Mastering.\n", ata_get_device_settings_str(dev));
-        kernel_panic("Failed ATA initialization.");
+        // Log a warning if the address indicates that bus mastering could not be initialized.
+        pr_warning("[%s] Failed to initialize Bus Mastering. The address is not an I/O space BAR.\n", ata_get_device_settings_str(dev));
+        return 1;
     }
-    /// When you want to retrieve the actual base address of a BAR, be sure to
-    /// mask the lower bits, for I/O space BARs you calculate (BAR & 0xFFFFFFFC).
+
+    // Mask the lower bits to retrieve the actual base address for I/O space
+    // BARs. The mask 0xFFFFFFFC is used to clear the lowest two bits.
     address &= 0xFFFFFFFC;
-    // Differentiate between primary or secondary ATA bus.
+
+    // Differentiate between the primary and secondary ATA buses to set the
+    // correct BMR fields.
     if (dev->primary) {
-        dev->bmr.command = address + 0x0;
-        dev->bmr.status  = address + 0x2;
-        dev->bmr.prdt    = address + 0x4;
+        // For the primary ATA bus, set the command, status, and PRDT (Physical
+        // Region Descriptor Table) addresses.
+        dev->bmr.command = address + 0x0; // Command register offset
+        dev->bmr.status  = address + 0x2; // Status register offset
+        dev->bmr.prdt    = address + 0x4; // PRDT offset
     } else {
-        dev->bmr.command = address + 0x8;
-        dev->bmr.status  = address + 0xA;
-        dev->bmr.prdt    = address + 0xC;
+        // For the secondary ATA bus, set the command, status, and PRDT
+        // addresses with different offsets.
+        dev->bmr.command = address + 0x8; // Command register offset
+        dev->bmr.status  = address + 0xA; // Status register offset
+        dev->bmr.prdt    = address + 0xC; // PRDT offset
     }
+
+    // Successfully initialized BMR addresses.
+    return 0;
 }
 
 // == ATA DEVICE MANAGEMENT ===================================================
 
 /// @brief Detects the type of device.
-/// @param dev the device for which we are checking the type.
-/// @return the device type.
+/// @param dev The device for which we are checking the type.
+/// @return The detected device type.
 static inline ata_device_type_t ata_detect_device_type(ata_device_t *dev)
 {
     pr_debug("[%s] Detecting device type...\n", ata_get_device_settings_str(dev));
-    // Select the drive.
+
+    // Select the drive (Master/Slave).
     outportb(dev->io_reg.hddevsel, 0xA0 | (dev->slave << 4U));
-    // Wait for the command to work.
+
+    // Wait for the command to settle.
     ata_io_wait(dev);
-    // Select the ATA device.
+
+    // Select the ATA device (preparing for IDENTIFY).
     outportb(dev->io_base + 1, 1);
-    // Disable IRQs.
+
+    // Disable IRQs for this operation.
     outportb(dev->io_control, 0);
-    // Select the device.
+
+    // Select the device again to ensure proper communication.
     outportb(dev->io_reg.hddevsel, 0xA0 | (dev->slave << 4U));
-    // Wait 400ns for the command to work.
+
+    // Wait for 400ns for the command to settle.
     ata_io_wait(dev);
+
     // The host is prohibited from writing the Features, Sector Count, Sector
     // Number, Cylinder Low, Cylinder High, or Device/Head registers when either
     // BSY or DRQ is set in the Status Register. Any write to the Command
@@ -708,48 +875,56 @@ static inline ata_device_type_t ata_detect_device_type(ata_device_t *dev)
     // Device Reset command.
     if (ata_status_wait_not(dev, ata_status_bsy | ata_status_drq, 100000)) {
         ata_print_status_error(dev);
-        return 1;
+        return ata_dev_type_unknown;
     }
+
     // ATA specs say these values must be zero before sending IDENTIFY.
     outportb(dev->io_reg.sector_count, 0);
     outportb(dev->io_reg.lba_lo, 0);
     outportb(dev->io_reg.lba_mid, 0);
     outportb(dev->io_reg.lba_hi, 0);
-    // Request the device identity.
+
+    // Request the device identity by sending the IDENTIFY command.
     outportb(dev->io_reg.command, ata_command_pata_ident);
-    // Wait for the device to become non-busy, and ready.
-    if (ata_status_wait_not(dev, ata_status_bsy & ~(ata_status_drq | ata_status_rdy), 100000)) {
+
+    // Wait for the device to become non-busy and ready.
+    // if (ata_status_wait_not(dev, ata_status_bsy & ~(ata_status_drq | ata_status_rdy), 100000)) {
+    if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
-        return 1;
+        return ata_dev_type_unknown;
     }
-    // Read the identity.
+
+    // Read the identity data from the device.
     inportsw(dev->io_reg.data, (uint16_t *)&dev->identity, (sizeof(ata_identity_t) / sizeof(uint16_t)));
-    // Fix the serial.
+
+    // Fix the serial number, firmware revision, and model number.
     ata_fix_string((char *)&dev->identity.serial_number, count_of(dev->identity.serial_number) - 1);
-    // Fix the firmware.
     ata_fix_string((char *)&dev->identity.firmware_revision, count_of(dev->identity.firmware_revision) - 1);
-    // Fix the model.
     ata_fix_string((char *)&dev->identity.model_number, count_of(dev->identity.model_number) - 1);
-    // Get the "signature bytes" by reading low and high cylinder register.
-    uint8_t lba_lo  = inportb(dev->io_reg.lba_hi);
+
+    // Get the "signature bytes" by reading low and high cylinder registers.
+    uint8_t lba_lo  = inportb(dev->io_reg.lba_lo);
     uint8_t lba_mid = inportb(dev->io_reg.lba_mid);
     uint8_t lba_hi  = inportb(dev->io_reg.lba_hi);
-    // Differentiate ATA, ATAPI, SATA and SATAPI.
+
+    // Differentiate between ATA, ATAPI, SATA, and SATAPI devices based on signature bytes.
     if ((lba_mid == 0x00) && (lba_hi == 0x00)) {
-        return ata_dev_type_pata;
+        return ata_dev_type_pata; // Parallel ATA
     }
     if ((lba_mid == 0x3C) && (lba_hi == 0xC3)) {
-        return ata_dev_type_sata;
+        return ata_dev_type_sata; // Serial ATA
     }
     if ((lba_mid == 0x14) && (lba_hi == 0xEB)) {
-        return ata_dev_type_patapi;
+        return ata_dev_type_patapi; // Parallel ATAPI
     }
     if ((lba_mid == 0x69) && (lba_hi == 0x96)) {
-        return ata_dev_type_satapi;
+        return ata_dev_type_satapi; // Serial ATAPI
     }
     if ((lba_mid == 0xFF) && (lba_hi == 0xFF)) {
-        return ata_dev_type_no_device;
+        return ata_dev_type_no_device; // No device present.
     }
+
+    // Return unknown type if none of the conditions are met.
     return ata_dev_type_unknown;
 }
 
@@ -758,31 +933,63 @@ static inline ata_device_type_t ata_detect_device_type(ata_device_t *dev)
 /// @return 0 on success, 1 on error.
 static bool_t ata_device_init(ata_device_t *dev)
 {
-    pr_debug("[%s] Initializing ATA device...\n", ata_get_device_settings_str(dev));
-    // Check the status of the device.
+    pr_debug("[%-16s, %-9s] Initializing ATA device...\n",
+             ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
+
+    // Check the status of the device to ensure it's ready for initialization.
     if (ata_status_wait_for(dev, ata_status_drq | ata_status_rdy, 100000)) {
+        // pr_crit("[%-16s, %-9s] Device not ready after waiting.\n",
+        //         ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
         ata_print_status_error(dev);
         return 1;
     }
+
     // Initialize the bus mastering addresses.
-    ata_dma_initialize_bus_mastering_address(dev);
+    if (ata_dma_initialize_bus_mastering_address(dev)) {
+        pr_crit("[%-16s, %-9s] Failed to initialize bus mastering address.\n",
+                ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
+        ata_print_status_error(dev);
+        return 1;
+    }
+
     // Check the status of the device.
     if (ata_status_wait_for(dev, ata_status_drq | ata_status_rdy, 100000)) {
+        pr_crit("[%-16s, %-9s] Device not ready after bus mastering initialization.\n",
+                ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
         ata_print_status_error(dev);
         return 1;
     }
+
     // Allocate the memory for the Physical Region Descriptor Table (PRDT).
-    dev->dma.prdt = (prdt_t *)ata_dma_malloc(sizeof(prdt_t), &dev->dma.prdt_phys);
+    dev->dma.prdt = (prdt_t *)ata_dma_alloc(sizeof(prdt_t), &dev->dma.prdt_phys);
+    if (dev->dma.prdt == NULL) {
+        pr_crit("[%-16s, %-9s] Failed to allocate memory for PRDT.\n",
+                ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
+        return 1;
+    }
+
     // Allocate the memory for the Direct Memory Access (DMA).
-    dev->dma.start = (uint8_t *)ata_dma_malloc(ATA_DMA_SIZE, &dev->dma.start_phys);
-    // Initialize the table, specifying the physical address of the DMA.
+    dev->dma.start = (uint8_t *)ata_dma_alloc(ATA_DMA_SIZE, &dev->dma.start_phys);
+    if (dev->dma.start == NULL) {
+        pr_crit("[%-16s, %-9s] Failed to allocate memory for DMA.\n",
+                ata_get_device_settings_str(dev), ata_get_device_type_str(dev->type));
+        // Free previously allocated PRDT.
+        ata_dma_free((uintptr_t)dev->dma.prdt);
+        return 1;
+    }
+
+    // Initialize the PRDT with the physical address of the DMA.
     dev->dma.prdt->physical_address = dev->dma.start_phys;
-    // The size of the DMA.
+
+    // Set the size of the DMA transfer.
     dev->dma.prdt->byte_count = ATA_DMA_SIZE;
-    // Set the EOT to 1.
+
+    // Set the End of Table (EOT) flag.
     dev->dma.prdt->end_of_table = 0x8000;
-    // Print the device data.
+
+    // Print the device data for debugging purposes.
     ata_dump_device(dev);
+
     return 0;
 }
 
@@ -794,83 +1001,100 @@ static bool_t ata_device_init(ata_device_t *dev)
 /// @param buffer the buffer we are writing.
 static void ata_device_read_sector(ata_device_t *dev, uint32_t lba_sector, uint8_t *buffer)
 {
-    // Check if we are trying to perform the read on the correct drive type.
+    // Check if we are trying to perform the read on a valid device type.
     if ((dev->type != ata_dev_type_pata) && (dev->type != ata_dev_type_sata)) {
+        pr_crit("[%s] Unsupported device type for read operation.\n", ata_get_device_settings_str(dev));
         return;
     }
-    // pr_debug("ata_device_read_sector(dev: %p, lba_sector: %d, buffer: %p)\n", dev, lba_sector, buffer);
+
+    // Acquire the lock for thread safety.
     spinlock_lock(&dev->lock);
 
-    // Wait for the
+    // Wait for the device to be ready (BSY flag should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
-    // Reset bus master register's command register.
+    // Reset the bus master register's command register.
     outportb(dev->bmr.command, 0x00);
 
-    // Set the PRDT.
+    // Set the Physical Region Descriptor Table (PRDT).
     outportl(dev->bmr.prdt, dev->dma.prdt_phys);
 
-    // Enable error, irq status.
+    // Enable error and IRQ status in the bus master register.
     outportb(dev->bmr.status, inportb(dev->bmr.status) | 0x04 | 0x02);
 
-    // Set read.
+    // Set the command to read data (0x08).
     outportb(dev->bmr.command, 0x08);
 
+    // Wait for the device to be ready again (BSY should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
+    // Disable IRQs to prevent interrupts during setup.
     outportb(dev->io_control, 0x00);
+
+    // Select the drive (set head and device).
     outportb(dev->io_reg.hddevsel, 0xe0 | (dev->slave << 4));
-    ata_io_wait(dev);
+    ata_io_wait(dev); // Wait for the device to process the selection.
+
+    // Clear the features register.
     outportb(dev->io_reg.feature, 0x00);
 
+    // Prepare the LBA sector address.
     outportb(dev->io_reg.sector_count, 0);
     outportb(dev->io_reg.lba_lo, (lba_sector & 0xff000000) >> 24);
     outportb(dev->io_reg.lba_mid, (lba_sector & 0xff00000000) >> 32);
     outportb(dev->io_reg.lba_hi, (lba_sector & 0xff0000000000) >> 40);
 
+    // Set the sector count to 1 and the remaining LBA address.
     outportb(dev->io_reg.sector_count, 1);
     outportb(dev->io_reg.lba_lo, (lba_sector & 0x000000ff) >> 0);
     outportb(dev->io_reg.lba_mid, (lba_sector & 0x0000ff00) >> 8);
     outportb(dev->io_reg.lba_hi, (lba_sector & 0x00ff0000) >> 16);
 
+    // Wait for the device to be ready for data transfer (BSY should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy & ~ata_status_rdy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
-    // Write the READ_DMA to the command register (0xC8)
+    // Write the READ_DMA command (0xC8) to the command register.
     outportb(dev->io_reg.command, ata_dma_command_read);
 
+    // Wait for the device to process the command.
     ata_io_wait(dev);
 
-    outportb(dev->bmr.command, 0x08 | 0x01);
+    // Set the bus master register to start the read operation.
+    outportb(dev->bmr.command, 0x08 | 0x01); // Start the DMA read operation.
 
+    // Wait for the DMA transfer to complete.
     while (1) {
         int status  = inportb(dev->bmr.status);
         int dstatus = inportb(dev->io_reg.status);
+        // Wait for the DMA transfer to complete.
         if (!(status & 0x04)) {
             continue;
         }
+        // Check if the device is no longer busy.
         if (!(dstatus & ata_status_bsy)) {
             break;
         }
     }
 
-    // Copy from DMA buffer to output buffer.
+    // Copy data from the DMA buffer to the output buffer.
     memcpy(buffer, dev->dma.start, ATA_DMA_SIZE);
 
-    // Inform device we are done.
+    // Inform the device that we are done with the data transfer.
     outportb(dev->bmr.status, inportb(dev->bmr.status) | 0x04 | 0x02);
 
+    // Release the lock after the operation.
     spinlock_unlock(&dev->lock);
 }
 
@@ -880,69 +1104,82 @@ static void ata_device_read_sector(ata_device_t *dev, uint32_t lba_sector, uint8
 /// @param buffer the buffer where we store what we read.
 static void ata_device_write_sector(ata_device_t *dev, uint32_t lba_sector, uint8_t *buffer)
 {
+    // Check if we are trying to perform the read on a valid device type.
+    if ((dev->type != ata_dev_type_pata) && (dev->type != ata_dev_type_sata)) {
+        pr_crit("[%s] Unsupported device type for read operation.\n", ata_get_device_settings_str(dev));
+        return;
+    }
+
+    // Acquire the lock for thread safety.
     spinlock_lock(&dev->lock);
 
-    // Copy the buffer over to the DMA area
+    // Copy the buffer over to the DMA area.
     memcpy(dev->dma.start, buffer, ATA_DMA_SIZE);
 
-    // Reset bus master register's command register
+    // Reset the bus master register's command register.
     outportb(dev->bmr.command, 0);
 
-    // Set prdt
+    // Set the Physical Region Descriptor Table (PRDT).
     outportl(dev->bmr.prdt, dev->dma.prdt_phys);
 
-    // Enable error, irq status.
+    // Enable error and IRQ status in the bus master register.
     outportb(dev->bmr.status, inportb(dev->bmr.status) | 0x04 | 0x02);
 
-    // Select drive
+    // Wait for the device to be ready (BSY flag should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
-    outportb(dev->io_reg.hddevsel, 0xe0 | dev->slave << 4 | (lba_sector & 0x0f000000) >> 24);
+    // Select the drive (set head and device).
+    outportb(dev->io_reg.hddevsel, 0xe0 | (dev->slave << 4) | ((lba_sector & 0x0F000000) >> 24));
 
+    // Wait for the device to be ready again (BSY flag should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
-    // Set sector counts and LBAs
-    outportb(dev->io_reg.feature, 0x00);
-    outportb(dev->io_reg.sector_count, 1);
-    outportb(dev->io_reg.lba_lo, (lba_sector & 0x000000ff) >> 0);
-    outportb(dev->io_reg.lba_mid, (lba_sector & 0x0000ff00) >> 8);
-    outportb(dev->io_reg.lba_hi, (lba_sector & 0x00ff0000) >> 16);
+    // Set the features, sector count, and LBA for the write operation.
+    outportb(dev->io_reg.feature, 0x00);                           // No features for this write operation.
+    outportb(dev->io_reg.sector_count, 1);                         // Write one sector.
+    outportb(dev->io_reg.lba_lo, (lba_sector & 0x000000FF) >> 0);  // LBA low byte.
+    outportb(dev->io_reg.lba_mid, (lba_sector & 0x0000FF00) >> 8); // LBA mid byte.
+    outportb(dev->io_reg.lba_hi, (lba_sector & 0x00FF0000) >> 16); // LBA high byte.
 
+    // Wait for the device to be ready for data transfer (BSY should be clear).
     if (ata_status_wait_not(dev, ata_status_bsy, 100000)) {
         ata_print_status_error(dev);
         spinlock_unlock(&dev->lock);
         return;
     }
 
-    // Notify that we are starting DMA writing.
+    // Notify that we are starting the DMA writing operation.
     outportb(dev->io_reg.command, ata_dma_command_write);
 
-    // Start DMA Writing.
-    outportb(dev->bmr.command, 0x1);
+    // Start the DMA writing process.
+    outportb(dev->bmr.command, 0x01); // Start the DMA transfer.
 
-    // Wait for dma write to complete.
+    // Wait for the DMA write to complete.
     while (1) {
         int status  = inportb(dev->bmr.status);
         int dstatus = inportb(dev->io_reg.status);
+        // Wait for DMA transfer to complete.
         if (!(status & 0x04)) {
             continue;
         }
-        if (!(dstatus & 0x80)) {
+        // Exit when device is no longer busy.
+        if (!(dstatus & ata_status_bsy)) {
             break;
         }
     }
 
-    // Inform device we are done.
+    // Inform the device that we are done with the write operation.
     outportb(dev->bmr.status, inportb(dev->bmr.status) | 0x04 | 0x02);
 
+    // Release the lock after the operation is complete.
     spinlock_unlock(&dev->lock);
 }
 
@@ -957,6 +1194,8 @@ static vfs_file_t *ata_open(const char *path, int flags, mode_t mode)
 {
     pr_debug("ata_open(%s, %d, %d)\n", path, flags, mode);
     ata_device_t *dev = NULL;
+
+    // Determine which device to open based on the provided path.
     if (strcmp(path, ata_primary_master.path) == 0) {
         dev = &ata_primary_master;
     } else if (strcmp(path, ata_primary_slave.path) == 0) {
@@ -966,12 +1205,20 @@ static vfs_file_t *ata_open(const char *path, int flags, mode_t mode)
     } else if (strcmp(path, ata_secondary_slave.path) == 0) {
         dev = &ata_secondary_slave;
     } else {
+        pr_crit("Device not found for path: %s\n", path);
         return NULL;
     }
+
+    // If the device's filesystem root is already allocated, increment its
+    // reference count.
     if (dev->fs_root) {
+        // Increment reference count for the file.
         ++dev->fs_root->count;
+        // Return the filesystem root associated with the device.
         return dev->fs_root;
     }
+
+    pr_crit("Filesystem root not initialized for device: %s\n", path);
     return NULL;
 }
 
@@ -981,17 +1228,35 @@ static vfs_file_t *ata_open(const char *path, int flags, mode_t mode)
 static int ata_close(vfs_file_t *file)
 {
     pr_debug("ata_close(%p)\n", file);
+
+    // Check if the file pointer is NULL.
+    if (file == NULL) {
+        pr_crit("Attempted to close a NULL file pointer.\n");
+        return 1;
+    }
+
     // Get the device from the VFS file.
     ata_device_t *dev = (ata_device_t *)file->device;
+
     // Check the device.
     if (dev == NULL) {
-        kernel_panic("Device not set.");
+        pr_crit("Device not set for file: %p\n", file);
+        return 1;
     }
-    //
+
+    // Check if the device is one of the ATA devices.
     if ((dev == &ata_primary_master) || (dev == &ata_primary_slave) ||
         (dev == &ata_secondary_master) || (dev == &ata_secondary_slave)) {
-        --file->count;
+        // Decrement the reference count for the file.
+        if (--file->count == 0) {
+            // Optional: Free any resources if this is the last reference.
+            // Freeing resources can be added here if necessary.
+        }
+    } else {
+        pr_crit("Invalid device encountered: %p\n", dev);
+        return 1;
     }
+
     return 0;
 }
 
@@ -1004,63 +1269,74 @@ static int ata_close(vfs_file_t *file)
 static ssize_t ata_read(vfs_file_t *file, char *buffer, off_t offset, size_t size)
 {
     // pr_debug("ata_read(file: 0x%p, buffer: 0x%p, offest: %8d, size: %8d)\n", file, buffer, offset, size);
+
     // Prepare a static support buffer.
     static char support_buffer[ATA_SECTOR_SIZE];
+
     // Get the device from the VFS file.
     ata_device_t *dev = (ata_device_t *)file->device;
+
     // Check the device.
     if (dev == NULL) {
-        kernel_panic("Device not set.");
-    }
-
-    if ((dev->type == ata_dev_type_pata) || (dev->type == ata_dev_type_sata)) {
-        uint32_t start_block  = offset / ATA_SECTOR_SIZE;
-        uint32_t start_offset = offset % ATA_SECTOR_SIZE;
-        uint32_t end_block    = (offset + size - 1) / ATA_SECTOR_SIZE;
-        uint32_t end_offset   = (offset + size - 1) % ATA_SECTOR_SIZE;
-        uint32_t prefix_size  = (ATA_SECTOR_SIZE - start_offset);
-        uint32_t postfix_size = (offset + size) % ATA_SECTOR_SIZE;
-        uint32_t max_offset   = ata_max_offset(dev);
-        uint32_t x_offset     = 0;
-
-        // Check if with the offset we are exceeding the size.
-        if (offset > max_offset) {
-            pr_warning("The offset is exceeding the disk size (%d > %d)\n", offset, max_offset);
-            ata_dump_device(dev);
-            // Get the error and status information of the device.
-            uint8_t error = inportb(dev->io_reg.error), status = inportb(dev->io_reg.status);
-            pr_err("Device error  : %s\n", ata_get_device_error_str(error));
-            pr_err("Device status : %s\n", ata_get_device_status_str(status));
-            return 0;
-        }
+        pr_crit("Device not set for file: %p\n", file);
+        return -1; // Return error if the device is not set.
+    }
 
-        // Check if we are going to reading over the size.
-        if ((offset + size) > max_offset) {
-            size = max_offset - offset;
-        }
+    // Check device type.
+    if (dev->type != ata_dev_type_pata && dev->type != ata_dev_type_sata) {
+        pr_warning("Unsupported device type.\n");
+        return -EPERM; // Return error for unsupported device types.
+    }
 
-        if (start_offset) {
-            ata_device_read_sector(dev, start_block, (uint8_t *)support_buffer);
-            memcpy(buffer, (void *)((uintptr_t)support_buffer + start_offset), prefix_size);
-            x_offset += prefix_size;
-            ++start_block;
-        }
+    uint32_t max_offset = ata_max_offset(dev);
+
+    // Check if the offset exceeds the disk size.
+    if (offset > max_offset) {
+        pr_warning("The offset is exceeding the disk size (%d > %d)\n", offset, max_offset);
+        ata_dump_device(dev);
+        // Get the error and status information of the device.
+        uint8_t error = inportb(dev->io_reg.error), status = inportb(dev->io_reg.status);
+        pr_err("Device error  : %s\n", ata_get_device_error_str(error));
+        pr_err("Device status : %s\n", ata_get_device_status_str(status));
+        return -1; // Return error on invalid offset.
+    }
 
-        if (postfix_size && (start_block <= end_block)) {
-            ata_device_read_sector(dev, end_block, (uint8_t *)support_buffer);
-            memcpy((void *)((uintptr_t)buffer + size - postfix_size), support_buffer, postfix_size);
-            --end_block;
-        }
+    // Check if reading exceeds the size.
+    if ((offset + size) > max_offset) {
+        size = max_offset - offset;
+    }
 
-        while (start_block <= end_block) {
-            ata_device_read_sector(dev, start_block, (uint8_t *)((uintptr_t)buffer + x_offset));
-            x_offset += ATA_SECTOR_SIZE;
-            ++start_block;
-        }
-    } else if ((dev->type == ata_dev_type_patapi) || (dev->type == ata_dev_type_satapi)) {
-        pr_warning("ATAPI and SATAPI drives are not currently supported.\n");
-        size = -EPERM;
+    uint32_t start_block  = offset / ATA_SECTOR_SIZE;
+    uint32_t start_offset = offset % ATA_SECTOR_SIZE;
+    uint32_t end_block    = (offset + size - 1) / ATA_SECTOR_SIZE;
+    uint32_t end_offset   = (offset + size - 1) % ATA_SECTOR_SIZE;
+    uint32_t prefix_size  = (ATA_SECTOR_SIZE - start_offset);
+    uint32_t postfix_size = (offset + size) % ATA_SECTOR_SIZE;
+    uint32_t x_offset     = 0;
+
+    if (start_offset) {
+        ata_device_read_sector(dev, start_block, (uint8_t *)support_buffer);
+        // Copy the prefix from the support buffer to the output buffer.
+        memcpy(buffer, (void *)((uintptr_t)support_buffer + start_offset), prefix_size);
+        x_offset += prefix_size;
+        ++start_block;
+    }
+
+    // Read postfix if needed.
+    if (postfix_size && (start_block <= end_block)) {
+        ata_device_read_sector(dev, end_block, (uint8_t *)support_buffer);
+        // Copy the postfix from the support buffer to the output buffer.
+        memcpy((void *)((uintptr_t)buffer + size - postfix_size), support_buffer, postfix_size);
+        --end_block;
+    }
+
+    // Read full sectors in between.
+    for (; start_block <= end_block; ++start_block) {
+        ata_device_read_sector(dev, start_block, (uint8_t *)((uintptr_t)buffer + x_offset));
+        x_offset += ATA_SECTOR_SIZE;
     }
+
+    // Return the number of bytes read.
     return size;
 }
 
@@ -1073,58 +1349,67 @@ static ssize_t ata_read(vfs_file_t *file, char *buffer, off_t offset, size_t siz
 static ssize_t ata_write(vfs_file_t *file, const void *buffer, off_t offset, size_t size)
 {
     pr_debug("ata_write(%p, %p, %d, %d)\n", file, buffer, offset, size);
+
     // Prepare a static support buffer.
     static char support_buffer[ATA_SECTOR_SIZE];
+
     // Get the device from the VFS file.
     ata_device_t *dev = (ata_device_t *)file->device;
+
     // Check the device.
     if (dev == NULL) {
-        kernel_panic("Device not set.");
-    }
-
-    if ((dev->type == ata_dev_type_pata) || (dev->type == ata_dev_type_sata)) {
-        uint32_t start_block  = offset / ATA_SECTOR_SIZE;
-        uint32_t start_offset = offset % ATA_SECTOR_SIZE;
-        uint32_t end_block    = (offset + size - 1) / ATA_SECTOR_SIZE;
-        uint32_t end_offset   = (offset + size - 1) % ATA_SECTOR_SIZE;
-        uint32_t prefix_size  = (ATA_SECTOR_SIZE - start_offset);
-        uint32_t postfix_size = (offset + size) % ATA_SECTOR_SIZE;
-        uint32_t max_offset   = ata_max_offset(dev);
-        uint32_t x_offset     = 0;
-
-        // Check if with the offset we are exceeding the size.
-        if (offset > max_offset) {
-            return 0;
-        }
+        pr_crit("Device not set for file: %p\n", file);
+        return -1; // Return error if the device is not set.
+    }
 
-        // Check if we are going to readoing over the size.
-        if (offset + size > max_offset) {
-            size = max_offset - offset;
-        }
-        if (start_offset) {
-            ata_device_read_sector(dev, start_block, (uint8_t *)support_buffer);
-            memcpy((void *)((uintptr_t)support_buffer + (start_offset)), buffer, prefix_size);
-            ata_device_write_sector(dev, start_block, (uint8_t *)support_buffer);
-            x_offset += prefix_size;
-            ++start_block;
-        }
+    // Check device type.
+    if (dev->type != ata_dev_type_pata && dev->type != ata_dev_type_sata) {
+        pr_warning("Unsupported device type.\n");
+        return -EPERM; // Return error for unsupported device types.
+    }
 
-        if (postfix_size && (start_block <= end_block)) {
-            ata_device_read_sector(dev, end_block, (uint8_t *)support_buffer);
-            memcpy(support_buffer, (void *)((uintptr_t)buffer + size - postfix_size), postfix_size);
-            ata_device_write_sector(dev, end_block, (uint8_t *)support_buffer);
-            --end_block;
-        }
+    uint32_t start_block  = offset / ATA_SECTOR_SIZE;
+    uint32_t start_offset = offset % ATA_SECTOR_SIZE;
+    uint32_t end_block    = (offset + size - 1) / ATA_SECTOR_SIZE;
+    uint32_t end_offset   = (offset + size - 1) % ATA_SECTOR_SIZE;
+    uint32_t prefix_size  = (ATA_SECTOR_SIZE - start_offset);
+    uint32_t postfix_size = (offset + size) % ATA_SECTOR_SIZE;
+    uint32_t max_offset   = ata_max_offset(dev);
+    uint32_t x_offset     = 0;
+
+    // Check if with the offset we are exceeding the size.
+    if (offset > max_offset) {
+        return 0;
+    }
 
-        while (start_block <= end_block) {
-            ata_device_write_sector(dev, start_block, (uint8_t *)((uintptr_t)buffer + x_offset));
-            x_offset += ATA_SECTOR_SIZE;
-            ++start_block;
-        }
-    } else if ((dev->type == ata_dev_type_patapi) || (dev->type == ata_dev_type_satapi)) {
-        pr_warning("ATAPI and SATAPI drives are not currently supported.\n");
-        size = -EPERM;
+    // Check if we are going to readoing over the size.
+    if (offset + size > max_offset) {
+        size = max_offset - offset;
+    }
+
+    // Handle the prefix if needed.
+    if (start_offset) {
+        ata_device_read_sector(dev, start_block, (uint8_t *)support_buffer);
+        memcpy((void *)((uintptr_t)support_buffer + (start_offset)), buffer, prefix_size);
+        ata_device_write_sector(dev, start_block, (uint8_t *)support_buffer);
+        x_offset += prefix_size;
+        ++start_block;
+    }
+
+    // Handle the postfix if needed.
+    if (postfix_size && (start_block <= end_block)) {
+        ata_device_read_sector(dev, end_block, (uint8_t *)support_buffer);
+        memcpy(support_buffer, (void *)((uintptr_t)buffer + size - postfix_size), postfix_size);
+        ata_device_write_sector(dev, end_block, (uint8_t *)support_buffer);
+        --end_block;
     }
+
+    // Write full sectors in between.
+    for (; start_block <= end_block; ++start_block) {
+        ata_device_write_sector(dev, start_block, (uint8_t *)((uintptr_t)buffer + x_offset));
+        x_offset += ATA_SECTOR_SIZE;
+    }
+
     return size;
 }
 
@@ -1286,6 +1571,9 @@ static ata_device_type_t ata_device_detect(ata_device_t *dev)
         }
         // Increment the drive letter.
         ++ata_drive_char;
+
+        pr_notice("Initialized %s device on %s.\n", ata_get_device_type_str(dev->type), ata_get_device_settings_str(dev));
+
     } else if ((type == ata_dev_type_patapi) || (type == ata_dev_type_satapi)) {
         pr_debug("[%s] ATAPI and SATAPI drives are not currently supported...\n", ata_get_device_settings_str(dev));
         type = ata_dev_type_no_device;
diff --git a/mentos/src/drivers/keyboard/keyboard.c b/mentos/src/drivers/keyboard/keyboard.c
index 654645f1..011ebd64 100644
--- a/mentos/src/drivers/keyboard/keyboard.c
+++ b/mentos/src/drivers/keyboard/keyboard.c
@@ -43,30 +43,33 @@ spinlock_t scancodes_lock;
 #define KBD_LEFT_ALT      (1 << 7) ///< Flag which identifies the left alt.
 #define KBD_RIGHT_ALT     (1 << 8) ///< Flag which identifies the right alt.
 
-/// @brief Returns the keypad number associated with the scancode.
-/// @param scancode the scan code we transform to number.
-/// @return the number it is associated with.
-static inline int get_keypad_number(unsigned int scancode)
+/// @brief Pushes a character into the scancode ring buffer.
+/// @param c The character to push into the ring buffer.
+static inline void keyboard_push_front(unsigned int c)
 {
-    if (scancode == KEY_KP0) { return 0; }
-    if (scancode == KEY_KP1) { return 1; }
-    if (scancode == KEY_KP2) { return 2; }
-    if (scancode == KEY_KP3) { return 3; }
-    if (scancode == KEY_KP4) { return 4; }
-    if (scancode == KEY_KP5) { return 5; }
-    if (scancode == KEY_KP6) { return 6; }
-    if (scancode == KEY_KP7) { return 7; }
-    if (scancode == KEY_KP8) { return 8; }
-    if (scancode == KEY_KP9) { return 9; }
-    return -1;
+    // Lock the scancode buffer to ensure thread safety during push operation.
+    spinlock_lock(&scancodes_lock);
+
+    // Push the character into the front of the scancode buffer.
+    fs_rb_scancode_push_front(&scancodes, (int)c);
+
+    // Unlock the buffer after the push operation is complete.
+    spinlock_unlock(&scancodes_lock);
 }
 
-/// @brief Pushes the character in the scancode ring buffer.
-/// @param c the char we push inside the ring buffer.
-static inline void keyboard_push_front(unsigned int c)
+/// @brief Pushes a sequence of characters (scancodes) into the keyboard buffer.
+/// @param sequence A null-terminated string representing the sequence to push.
+static inline void keyboard_push_sequence(char *sequence)
 {
+    // Lock the scancodes ring buffer to ensure thread safety.
     spinlock_lock(&scancodes_lock);
-    fs_rb_scancode_push_front(&scancodes, (int)c);
+
+    // Iterate through each character in the sequence and push it to the buffer.
+    for (size_t i = 0; i < strlen(sequence); ++i) {
+        fs_rb_scancode_push_front(&scancodes, (int)sequence[i]);
+    }
+
+    // Unlock the buffer after the operation is complete.
     spinlock_unlock(&scancodes_lock);
 }
 
@@ -121,13 +124,13 @@ void keyboard_isr(pt_regs *f)
     }
 
     // Take scancode from the port.
-    scancode = ps2_read();
+    scancode = ps2_read_data();
     if (scancode == 0xE0) {
-        scancode = (scancode << 8U) | ps2_read();
+        scancode = (scancode << 8U) | ps2_read_data();
     }
 
-    // Get the keypad number, of num-lock is disabled. Otherwise, initialize to -1;
-    int keypad_fun_number = !bitmask_check(kflags, KBD_NUM_LOCK) ? get_keypad_number(scancode) : -1;
+    // Get the keypad number, of num-lock is disabled.
+    int keypad_code = !bitmask_check(kflags, KBD_NUM_LOCK) ? scancode : 0;
 
     // If the key has just been released.
     if (scancode == KEY_LEFT_SHIFT) {
@@ -183,51 +186,78 @@ void keyboard_isr(pt_regs *f)
     } else if (scancode == KEY_BACKSPACE) {
         keyboard_push_front('\b');
         pr_debug("Press(KEY_BACKSPACE)\n");
-    } else if (scancode == KEY_DELETE) {
-        keyboard_push_front(0x7F);
-        pr_debug("Press(KEY_DELETE)\n");
     } else if ((scancode == KEY_ENTER) || (scancode == KEY_KP_RETURN)) {
         keyboard_push_front('\n');
         pr_debug("Press(KEY_ENTER)\n");
-    } else if ((scancode == KEY_PAGE_UP) || (keypad_fun_number == 9)) {
-        keyboard_push_front(scancode);
-        pr_debug("Press(KEY_PAGE_UP)\n");
-    } else if ((scancode == KEY_PAGE_DOWN) || (keypad_fun_number == 2)) {
-        keyboard_push_front(scancode);
-        pr_debug("Press(KEY_PAGE_DOWN)\n");
-    } else if ((scancode == KEY_UP_ARROW) || (keypad_fun_number == 8)) {
+    } else if ((scancode == KEY_UP_ARROW) || (keypad_code == KEY_KP8)) {
         pr_debug("Press(KEY_UP_ARROW)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('A');
-    } else if ((scancode == KEY_DOWN_ARROW) || (keypad_fun_number == 2)) {
+        keyboard_push_sequence("\033[A");
+    } else if ((scancode == KEY_DOWN_ARROW) || (keypad_code == KEY_KP2)) {
         pr_debug("Press(KEY_DOWN_ARROW)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('B');
-    } else if ((scancode == KEY_RIGHT_ARROW) || (keypad_fun_number == 6)) {
+        keyboard_push_sequence("\033[B");
+    } else if ((scancode == KEY_RIGHT_ARROW) || (keypad_code == KEY_KP6)) {
         pr_debug("Press(KEY_RIGHT_ARROW)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('C');
-    } else if ((scancode == KEY_LEFT_ARROW) || (keypad_fun_number == 4)) {
+        keyboard_push_sequence("\033[C");
+    } else if ((scancode == KEY_LEFT_ARROW) || (keypad_code == KEY_KP4)) {
         pr_debug("Press(KEY_LEFT_ARROW)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('D');
-    } else if ((scancode == KEY_HOME) || (keypad_fun_number == 7)) {
+        keyboard_push_sequence("\033[D");
+    } else if (scancode == KEY_F1) {
+        pr_debug("Press(KEY_F1)\n");
+        keyboard_push_sequence("\033[11~");
+    } else if (scancode == KEY_F2) {
+        pr_debug("Press(KEY_F2)\n");
+        keyboard_push_sequence("\033[12~");
+    } else if (scancode == KEY_F3) {
+        pr_debug("Press(KEY_F3)\n");
+        keyboard_push_sequence("\033[13~");
+    } else if (scancode == KEY_F4) {
+        pr_debug("Press(KEY_F4)\n");
+        keyboard_push_sequence("\033[14~");
+    } else if (scancode == KEY_F5) {
+        pr_debug("Press(KEY_F5)\n");
+        keyboard_push_sequence("\033[15~");
+    } else if (scancode == KEY_F6) {
+        pr_debug("Press(KEY_F6)\n");
+        keyboard_push_sequence("\033[17~");
+    } else if (scancode == KEY_F7) {
+        pr_debug("Press(KEY_F7)\n");
+        keyboard_push_sequence("\033[18~");
+    } else if (scancode == KEY_F8) {
+        pr_debug("Press(KEY_F8)\n");
+        keyboard_push_sequence("\033[19~");
+    } else if (scancode == KEY_F9) {
+        pr_debug("Press(KEY_F9)\n");
+        keyboard_push_sequence("\033[20~");
+    } else if (scancode == KEY_F10) {
+        pr_debug("Press(KEY_F10)\n");
+        keyboard_push_sequence("\033[21~");
+    } else if (scancode == KEY_F11) {
+        pr_debug("Press(KEY_F11)\n");
+        keyboard_push_sequence("\033[23~");
+    } else if (scancode == KEY_F12) {
+        pr_debug("Press(KEY_F12)\n");
+        keyboard_push_sequence("\033[24~");
+    } else if ((scancode == KEY_INSERT) || (keypad_code == KEY_KP0)) {
+        pr_debug("Press(KEY_INSERT)\n");
+        keyboard_push_sequence("\033[2~");
+    } else if ((scancode == KEY_DELETE) || (keypad_code == KEY_KP_DEC)) {
+        pr_debug("Press(KEY_DELETE)\n");
+        keyboard_push_sequence("\033[3~");
+    } else if ((scancode == KEY_HOME) || (keypad_code == KEY_KP7)) {
         pr_debug("Press(KEY_HOME)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('H');
-    } else if ((scancode == KEY_END) || (keypad_fun_number == 1)) {
+        keyboard_push_sequence("\033[1~");
+    } else if ((scancode == KEY_END) || (keypad_code == KEY_KP1)) {
         pr_debug("Press(KEY_END)\n");
-        keyboard_push_front('\033');
-        keyboard_push_front('[');
-        keyboard_push_front('F');
+        keyboard_push_sequence("\033[4~");
+    } else if ((scancode == KEY_PAGE_UP) || (keypad_code == KEY_KP9)) {
+        pr_debug("Press(KEY_PAGE_UP)\n");
+        keyboard_push_sequence("\033[5~");
+    } else if ((scancode == KEY_PAGE_DOWN) || (keypad_code == KEY_KP3)) {
+        pr_debug("Press(KEY_PAGE_DOWN)\n");
+        keyboard_push_sequence("\033[6~");
     } else if (scancode == KEY_ESCAPE) {
         // Nothing to do.
-    } else if (keypad_fun_number == 5) {
+    } else if (keypad_code == KEY_5) {
         // Nothing to do.
     } else if (!(scancode & CODE_BREAK)) {
         pr_debug("scancode : %04x\n", scancode);
diff --git a/mentos/src/drivers/ps2.c b/mentos/src/drivers/ps2.c
index dc89e50f..2df752a3 100644
--- a/mentos/src/drivers/ps2.c
+++ b/mentos/src/drivers/ps2.c
@@ -15,24 +15,58 @@
 #include "stdbool.h"
 #include "sys/bitops.h"
 
-#define PS2_DATA    0x60 ///< Data signal line.
-#define PS2_STATUS  0x64 ///< Status signal line.
-#define PS2_COMMAND 0x64 ///< Command signal line.
-
-#define PS2_CTRL_TEST_CONTROLLER 0xAA ///< Test PS/2 Controller. 0x55 passed, 0xFC failed.
-#define PS2_CTRL_P1_ENABLE       0xAE ///< Enable first PS/2 port. No response.
-#define PS2_CTRL_P1_DISABLE      0xAD ///< Disable first PS/2 port. No response.
-#define PS2_CTRL_P1_TEST         0xAB ///< Test first PS/2 port.
-#define PS2_CTRL_P2_ENABLE       0xA8 ///< Enable second PS/2 port. No response.
-#define PS2_CTRL_P2_DISABLE      0xA7 ///< Disable second PS/2 port. No response.
-#define PS2_CTRL_P2_TEST         0xA9 ///< Test second PS/2 port (only if 2 PS/2 ports supported).
-
-#define PS2_TEST_SUCCESS 0xAA ///< Self test passed (sent after "0xFF (reset)" command or keyboard power up).
-#define PS2_ECHO_RES     0xEE ///< Response to "0xEE (echo)" command.
-#define PS2_ACK          0xFA ///< Command acknowledged (ACK).
-#define PS2_TEST_FAIL1   0xFC ///< Self test failed (sent after "0xFF (reset)" command or keyboard power up).
-#define PS2_TEST_FAIL2   0xFD ///< Self test failed (sent after "0xFF (reset)" command or keyboard power up).
-#define PS2_RESEND       0xFE ///< Resend (keyboard wants controller to repeat last command it sent).
+/// @defgroup PS2_IO_PORTS PS/2 I/O Ports
+/// @{
+#define PS2_DATA   0x60 ///< Data signal line.
+#define PS2_STATUS 0x64 ///< Status and command signal line.
+/// @}
+
+/// @defgroup PS2_CONTROLLER_COMMANDS PS/2 Controller Commands
+/// @{
+#define PS2_CTRL_TEST_CONTROLLER   0xAA ///< Command to test the PS/2 controller; returns 0x55 for pass, 0xFC for fail.
+#define PS2_CTRL_P1_ENABLE         0xAE ///< Command to enable the first PS/2 port; does not return a response.
+#define PS2_CTRL_P1_DISABLE        0xAD ///< Command to disable the first PS/2 port; does not return a response.
+#define PS2_CTRL_P1_TEST           0xAB ///< Command to test the first PS/2 port; returns status results.
+#define PS2_CTRL_P2_ENABLE         0xA8 ///< Command to enable the second PS/2 port; does not return a response.
+#define PS2_CTRL_P2_DISABLE        0xA7 ///< Command to disable the second PS/2 port; does not return a response.
+#define PS2_CTRL_P2_TEST           0xA9 ///< Command to test the second PS/2 port; applicable only if both ports are supported.
+#define PS2_CTRL_READ_OUTPUT_PORT  0xD0 ///< Reads the current state of the output port.
+#define PS2_CTRL_WRITE_OUTPUT_PORT 0xD1 ///< Writes to the output port, controls system reset line and other signals.
+#define PS2_CTRL_READ_RAM_BYTE_0   0x20 ///< Reads the configuration byte from PS/2 controller RAM.
+#define PS2_CTRL_WRITE_RAM_BYTE_0  0x60 ///< Writes to the configuration byte in PS/2 controller RAM.
+#define PS2_CTRL_P1_RESET          0xFE ///< Resets the first PS/2 port.
+/// @}
+
+/// @defgroup PS2_DEVICE_COMMANDS PS/2 Device (Keyboard) Commands
+/// @{
+#define PS2_DEV_RESET         0xFF ///< Resets the device (keyboard or mouse), triggers self-test.
+#define PS2_DEV_DISABLE_SCAN  0xF5 ///< Disables scanning, stops the device from sending scancodes.
+#define PS2_DEV_ENABLE_SCAN   0xF4 ///< Enables scanning, allowing the device to send scancodes.
+#define PS2_DEV_SET_DEFAULTS  0xF6 ///< Sets the device to its default settings.
+#define PS2_DEV_SET_LED       0xED ///< Sets the keyboard LED state (Caps Lock, Num Lock, Scroll Lock).
+#define PS2_DEV_SCAN_CODE_SET 0xF0 ///< Selects the scancode set (requires additional byte to specify the set).
+/// @}
+
+/// @defgroup PS2_DEVICE_RESPONSES PS/2 Device Responses
+/// @{
+#define PS2_DEV_SELF_TEST_PASS    0xAA ///< Self-test passed (sent after a reset or power-up).
+#define PS2_DEV_SET_TYPEMATIC_ACK 0xFA ///< Acknowledges the Set Typematic Rate/Delay command.
+#define PS2_DEV_OVERRUN           0xFF ///< Indicates a buffer overrun during communication.
+#define PS2_ECHO_RES              0xEE ///< Response indicating the controller received an "echo" command (0xEE).
+#define PS2_TEST_FAIL1            0xFC ///< Response indicating self-test failure (after 0xFF reset command or power-up).
+#define PS2_TEST_FAIL2            0xFD ///< Response indicating self-test failure (after 0xFF reset command or power-up).
+#define PS2_RESEND                0xFE ///< Response requesting the controller to resend the last command sent.
+/// @}
+
+/// @defgroup PS2_STATUS_REGISTER_FLAGS PS/2 Status Register Flags
+/// @{
+#define PS2_STATUS_OUTPUT_FULL  0x01 ///< Output buffer is full, data is available to be read.
+#define PS2_STATUS_INPUT_FULL   0x02 ///< Input buffer is full, cannot send another command until it's clear.
+#define PS2_STATUS_SYSTEM       0x04 ///< "System" flag, distinguishes between system and non-system events.
+#define PS2_STATUS_COMMAND      0x08 ///< 1 if data in input buffer is a command, 0 if it's data.
+#define PS2_STATUS_TIMEOUT      0x40 ///< Timeout error has occurred.
+#define PS2_STATUS_PARITY_ERROR 0x80 ///< Parity error occurred during communication.
+/// @}
 
 // PS/2 Controller Configuration Byte
 // Bit | Meaning
@@ -45,56 +79,52 @@
 //  6  | First PS/2 port translation (1 = enabled, 0 = disabled)
 //  7  | Must be zero
 
-/// @brief Polling until we can receive bytes from the device.
-static inline void __ps2_wait_read(void)
+void ps2_write_data(unsigned char data)
 {
-    while (!bit_check(inportb(PS2_STATUS), 0)) {
+    // Wait for the input buffer to be empty before sending data.
+    while (inportb(PS2_STATUS) & PS2_STATUS_INPUT_FULL) {
         pause();
     }
+
+    outportb(PS2_DATA, data);
 }
 
-/// @brief Polling until we can send bytes to the device.
-static inline void __ps2_wait_write(void)
+void ps2_write_command(unsigned char command)
 {
-    while (bit_check(inportb(PS2_STATUS), 1)) {
+    // Wait for the input buffer to be empty before sending data.
+    while (inportb(PS2_STATUS) & PS2_STATUS_INPUT_FULL) {
         pause();
     }
-}
 
-void ps2_write(unsigned char data)
-{
-    __ps2_wait_write();
-    outportb(PS2_DATA, data);
+    // Write the command to the PS/2 data register.
+    outportb(PS2_STATUS, command);
 }
 
-unsigned char ps2_read(void)
+unsigned char ps2_read_data(void)
 {
-    __ps2_wait_read();
-    return inportb(PS2_DATA);
-}
+    // Wait until the output buffer is not full (data is available).
+    while (!(inportb(PS2_STATUS) & PS2_STATUS_OUTPUT_FULL)) {
+        pause(); // Short wait to avoid busy-waiting.
+    }
 
-/// @brief Writes the given command to the PS2 port.
-/// @param command the command to write.
-static inline void __ps2_write_command(unsigned char command)
-{
-    __ps2_wait_write();
-    outportb(PS2_COMMAND, command);
+    // Read and return the data from the PS/2 data register.
+    return inportb(PS2_DATA);
 }
 
 /// @brief Reads the PS2 controller status.
 /// @return the PS2 controller status.
 static inline unsigned char __ps2_get_controller_status(void)
 {
-    __ps2_write_command(0x20);
-    return ps2_read();
+    ps2_write_command(PS2_CTRL_READ_RAM_BYTE_0);
+    return ps2_read_data();
 }
 
 /// @brief Sets the PS2 controller status.
 /// @param status the PS2 controller status.
 static inline void __ps2_set_controller_status(unsigned char status)
 {
-    __ps2_write_command(0x60);
-    ps2_write(status);
+    ps2_write_command(PS2_CTRL_WRITE_RAM_BYTE_0);
+    ps2_write_data(status);
 }
 
 /// @brief Checks if the PS2 controller is dual channel.
@@ -107,40 +137,44 @@ static inline int __ps2_is_dual_channel(void)
 /// @brief Enables the first PS2 port.
 static inline void __ps2_enable_first_port(void)
 {
-    __ps2_write_command(PS2_CTRL_P1_ENABLE);
+    ps2_write_command(PS2_CTRL_P1_ENABLE);
 }
 
 /// @brief Enables the second PS2 port.
 static inline void __ps2_enable_second_port(void)
 {
-    __ps2_write_command(PS2_CTRL_P2_ENABLE);
+    ps2_write_command(PS2_CTRL_P2_ENABLE);
 }
 
 /// @brief Disables the first PS2 port.
 static inline void __ps2_disable_first_port(void)
 {
-    __ps2_write_command(PS2_CTRL_P1_DISABLE);
+    ps2_write_command(PS2_CTRL_P1_DISABLE);
 }
 
 /// @brief Disables the second PS2 port.
 static inline void __ps2_disable_second_port(void)
 {
-    __ps2_write_command(PS2_CTRL_P2_DISABLE);
+    ps2_write_command(PS2_CTRL_P2_DISABLE);
 }
 
-/// @brief Writes on the first PS2 port.
-/// @param byte the value to write.
+/// @brief Writes a byte of data to the first PS/2 port (typically for a keyboard).
+/// @param byte The value to write to the first PS/2 port.
 static inline void __ps2_write_first_port(unsigned char byte)
 {
-    ps2_write(byte);
+    // Directly write the specified byte to the first PS/2 port.
+    ps2_write_data(byte);
 }
 
-/// @brief Writes on the second PS2 port.
-/// @param byte the value to write.
+/// @brief Writes a byte of data to the second PS/2 port (typically for a mouse).
+/// @param byte The value to write to the second PS/2 port.
 static inline void __ps2_write_second_port(unsigned char byte)
 {
-    __ps2_write_command(0xD4);
-    ps2_write(byte);
+    // Send the command to direct the next byte to the second PS/2 port.
+    ps2_write_command(0xD4);
+
+    // Write the specified byte to the second PS/2 port.
+    ps2_write_data(byte);
 }
 
 /// @brief Returns the string describing the received response.
@@ -196,7 +230,7 @@ int ps2_initialize(void)
     // you're discarding the data and don't care what it was).
 
     pr_debug("Flushing the output buffer...\n");
-    ps2_read();
+    ps2_read_data();
 
     // ========================================================================
     // Step 3: Set the Controller Configuration Byte
@@ -229,9 +263,9 @@ int ps2_initialize(void)
     // based on the above table or restore the value read before issuing 0xAA.
 
     // Send 0xAA to the controller.
-    __ps2_write_command(PS2_CTRL_TEST_CONTROLLER);
+    ps2_write_command(PS2_CTRL_TEST_CONTROLLER);
     // Read the response.
-    response = ps2_read();
+    response = ps2_read_data();
     if (response == PS2_TEST_FAIL1) {
         pr_err("Self-test failed : 0x%02x\n", response);
         return 1;
@@ -271,8 +305,8 @@ int ps2_initialize(void)
     // Note: If one of the PS/2 ports on a dual PS/2 controller fails, then you
     // can still keep using/supporting the other PS/2 port.
 
-    __ps2_write_command(PS2_CTRL_P1_TEST);
-    response = ps2_read();
+    ps2_write_command(PS2_CTRL_P1_TEST);
+    response = ps2_read_data();
     if (response && (response >= 0x01) && (response <= 0x04)) {
         pr_err("Interface test failed on first port : %02x\n", response);
         pr_err("Reason: %s.\n", __ps2_get_response_error_message(response));
@@ -280,8 +314,8 @@ int ps2_initialize(void)
     }
     // If it is a dual channel, check the second port.
     if (dual) {
-        __ps2_write_command(PS2_CTRL_P2_TEST);
-        response = ps2_read();
+        ps2_write_command(PS2_CTRL_P2_TEST);
+        response = ps2_read_data();
         if (response && (response >= 0x01) && (response <= 0x04)) {
             pr_err("Interface test failed on second port : %02x\n", response);
             pr_err("Reason: %s.\n", __ps2_get_response_error_message(response));
@@ -328,14 +362,14 @@ int ps2_initialize(void)
     // Reset first port.
     __ps2_write_first_port(0xFF);
     // Wait for `command acknowledged`.
-    response = ps2_read();
-    if ((response) != PS2_ACK) {
+    response = ps2_read_data();
+    if ((response) != PS2_DEV_SET_TYPEMATIC_ACK) {
         pr_err("Failed to reset first PS/2 port: %d\n", response);
         return 1;
     }
     // Wait for `self test successful`.
-    response = ps2_read();
-    if ((response) != PS2_TEST_SUCCESS) {
+    response = ps2_read_data();
+    if ((response) != PS2_DEV_SELF_TEST_PASS) {
         pr_err("Failed to reset first PS/2 port: %d\n", response);
         return 1;
     }
@@ -343,14 +377,14 @@ int ps2_initialize(void)
     // Reset second port.
     __ps2_write_second_port(0xFF);
     // Wait for `command acknowledged`.
-    response = ps2_read();
-    if ((response) != PS2_ACK) {
+    response = ps2_read_data();
+    if ((response) != PS2_DEV_SET_TYPEMATIC_ACK) {
         pr_err("Failed to reset first PS/2 port: %d\n", response);
         return 1;
     }
     // Wait for `self test successful`.
-    response = ps2_read();
-    if ((response) != PS2_TEST_SUCCESS) {
+    response = ps2_read_data();
+    if ((response) != PS2_DEV_SELF_TEST_PASS) {
         pr_err("Failed to reset first PS/2 port: %d\n", response);
         return 1;
     }
@@ -359,5 +393,8 @@ int ps2_initialize(void)
     status = __ps2_get_controller_status();
     pr_debug("Status   : %s (%3d | %02x)\n", dec_to_binary(status, 8), status, status);
 
+    pr_debug("Flushing the output buffer...\n");
+    ps2_read_data();
+
     return 0;
 }
diff --git a/mentos/src/fs/ext2.c b/mentos/src/fs/ext2.c
index 2ec0f699..f9378db3 100644
--- a/mentos/src/fs/ext2.c
+++ b/mentos/src/fs/ext2.c
@@ -1797,7 +1797,7 @@ ext2_direntry_iterator_t ext2_direntry_iterator_begin(ext2_filesystem_t *fs, uin
 }
 
 /// @brief Moves to the next direntry, and moves to the next block if necessary.
-/// @param iterator the iterator.
+/// @param it the iterator.
 void ext2_direntry_iterator_next(ext2_direntry_iterator_t *it)
 {
     // Advance the offsets.
@@ -1909,58 +1909,87 @@ static inline void ext2_initialize_direntry(
     strncpy(direntry->name, name, direntry->name_len);
 }
 
+/// @brief Initializes a new directory entry block for the specified inode.
+/// @param fs Pointer to the ext2 filesystem structure.
+/// @param inode_index The index of the inode for which the directory entry block is to be initialized.
+/// @param block_index The index of the block to be allocated.
+/// @return 1 on success, 0 on failure.
 static inline int ext2_initialize_new_direntry_block(
     ext2_filesystem_t *fs,
     uint32_t inode_index,
     uint32_t block_index)
 {
     ext2_inode_t inode;
+
+    // Error check: Ensure the filesystem pointer is valid
+    if (!fs) {
+        pr_err("Invalid filesystem pointer.\n");
+        return 0;
+    }
+
+    // Read the inode for the specified inode index
     if (ext2_read_inode(fs, &inode, inode_index) == -1) {
         pr_err("Failed to read the inode of `%u`.\n", inode_index);
         return 0;
     }
-    // Allocate a new block.
+
+    // Allocate a new block for the inode
     if (ext2_allocate_inode_block(fs, &inode, inode_index, block_index) == -1) {
-        pr_err("Failed to allocate a new block for an inode.\n");
+        pr_err("Failed to allocate a new block for inode `%u`.\n", inode_index);
         return 0;
     }
-    // Update the inode size.
+
+    // Update the inode size based on the new block index
     inode.size = (block_index + 1) * fs->block_size;
-    // Update the inode.
+
+    // Write the updated inode back to the filesystem
     if (ext2_write_inode(fs, &inode, inode_index) == -1) {
-        pr_err("Failed to update the inode of directory.\n");
+        pr_err("Failed to update the inode of `%u`.\n", inode_index);
         return 0;
     }
-    // Create a cache.
+
+    // Allocate memory for the cache
     uint8_t *cache = ext2_alloc_cache(fs);
-    // Get the first non-initizlied direntry.
+
+    // Get the first uninitialized directory entry in the block
     ext2_dirent_t *direntry = (ext2_dirent_t *)cache;
-    // Initialize the new directory entry.
+
+    // Initialize the new directory entry with an empty name and unknown file type
     ext2_initialize_direntry(direntry, "", 0, fs->block_size, ext2_file_type_unknown);
-    // Update the inode block.
+
+    // Write the updated block (with new directory entry) back to the filesystem
     if (ext2_write_inode_block(fs, &inode, inode_index, block_index, cache) == -1) {
-        pr_err("Failed to update the block of the father directory.\n");
-        ext2_dealloc_cache(cache);
+        pr_err("Failed to write the block for inode `%u`.\n", inode_index);
+        ext2_dealloc_cache(cache); // Free allocated cache memory before returning
         return 0;
     }
+
+    // Free the allocated cache memory after usage
     ext2_dealloc_cache(cache);
+
+    // Return success
     return 1;
 }
 
 /// @brief Dumps the directory entries inside the parent directory.
-/// @param fs a pointer to the filesystem.
-/// @param cache cache for memory EXT2 operations.
-/// @param parent_inode the parent inode.
+/// @param fs A pointer to the filesystem structure.
+/// @param cache A pointer to a memory cache used for EXT2 operations.
+/// @param parent_inode A pointer to the parent inode whose directory entries
+/// are to be dumped.
 static inline void ext2_dump_direntries(
     ext2_filesystem_t *fs,
     uint8_t *cache,
     ext2_inode_t *parent_inode)
 {
+    /// Initialize the directory entry iterator for the parent directory
     ext2_direntry_iterator_t it = ext2_direntry_iterator_begin(fs, cache, parent_inode);
-    // Iterate the directory entries.
+
+    /// Iterate through all directory entries in the parent directory
     for (; ext2_direntry_iterator_valid(&it); ext2_direntry_iterator_next(&it)) {
-        // Dump the entry.
-        pr_debug("    [%2u, %4u] ", it.block_index, it.block_offset);
+        /// Dump debug information for the directory entry's block index and offset
+        pr_debug("    [Block: %2u, Offset: %4u] ", it.block_index, it.block_offset);
+
+        /// Dump detailed information about the current directory entry
         ext2_dump_dirent(it.direntry);
     }
 }
@@ -2207,12 +2236,14 @@ static int ext2_allocate_direntry(
     return 0;
 }
 
-/// @brief Destroys a directory entry.
-/// @param fs a pointer to the filesystem.
-/// @param parent_inode_index the inode index of the parent.
-/// @param direntry_inode_index the inode index of the new entry.
-/// @param name the name of the new entry.
-/// @param file_type the type of file.
+/// @brief Destroys a directory entry in the parent directory.
+/// @param fs A pointer to the filesystem structure.
+/// @param parent The inode of the parent directory.
+/// @param inode The inode of the directory entry to be destroyed.
+/// @param parent_index The index of the parent inode.
+/// @param inode_index The index of the directory entry's inode.
+/// @param block_index The block index where the directory entry resides.
+/// @param block_offset The offset within the block where the directory entry is located.
 /// @return 0 on success, a negative value on failure.
 static int ext2_destroy_direntry(
     ext2_filesystem_t *fs,
@@ -2224,18 +2255,40 @@ static int ext2_destroy_direntry(
     uint32_t block_offset)
 {
     pr_debug("destroy_direntry(parent: %u, entry: %u)\n", parent_index, inode_index);
-    // Allocate the cache and clean it.
+
+    // Validate filesystem pointer
+    if (!fs) {
+        pr_err("Invalid filesystem pointer.\n");
+        return -EINVAL;
+    }
+
+    // Validate inode indices
+    if (parent_index == 0 || inode_index == 0) {
+        pr_err("Invalid inode index (parent: %u, inode: %u).\n", parent_index, inode_index);
+        return -EINVAL;
+    }
+
+    // Allocate and clean the cache
     uint8_t *cache = ext2_alloc_cache(fs);
+
     // Check if the directory is empty, if it enters the loop then it means it is not empty.
     if (!ext2_directory_is_empty(fs, cache, &inode)) {
-        pr_err("The directory is not empty `%d`.\n", inode_index);
+        pr_err("Directory `%u` is not empty.\n", inode_index);
         ext2_dealloc_cache(cache);
         return -ENOTEMPTY;
     }
-    // Get the group index of the parent.
+
+    // Get the group index of the parent
     uint32_t group_index = ext2_inode_index_to_group_index(fs, parent_index);
-    // Increase the number of directories inside the group.
-    fs->block_groups[group_index].used_dirs_count -= 1;
+
+    // Decrease the number of directories in the group
+    if (fs->block_groups[group_index].used_dirs_count == 0) {
+        pr_err("Directory count underflow in block group `%u`.\n", group_index);
+        ext2_dealloc_cache(cache);
+        return -EINVAL;
+    }
+    fs->block_groups[group_index].used_dirs_count--;
+
     // Reduce the number of links to the parent directory.
     parent.links_count--;
     if (ext2_write_inode(fs, &parent, parent_index) < 0) {
@@ -2243,42 +2296,51 @@ static int ext2_destroy_direntry(
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Reduce the number of links to the directory.
     inode.links_count = 0;
+
     // Update the delete time.
     inode.dtime = sys_time(NULL);
+
     if (ext2_write_inode(fs, &inode, inode_index) < 0) {
         pr_err("Failed to update the inode of `%d`.\n", inode_index);
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Free the inode.
     if (ext2_free_inode(fs, &inode, inode_index) < 0) {
-        pr_err("Failed to free the inode of `%d`.\n", inode_index);
+        pr_err("Failed to update inode `%u`.\n", inode_index);
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Read the block where the direntry resides.
     if (ext2_read_inode_block(fs, &parent, block_index, cache) == -1) {
-        pr_err("Failed to read the parent inode block `%d`\n", block_index);
+        pr_err("Failed to read block `%u` for parent inode `%u`.\n", block_index, parent_index);
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Get a pointer to the direntry.
     ext2_dirent_t *dirent = (ext2_dirent_t *)((uintptr_t)cache + block_offset);
-    if (dirent == NULL) {
-        pr_err("We found a NULL ext2_dirent_t\n");
+    if (!dirent) {
+        pr_err("Found a NULL directory entry at offset `%u` in block `%u`.\n", block_offset, block_index);
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Set the inode to zero.
     dirent->inode = 0;
+
     // Write back the parent directory block.
     if (!ext2_write_inode_block(fs, &parent, parent_index, block_index, cache)) {
-        pr_err("Failed to write the inode block `%d`\n", block_index);
+        pr_err("Failed to write block `%u` for parent inode `%u`.\n", block_index, parent_index);
         ext2_dealloc_cache(cache);
         return -1;
     }
+
     // Free the cache.
     ext2_dealloc_cache(cache);
     return 0;
@@ -2842,7 +2904,6 @@ static int ext2_unlink(const char *path)
     memset(&search, 0, sizeof(ext2_direntry_search_t));
     // Resolve the path to the directory entry.
     if (ext2_resolve_path(fs->root, path, &search)) {
-        pr_err("ext2_unlink(%s): Failed to resolve path.\n", path);
         return -ENOENT;
     }
     // Get the inode associated with the parent directory entry.
@@ -3109,7 +3170,6 @@ static int ext2_stat(const char *path, stat_t *stat)
     memset(&search, 0, sizeof(ext2_direntry_search_t));
     // Resolve the path.
     if (ext2_resolve_path(fs->root, path, &search)) {
-        pr_err("ext2_stat(path: %s): Failed to resolve path.\n", path);
         return -ENOENT;
     }
     // Get the inode associated with the directory entry.
@@ -3195,42 +3255,63 @@ static ssize_t ext2_getdents(vfs_file_t *file, dirent_t *dirp, off_t doff, size_
 }
 
 /// @brief Read the symbolic link, if present.
-/// @param file the file for which we want to read the symbolic link information.
-/// @param buffer the buffer where we will store the symbolic link path.
-/// @param bufsize the size of the buffer.
-/// @return The number of read characters on success, -1 otherwise and errno is
-/// set to indicate the error.
+/// @param path The path to the file for which we want to read the symbolic link information.
+/// @param buffer The buffer where we will store the symbolic link path.
+/// @param bufsize The size of the buffer.
+/// @return The number of read characters on success, -1 on failure, with errno set to indicate the error.
 static ssize_t ext2_readlink(const char *path, char *buffer, size_t bufsize)
 {
+    // Check if path and buffer are valid
+    if (!path || !buffer || bufsize == 0) {
+        pr_err("Invalid arguments: path or buffer is NULL or bufsize is zero.\n");
+        return -EINVAL;
+    }
+
     pr_debug("ext2_readlink(path: %s)\n", path);
-    // Get the EXT2 filesystem.
+
+    // Get the EXT2 filesystem associated with the given path
     ext2_filesystem_t *fs = get_ext2_filesystem(path);
-    if (fs == NULL) {
+    if (!fs) {
         pr_err("ext2_readlink(path: %s): Failed to get the EXT2 filesystem.\n", path);
         return -ENOENT;
     }
-    // Prepare the structure for the search.
+
+    // Initialize the structure used for searching the directory entry.
     ext2_direntry_search_t search;
     memset(&search, 0, sizeof(ext2_direntry_search_t));
-    // Resolve the path.
-    if (ext2_resolve_path(fs->root, path, &search)) {
+
+    // Resolve the given path to find the associated directory entry.
+    if (ext2_resolve_path(fs->root, path, &search) != 0) {
         pr_err("ext2_readlink(path: %s): Failed to resolve path.\n", path);
         return -ENOENT;
     }
-    // Get the inode associated with the file.
+
+    // Read the inode associated with the directory entry.
     ext2_inode_t inode;
     if (ext2_read_inode(fs, &inode, search.direntry.inode) == -1) {
         pr_err("ext2_readlink(path: %s): Failed to read the inode (%d).\n", path, search.direntry.inode);
         return -ENOENT;
     }
-    ssize_t ret = -ENOENT;
-    if (S_ISLNK(inode.mode)) {
-        // Get the length of the symlink.
-        ret = min(strlen(inode.data.symlink), bufsize);
-        // Copy the symlink information.
-        strncpy(buffer, inode.data.symlink, ret);
+
+    // Check if the inode represents a symbolic link.
+    if (!S_ISLNK(inode.mode)) {
+        pr_err("ext2_readlink(path: %s): The file is not a symbolic link.\n", path);
+        return -EINVAL;
     }
-    // Return how much we read.
+
+    // Determine the number of characters to read (symlink length or buffer
+    // size, whichever is smaller).
+    ssize_t ret = min(strlen(inode.data.symlink), bufsize);
+
+    // Copy the symbolic link content to the buffer.
+    strncpy(buffer, inode.data.symlink, ret);
+
+    // Null-terminate the buffer if there's space.
+    if (ret < bufsize) {
+        buffer[ret] = '\0';
+    }
+
+    // Return the number of characters read.
     return ret;
 }
 
@@ -3332,7 +3413,6 @@ static int ext2_rmdir(const char *path)
     memset(&search, 0, sizeof(ext2_direntry_search_t));
     // Resolve the path to the directory entry.
     if (ext2_resolve_path(fs->root, path, &search)) {
-        pr_err("ext2_rmdir(path: %s): Failed to resolve path.\n", path);
         return -ENOENT;
     }
 
@@ -3431,7 +3511,6 @@ static int ext2_setattr(const char *path, struct iattr *attr)
     memset(&search, 0, sizeof(ext2_direntry_search_t));
     // Resolve the path.
     if (ext2_resolve_path(fs->root, path, &search)) {
-        pr_err("setattr(%s): Failed to resolve path.\n", path);
         return -ENOENT;
     }
     // Get the inode associated with the directory entry.
diff --git a/mentos/src/fs/namei.c b/mentos/src/fs/namei.c
index 0d4be61d..9b37f74b 100644
--- a/mentos/src/fs/namei.c
+++ b/mentos/src/fs/namei.c
@@ -132,7 +132,7 @@ static inline int __get_link_content(const char *path, char *buffer, size_t bufl
 
 /// @brief Resolve the path by following all symbolic links.
 /// @param path the path to resolve.
-/// @param buffer the buffer where the resolved path is stored.
+/// @param abspath the buffer where the resolved path is stored.
 /// @param buflen the size of the provided resolved_path buffer.
 /// @param flags the flags controlling how the path is resolved.
 /// @param link_depth the current link depth.
@@ -228,7 +228,7 @@ int __resolve_path(const char *path, char *abspath, size_t buflen, int flags, in
     return 0;
 }
 
-int resolve_path(const char *path, char *abspath, size_t buflen, int flags)
+int resolve_path(const char *path, char *buffer, size_t buflen, int flags)
 {
-    return __resolve_path(path, abspath, buflen, flags, 0);
+    return __resolve_path(path, buffer, buflen, flags, 0);
 }
diff --git a/mentos/src/hardware/timer.c b/mentos/src/hardware/timer.c
index 96fa87fd..70b4ad09 100644
--- a/mentos/src/hardware/timer.c
+++ b/mentos/src/hardware/timer.c
@@ -354,16 +354,16 @@ void remove_timer(struct timer_list *timer)
 
 /// @brief Contains the entry of a wait queue and timespec which keeps trakc of
 /// the remaining time.
-typedef struct sleep_data_t {
+typedef struct sleep_data {
     /// POinter to the entry of a wait queue.
     wait_queue_entry_t *wait_queue_entry;
     /// Keeps track of the remaining time.
-    timespec *remaining;
+    struct timespec *remaining;
 } sleep_data_t;
 
 /// @brief Allocates the memory for sleep_data.
 /// @return a pointer to the allocated sleep_data.
-static inline struct sleep_data_t *__sleep_data_alloc(void)
+static inline sleep_data_t *__sleep_data_alloc(void)
 {
     // Allocate the memory.
     sleep_data_t *sleep_data = (sleep_data_t *)kmalloc(sizeof(sleep_data_t));
@@ -600,7 +600,7 @@ static inline void real_timer_timeout(unsigned long task_ptr)
 // TIMING FUNCTIONS
 // ============================================================================
 
-int sys_nanosleep(const timespec *req, timespec *rem)
+int sys_nanosleep(const struct timespec *req, struct timespec *rem)
 {
     // We need to store rem somewhere, because it contains how much time left
     // until the timer expires, when the timer is stopped early by a signal.
@@ -672,7 +672,7 @@ int sys_getitimer(int which, struct itimerval *curr_value)
     } else if (which == ITIMER_PROF) {
         __values_to_itimerval(task->it_prof_incr, task->it_prof_value, curr_value);
     } else {
-        return EINVAL;
+        return -EINVAL;
     }
     return 0;
 }
@@ -681,7 +681,7 @@ int sys_setitimer(int which, const struct itimerval *new_value, struct itimerval
 {
     // Invalid time domain
     if (which < 0 || which > 3) {
-        return EINVAL;
+        return -EINVAL;
     }
     // Returns old timer interval
     if (old_value != NULL) {
@@ -699,7 +699,7 @@ int sys_setitimer(int which, const struct itimerval *new_value, struct itimerval
             task->real_timer = NULL;
         }
         __update_task_itimerval(which, new_value);
-        return -1;
+        return 0;
     }
     switch (which) {
     // Uses Dynamic Timers
@@ -727,7 +727,7 @@ int sys_setitimer(int which, const struct itimerval *new_value, struct itimerval
     }
 
     __update_task_itimerval(which, new_value);
-    return -1;
+    return 0;
 }
 
 void update_process_profiling_timer(task_struct *proc)
diff --git a/mentos/src/io/proc_video.c b/mentos/src/io/proc_video.c
index 96e71684..957630b4 100644
--- a/mentos/src/io/proc_video.c
+++ b/mentos/src/io/proc_video.c
@@ -49,141 +49,114 @@ static ssize_t procv_read(vfs_file_t *file, char *buf, off_t offset, size_t nbyt
 
     // Get the currently running process.
     task_struct *process = scheduler_get_current_process();
-    // Get a pointer to its ketboard ring-buffer.
+    // Get a pointer to its keyboard ring buffer.
     fs_rb_scancode_t *rb = &process->keyboard_rb;
-    // Pre-check the flags.
+
+    // Pre-check the terminal flags.
     bool_t flg_icanon = bitmask_check(process->termios.c_lflag, ICANON) == ICANON;
     bool_t flg_echoe  = bitmask_check(process->termios.c_lflag, ECHOE) == ECHOE;
     bool_t flg_echo   = bitmask_check(process->termios.c_lflag, ECHO) == ECHO;
     bool_t flg_isig   = bitmask_check(process->termios.c_lflag, ISIG) == ISIG;
 
-    // If we are in canonical mode, and the last inserted element is a newline,
-    // we pop the buffer until it's empty.
-    if (!fs_rb_scancode_empty(rb) && (!flg_icanon || (flg_icanon && (fs_rb_scancode_front(rb) == '\n')))) {
+    // If we are in canonical mode and the last inserted element is a newline,
+    // pop the buffer until it's empty.
+    if (!fs_rb_scancode_empty(rb) && (!flg_icanon || (fs_rb_scancode_front(rb) == '\n'))) {
+        // Return the newline character.
         *((char *)buf) = fs_rb_scancode_pop_back(rb) & 0x00FF;
+        // Indicate a character has been returned.
         return 1;
     }
 
-    // Once we have dealt with the canonical mode, get the character.
+    // Once we have dealt with canonical mode, get the character.
     int c = keyboard_pop_back();
 
-    // Check that it's a valid caracter.
+    // Check that it's a valid character.
     if (c < 0) {
-        return 0;
+        return 0; // No valid character received.
     }
 
-    // Keep only the character not the scancode.
+    // Keep only the character, not the scancode.
     c &= 0x00FF;
 
-    // We just received backspace.
+    // Handle backspace.
     if (c == '\b') {
-        // If !ECHOE and ECHO, We need to show the the `^?` string.
+        // If ECHOE is off and ECHO is on, show the `^?` string.
         if (!flg_echoe && flg_echo) {
             video_puts("^?");
         }
-        // If we are in canonical mode, we pop the previous character.
+
+        // If we are in canonical mode, pop the previous character.
         if (flg_icanon) {
-            // Pop the previous character in buffer.
+            // Remove the last character from the buffer.
             fs_rb_scancode_pop_front(rb);
-            // Delete the previous character on video.
-            if (flg_echoe) {
-                video_putc(c);
-            }
+
+            // Optionally display the backspace character.
+            if (flg_echoe) { video_putc(c); }
         } else {
-            // Add the character to the buffer.
+            // Add the backspace character to the buffer.
             fs_rb_scancode_push_front(rb, c);
-            // Return the character.
+
+            // Return the backspace character.
             *((char *)buf) = fs_rb_scancode_pop_back(rb) & 0x00FF;
+
+            // Indicate a character has been returned.
             return 1;
         }
+
+        // No character returned for backspace handling.
         return 0;
     }
-    if (c == 0x7f) {
+
+    // Handle delete key (0x7F).
+    if (c == 0x7F) {
         if (flg_echo) {
+            // Print escape sequence for delete.
             video_puts("^[[3~");
         }
-        // Add the character to the buffer.
-        fs_rb_scancode_push_front(rb, '\033');
-        fs_rb_scancode_push_front(rb, '[');
-        fs_rb_scancode_push_front(rb, '3');
-        fs_rb_scancode_push_front(rb, '~');
+
+        // Indicate no character was returned.
         return 0;
     }
+
     // Add the character to the buffer.
     fs_rb_scancode_push_front(rb, c);
 
-    // If echo is activated, output the character to video.
-    if (flg_echo) {
-        if (iscntrl(c) && (isalpha('A' + (c - 1)) && (c != '\n') && (c != '\b'))) {
-            video_putc('^');
-            video_putc('A' + (c - 1));
-        } else {
-            video_putc(c);
+    if (iscntrl(c)) {
+        if ((c == 0x03) && (flg_isig)) {
+            sys_kill(process->pid, SIGTERM);
+        } else if ((c == 0x1A) && (flg_isig)) {
+            sys_kill(process->pid, SIGSTOP);
         }
-    }
 
-    if (flg_isig) {
-        if (iscntrl(c)) {
-            if (c == 0x03) {
-                sys_kill(process->pid, SIGTERM);
-            } else if (c == 0x1A) {
-                sys_kill(process->pid, SIGSTOP);
+        if (isalpha('A' + (c - 1)) && (c != '\n') && (c != '\b') && (c != '\t')) {
+            // If echo is activated, output the character to video.
+            if (flg_echo) {
+                video_putc('^');
+                video_putc('A' + (c - 1));
             }
+
+            fs_rb_scancode_push_front(rb, '\033');
+            fs_rb_scancode_push_front(rb, '^');
+            fs_rb_scancode_push_front(rb, 'A' + (c - 1));
+
+            return 3;
         }
+        // Echo the character.
+        // if (flg_echo) {
+        //     video_putc(c);
+        // }
+        // return 1;
     }
 
-    // If we are NOT in canonical mode, we can send the character back to user
-    // right away.
+    // If we are NOT in canonical mode, send the character back to user immediately.
     if (!flg_icanon) {
+        // Return the character.
         *((char *)buf) = fs_rb_scancode_pop_back(rb) & 0x00FF;
+        // Indicate a character has been returned.
         return 1;
     }
 
-#if 0
-
-    // The last inserted character.
-    int back_c = keyboard_back();
-
-    if (back_c < 0)
-        return 0;
-
-    // The first inserted character.
-    int front_c = keyboard_front();
-
-    pr_debug("'%c' (%3d %04x) [F: '%c' (%04x)]\n", back_c, back_c, back_c, front_c, front_c);
-
-    // Echo the character to video.
-    if (flg_echo) {
-        video_putc(back_c & 0x00FF);
-    }
-
-    // If we have the canonical input active, we should not return characters,
-    // until we receive a newline.
-    if ((flg_icanon && (front_c == '\n')) ||
-        !flg_icanon) {
-        *((char *)buf) = keyboard_pop_back() & 0x00FF;
-        return 1;
-    }
-#endif
-
-#if 0
-    // Read the character from the keyboard.
-    int c = keyboard_getc(false) & 0x00FF;
-    if (c < 0)
-        return 0;
-    if (c == KEY_PAGE_UP) {
-        video_shift_one_page_down();
-        return 0;
-    } else if (c == KEY_PAGE_DOWN) {
-        video_shift_one_page_up();
-        return 0;
-    } else {
-        // Echo the character to video.
-        if (flg_echo) {
-            video_putc(c & 0x00FF);
-        }
-    }
-#endif
+    // Default return indicating no character was processed.
     return 0;
 }
 
diff --git a/mentos/src/kernel.c b/mentos/src/kernel.c
index 8336c840..8a4652de 100644
--- a/mentos/src/kernel.c
+++ b/mentos/src/kernel.c
@@ -152,7 +152,10 @@ int kmain(boot_info_t *boot_informations)
     //==========================================================================
     pr_notice("Initialize slab allocator.\n");
     printf("Initialize slab...");
-    kmem_cache_init();
+    if (kmem_cache_init() < 0) {
+        print_fail();
+        return 1;
+    }
     print_ok();
 
     //==========================================================================
@@ -194,7 +197,10 @@ int kmain(boot_info_t *boot_informations)
     //==========================================================================
     pr_notice("Initialize virtual memory mapping.\n");
     printf("Initialize virtual memory mapping...");
-    virt_init();
+    if (virt_init() < 0) {
+        print_fail();
+        return 1;
+    }
     print_ok();
 
     //==========================================================================
@@ -409,8 +415,8 @@ int kmain(boot_info_t *boot_informations)
     //==========================================================================
     // TODO: fix the hardcoded check for the flags set by GRUB
     runtests = boot_info.multiboot_header->flags == 0x1a67 &&
-        bitmask_check(boot_info.multiboot_header->flags, MULTIBOOT_FLAG_CMDLINE) &&
-        strcmp((char *)boot_info.multiboot_header->cmdline, "runtests") == 0;
+               bitmask_check(boot_info.multiboot_header->flags, MULTIBOOT_FLAG_CMDLINE) &&
+               strcmp((char *)boot_info.multiboot_header->cmdline, "runtests") == 0;
 
     task_struct *init_p;
     if (runtests) {
diff --git a/mentos/src/klib/fcvt.c b/mentos/src/klib/fcvt.c
index 06497ea0..c8782012 100644
--- a/mentos/src/klib/fcvt.c
+++ b/mentos/src/klib/fcvt.c
@@ -3,21 +3,43 @@
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[FCVT]  "      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
+
 #include "fcvt.h"
 #include "math.h"
 
+/// @brief Converts a floating-point number into a string representation.
+/// @param arg The floating-point number to convert.
+/// @param ndigits The number of digits to generate after the decimal point.
+/// @param decpt A pointer to an integer that will store the position of the decimal point.
+/// @param sign A pointer to an integer that will store the sign of the number (1 if negative, 0 otherwise).
+/// @param buf A character buffer where the resulting string will be stored.
+/// @param buf_size The size of the buffer.
+/// @param eflag A flag indicating whether to use exponential notation (1 for exponential, 0 for standard).
 static void cvt(double arg, int ndigits, int *decpt, int *sign, char *buf, unsigned buf_size, int eflag)
 {
+    // Error check: Ensure the buffer is valid and has enough space
+    if (!buf || buf_size == 0) {
+        pr_err("Invalid buffer or buffer size.\n");
+        return;
+    }
+
     int r2;
     double fi, fj;
     char *p, *p1;
 
     char *buf_end = (buf + buf_size);
 
+    // Adjust the number of digits if it's negative or larger than buffer size
     if (ndigits < 0) {
         ndigits = 0;
     }
 
+    // Ensure there's space for the null terminator.
     if (ndigits >= buf_size - 1) {
         ndigits = buf_size - 2;
     }
@@ -26,62 +48,94 @@ static void cvt(double arg, int ndigits, int *decpt, int *sign, char *buf, unsig
     *sign = 0;
     p     = &buf[0];
 
+    // Handle negative numbers by adjusting the sign and converting to positive
     if (arg < 0) {
         *sign = 1;
         arg   = -arg;
     }
 
+    // Split the number into its integer and fractional parts.
     arg = modf(arg, &fi);
-    p1  = buf_end;
 
+    // Start filling from the end of the buffer
+    p1 = buf_end;
+
+    // Process the integer part (if non-zero).
     if (fi != 0) {
         p1 = buf_end;
-        while (fi != 0) {
+
+        // Prevent buffer overflow.
+        while ((fi != 0) && (p1 > buf)) {
             fj    = modf(fi / 10, &fi);
+
+            // Convert each digit.
             *--p1 = (int)((fj + .03) * 10) + '0';
+
+            // Increment the position of the decimal point.
             r2++;
         }
+        // Copy the integer part to the buffer.
         while (p1 < buf_end) {
             *p++ = *p1++;
         }
     } else if (arg > 0) {
+        // Handle fractional parts when there's no integer part.
         while ((fj = arg * 10) < 1) {
             arg = fj;
+
+            // Shift the decimal point for fractional values.
             r2--;
         }
     }
 
+    // Prepare to process the fractional part
     p1 = &buf[ndigits];
+
+    // Adjust for standard notation.
     if (eflag == 0) {
         p1 += r2;
     }
 
+    // Store the decimal point position.
     *decpt = r2;
+
+    // If the buffer is too small, terminate early.
     if (p1 < &buf[0]) {
         buf[0] = '\0';
         return;
     }
 
+    // Process the fractional part and fill the buffer.
     while (p <= p1 && p < buf_end) {
         arg *= 10;
         arg  = modf(arg, &fj);
         *p++ = (int)fj + '0';
     }
 
+    // Ensure we terminate the string if it exceeds the buffer.
     if (p1 >= buf_end) {
         buf[buf_size - 1] = '\0';
         return;
     }
 
+    // Round the last digit and handle carry propagation.
     p = p1;
     *p1 += 5;
     while (*p1 > '9') {
+        // Carry propagation if rounding overflows.
         *p1 = '0';
+
+        // Propagate carry to the previous digit.
         if (p1 > buf) {
             ++*--p1;
         } else {
+            // Handle overflow at the beginning.
             *p1 = '1';
+
+            // Increment the decimal point.
             (*decpt)++;
+
+            // Pad with zeros if needed.
             if (eflag == 0) {
                 if (p > buf) {
                     *p = '0';
@@ -90,6 +144,8 @@ static void cvt(double arg, int ndigits, int *decpt, int *sign, char *buf, unsig
             }
         }
     }
+    
+    // Terminate the string.
     *p = '\0';
 }
 
diff --git a/mentos/src/mem/kheap.c b/mentos/src/mem/kheap.c
index 65e05b9e..802518d8 100644
--- a/mentos/src/mem/kheap.c
+++ b/mentos/src/mem/kheap.c
@@ -23,73 +23,107 @@
 #include "sys/bitops.h"
 #include "sys/list_head.h"
 
-/// The heap size.
+/// @brief The size of the heap in bytes, defined as 4 megabytes.
 #define HEAP_SIZE (4 * M)
-/// The lower bound address, when randomly placing the virtual memory area.
+
+/// @brief The lower bound address for virtual memory area placement.
+/// This address marks the starting point of the heap.
 #define HEAP_VM_LB 0x40000000
-/// The upper bound address, when randomly placing the virtual memory area.
+
+/// @brief The upper bound address for virtual memory area placement.
+/// This address marks the endpoint of the heap, ensuring no overlap with other memory regions.
 #define HEAP_VM_UB 0x50000000
 
-/// Overhead given by the block_t itself.
+/// @brief The overhead introduced by the block_t structure itself.
+/// This is used for memory management and bookkeeping.
 #define OVERHEAD sizeof(block_t)
-/// Align the given address.
+
+/// @brief Aligns the given address to the nearest upper page boundary.
+/// The address will be aligned to 4096 bytes (0x1000).
+/// @param addr The address to align.
+/// @return The aligned address.
 #define ADDR_ALIGN(addr) ((((uint32_t)(addr)) & 0xFFFFF000) + 0x1000)
-/// Checks if the given address is aligned.
+
+/// @brief Checks if the given address is aligned to a page boundary.
+/// @param addr The address to check.
+/// @return Non-zero value if the address is aligned, zero otherwise.
 #define IS_ALIGN(addr) ((((uint32_t)(addr)) & 0x00000FFF) == 0)
 
-/// @brief Identifies a block of memory.
+/// @brief Represents a block of memory within the heap.
+/// This structure includes metadata for managing memory allocation and free status.
 typedef struct block_t {
-    /// @brief Single bit that identifies if the block is free.
+    /// @brief A single bit indicating if the block is free (1) or allocated (0).
     unsigned int is_free : 1;
-    /// @brief Size of the block.
+
+    /// @brief The size of the block in bytes.
+    /// This includes the space for the block's overhead.
     unsigned int size : 31;
-    /// @brief Entry in the list of blocks.
+
+    /// @brief Entry in the list of all blocks in the heap.
     list_head list;
+
     /// @brief Entry in the list of free blocks.
     list_head free;
 } block_t;
 
-/// @brief Maps the heap memory to this three easily accessible values.
+/// @brief Maps the heap memory to easily accessible values.
+/// This structure contains pointers to the list of all blocks and the list of free blocks.
 typedef struct {
-    /// @brief List of blocks.
+    /// @brief List of all memory blocks, both free and allocated.
     list_head list;
-    /// @brief List of free blocks.
+
+    /// @brief List of free blocks available for allocation.
     list_head free;
 } heap_header_t;
 
-/// @brief Returns the given size, rounded in multiples of 16.
-/// @param size the given size.
-/// @return the size rounded to the nearest multiple of 16.
+/// @brief Returns the given size, rounded to the nearest multiple of 16. This
+/// is useful for ensuring memory alignment requirements are met.
+/// @param size The given size to be rounded.
+/// @return The size rounded to the nearest multiple of 16.
 static inline uint32_t __blkmngr_get_rounded_size(uint32_t size)
 {
     return round_up(size, 16);
 }
 
-/// @brief Checks if the given size fits inside the block.
-/// @param block The given block.
-/// @param size  The size to check
-/// @return 1 if it fits, 0 otherwise.
+/// @brief Checks if the given size fits inside the block. This function
+/// verifies whether the specified size can be accommodated within the block's
+/// available size.
+/// @param block The given block to check. Must not be NULL.
+/// @param size  The size to check against the block's size.
+/// @return 1 if the size fits within the block, -1 if the block is NULL.
 static inline int __blkmngr_does_it_fit(block_t *block, uint32_t size)
 {
-    assert(block && "Received null block.");
+    // Check for a null block pointer to avoid dereferencing a null pointer
+    if (!block) {
+        pr_crit("Received null block.\n");
+        return -1; // Error: Block pointer is NULL.
+    }
+
+    // Check if the block can accommodate the requested size.
     return block->size >= size;
 }
 
-/// @brief Prepares a string that represents the block.
-/// @param block the block to represent.
-/// @return a string with the block info.
+/// @brief Prepares a string that represents the block. This function formats
+/// the information of the specified block into a human-readable string.
+/// @param block The block to represent. Can be NULL.
+/// @return A string containing the block's address, size, and free status.
 static inline const char *__block_to_string(block_t *block)
 {
+    // Static buffer to hold the string representation of the block.
     static char buffer[256];
+
     if (block) {
+        // Format the block's information into the buffer
         sprintf(buffer, "0x%p [%9s](%d)",
-                block,
-                to_human_size(block->size),
-                block->is_free);
+                (void *)block,              // Pointer to the block
+                to_human_size(block->size), // Human-readable size
+                block->is_free);            // Free status (1 if free, 0 if allocated)
     } else {
+        // If the block is NULL, indicate this in the buffer.
         sprintf(buffer, "NULL");
     }
-    return buffer;
+
+    return buffer; // Return the formatted string.
 }
 
 /// @brief Dumpts debug information about the heap.
@@ -145,263 +179,486 @@ static inline void __blkmngr_dump(heap_header_t *header)
 /// @return a block that should fit our needs.
 static inline block_t *__blkmngr_find_best_fitting(heap_header_t *header, uint32_t size)
 {
-    assert(header && "Received a NULL heap header.");
-    block_t *best_fitting = NULL, *block;
+    // Check if the header is NULL, log an error and return NULL
+    if (!header) {
+        pr_crit("Received a NULL heap header.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    block_t *best_fitting = NULL; // Initialize the best fitting block to NULL.
+    block_t *block;               // Declare a pointer for the current block.
+
+    // Iterate over the list of free blocks.
     list_for_each_decl(it, &header->free)
     {
+        // Get the current block from the list.
         block = list_entry(it, block_t, free);
+
+        // Skip if the block is not free.
         if (!block->is_free) {
             continue;
         }
+
+        // Check if the block can accommodate the requested size.
         if (!__blkmngr_does_it_fit(block, size)) {
             continue;
         }
+
+        // Update the best fitting block if it's the first found or smaller than
+        // the current best.
         if (!best_fitting || (block->size < best_fitting->size)) {
             best_fitting = block;
         }
     }
+
+    // Return the best fitting block found, or NULL if none were suitable.
     return best_fitting;
 }
 
 /// @brief Given a block, finds its previous block.
 /// @param header the heap header.
 /// @param block the block.
-/// @return a pointer to the previous block.
+/// @return a pointer to the previous block or NULL if an error occurs.
 static inline block_t *__blkmngr_get_previous_block(heap_header_t *header, block_t *block)
 {
-    assert(header && "Received a NULL heap header.");
-    assert(block && "Received null block.");
-    // If the block is actually the head of the list, return NULL.
+    // Check if the heap header is valid.
+    if (!header) {
+        pr_crit("Received a NULL heap header.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Check if the block is valid.
+    if (!block) {
+        pr_crit("Received a NULL block.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // If the block is the head of the list, return NULL.
     if (block->list.prev == &header->list) {
-        return NULL;
+        return NULL; // No previous block exists.
     }
+
+    // Return the previous block by accessing the list entry.
     return list_entry(block->list.prev, block_t, list);
 }
 
-/// @brief Given a block, finds its next block.
-/// @param header the heap header.
-/// @param block the block.
-/// @return a pointer to the next block.
+/// @brief Given a block, finds its next block in the memory pool.
+/// @param header The heap header containing information about the heap.
+/// @param block The current block for which the next block is to be found.
+/// @return A pointer to the next block if it exists, or NULL if an error occurs or if the block is the last one.
 static inline block_t *__blkmngr_get_next_block(heap_header_t *header, block_t *block)
 {
-    assert(header && "Received a NULL heap header.");
-    assert(block && "Received null block.");
-    // If the block is actually the tail of the list, return NULL.
+    // Check if the heap header is valid.
+    if (!header) {
+        pr_crit("Received a NULL heap header.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Check if the block is valid.
+    if (!block) {
+        pr_crit("Received a NULL block.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // If the block is the tail of the list, return NULL as there is no next block.
     if (block->list.next == &header->list) {
-        return NULL;
+        return NULL; // No next block exists.
     }
+
+    // Return the next block by accessing the list entry.
     return list_entry(block->list.next, block_t, list);
 }
 
-/// @brief Checks if the given `previous` block, is before `block`.
-/// @param block the block from which we check the other block.
-/// @param previous the supposedly previous block.
-/// @return 1 if it is the previous block, 0 otherwise.
+/// @brief Checks if the given `previous` block is actually the block that comes
+/// before `block` in the memory pool.
+/// @param block The current block from which we are checking the previous block.
+/// @param previous The block that is supposedly the previous block.
+/// @return 1 if `previous` is the actual previous block of `block`, 0
+/// otherwise. Returns -1 on error.
 static inline int __blkmngr_is_previous_block(block_t *block, block_t *previous)
 {
-    assert(block && "Received null block.");
-    assert(previous && "Received null previous block.");
+    // Check if the current block is valid.
+    if (!block) {
+        pr_crit("Received a NULL block.\n");
+        return -1; // Error: Invalid block.
+    }
+
+    // Check if the previous block is valid.
+    if (!previous) {
+        pr_crit("Received a NULL previous block.\n");
+        return -1; // Error: Invalid previous block.
+    }
+
+    // Check if the previous block's list entry matches the previous entry of
+    // the current block.
     return block->list.prev == &previous->list;
 }
 
-/// @brief Checks if the given `next` block, is after `block`.
-/// @param block the block from which we check the other block.
-/// @param next the supposedly next block.
-/// @return 1 if it is the next block, 0 otherwise.
+/// @brief Checks if the given `next` block is actually the block that comes
+/// after `block` in the memory pool.
+/// @param block The current block from which we are checking the next block.
+/// @param next The block that is supposedly the next block.
+/// @return 1 if `next` is the actual next block of `block`, 0 otherwise.
+/// Returns -1 on error.
 static inline int __blkmngr_is_next_block(block_t *block, block_t *next)
 {
-    assert(block && "Received null block.");
-    assert(next && "Received null next block.");
+    // Check if the current block is valid.
+    if (!block) {
+        pr_crit("Received a NULL block.\n");
+        return -1; // Error: Invalid block.
+    }
+
+    // Check if the next block is valid.
+    if (!next) {
+        pr_crit("Received a NULL next block.\n");
+        return -1; // Error: Invalid next block.
+    }
+
+    // Check if the next block's list entry matches the next entry of the
+    // current block.
     return block->list.next == &next->list;
 }
 
-/// @brief Splits a block in two blocks, provided the size of the first one.
-/// @param header the heap header.
-/// @param block the block to split.
-/// @param size the size of the first of the two new blocks.
-static inline void __blkmngr_split_block(heap_header_t *header, block_t *block, uint32_t size)
+/// @brief Splits a block into two blocks based on the specified size for the first block.
+/// @param header The heap header containing metadata about the memory pool.
+/// @param block The block to be split, which must be free.
+/// @param size The size of the first of the two new blocks. Must be less than the original block's size minus overhead.
+/// @return 0 on success, -1 on error.
+static inline int __blkmngr_split_block(heap_header_t *header, block_t *block, uint32_t size)
 {
-    assert(block && "Received NULL block.");
-    assert(block->is_free && "The block is not free.");
+    // Check if the block is valid.
+    if (!block) {
+        pr_crit("Received NULL block.\n");
+        return -1; // Cannot proceed without a valid block.
+    }
+
+    // Check if the block is free; splitting a used block is not allowed.
+    if (!block->is_free) {
+        pr_crit("The block is not free and cannot be split.\n");
+        return -1; // Cannot split a non-free block.
+    }
+
+    // Check if the requested size is valid (greater than 0 and less than the
+    // current block size minus overhead).
+    if ((size == 0) || (size + OVERHEAD >= block->size)) {
+        pr_crit("Invalid size for splitting: size must be > 0 and < %u.\n", block->size - OVERHEAD);
+        return -1; // Size is invalid for splitting.
+    }
 
     pr_debug("Splitting %s\n", __block_to_string(block));
 
-    // Create the new block.
+    // Create the new block by calculating its address based on the original block and the specified size.
     block_t *split = (block_t *)((char *)block + OVERHEAD + size);
-    // Insert the block in the list.
+
+    // Insert the new block into the main list after the current block.
     list_head_insert_after(&split->list, &block->list);
-    // Insert the block in the free list.
+
+    // Insert the new block into the free list.
     list_head_insert_after(&split->free, &block->free);
-    // Update the size of the new block.
+
+    // Update the size of the new block to reflect the remaining size after splitting.
     split->size = block->size - OVERHEAD - size;
-    // Update the size of the base block.
+
+    // Update the size of the original block to the new size.
     block->size = size;
-    // Set the blocks as free.
+
+    // Mark both blocks as free.
     block->is_free = 1;
     split->is_free = 1;
 
     pr_debug("Into      %s\n", __block_to_string(block));
     pr_debug("And       %s\n", __block_to_string(split));
+
+    return 0; // Success
 }
 
-/// @brief Merges two blocks, into the first block.
-/// @param header the heap header.
-/// @param block the first block.
-/// @param other the second block, which is lost in the process.
-static inline void __blkmngr_merge_blocks(heap_header_t *header, block_t *block, block_t *other)
+/// @brief Merges two adjacent blocks into the first block, effectively expanding its size.
+/// @param header The heap header containing metadata about the memory pool.
+/// @param block The first block that will be expanded.
+/// @param other The second block that will be merged into the first block, becoming invalid in the process.
+/// @return 0 on success, -1 on error.
+static inline int __blkmngr_merge_blocks(heap_header_t *header, block_t *block, block_t *other)
 {
-    assert(block && "Received NULL first block.");
-    assert(other && "Received NULL second block.");
-    assert(block->is_free && "The first block is not free.");
-    assert(other->is_free && "The second block is not free.");
-    assert(__blkmngr_is_next_block(block, other) && "The blocks are not adjacent.");
+    // Check if the first block is valid.
+    if (!block) {
+        pr_crit("Received NULL first block.\n");
+        return -1; // Cannot proceed without a valid first block.
+    }
+
+    // Check if the second block is valid.
+    if (!other) {
+        pr_crit("Received NULL second block.\n");
+        return -1; // Cannot proceed without a valid second block.
+    }
+
+    // Check if the first block is free.
+    if (!block->is_free) {
+        pr_crit("The first block is not free.\n");
+        return -1; // Cannot merge a non-free block.
+    }
+
+    // Check if the second block is free.
+    if (!other->is_free) {
+        pr_crit("The second block is not free.\n");
+        return -1; // Cannot merge with a non-free block.
+    }
+
+    // Check if the blocks are adjacent.
+    if (!__blkmngr_is_next_block(block, other)) {
+        pr_crit("The blocks are not adjacent and cannot be merged.\n");
+        return -1; // Blocks must be adjacent to merge.
+    }
 
     pr_debug("Merging %s\n", __block_to_string(block));
     pr_debug("And     %s\n", __block_to_string(other));
 
-    // Remove the other block from the free list.
+    // Remove the other block from the free list, effectively marking it as not available.
     list_head_remove(&other->free);
-    // Remove the other block from the list.
+
+    // Remove the other block from the main list.
     list_head_remove(&other->list);
-    // Update the size.
-    block->size = block->size + other->size + OVERHEAD;
-    // Set the splitted block as free.
+
+    // Update the size of the first block to include the size of the second block and overhead.
+    block->size += other->size + OVERHEAD;
+
+    // The first block remains free after merging, so set its free status.
     block->is_free = 1;
 
     pr_debug("Into    %s\n", __block_to_string(block));
+
+    return 0; // Success
 }
 
-/// @brief Extends the provided heap of the given increment.
-/// @param heap      Pointer to the heap.
-/// @param increment Increment to the heap.
-/// @return Pointer to the old top of the heap, ready to be used.
+/// @brief Extends the provided heap by a specified increment.
+/// @param heap Pointer to the heap structure that tracks the heap's memory area.
+/// @param increment The amount by which to increase the heap size.
+/// @return Pointer to the old top of the heap, or NULL if an error occurred.
 static void *__do_brk(vm_area_struct_t *heap, uint32_t increment)
 {
-    assert(heap && "Pointer to the heap is NULL.");
+    // Check if the heap pointer is valid.
+    if (!heap) {
+        pr_crit("Pointer to the heap is NULL.\n");
+        return NULL; // Cannot proceed without a valid heap pointer.
+    }
+
     // Get the current process.
     task_struct *task = scheduler_get_current_process();
-    assert(task && "There is no current task!\n");
-    // Get the memory descriptor.
+    // Check if there is a current task.
+    if (!task) {
+        pr_crit("There is no current task!\n");
+        return NULL; // Cannot proceed without a current task.
+    }
+
+    // Get the memory descriptor for the current task.
     mm_struct_t *mm = task->mm;
-    assert(mm && "The mm_struct of the current task is not initialized!\n");
-    // Compute the new heap top.
+    // Check if the memory descriptor is initialized.
+    if (!mm) {
+        pr_crit("The mm_struct of the current task is not initialized!\n");
+        return NULL; // Cannot proceed without a valid mm_struct.
+    }
+
+    // Compute the new top of the heap by adding the increment to the current break.
     uint32_t new_heap_top = mm->brk + increment;
-    // Debugging message.
-    pr_notice("Expanding heap from 0x%p to 0x%p.\n", mm->brk, new_heap_top);
-    // If new boundary is larger than the end, we fail.
+
+    // Debugging message to indicate the expansion of the heap.
+    pr_debug("Expanding heap from 0x%p to 0x%p.\n", mm->brk, new_heap_top);
+
+    // Check if the new heap top exceeds the boundaries of the heap.
     if (new_heap_top > heap->vm_end) {
-        pr_err("The new boundary is larger than the end!");
-        return NULL;
+        pr_err("The new boundary is larger than the end of the heap!\n");
+        return NULL; // New boundary exceeds the allowed heap area.
     }
-    // Overwrite the top of the heap.
+
+    // Update the break (top of the heap) to the new value.
     mm->brk = new_heap_top;
-    // Return the old top of the heap.
+
+    // Return the pointer to the old top of the heap before the increment.
     return (void *)(mm->brk - increment);
 }
 
-/// @brief Allocates size bytes of uninitialized storage.
-/// @param heap Heap from which we get the unallocated memory.
-/// @param size Size of the desired memory area.
-/// @return Pointer to the allocated memory area.
+/// @brief Allocates a specified number of bytes of uninitialized storage from the heap.
+/// @param heap Pointer to the heap from which we will allocate memory.
+/// @param size The size of the desired memory area to allocate.
+/// @return Pointer to the allocated memory area, or NULL if allocation fails.
 static void *__do_malloc(vm_area_struct_t *heap, size_t size)
 {
+    // Check if the heap pointer is valid.
+    if (!heap) {
+        pr_crit("Pointer to the heap is NULL.\n");
+        return NULL; // Cannot proceed without a valid heap pointer.
+    }
+
+    // Check if the requested size is zero.
     if (size == 0) {
-        return NULL;
+        pr_err("Requested allocation size is zero.\n");
+        return NULL; // No allocation for zero size.
     }
-    // Get the heap header.
+
+    // Get the heap header to access the memory management structures.
     heap_header_t *header = (heap_header_t *)heap->vm_start;
-    // Calculate size that's used, round it to multiple of 16.
+    if (!header) {
+        pr_err("Heap header is NULL.\n");
+        return NULL; // Cannot proceed without a valid heap header.
+    }
+
+    // Calculate the size that is used, rounding it to the nearest multiple of 16.
     uint32_t rounded_size = __blkmngr_get_rounded_size(size);
-    // Calculate actual size we need, which is the rounded size
+    // Calculate the actual size required, which includes overhead for the block header.
     uint32_t actual_size = rounded_size + OVERHEAD;
-    pr_debug("Searching block of size: %s\n", to_human_size(rounded_size));
-    // Find the best fitting block.
+
+    pr_debug("Searching for a block of size: %s\n", to_human_size(rounded_size));
+
+    // Find the best fitting block in the heap.
     block_t *block = __blkmngr_find_best_fitting(header, rounded_size);
-    // If we were able to find a suitable block, either split it, or return it.
+
+    // If a suitable block is found, either split it or use it directly.
     if (block) {
+        // Check if the block size is larger than the actual size needed.
         if (block->size > actual_size) {
-            // Split the block, provide the rounded size to the function.
-            __blkmngr_split_block(header, block, rounded_size);
+            // Split the block, providing the rounded size to the splitting function.
+            if (__blkmngr_split_block(header, block, rounded_size) < 0) {
+                pr_err("Failed to split the block.\n");
+                return NULL; // Return NULL if splitting fails.
+            }
         } else {
             pr_debug("Found perfect block: %s\n", __block_to_string(block));
         }
-        // Remove the block from the free list.
+
+        // Remove the block from the free list to mark it as allocated.
         list_head_remove(&block->free);
     } else {
-        pr_debug("Failed to find suitable block, we need to create a new one.\n");
-        // We need more space, specifically the size of the block plus the size
-        // of the block_t structure.
+        pr_debug("Failed to find a suitable block; creating a new one.\n");
+
+        // We need more space, specifically the size of the block plus the size of the block_t structure.
         block = __do_brk(heap, actual_size);
-        // Set the size.
+        // Check if the block allocation was successful.
+        if (!block) {
+            pr_err("Failed to create a new block.\n");
+            return NULL; // Return NULL if block creation fails.
+        }
+
+        // Set the size for the newly created block.
         block->size = rounded_size;
-        // Check the block.
-        assert(block && "Failed to create a new block!");
-        // Setup the new block.
+
+        // Initialize the new block's list pointers.
         list_head_init(&block->list);
         list_head_init(&block->free);
+        // Insert the block into the header's list of blocks.
         list_head_insert_before(&block->list, &header->list);
     }
-    // Set the new block as used.
+
+    // Set the block as used (allocated).
     block->is_free = 0;
+
+    // Optionally dump the current state of the heap for debugging.
     __blkmngr_dump(header);
+
+    // Return a pointer to the memory area, skipping the block header.
     return (void *)((char *)block + OVERHEAD);
 }
 
-/// @brief Deallocates previously allocated space.
-/// @param heap Heap to which we return the allocated memory.
-/// @param ptr  Pointer to the allocated memory.
-static void __do_free(vm_area_struct_t *heap, void *ptr)
+/// @brief Deallocates previously allocated space, returning it to the heap.
+/// @param heap Pointer to the heap to which the allocated memory is returned.
+/// @param ptr Pointer to the previously allocated memory to be deallocated.
+/// @return 0 on success, -1 on error.
+static int __do_free(vm_area_struct_t *heap, void *ptr)
 {
-    // We will use these in writing.
+    // Check if the heap pointer is valid.
+    if (!heap) {
+        pr_crit("Pointer to the heap is NULL.\n");
+        return -1; // Return error if the heap pointer is NULL.
+    }
+
+    // Check if the pointer to be freed is NULL.
+    if (!ptr) {
+        pr_err("Attempted to free a NULL pointer.\n");
+        return -1; // Return error if the pointer is NULL.
+    }
+
+    // Get the heap header to access the memory management structures.
     heap_header_t *header = (heap_header_t *)heap->vm_start;
-    // Get the current block.
+    if (!header) {
+        pr_err("Heap header is NULL.\n");
+        return -1; // Return error if the heap header is not valid.
+    }
+
+    // Calculate the block pointer from the provided pointer.
     block_t *block = (block_t *)((char *)ptr - OVERHEAD);
-    // Get the previous block.
+    if (!block) {
+        pr_err("Calculated block pointer is NULL.\n");
+        return -1; // Safety check; should not happen.
+    }
+
+    // Get the previous and next blocks for merging purposes.
     block_t *prev = __blkmngr_get_previous_block(header, block);
-    // Get the next block.
     block_t *next = __blkmngr_get_next_block(header, block);
+
     pr_debug("Freeing block %s\n", __block_to_string(block));
-    // Set the block free.
+
+    // Mark the block as free.
     block->is_free = 1;
-    // Merge adjacent blocks.
+
+    // Attempt to merge with adjacent blocks if they are free.
     if (prev && prev->is_free && next && next->is_free) {
-        pr_debug("Merging with previous and next.\n");
-        __blkmngr_merge_blocks(header, prev, block);
-        __blkmngr_merge_blocks(header, prev, next);
+        pr_debug("Merging with previous and next blocks.\n");
+        __blkmngr_merge_blocks(header, prev, block); // Merge with previous.
+        __blkmngr_merge_blocks(header, prev, next);  // Merge with next.
     } else if (prev && prev->is_free) {
-        pr_debug("Merging with previous.\n");
-        __blkmngr_merge_blocks(header, prev, block);
+        pr_debug("Merging with previous block.\n");
+        __blkmngr_merge_blocks(header, prev, block); // Merge with previous.
     } else if (next && next->is_free) {
-        pr_debug("Merging with next.\n");
-        // Merge the blocks.
+        pr_debug("Merging with next block.\n");
+        // Merge the blocks with the next one.
         __blkmngr_merge_blocks(header, block, next);
-        // Add the block to the free list.
+        // Add the current block to the free list.
         list_head_insert_before(&block->free, &header->free);
     } else {
-        pr_debug("No merging required.\n");
-        // Add the block to the free list.
+        pr_debug("No merging required; adding block to free list.\n");
+        // Add the block to the free list since no merging is needed.
         list_head_insert_before(&block->free, &header->free);
     }
+
+    // Dump the current state of the heap for debugging purposes.
     __blkmngr_dump(header);
+
+    return 0; // Return success.
 }
 
 void *sys_brk(void *addr)
 {
+    // Check if the address is NULL.
+    if (!addr) {
+        pr_err("Received a NULL addr.\n");
+        return NULL; // Return error if the addr is NULL.
+    }
+
     // Get the current process.
     task_struct *task = scheduler_get_current_process();
-    assert(task && "There is no current task!\n");
-    // Get the memory descriptor.
+    if (!task) {
+        pr_err("There is no current task!\n");
+        return NULL; // Return error if there is no current task.
+    }
+
+    // Get the memory descriptor for the current task.
     mm_struct_t *mm = task->mm;
-    assert(mm && "The mm_struct of the current task is not initialized!\n");
-    // Get the heap.
+    if (!mm) {
+        pr_err("The mm_struct of the current task is not initialized!\n");
+        return NULL; // Return error if memory descriptor is not initialized.
+    }
+
+    // Get the heap associated with the current task.
     vm_area_struct_t *heap = find_vm_area(task->mm, task->mm->start_brk);
-    // Allocate the segment if don't exist.
+
+    // If the heap does not exist, allocate it.
     if (heap == NULL) {
         pr_debug("Allocating heap!\n");
-        // Set the heap to 4 Mb.
+
+        // Set the heap size to 4 MB.
         size_t heap_size = HEAP_SIZE;
-        // Add to that the space required to store the header, and the first block.
+
+        // Calculate the total segment size needed (header + initial block).
         size_t segment_size = heap_size + sizeof(heap_header_t) + sizeof(block_t);
+
         // Create the virtual memory area, we are goin to place the area between
         // 0x40000000 and 0x50000000, which surely is below the stack. The VM
         // code will check if it is a valid area anyway.
@@ -411,39 +668,63 @@ void *sys_brk(void *addr)
             segment_size,
             MM_RW | MM_PRESENT | MM_USER | MM_UPDADDR,
             GFP_HIGHUSER);
+        if (!heap) {
+            pr_err("Failed to allocate heap memory area.\n");
+            return NULL; // Return error if heap allocation fails.
+        }
+
         pr_debug("Heap size  : %s.\n", to_human_size(heap_size));
         pr_debug("Heap start : 0x%p.\n", heap->vm_start);
         pr_debug("Heap end   : 0x%p.\n", heap->vm_end);
-        // Initialize the memory.
+
+        // Initialize the memory for the heap.
         memset((char *)heap->vm_start, 0, segment_size);
-        // Save where the original heap starts.
+
+        // Save the starting address of the heap.
         task->mm->start_brk = heap->vm_start;
-        // Initialize the header.
+
+        // Initialize the heap header.
         heap_header_t *header = (heap_header_t *)heap->vm_start;
         list_head_init(&header->list);
         list_head_init(&header->free);
-        // Preare the first block.
-        block_t *block = (block_t *)(header + sizeof(heap_header_t));
-        // Let us start with a block of 1 Kb.
-        block->size = K;
+
+        // Prepare the first block of memory.
+        block_t *block = (block_t *)((char *)header + sizeof(heap_header_t));
+        block->size    = K; // Start with a block of 1 KB.
         list_head_init(&block->list);
         list_head_init(&block->free);
-        // Insert the block inside the heap.
+
+        // Insert the initial block into the heap.
         list_head_insert_before(&block->list, &header->list);
         list_head_insert_before(&block->free, &header->free);
-        // Save where the heap actually start.
+
+        // Set the actual starting address of the heap.
         task->mm->brk = (uint32_t)((char *)block + OVERHEAD + block->size);
-        // Set the block as free.
+        // Mark the initial block as free.
         block->is_free = 1;
+
+        // Dump the state of the memory manager for debugging.
         __blkmngr_dump(header);
     }
+
+    // Variable to hold the return pointer.
     void *_ret = NULL;
-    // If the address falls inside the memory region, call the free function,
-    // otherwise execute a malloc of the specified amount.
+
+    // Check if the specified address is within the allocated heap range.
     if (((uintptr_t)addr > heap->vm_start) && ((uintptr_t)addr < heap->vm_end)) {
-        __do_free(heap, addr);
+        // If it is, free the specified address.
+        if (__do_free(heap, addr) < 0) {
+            pr_err("Failed to free memory at address: 0x%p.\n", addr);
+            return NULL; // Return error if freeing fails.
+        }
     } else {
+        // If not, allocate new memory of the specified size.
         _ret = __do_malloc(heap, (size_t)addr);
+        if (!_ret) {
+            pr_err("Memory allocation failed for size: %zu.\n", (size_t)addr);
+            return NULL; // Return error if allocation fails.
+        }
     }
-    return _ret;
+
+    return _ret; // Return the pointer to the allocated memory or NULL on failure.
 }
diff --git a/mentos/src/mem/paging.c b/mentos/src/mem/paging.c
index 2d375d54..45e74845 100644
--- a/mentos/src/mem/paging.c
+++ b/mentos/src/mem/paging.c
@@ -4,10 +4,10 @@
 /// See LICENSE.md for details.
 
 // Setup the logging for this file (do this before any other include).
-#include "sys/kernel_levels.h"          // Include kernel log levels.
-#define __DEBUG_HEADER__ "[PAGING]"     ///< Change header.
-#define __DEBUG_LEVEL__  LOGLEVEL_DEBUG ///< Set log level.
-#include "io/debug.h"                   // Include debugging functions.
+#include "sys/kernel_levels.h"           // Include kernel log levels.
+#define __DEBUG_HEADER__ "[PAGING]"      ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_NOTICE ///< Set log level.
+#include "io/debug.h"                    // Include debugging functions.
 
 #include "assert.h"
 #include "descriptor_tables/isr.h"
@@ -59,14 +59,53 @@ typedef struct pg_iter_entry_s {
 
 page_directory_t *paging_get_main_directory(void)
 {
+    // Ensure the main_mm structure is initialized.
+    if (!main_mm) {
+        pr_crit("main_mm is not initialized\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Return the pointer to the main page directory.
     return main_mm->pgd;
 }
 
-/// @brief Switches paging directory, the pointer can be a lowmem address
-void paging_switch_directory_va(page_directory_t *dir)
+int is_current_pgd(page_directory_t *pgd)
+{
+    // Check if the pgd pointer is NULL
+    if (pgd == NULL) {
+        // Return 0 (false) if the pgd pointer is NULL
+        return 0;
+    }
+    // Compare the given pgd with the current page directory
+    return pgd == paging_get_current_directory();
+}
+
+int paging_switch_directory_va(page_directory_t *dir)
 {
-    page_t *page = get_lowmem_page_from_address((uintptr_t)dir);
-    paging_switch_directory((page_directory_t *)get_physical_address_from_page(page));
+    // Ensure the directory pointer is valid.
+    if (!dir) {
+        pr_crit("Invalid page directory pointer\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Get the low memory page corresponding to the given directory address.
+    page_t *page = get_page_from_virtual_address((uintptr_t)dir);
+    if (!page) {
+        pr_crit("Failed to get low memory page from address\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Get the physical address of the low memory page.
+    uintptr_t phys_addr = get_physical_address_from_page(page);
+    if (!phys_addr) {
+        pr_crit("Failed to get physical address from page\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Switch to the new paging directory using the physical address.
+    paging_switch_directory((page_directory_t *)phys_addr);
+
+    return 0; // Return success.
 }
 
 void paging_flush_tlb_single(unsigned long addr)
@@ -86,25 +125,44 @@ vm_area_struct_t *create_vm_area(mm_struct_t *mm,
 
     // Compute the end of the virtual memory area.
     vm_end = vm_start + size;
+
     // Check if the range is already occupied.
     if (is_valid_vm_area(mm, vm_start, vm_end) <= 0) {
         pr_crit("The virtual memory area range [%p, %p] is already in use.\n", vm_start, vm_end);
-        kernel_panic("Wrong virtual memory area range.");
+        return NULL; // Return NULL to indicate failure.
     }
+
     // Allocate on kernel space the structure for the segment.
     segment = kmem_cache_alloc(vm_area_cache, GFP_KERNEL);
+    if (!segment) {
+        pr_crit("Failed to allocate vm_area_struct\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
     // Find the nearest order for the given memory size.
     order = find_nearest_order_greater(vm_start, size);
 
     if (pgflags & MM_COW) {
+        // If the area is copy-on-write, clear the present and update address
+        // flags.
         pgflags   = pgflags & ~(MM_PRESENT | MM_UPDADDR);
         phy_start = 0;
     } else {
-        pgflags      = pgflags | MM_UPDADDR;
+        // Otherwise, set the update address flag and allocate physical pages.
+        pgflags = pgflags | MM_UPDADDR;
+
         page_t *page = _alloc_pages(gfpflags, order);
-        phy_start    = get_physical_address_from_page(page);
+        if (!page) {
+            pr_crit("Failed to allocate pages\n");
+            kmem_cache_free(segment);
+            return NULL; // Return NULL to indicate failure.
+        }
+
+        // Retrieve the physical address from the allocated page.
+        phy_start = get_physical_address_from_page(page);
     }
 
+    // Update the virtual memory area in the page directory.
     mem_upd_vm_area(mm->pgd, vm_start, phy_start, size, pgflags);
 
     // Update vm_area_struct info.
@@ -112,55 +170,86 @@ vm_area_struct_t *create_vm_area(mm_struct_t *mm,
     segment->vm_end   = vm_end;
     segment->vm_mm    = mm;
 
-    // Update memory descriptor list of vm_area_struct.
+    // Insert the new segment into the memory descriptor's list of vm_area_structs.
     list_head_insert_after(&segment->vm_list, &mm->mmap_list);
     mm->mmap_cache = segment;
 
-    // Sort the mmap_list.
+    // Sort the mmap_list to maintain order.
     list_head_sort(&mm->mmap_list, vm_area_compare);
 
     // Update memory descriptor info.
     mm->map_count++;
-
     mm->total_vm += (1U << order);
 
-    return segment;
+    return segment; // Return the created vm_area_struct.
 }
 
 uint32_t clone_vm_area(mm_struct_t *mm, vm_area_struct_t *area, int cow, uint32_t gfpflags)
 {
+    // Allocate a new vm_area_struct for the cloned area.
     vm_area_struct_t *new_segment = kmem_cache_alloc(vm_area_cache, GFP_KERNEL);
+    if (!new_segment) {
+        pr_crit("Failed to allocate memory for new vm_area_struct\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Copy the content of the existing vm_area_struct to the new segment.
     memcpy(new_segment, area, sizeof(vm_area_struct_t));
 
+    // Update the memory descriptor for the new segment.
     new_segment->vm_mm = mm;
 
+    // Calculate the size and the nearest order for the new segment's memory allocation.
     uint32_t size  = new_segment->vm_end - new_segment->vm_start;
     uint32_t order = find_nearest_order_greater(area->vm_start, size);
 
     if (!cow) {
         // If not copy-on-write, allocate directly the physical pages
-        page_t *dst_page      = _alloc_pages(gfpflags, order);
+        page_t *dst_page = _alloc_pages(gfpflags, order);
+        if (!dst_page) {
+            pr_crit("Failed to allocate physical pages for the new vm_area\n");
+            // Free the newly allocated segment on failure.
+            kmem_cache_free(new_segment);
+            return -1; // Return -1 to indicate failure.
+        }
+
         uint32_t phy_vm_start = get_physical_address_from_page(dst_page);
 
-        // Then update the virtual memory map
-        mem_upd_vm_area(mm->pgd, new_segment->vm_start, phy_vm_start, size,
-                        MM_RW | MM_PRESENT | MM_UPDADDR | MM_USER);
+        // Update the virtual memory map in the page directory.
+        if (mem_upd_vm_area(mm->pgd, new_segment->vm_start, phy_vm_start, size,
+                            MM_RW | MM_PRESENT | MM_UPDADDR | MM_USER) < 0) {
+            pr_crit("Failed to update virtual memory area in page directory\n");
+            // Free the allocated pages on failure.
+            __free_pages(dst_page);
+            // Free the newly allocated segment.
+            kmem_cache_free(new_segment);
+            return -1; // Return -1 to indicate failure.
+        }
 
-        // Copy virtual memory of source area into dest area by using a virtual mapping
+        // Copy virtual memory from source area into destination area using a virtual mapping.
         virt_memcpy(mm, area->vm_start, area->vm_mm, area->vm_start, size);
     } else {
-        // If copy-on-write, set the original pages as read-only
-        mem_upd_vm_area(area->vm_mm->pgd, area->vm_start, 0, size,
-                        MM_COW | MM_PRESENT | MM_USER);
+        // If copy-on-write, set the original pages as read-only.
+        if (mem_upd_vm_area(area->vm_mm->pgd, area->vm_start, 0, size,
+                            MM_COW | MM_PRESENT | MM_USER) < 0) {
+            pr_crit("Failed to mark original pages as copy-on-write\n");
+            // Free the newly allocated segment.
+            kmem_cache_free(new_segment);
+            return -1; // Return -1 to indicate failure.
+        }
 
-        // Do a cow of the whole virtual memory area, handling fragmented physical memory
-        // and set it as read-only
-        mem_clone_vm_area(area->vm_mm->pgd,
-                          mm->pgd,
-                          area->vm_start,
-                          new_segment->vm_start,
-                          size,
-                          MM_COW | MM_PRESENT | MM_UPDADDR | MM_USER);
+        // Perform a COW of the whole virtual memory area, handling fragmented physical memory.
+        if (mem_clone_vm_area(area->vm_mm->pgd,
+                              mm->pgd,
+                              area->vm_start,
+                              new_segment->vm_start,
+                              size,
+                              MM_COW | MM_PRESENT | MM_UPDADDR | MM_USER) < 0) {
+            pr_crit("Failed to clone virtual memory area\n");
+            // Free the newly allocated segment.
+            kmem_cache_free(new_segment);
+            return -1; // Return -1 to indicate failure.
+        }
     }
 
     // Update memory descriptor list of vm_area_struct.
@@ -169,7 +258,6 @@ uint32_t clone_vm_area(mm_struct_t *mm, vm_area_struct_t *area, int cow, uint32_
 
     // Update memory descriptor info.
     mm->map_count++;
-
     mm->total_vm += (1U << order);
 
     return 0;
@@ -180,99 +268,177 @@ int destroy_vm_area(mm_struct_t *mm, vm_area_struct_t *area)
     size_t area_total_size, area_size, area_start;
     uint32_t order, block_size;
     page_t *phy_page;
-    // Get the total area size.
+
+    // Get the total size of the virtual memory area.
     area_total_size = area->vm_end - area->vm_start;
-    // Get the starting location.
+
+    // Get the starting address of the area.
     area_start = area->vm_start;
-    // Free all the memory.
+
+    // Free all the memory associated with the virtual memory area.
     while (area_total_size > 0) {
         area_size = area_total_size;
-        phy_page  = mem_virtual_to_page(mm->pgd, area_start, &area_size);
-        // If the pages are marked as copy-on-write, do not deallocate them!
+
+        // Translate the virtual address to the physical page.
+        phy_page = mem_virtual_to_page(mm->pgd, area_start, &area_size);
+
+        // Check if the page was successfully retrieved.
+        if (!phy_page) {
+            pr_crit("Failed to retrieve physical page for virtual address %p\n", (void *)area_start);
+            return -1; // Return -1 to indicate error.
+        }
+
+        // If the pages are marked as copy-on-write, do not deallocate them.
         if (page_count(phy_page) > 1) {
             order      = phy_page->bbpage.order;
             block_size = 1UL << order;
+
+            // Decrement the reference count for each page in the block.
             for (int i = 0; i < block_size; i++) {
                 page_dec(phy_page + i);
             }
         } else {
+            // If not copy-on-write, free the allocated pages.
             __free_pages(phy_page);
         }
+
+        // Update the remaining size and starting address for the next iteration.
         area_total_size -= area_size;
         area_start += area_size;
     }
-    // Delete segment from the mmap.
+
+    // Remove the segment from the memory map list.
     list_head_remove(&area->vm_list);
-    // Free the memory.
+
+    // Free the memory allocated for the vm_area_struct.
     kmem_cache_free(area);
-    // Reduce the counter for memory mapped areas.
+
+    // Decrement the counter for the number of memory-mapped areas.
     --mm->map_count;
-    return 0;
+
+    return 0; // Return 0 to indicate success.
 }
 
-inline vm_area_struct_t *find_vm_area(mm_struct_t *mm, uint32_t vm_start)
+vm_area_struct_t *find_vm_area(mm_struct_t *mm, uint32_t vm_start)
 {
     vm_area_struct_t *segment;
-    // Find the area.
+
+    // Iterate through the memory map list in reverse order to find the area.
     list_for_each_prev_decl(it, &mm->mmap_list)
     {
+        // Get the current segment from the list entry.
         segment = list_entry(it, vm_area_struct_t, vm_list);
+
+        // Assert that the segment is not NULL.
         assert(segment && "There is a NULL area in the list.");
+
+        // Check if the starting address matches the requested vm_start.
         if (segment->vm_start == vm_start) {
-            return segment;
+            return segment; // Return the found segment.
         }
     }
+
+    // If the area is not found, return NULL.
     return NULL;
 }
 
-inline int is_valid_vm_area(mm_struct_t *mm, uintptr_t vm_start, uintptr_t vm_end)
+int is_valid_vm_area(mm_struct_t *mm, uintptr_t vm_start, uintptr_t vm_end)
 {
+    // Check for a valid memory descriptor.
+    if (!mm || !vm_start || !vm_end) {
+        pr_crit("Invalid arguments: mm or vm_start or vm_end is NULL.");
+        return -1; // Return -1 to indicate error due to invalid input.
+    }
+
+    // Check if the ending address is less than or equal to the starting address.
     if (vm_end <= vm_start) {
-        return -1;
+        pr_crit("Invalid virtual memory area: vm_end (%p) must be greater than vm_start (%p)",
+                (void *)vm_end, (void *)vm_start);
+        return -1; // Return -1 to indicate an error due to invalid input.
     }
-    // Get the stack.
+
+    // Iterate through the list of memory areas to check for overlaps.
     vm_area_struct_t *area;
     list_for_each_prev_decl(it, &mm->mmap_list)
     {
+        // Get the current area from the list entry.
         area = list_entry(it, vm_area_struct_t, vm_list);
-        assert(area && "There is a NULL area in the list.");
+
+        // Check if the area is NULL.
+        if (!area) {
+            pr_crit("Encountered a NULL area in the list.");
+            return -1; // Return -1 to indicate an error due to a NULL area.
+        }
+
+        // Check if the new area overlaps with the current area.
         if ((vm_start > area->vm_start) && (vm_start < area->vm_end)) {
-            pr_crit("INSIDE(START): %p <= %p <= %p", area->vm_start, vm_start, area->vm_end);
-            return 0;
+            pr_crit("Overlap detected at start: %p <= %p <= %p",
+                    (void *)area->vm_start, (void *)vm_start, (void *)area->vm_end);
+            return 0; // Return 0 to indicate an overlap with an existing area.
         }
+
         if ((vm_end > area->vm_start) && (vm_end < area->vm_end)) {
-            pr_crit("INSIDE(END): %p <= %p <= %p", area->vm_start, vm_end, area->vm_end);
-            return 0;
+            pr_crit("Overlap detected at end: %p <= %p <= %p",
+                    (void *)area->vm_start, (void *)vm_end, (void *)area->vm_end);
+            return 0; // Return 0 to indicate an overlap with an existing area.
         }
+
         if ((vm_start < area->vm_start) && (vm_end > area->vm_end)) {
-            pr_crit("WRAPS: %p <= (%p, %p) <= %p", vm_start, area->vm_start, area->vm_end, vm_end);
-            return 0;
+            pr_crit("Wrap-around detected: %p <= (%p, %p) <= %p",
+                    (void *)vm_start, (void *)area->vm_start, (void *)area->vm_end, (void *)vm_end);
+            return 0; // Return 0 to indicate the new area wraps around an existing area.
         }
     }
+
+    // If no overlaps were found, return 1 to indicate the area is valid.
     return 1;
 }
 
-inline int find_free_vm_area(mm_struct_t *mm, size_t length, uintptr_t *vm_start)
+int find_free_vm_area(mm_struct_t *mm, size_t length, uintptr_t *vm_start)
 {
-    // Get the stack.
+    // Check for a valid memory descriptor.
+    if (!mm || !length || !vm_start) {
+        pr_crit("Invalid arguments: mm or length or vm_start is NULL.");
+        return -1; // Return -1 to indicate error due to invalid input.
+    }
+
     vm_area_struct_t *area, *prev_area;
+
+    // Iterate through the list of memory areas in reverse order.
     list_for_each_prev_decl(it, &mm->mmap_list)
     {
+        // Get the current area from the list entry.
         area = list_entry(it, vm_area_struct_t, vm_list);
-        assert(area && "There is a NULL area in the list.");
-        // Check the previous segment.
+
+        // Check if the current area is NULL.
+        if (!area) {
+            pr_crit("Encountered a NULL area in the list.");
+            return -1; // Return -1 to indicate an error due to a NULL area.
+        }
+
+        // Check the previous segment if it exists.
         if (area->vm_list.prev != &mm->mmap_list) {
             prev_area = list_entry(area->vm_list.prev, vm_area_struct_t, vm_list);
-            assert(prev_area && "There is a NULL area in the list.");
-            // Compute the available space.
+
+            // Check if the previous area is NULL.
+            if (!prev_area) {
+                pr_crit("Encountered a NULL previous area in the list.");
+                return -1; // Return -1 to indicate an error due to a NULL area.
+            }
+
+            // Compute the available space between the current area and the previous area.
             unsigned available_space = area->vm_start - prev_area->vm_end;
-            // If the space is enough, return the address.
+
+            // If the available space is sufficient for the requested length,
+            // return the starting address.
             if (available_space >= length) {
                 *vm_start = area->vm_start - length;
-                return 0;
+                return 0; // Return 0 to indicate success.
             }
         }
     }
+
+    // If no suitable area was found, return 1 to indicate failure.
     return 1;
 }
 
@@ -290,30 +456,86 @@ static void __init_pagetable(page_table_t *ptable)
     *ptable = (page_table_t){ { 0 } };
 }
 
-void paging_init(boot_info_t *info)
+int paging_init(boot_info_t *info)
 {
-    mm_cache      = KMEM_CREATE(mm_struct_t);
+    // Check if the info pointer is valid.
+    if (!info) {
+        pr_crit("Invalid boot info provided.\n");
+        return -1; // Return -1 if memory cache creation fails.
+    }
+
+    // Create memory cache for managing mm_struct.
+    mm_cache = KMEM_CREATE(mm_struct_t);
+    if (!mm_cache) {
+        pr_crit("Failed to create mm_cache.\n");
+        return -1; // Return -1 if memory cache creation fails.
+    }
+
+    // Create memory cache for managing vm_area_struct.
     vm_area_cache = KMEM_CREATE(vm_area_struct_t);
+    if (!vm_area_cache) {
+        pr_crit("Failed to create vm_area_cache.\n");
+        return -1; // Return -1 if memory cache creation fails.
+    }
 
+    // Create cache for page directory with custom constructor function.
     pgdir_cache = KMEM_CREATE_CTOR(page_directory_t, __init_pagedir);
+    if (!pgdir_cache) {
+        pr_crit("Failed to create pgdir_cache.\n");
+        return -1; // Return -1 if page directory cache creation fails.
+    }
+
+    // Create cache for page table with custom constructor function.
     pgtbl_cache = KMEM_CREATE_CTOR(page_table_t, __init_pagetable);
+    if (!pgtbl_cache) {
+        pr_crit("Failed to create pgtbl_cache.\n");
+        return -1; // Return -1 if page table cache creation fails.
+    }
 
+    // Allocate the main memory management structure.
     main_mm = kmem_cache_alloc(mm_cache, GFP_KERNEL);
+    if (!main_mm) {
+        pr_crit("Failed to allocate main_mm.\n");
+        return -1; // Return -1 if allocation for mm_struct fails.
+    }
 
+    // Allocate the page directory for the main memory management structure.
     main_mm->pgd = kmem_cache_alloc(pgdir_cache, GFP_KERNEL);
+    if (!main_mm->pgd) {
+        pr_crit("Failed to allocate main_mm page directory.\n");
+        return -1; // Return -1 if allocation for page directory fails.
+    }
 
+    // Calculate the size of low kernel memory.
     uint32_t lowkmem_size = info->stack_end - info->kernel_start;
 
-    // Map the first 1MB of memory with physical mapping to access video memory and other bios stuff
-    mem_upd_vm_area(main_mm->pgd, 0, 0, 1024 * 1024, MM_RW | MM_PRESENT | MM_GLOBAL | MM_UPDADDR);
+    // Map the first 1MB of memory with physical mapping to access video memory and other BIOS functions.
+    if (mem_upd_vm_area(main_mm->pgd, 0, 0, 1024 * 1024,
+                        MM_RW | MM_PRESENT | MM_GLOBAL | MM_UPDADDR) < 0) {
+        pr_crit("Failed to map the first 1MB of memory.\n");
+        return -1; // Return -1 if memory mapping fails.
+    }
 
-    mem_upd_vm_area(main_mm->pgd, info->kernel_start, info->kernel_phy_start, lowkmem_size,
-                    MM_RW | MM_PRESENT | MM_GLOBAL | MM_UPDADDR);
+    // Map the kernel memory region into the virtual memory space.
+    if (mem_upd_vm_area(main_mm->pgd, info->kernel_start, info->kernel_phy_start, lowkmem_size,
+                        MM_RW | MM_PRESENT | MM_GLOBAL | MM_UPDADDR) < 0) {
+        pr_crit("Failed to map kernel memory region.\n");
+        return -1; // Return -1 if memory mapping fails.
+    }
 
-    isr_install_handler(PAGE_FAULT, page_fault_handler, "page_fault_handler");
+    // Install the page fault interrupt service routine (ISR) handler.
+    if (isr_install_handler(PAGE_FAULT, page_fault_handler, "page_fault_handler") < 0) {
+        pr_crit("Failed to install page fault handler.\n");
+        return -1; // Return -1 if ISR installation fails.
+    }
 
+    // Switch to the newly created page directory.
     paging_switch_directory_va(main_mm->pgd);
+
+    // Enable paging.
     paging_enable();
+
+    return 0; // Return 0 on success.
 }
 
 // Error code interpretation.
@@ -328,12 +550,24 @@ void paging_init(boot_info_t *info)
 /// @param flags the flags to set.
 static inline void __set_pg_table_flags(page_table_entry_t *table, uint32_t flags)
 {
-    table->rw         = (flags & MM_RW) != 0;
-    table->present    = (flags & MM_PRESENT) != 0;
-    table->kernel_cow = (flags & MM_COW) != 0; // Store the cow/not cow status
-    table->available  = 1;                     // Future kernel data 2 bits
-    table->global     = (flags & MM_GLOBAL) != 0;
-    table->user       = (flags & MM_USER) != 0;
+    // Check if the table pointer is valid.
+    if (!table) {
+        pr_crit("Invalid page table entry provided.\n");
+        return; // Exit the function early if the table is null.
+    }
+    // Set the Read/Write flag: 1 if the MM_RW flag is set, 0 otherwise.
+    table->rw = (flags & MM_RW) != 0;
+    // Set the Present flag: 1 if the MM_PRESENT flag is set, 0 otherwise.
+    table->present = (flags & MM_PRESENT) != 0;
+    // Set the Copy-On-Write flag: 1 if the MM_COW flag is set, 0 otherwise.
+    // This flag is used to track if the page is a copy-on-write page.
+    table->kernel_cow = (flags & MM_COW) != 0;
+    // Set the Available bits: these are reserved for future use, so set them to 1.
+    table->available = 1; // Currently just sets this to 1 as a placeholder.
+    // Set the Global flag: 1 if the MM_GLOBAL flag is set, 0 otherwise.
+    table->global = (flags & MM_GLOBAL) != 0;
+    // Set the User flag: 1 if the MM_USER flag is set, 0 otherwise.
+    table->user = (flags & MM_USER) != 0;
 }
 
 /// @brief Prints stack frame data and calls kernel_panic.
@@ -378,74 +612,165 @@ static void __page_fault_panic(pt_regs *f, uint32_t addr)
     __asm__ __volatile__("cli");
 }
 
-/// @brief Handles the copy-on-write.
-/// @param entry the entry to manage.
+/// @brief Handles the Copy-On-Write (COW) mechanism for a page table entry.
+///        If the page is marked as COW, it allocates a new page and updates the entry.
+/// @param entry The page table entry to manage.
 /// @return 0 on success, 1 on error.
 static int __page_handle_cow(page_table_entry_t *entry)
 {
+    // Check if the entry pointer is valid.
+    if (!entry) {
+        pr_crit("Invalid page table entry provided.\n");
+        return 1; // Return error if the entry is null.
+    }
+
     // Check if the page is Copy On Write (COW).
     if (entry->kernel_cow) {
-        // Set the entry is no longer COW.
+        // Mark the page as no longer Copy-On-Write.
         entry->kernel_cow = 0;
-        // Check if the entry is not present (allocated).
+
+        // If the page is not currently present (not allocated in physical memory).
         if (!entry->present) {
-            // Allocate a new page.
+            // Allocate a new physical page using high user memory flag.
             page_t *page = _alloc_pages(GFP_HIGHUSER, 0);
-            // Clear the new page.
+            if (!page) {
+                pr_crit("Failed to allocate a new page.\n");
+                return 1; // Return error if the page allocation fails.
+            }
+
+            // Map the allocated physical page to a virtual address.
             uint32_t vaddr = virt_map_physical_pages(page, 1);
+            if (!vaddr) {
+                pr_crit("Failed to map the physical page to virtual address.\n");
+                return 1; // Return error if virtual mapping fails.
+            }
+
+            // Clear the new page by setting all its bytes to 0.
             memset((void *)vaddr, 0, PAGE_SIZE);
-            // Unmap the virtual address.
+
+            // Unmap the virtual address after clearing the page.
             virt_unmap(vaddr);
-            // Set it as current table entry frame.
-            entry->frame = get_physical_address_from_page(page) >> 12U;
-            // Set it as allocated.
+
+            // Set the physical frame address of the allocated page into the entry.
+            entry->frame = get_physical_address_from_page(page) >> 12U; // Shift to get page frame number.
+
+            // Mark the page as present in memory.
             entry->present = 1;
-            return 0;
+
+            return 0; // Success, COW handled and page allocated.
         }
     }
-    pr_err("Page not cow!\n");
-    return 1;
+
+    // If the page is not marked as COW, print an error.
+    pr_err("Page not marked as copy-on-write (COW)!\n");
+    return 1; // Return error as the page is not COW.
 }
 
 /// @brief Allocates memory for a page table entry.
-/// @param entry the entry for which we allocate memory.
-/// @param flags the flags to control the allocation.
-/// @return a pointer to the page table entry.
+/// @details If the page table is not present, allocates a new one and sets
+/// flags accordingly.
+/// @param entry The page directory entry for which memory is being allocated.
+/// @param flags The flags that control the allocation, such as permissions and
+/// attributes.
+/// @return A pointer to the allocated page table, or NULL if allocation fails.
 static page_table_t *__mem_pg_entry_alloc(page_dir_entry_t *entry, uint32_t flags)
 {
+    // Check if the page directory entry is valid.
+    if (!entry) {
+        pr_crit("Invalid page directory entry provided.\n");
+        return NULL; // Return NULL to indicate error.
+    }
+
+    // If the page table is not present, allocate a new one.
     if (!entry->present) {
-        // Alloc page table if not present
-        // Present should be always 1, to indicate that the page tables
-        // have been allocated and allow lazy physical pages allocation
-        entry->present   = 1;
-        entry->rw        = 1;
-        entry->global    = (flags & MM_GLOBAL) != 0;
-        entry->user      = (flags & MM_USER) != 0;
-        entry->accessed  = 0;
-        entry->available = 1;
-        return kmem_cache_alloc(pgtbl_cache, GFP_KERNEL);
-    }
-    entry->present |= (flags & MM_PRESENT) != 0;
-    entry->rw |= (flags & MM_RW) != 0;
-
-    // We should not remove a global flag from a page directory,
-    // if this happens there is probably a bug in the kernel
-    assert(!entry->global || (flags & MM_GLOBAL));
-
-    entry->global &= (flags & MM_GLOBAL) != 0;
-    entry->user |= (flags & MM_USER) != 0;
-    return (page_table_t *)get_lowmem_address_from_page(
-        get_page_from_physical_address(((uint32_t)entry->frame) << 12U));
+        // Mark the page table as present and set read/write and global/user flags.
+        entry->present   = 1;                        // Indicate that the page table has been allocated.
+        entry->rw        = 1;                        // Allow read/write access by default.
+        entry->global    = (flags & MM_GLOBAL) != 0; // Set global flag if specified.
+        entry->user      = (flags & MM_USER) != 0;   // Set user-mode flag if specified.
+        entry->accessed  = 0;                        // Mark as not accessed.
+        entry->available = 1;                        // Available for kernel use.
+
+        // Allocate the page table using a memory cache.
+        page_table_t *new_table = kmem_cache_alloc(pgtbl_cache, GFP_KERNEL);
+        if (!new_table) {
+            pr_crit("Failed to allocate memory for page table.\n");
+            return NULL; // Return NULL if allocation fails.
+        }
+
+        return new_table; // Return the newly allocated page table.
+    }
+
+    // If the page table is already present, update the flags accordingly.
+    entry->present |= (flags & MM_PRESENT) != 0; // Update the present flag if MM_PRESENT is set.
+    entry->rw |= (flags & MM_RW) != 0;           // Update the read/write flag if MM_RW is set.
+
+    // Ensure that the global flag is not removed if it was previously set.
+    // Removing a global flag from a page directory might indicate a bug in the kernel.
+    if (entry->global && !(flags & MM_GLOBAL)) {
+        kernel_panic("Attempted to remove the global flag from a page directory entry.\n");
+    }
+
+    // Update the global and user flags.
+    entry->global &= (flags & MM_GLOBAL) != 0; // Keep the global flag if specified.
+    entry->user |= (flags & MM_USER) != 0;     // Set the user-mode flag if specified.
+
+    // Retrieve the physical address of the page.
+    page_t *page = get_page_from_physical_address(((uint32_t)entry->frame) << 12U);
+    if (!page) {
+        pr_crit("Failed to retrieve page from physical address.\n");
+        return NULL; // Return NULL if the page retrieval fails.
+    }
+
+    // Convert the physical address into a low memory address.
+    page_table_t *lowmem_addr = (page_table_t *)get_virtual_address_from_page(page);
+    if (!lowmem_addr) {
+        pr_crit("Failed to map page to low memory address.\n");
+        return NULL; // Return NULL if the low memory mapping fails.
+    }
+
+    return lowmem_addr; // Return the mapped page table.
 }
 
-/// @brief Sets the frame attribute of a page table entry.
-/// @param entry the entry.
-/// @param table the page table.
-static inline void __set_pg_entry_frame(page_dir_entry_t *entry, page_table_t *table)
+/// @brief Sets the frame attribute of a page directory entry based on the page table's physical address.
+/// @param entry The page directory entry to modify.
+/// @param table The page table whose frame is being set in the directory entry.
+/// @return 0 on success, -1 on failure.
+static inline int __set_pg_entry_frame(page_dir_entry_t *entry, page_table_t *table)
 {
-    page_t *table_page = get_lowmem_page_from_address((uint32_t)table);
-    uint32_t phy_addr  = get_physical_address_from_page(table_page);
-    entry->frame       = phy_addr >> 12u;
+    // Ensure the entry is not NULL.
+    if (!entry) {
+        pr_crit("Invalid page directory entry provided.\n");
+        return -1; // Return -1 if the entry is NULL (error).
+    }
+
+    // Ensure the table is not NULL.
+    if (!table) {
+        pr_crit("Invalid page table provided.\n");
+        return -1; // Return -1 if the table is NULL (error).
+    }
+
+    // Retrieve the low memory page structure from the virtual address of the table.
+    page_t *table_page = get_page_from_virtual_address((uint32_t)table);
+    if (!table_page) {
+        pr_crit("Failed to retrieve low memory page from table address: %p\n", table);
+        return -1; // Return -1 if the low memory page retrieval fails (error).
+    }
+
+    // Retrieve the physical address from the page structure.
+    uint32_t phy_addr = get_physical_address_from_page(table_page);
+    if (!phy_addr) {
+        pr_crit("Failed to retrieve physical address from page: %p\n", table_page);
+        return -1; // Return -1 if the physical address retrieval fails (error).
+    }
+
+    // Set the frame attribute in the page directory entry (shifted by 12 bits
+    // to represent the frame number).
+    entry->frame = phy_addr >> 12u;
+
+    pr_debug("Set page directory entry frame to 0x%x for table: %p\n", entry->frame, table);
+
+    return 0; // Return 0 on success.
 }
 
 void page_fault_handler(pt_regs *f)
@@ -468,26 +793,44 @@ void page_fault_handler(pt_regs *f)
     // |  1  1  0 | User process tried to write to a non-present page entry
     // |  1  1  1 | User process tried to write a page and caused a protection fault
 
-    // First, read the linear address that caused the Page Fault. When the exception occurs, the CPU control unit stores
-    // that value in the cr2 control register.
-    uint32_t faulting_addr;
-    __asm__ __volatile__("mov %%cr2, %0"
-                         : "=r"(faulting_addr));
-    // Get the physical address of the current page directory.
+    // Extract the error
+    int err_user    = bit_check(f->err_code, 2) != 0;
+    int err_rw      = bit_check(f->err_code, 1) != 0;
+    int err_present = bit_check(f->err_code, 0) != 0;
+
+    // Extract the address that caused the page fault from the CR2 register.
+    uint32_t faulting_addr = get_cr2();
+
+    // Retrieve the current page directory's physical address.
     uint32_t phy_dir = (uint32_t)paging_get_current_directory();
-    // Get the page directory.
-    page_directory_t *lowmem_dir = (page_directory_t *)get_lowmem_address_from_page(get_page_from_physical_address(phy_dir));
-    // Get the directory entry.
+    if (!phy_dir) {
+        pr_crit("Failed to retrieve current page directory.\n");
+        __page_fault_panic(f, faulting_addr);
+    }
+
+    // Get the page from the physical address of the directory.
+    page_t *dir_page = get_page_from_physical_address(phy_dir);
+    if (!dir_page) {
+        pr_crit("Failed to get page from physical address: %p\n", (void *)phy_dir);
+        __page_fault_panic(f, faulting_addr);
+    }
+
+    // Get the low memory address from the page and cast it to a page directory structure.
+    page_directory_t *lowmem_dir = (page_directory_t *)get_virtual_address_from_page(dir_page);
+    if (!lowmem_dir) {
+        pr_crit("Failed to get low memory address from page: %p\n", (void *)dir_page);
+        __page_fault_panic(f, faulting_addr);
+    }
+
+    // Get the directory entry that corresponds to the faulting address.
     page_dir_entry_t *direntry = &lowmem_dir->entries[faulting_addr / (1024U * PAGE_SIZE)];
-    // Extract the error
-    bool_t err_user    = bit_check(f->err_code, 2) != 0;
-    bool_t err_rw      = bit_check(f->err_code, 1) != 0;
-    bool_t err_present = bit_check(f->err_code, 0) != 0;
+
     // Panic only if page is in kernel memory, else abort process with SIGSEGV.
     if (!direntry->present) {
-        pr_crit("ERR(0): %d%d%d\n", err_user, err_rw, err_present);
+        pr_crit("ERR(0): Page directory entry not present (%d%d%d)\n", err_user, err_rw, err_present);
+
+        // If the fault was caused by a user process, send a SIGSEGV signal.
         if (err_user) {
-            // Get the current process.
             task_struct *task = scheduler_get_current_process();
             if (task) {
                 // Notifies current process.
@@ -503,32 +846,61 @@ void page_fault_handler(pt_regs *f)
         pr_crit("ERR(0): So, it is not present, and it was not the user.\n");
         __page_fault_panic(f, faulting_addr);
     }
-    // Get the physical address of the page table.
+
+    // Retrieve the physical address of the page table.
     uint32_t phy_table = direntry->frame << 12U;
-    // Get the page table.
-    page_table_t *lowmem_table = (page_table_t *)get_lowmem_address_from_page(get_page_from_physical_address(phy_table));
+
+    // Get the page from the physical address of the page table.
+    page_t *table_page = get_page_from_physical_address(phy_table);
+    if (!table_page) {
+        pr_crit("Failed to get page from physical address: %p\n", (void *)phy_table);
+        __page_fault_panic(f, faulting_addr);
+    }
+
+    // Get the low memory address from the page and cast it to a page table structure.
+    page_table_t *lowmem_table = (page_table_t *)get_virtual_address_from_page(table_page);
+    if (!lowmem_table) {
+        pr_crit("Failed to get low memory address from page: %p\n", (void *)table_page);
+        __page_fault_panic(f, faulting_addr);
+    }
+
     // Get the entry inside the table that caused the fault.
     uint32_t table_index = (faulting_addr / PAGE_SIZE) % 1024U;
+
     // Get the corresponding page table entry.
     page_table_entry_t *entry = &lowmem_table->pages[table_index];
-    // There was a page fault on a virtual mapped address,
-    // so we must first update the original mapped page
+    if (!entry) {
+        pr_crit("Failed to retrieve page table entry.\n");
+        __page_fault_panic(f, faulting_addr);
+    }
+
+    // There was a page fault on a virtual mapped address, so we must first
+    // update the original mapped page
     if (virtual_check_address(faulting_addr)) {
         // Get the original page table entry from the virtually mapped one.
         page_table_entry_t *orig_entry = (page_table_entry_t *)(*(uint32_t *)entry);
+        if (!orig_entry) {
+            pr_crit("Original page table entry is NULL.\n");
+            __page_fault_panic(f, faulting_addr);
+        }
+
         // Check if the page is Copy on Write (CoW).
         if (__page_handle_cow(orig_entry)) {
             pr_crit("ERR(1): %d%d%d\n", err_user, err_rw, err_present);
             __page_fault_panic(f, faulting_addr);
         }
+
         // Update the page table entry frame.
         entry->frame = orig_entry->frame;
+
         // Update the entry flags.
         __set_pg_table_flags(entry, MM_PRESENT | MM_RW | MM_GLOBAL | MM_COW | MM_UPDADDR);
     } else {
         // Check if the page is Copy on Write (CoW).
         if (__page_handle_cow(entry)) {
             pr_crit("ERR(2): %d%d%d\n", err_user, err_rw, err_present);
+
+            // If the fault was caused by a user process, send a SIGSEGV signal.
             if (err_user && err_rw && err_present) {
                 // Get the current process.
                 task_struct *task = scheduler_get_current_process();
@@ -548,7 +920,8 @@ void page_fault_handler(pt_regs *f)
             __page_fault_panic(f, faulting_addr);
         }
     }
-    // Invalidate the page table entry.
+
+    // Invalidate the TLB entry for the faulting address.
     paging_flush_tlb_single(faulting_addr);
 }
 
@@ -558,262 +931,517 @@ void page_fault_handler(pt_regs *f)
 /// @param addr_start The starting address.
 /// @param size       The total amount we want to iterate.
 /// @param flags      Allocation flags.
-static void __pg_iter_init(page_iterator_t *iter,
-                           page_directory_t *pgd,
-                           uint32_t addr_start,
-                           uint32_t size,
-                           uint32_t flags)
+/// @return 0 on success, -1 on error.
+static int __pg_iter_init(page_iterator_t *iter,
+                          page_directory_t *pgd,
+                          uint32_t addr_start,
+                          uint32_t size,
+                          uint32_t flags)
 {
+    // Calculate the starting page frame number (PFN) based on the starting address.
     uint32_t start_pfn = addr_start / PAGE_SIZE;
 
+    // Calculate the ending page frame number (PFN) based on the starting address and size.
     uint32_t end_pfn = (addr_start + size + PAGE_SIZE - 1) / PAGE_SIZE;
 
+    // Determine the base page table index from the starting PFN.
     uint32_t base_pgt = start_pfn / 1024;
-    iter->entry       = pgd->entries + base_pgt;
-    iter->pfn         = start_pfn;
-    iter->last_pfn    = end_pfn;
-    iter->flags       = flags;
 
+    // Ensure that the base page table index is within valid range.
+    if (base_pgt >= MAX_PAGE_TABLE_ENTRIES) {
+        pr_crit("Base page table index %u is out of bounds.\n", base_pgt);
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Initialize the iterator's entry pointer to point to the corresponding page directory entry.
+    iter->entry = pgd->entries + base_pgt;
+
+    // Set the page frame numbers for the iterator.
+    iter->pfn      = start_pfn;
+    iter->last_pfn = end_pfn;
+    iter->flags    = flags;
+
+    // Allocate memory for the page table entry associated with the iterator.
     iter->table = __mem_pg_entry_alloc(iter->entry, flags);
+    // Check if the allocation was successful.
+    if (!iter->table) {
+        pr_crit("Failed to allocate memory for page table entry.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Set the frame for the page entry.
     __set_pg_entry_frame(iter->entry, iter->table);
+
+    return 0; // Return 0 to indicate success.
 }
 
 /// @brief Checks if the iterator has a next entry.
-/// @param iter The iterator.
-/// @return If we can continue the iteration.
+/// @param iter The iterator to check.
+/// @return Returns 1 if the iterator can continue the iteration; otherwise, returns 0.
 static int __pg_iter_has_next(page_iterator_t *iter)
 {
+    // Check for a null iterator pointer to avoid dereferencing a null pointer.
+    if (!iter) {
+        pr_crit("The page iterator is null.\n");
+        return 0; // Return 0, indicating there are no entries to iterate.
+    }
+
+    // Check if the current page frame number (pfn) is less than the last page frame number (last_pfn).
+    // This condition determines if there are more entries to iterate over.
     return iter->pfn < iter->last_pfn;
 }
 
 /// @brief Moves the iterator to the next entry.
-/// @param iter The itetator.
-/// @return The iterator after moving to the next entry.
+/// @param iter The iterator to advance.
+/// @return The current entry after moving to the next entry.
 static pg_iter_entry_t __pg_iter_next(page_iterator_t *iter)
 {
+    // Check for a null iterator pointer to avoid dereferencing a null pointer.
+    if (!iter) {
+        pr_crit("The page iterator is null.\n");
+        return (pg_iter_entry_t){ 0 }; // Return a default entry indicating an error.
+    }
+
+    // Initialize the result entry with the current page frame number (pfn).
     pg_iter_entry_t result = {
         .entry = &iter->table->pages[iter->pfn % 1024],
         .pfn   = iter->pfn
     };
 
-    if (++iter->pfn % 1024 == 0) {
-        // Create a new page only if we haven't reached the end
-        // The page directory is always aligned to page boundaries,
-        // so we can easily know when we've skipped the last page by checking
-        // if the address % PAGE_SIZE is equal to zero.
-        if (iter->pfn != iter->last_pfn && ((uint32_t)++iter->entry) % 4096 != 0) {
-            iter->table = __mem_pg_entry_alloc(iter->entry, iter->flags);
-            __set_pg_entry_frame(iter->entry, iter->table);
+    // Move to the next page frame number.
+    iter->pfn++;
+
+    // Check if we have wrapped around to a new page.
+    if (iter->pfn % 1024 == 0) {
+        // Check if we haven't reached the end of the last page.
+        if (iter->pfn != iter->last_pfn) {
+            // Ensure that the new entry address is valid and page-aligned.
+            if (((uint32_t)++iter->entry) % 4096 != 0) {
+                // Attempt to allocate memory for a new page entry.
+                iter->table = __mem_pg_entry_alloc(iter->entry, iter->flags);
+                if (!iter->table) {
+                    pr_crit("Failed to allocate memory for new page entry.\n");
+                    return (pg_iter_entry_t){ 0 }; // Return a default entry indicating an error.
+                }
+
+                // Set the frame for the newly allocated entry.
+                __set_pg_entry_frame(iter->entry, iter->table);
+            }
         }
     }
 
-    return result;
+    return result; // Return the current entry after moving to the next.
 }
 
-page_t *mem_virtual_to_page(page_directory_t *pgdir, uint32_t virt_start, size_t *size)
+page_t *mem_virtual_to_page(page_directory_t *pgd, uint32_t virt_start, size_t *size)
 {
+    // Check for null pointer to the page directory to avoid dereferencing.
+    if (!pgd) {
+        pr_crit("The page directory is null.\n");
+        return NULL; // Return NULL to indicate an error.
+    }
+
+    // Calculate the page frame number and page table index from the virtual address.
     uint32_t virt_pfn        = virt_start / PAGE_SIZE;
-    uint32_t virt_pgt        = virt_pfn / 1024;
-    uint32_t virt_pgt_offset = virt_pfn % 1024;
+    uint32_t virt_pgt        = virt_pfn / 1024; // Page table index.
+    uint32_t virt_pgt_offset = virt_pfn % 1024; // Offset within the page table.
 
-    page_t *pgd_page = mem_map + pgdir->entries[virt_pgt].frame;
+    // Get the physical page for the page directory entry.
+    page_t *pgd_page = mem_map + pgd->entries[virt_pgt].frame;
 
-    page_table_t *pgt_address = (page_table_t *)get_lowmem_address_from_page(pgd_page);
+    // Get the low memory address of the page table.
+    page_table_t *pgt_address = (page_table_t *)get_virtual_address_from_page(pgd_page);
+    if (!pgt_address) {
+        pr_crit("Failed to get low memory address from page directory entry.\n");
+        return NULL; // Return NULL if unable to retrieve page table address.
+    }
 
+    // Get the physical frame number for the corresponding entry in the page table.
     uint32_t pfn = pgt_address->pages[virt_pgt_offset].frame;
 
+    // Map the physical frame number to a physical page.
     page_t *page = mem_map + pfn;
 
-    // FIXME: handle unaligned page mapping
-    // to return the correct to-block-end size
-    // instead of 0 (1 page at a time)
+    // FIXME: handle unaligned page mapping to return the correct to-block-end
+    // size instead of returning 0 (1 page at a time).
     if (size) {
-        uint32_t pfn_count   = 1U << page->bbpage.order;
-        uint32_t bytes_count = pfn_count * PAGE_SIZE;
-        *size                = min(*size, bytes_count);
+        uint32_t pfn_count   = 1U << page->bbpage.order; // Calculate the number of pages.
+        uint32_t bytes_count = pfn_count * PAGE_SIZE;    // Calculate the total byte count.
+        *size                = min(*size, bytes_count);  // Store the size, ensuring it doesn't exceed the maximum.
     }
 
-    return page;
+    return page; // Return the pointer to the mapped physical page.
 }
 
-void mem_upd_vm_area(page_directory_t *pgd,
-                     uint32_t virt_start,
-                     uint32_t phy_start,
-                     size_t size,
-                     uint32_t flags)
+int mem_upd_vm_area(page_directory_t *pgd,
+                    uint32_t virt_start,
+                    uint32_t phy_start,
+                    size_t size,
+                    uint32_t flags)
 {
+    // Check for null pointer to the page directory to avoid dereferencing.
+    if (!pgd) {
+        pr_crit("The page directory is null.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Initialize the page iterator for the virtual memory area.
     page_iterator_t virt_iter;
-    __pg_iter_init(&virt_iter, pgd, virt_start, size, flags);
+    if (__pg_iter_init(&virt_iter, pgd, virt_start, size, flags) < 0) {
+        pr_crit("Failed to initialize source page iterator\n");
+        return -1; // Return -1 to indicate error.
+    }
 
+    // Calculate the starting page frame number for the physical address.
     uint32_t phy_pfn = phy_start / PAGE_SIZE;
 
+    // Iterate through the virtual memory area.
     while (__pg_iter_has_next(&virt_iter)) {
         pg_iter_entry_t it = __pg_iter_next(&virt_iter);
+
+        // If the MM_UPDADDR flag is set, update the frame address.
         if (flags & MM_UPDADDR) {
+            // Ensure the physical frame number is valid before assignment.
+            if (phy_pfn >= MAX_PHY_PFN) {
+                pr_crit("Physical frame number exceeds maximum limit.\n");
+                return -1; // Return -1 to indicate error.
+            }
             it.entry->frame = phy_pfn++;
-            // Flush the tlb to allow address update
-            // TODO(enrico): Check if it's always needed (ex. when the pgdir is not the current one)
+            // Flush the TLB only if the page directory is the current one.
             paging_flush_tlb_single(it.pfn * PAGE_SIZE);
         }
+
+        // Set the page table flags.
         __set_pg_table_flags(it.entry, flags);
     }
+
+    return 0; // Return 0 to indicate success.
 }
 
-void mem_clone_vm_area(page_directory_t *src_pgd,
-                       page_directory_t *dst_pgd,
-                       uint32_t src_start,
-                       uint32_t dst_start,
-                       size_t size,
-                       uint32_t flags)
+int mem_clone_vm_area(page_directory_t *src_pgd,
+                      page_directory_t *dst_pgd,
+                      uint32_t src_start,
+                      uint32_t dst_start,
+                      size_t size,
+                      uint32_t flags)
 {
-    page_iterator_t src_iter;
-    page_iterator_t dst_iter;
+    // Check for null pointer.
+    if (!src_pgd) {
+        pr_crit("The source page directory is null.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Check for null pointer.
+    if (!dst_pgd) {
+        pr_crit("The source page directory is null.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Initialize iterators for both source and destination page directories.
+    page_iterator_t src_iter, dst_iter;
 
-    __pg_iter_init(&src_iter, src_pgd, src_start, size, flags);
-    __pg_iter_init(&dst_iter, dst_pgd, dst_start, size, flags);
+    // Initialize the source iterator to iterate through the source page directory.
+    if (__pg_iter_init(&src_iter, src_pgd, src_start, size, flags) < 0) {
+        pr_crit("Failed to initialize source page iterator\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Initialize the destination iterator to iterate through the destination page directory.
+    if (__pg_iter_init(&dst_iter, dst_pgd, dst_start, size, flags) < 0) {
+        pr_crit("Failed to initialize destination page iterator\n");
+        return -1; // Return -1 to indicate error.
+    }
 
+    // Iterate over the pages in the source and destination page directories.
     while (__pg_iter_has_next(&src_iter) && __pg_iter_has_next(&dst_iter)) {
         pg_iter_entry_t src_it = __pg_iter_next(&src_iter);
         pg_iter_entry_t dst_it = __pg_iter_next(&dst_iter);
 
+        // Check if the source page is marked as copy-on-write (COW).
         if (src_it.entry->kernel_cow) {
+            // Clone the page by assigning the address of the source entry to the destination.
             *(uint32_t *)dst_it.entry = (uint32_t)src_it.entry;
-            // This is to make it clear that the page is not present,
-            // can be omitted because the .entry address is aligned to 4 bytes boundary
-            // so it's first two bytes are always zero
+            // Mark the destination page as not present.
             dst_it.entry->present = 0;
         } else {
+            // Copy the frame information from the source entry to the destination entry.
             dst_it.entry->frame = src_it.entry->frame;
+            // Set the page table flags for the destination entry.
             __set_pg_table_flags(dst_it.entry, flags);
         }
 
-        // Flush the tlb to allow address update
-        // TODO(enrico): Check if it's always needed (ex. when the pgdir is not the current one)
+        // Flush the TLB entry for the destination page to ensure the address is
+        // updated. It's essential to verify whether this is required in every
+        // case.
         paging_flush_tlb_single(dst_it.pfn * PAGE_SIZE);
     }
+
+    return 0; // Return 0 to indicate success.
 }
 
 mm_struct_t *create_blank_process_image(size_t stack_size)
 {
-    // Allocate the mm_struct.
+    // Allocate the mm_struct for the new process image.
     mm_struct_t *mm = kmem_cache_alloc(mm_cache, GFP_KERNEL);
+    if (!mm) {
+        pr_crit("Failed to allocate memory for mm_struct\n");
+        return NULL; // Return NULL to indicate error in allocation.
+    }
+
+    // Initialize the allocated mm_struct to zero.
     memset(mm, 0, sizeof(mm_struct_t));
 
-    // TODO(enrico): Use this field
+    // Initialize the list for memory management (mm) structures.
+    // TODO(enrico): Use this field for process memory management.
     list_head_init(&mm->mm_list);
 
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return NULL; // Return NULL to indicate error.
+    }
+
+    // Allocate a new page directory structure and copy the main page directory.
     page_directory_t *pdir_cpy = kmem_cache_alloc(pgdir_cache, GFP_KERNEL);
-    memcpy(pdir_cpy, paging_get_main_directory(), sizeof(page_directory_t));
+    if (!pdir_cpy) {
+        pr_crit("Failed to allocate memory for page directory\n");
+        // Free previously allocated mm_struct.
+        kmem_cache_free(mm);
+        return NULL; // Return NULL to indicate error in allocation.
+    }
 
+    // Initialize the allocated page_directory to zero.
+    memcpy(pdir_cpy, main_pgd, sizeof(page_directory_t));
+
+    // Assign the copied page directory to the mm_struct.
     mm->pgd = pdir_cpy;
 
-    // Initialize vm areas list
+    // Initialize the virtual memory areas list for the new process.
     list_head_init(&mm->mmap_list);
 
     // Allocate the stack segment.
     vm_area_struct_t *segment = create_vm_area(mm, PROCAREA_END_ADDR - stack_size, stack_size,
                                                MM_PRESENT | MM_RW | MM_USER | MM_COW, GFP_HIGHUSER);
-    //    Update the start of the stack.
+    if (!segment) {
+        pr_crit("Failed to create stack segment for new process\n");
+        // Free page directory if allocation fails.
+        kmem_cache_free(pdir_cpy);
+        // Free mm_struct as well.
+        kmem_cache_free(mm);
+        return NULL; // Return NULL to indicate error in stack allocation.
+    }
+
+    // Update the start of the stack in the mm_struct.
     mm->start_stack = segment->vm_start;
-    return mm;
+
+    return mm; // Return the initialized mm_struct for the new process.
 }
 
 mm_struct_t *clone_process_image(mm_struct_t *mmp)
 {
-    // Allocate the mm_struct.
+    // Check if the input mm_struct pointer is valid.
+    if (!mmp) {
+        pr_crit("Invalid source mm_struct pointer.\n");
+        return NULL; // Return NULL to indicate error.
+    }
+
+    // Allocate the mm_struct for the new process image.
     mm_struct_t *mm = kmem_cache_alloc(mm_cache, GFP_KERNEL);
+    if (!mm) {
+        pr_crit("Failed to allocate memory for mm_struct\n");
+        return NULL; // Return NULL to indicate error in allocation.
+    }
+
+    // Copy the contents of the source mm_struct to the new one.
     memcpy(mm, mmp, sizeof(mm_struct_t));
 
-    // Initialize the process with the main directory, to avoid page tables data races.
-    // Pages from the old process are copied/cow when segments are cloned
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return NULL; // Return NULL to indicate error.
+    }
+
+    // Allocate a new page directory to avoid data races on page tables.
     page_directory_t *pdir_cpy = kmem_cache_alloc(pgdir_cache, GFP_KERNEL);
-    memcpy(pdir_cpy, paging_get_main_directory(), sizeof(page_directory_t));
+    if (!pdir_cpy) {
+        pr_crit("Failed to allocate page directory for new process.\n");
+        // Free the previously allocated mm_struct.
+        kmem_cache_free(mm);
+        return NULL; // Return NULL to indicate error.
+    }
+
+    // Initialize the new page directory by copying from the main directory.
+    memcpy(pdir_cpy, main_pgd, sizeof(page_directory_t));
 
+    // Assign the copied page directory to the mm_struct.
     mm->pgd = pdir_cpy;
 
     vm_area_struct_t *vm_area = NULL;
 
-    // Reset vm areas to allow easy clone
+    // Reset the memory area list to prepare for cloning.
     list_head_init(&mm->mmap_list);
     mm->map_count = 0;
     mm->total_vm  = 0;
 
-    // Clone each memory area to the new process!
+    // Clone each memory area from the source process to the new process.
     list_head *it;
     list_for_each (it, &mmp->mmap_list) {
         vm_area = list_entry(it, vm_area_struct_t, vm_list);
-        clone_vm_area(mm, vm_area, 0, GFP_HIGHUSER);
-    }
 
-    //
-    //    // Allocate the stack segment.
-    //    mm->start_stack = create_segment(mm, stack_size);
+        if (clone_vm_area(mm, vm_area, 0, GFP_HIGHUSER) < 0) {
+            pr_crit("Failed to clone vm_area from source process.\n");
+            // Free the previously allocated mm_struct.
+            kmem_cache_free(mm);
+            // Free the previously allocated page_directory.
+            kmem_cache_free(pdir_cpy);
+            return NULL; // Return NULL to indicate error.
+        }
+    }
 
-    return mm;
+    return mm; // Return the newly cloned mm_struct.
 }
 
-void destroy_process_image(mm_struct_t *mm)
+int destroy_process_image(mm_struct_t *mm)
 {
-    assert(mm != NULL);
+    // Check if the input mm_struct pointer is valid.
+    if (!mm) {
+        pr_crit("Invalid source mm_struct pointer.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Retrieve the current page directory.
+    uint32_t current_paging_dir = (uint32_t)paging_get_current_directory();
+    if (current_paging_dir == 0) {
+        pr_crit("Failed to retrieve the current paging directory.\n");
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Get the low memory page associated with the given mm_struct.
+    page_t *lowmem_page = get_page_from_virtual_address((uint32_t)mm->pgd);
+    if (!lowmem_page) {
+        pr_crit("Failed to get low memory page from mm->pgd address: %p\n", (void *)mm->pgd);
+        return -1; // Return -1 to indicate error.
+    }
+
+    // Step 2: Get the physical address from the low memory page.
+    uint32_t mm_pgd_phys_addr = get_physical_address_from_page(lowmem_page);
+    if (mm_pgd_phys_addr == 0) {
+        pr_crit("Failed to get physical address from low memory page: %p.\n", lowmem_page);
+        return -1; // Return -1 to indicate error.
+    }
 
-    if ((uint32_t)paging_get_current_directory() == get_physical_address_from_page(get_lowmem_page_from_address((uint32_t)mm->pgd))) {
-        paging_switch_directory_va(paging_get_main_directory());
+    // Compare the current page directory with the one associated with the process.
+    if (current_paging_dir == mm_pgd_phys_addr) {
+        // Switch to the main directory if they are the same.
+        if (paging_switch_directory_va(main_pgd) < 0) {
+            pr_crit("Failed to switch to the main directory.\n");
+            return -1; // Return -1 to indicate error.
+        }
     }
 
     // Free each segment inside mm.
     vm_area_struct_t *segment = NULL;
-    // Iterate the list.
+    // Iterate through the list of memory areas.
     list_head *it = mm->mmap_list.next, *next;
+
     while (!list_head_empty(it)) {
         segment = list_entry(it, vm_area_struct_t, vm_list);
+
         // Save the pointer to the next element in the list.
         next = segment->vm_list.next;
-        if (destroy_vm_area(mm, segment)) {
-            // Destroy the area.
-            kernel_panic("We failed to destroy the virtual memory area.");
+
+        // Destroy the current virtual memory area. Return -1 on failure.
+        if (destroy_vm_area(mm, segment) < 0) {
+            pr_err("We failed to destroy the virtual memory area.");
+            return -1; // Failed to destroy the virtual memory area.
         }
+
         // Move to the next element.
         it = next;
     }
 
-    // Free all the page tables
+    // Free all the page tables.
     for (int i = 0; i < 1024; i++) {
         page_dir_entry_t *entry = &mm->pgd->entries[i];
+        // Check if the page table entry is present and not global.
         if (entry->present && !entry->global) {
-            page_t *pgt_page  = get_page_from_physical_address(entry->frame * PAGE_SIZE);
-            uint32_t pgt_addr = get_lowmem_address_from_page(pgt_page);
+            // Get the physical page for the page table.
+            page_t *pgt_page = get_page_from_physical_address(entry->frame * PAGE_SIZE);
+            if (!pgt_page) {
+                pr_crit("Failed to get physical page for entry %d.\n", i);
+                continue; // Skip to the next entry on error.
+            }
+
+            // Get the low memory address for the page table.
+            uint32_t pgt_addr = get_virtual_address_from_page(pgt_page);
+            if (pgt_addr == 0) {
+                pr_crit("Failed to get low memory address for physical page %p.\n", (void *)pgt_page);
+                continue; // Skip to the next entry on error.
+            }
+
+            // Free the page table.
             kmem_cache_free((void *)pgt_addr);
+
+            pr_debug("Successfully freed page table for entry %d at address %p.\n", i, (void *)pgt_addr);
         }
     }
+
+    // Free the page directory structure.
     kmem_cache_free((void *)mm->pgd);
 
-    // Free the mm_struct.
+    // Free the memory structure representing the process image.
     kmem_cache_free(mm);
+
+    return 0; // Success.
 }
 
 void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
 {
     uintptr_t vm_start;
+
     // Get the current task.
     task_struct *task = scheduler_get_current_process();
-    // Check if we were asked for a specific spot.
+
+    // Check if a specific address was requested for the memory mapping.
     if (addr && is_valid_vm_area(task->mm, (uintptr_t)addr, (uintptr_t)addr + length)) {
+        // If the requested address is valid, use it as the starting address.
         vm_start = (uintptr_t)addr;
     } else {
-        // Find an empty spot.
+        // Find an empty spot if no specific address was provided or the provided one is invalid.
         if (find_free_vm_area(task->mm, length, &vm_start)) {
-            pr_err("We failed to find a suitable spot for a new virtual memory area.\n");
-            return NULL;
+            pr_err("Failed to find a suitable spot for a new virtual memory area.\n");
+            return NULL; // Return NULL to indicate failure in finding a suitable memory area.
         }
     }
-    // Allocate the segment.
+
+    // Allocate the virtual memory area segment.
     vm_area_struct_t *segment = create_vm_area(
         task->mm,
         vm_start,
         length,
         MM_PRESENT | MM_RW | MM_COW | MM_USER,
         GFP_HIGHUSER);
+    if (!segment) {
+        pr_err("Failed to allocate virtual memory area segment.\n");
+        return NULL; // Return NULL to indicate allocation failure.
+    }
+
+    // Set the memory flags for the mapping.
     task->mm->mmap_cache->vm_flags = flags;
+
+    // Return the starting address of the newly created memory segment.
     return (void *)segment->vm_start;
 }
 
@@ -821,23 +1449,42 @@ int sys_munmap(void *addr, size_t length)
 {
     // Get the current task.
     task_struct *task = scheduler_get_current_process();
-    // Get the stack.
-    vm_area_struct_t *segment;
-    //
-    unsigned vm_start = (uintptr_t)addr, size;
-    // Find the area.
+
+    // Initialize variables.
+    vm_area_struct_t *segment;           // The virtual memory area segment.
+    unsigned vm_start = (uintptr_t)addr; // Starting address of the memory area to unmap.
+    unsigned size;                       // Size of the segment.
+
+    // Iterate through the list of memory mapped areas in reverse order.
     list_for_each_prev_decl(it, &task->mm->mmap_list)
     {
         segment = list_entry(it, vm_area_struct_t, vm_list);
-        assert(segment && "There is a NULL area in the list.");
-        // Compute the size of the segment.
+
+        // Check if the segment is valid.
+        if (!segment) {
+            pr_crit("Found a NULL area in the mmap list.\n");
+            return -1; // Return -1 to indicate an error due to NULL segment.
+        }
+
+        // Compute the size of the current segment.
         size = segment->vm_end - segment->vm_start;
-        // Check the segment.
+
+        // Check if the requested address and length match the current segment.
         if ((vm_start == segment->vm_start) && (length == size)) {
-            pr_warning("[0x%p:0x%p] Found it, destroying it.\n", segment->vm_start, segment->vm_end);
-            destroy_vm_area(task->mm, segment);
-            return 0;
+            pr_debug("[0x%p:0x%p] Found it, destroying it.\n",
+                     (void *)segment->vm_start, (void *)segment->vm_end);
+
+            // Step 6: Destroy the found virtual memory area.
+            if (destroy_vm_area(task->mm, segment) < 0) {
+                pr_err("Failed to destroy the virtual memory area at [0x%p:0x%p].\n",
+                       (void *)segment->vm_start, (void *)segment->vm_end);
+                return -1; // Return -1 to indicate an error during destruction.
+            }
+
+            return 0; // Return 0 to indicate success.
         }
     }
-    return 1;
+
+    pr_err("No matching memory area found for unmapping at address 0x%p with length %zu.\n", addr, length);
+    return 1; // Return 1 to indicate no matching area found.
 }
diff --git a/mentos/src/mem/slab.c b/mentos/src/mem/slab.c
index 234f2ffb..8dbf7b7d 100644
--- a/mentos/src/mem/slab.c
+++ b/mentos/src/mem/slab.c
@@ -1,5 +1,8 @@
-/// @file mouse.h
-/// @brief  Driver for *PS2* Mouses.
+/// @file slab.c
+/// @brief Memory slab allocator implementation in kernel. This file provides
+/// functions for managing memory allocation using the slab allocator technique.
+/// Slab allocators are efficient in managing frequent small memory allocations
+/// with minimal fragmentation.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -14,101 +17,248 @@
 #include "mem/slab.h"
 #include "mem/zone_allocator.h"
 
-/// @brief Use it to manage cached pages.
+/// @brief Structure to represent an individual memory object within a slab.
+/// @details This structure is used to manage individual objects allocated from
+/// the slab. It contains a linked list to connect objects in the cache.
 typedef struct kmem_obj {
-    /// The list_head for this object.
+    /// @brief Linked list node for tracking objects in the slab.
     list_head objlist;
-} kmem_obj;
+} kmem_obj_t;
 
-/// Max order of kmalloc cache allocations, if greater raw page allocation is done.
+/// @brief Maximum order of kmalloc cache allocations.
+/// @details If a requested memory allocation exceeds this order, a raw page
+/// allocation is done instead of using the slab cache.
 #define MAX_KMALLOC_CACHE_ORDER 12
 
-#define KMEM_OBJ_OVERHEAD                    sizeof(kmem_obj)
-#define KMEM_START_OBJ_COUNT                 8
-#define KMEM_MAX_REFILL_OBJ_COUNT            64
-#define KMEM_OBJ(cachep, addr)               ((kmem_obj *)(addr))
-#define ADDR_FROM_KMEM_OBJ(cachep, kmem_obj) ((void *)(kmem_obj))
+/// @brief Overhead size for each memory object in the slab cache.
+/// @details This defines the extra space required for managing the object,
+/// including the `kmem_obj` structure itself.
+#define KMEM_OBJ_OVERHEAD sizeof(kmem_obj_t)
 
-// The list of caches.
+/// @brief Initial object count for each slab.
+/// @details The starting number of objects in a newly allocated slab cache.
+#define KMEM_START_OBJ_COUNT 8
+
+/// @brief Maximum number of objects to refill in a slab cache at once.
+/// @details This defines the upper limit on how many objects to replenish in
+/// the slab when it runs out of free objects.
+#define KMEM_MAX_REFILL_OBJ_COUNT 64
+
+/// @brief Macro to convert an address into a kmem_obj pointer.
+/// @param addr Address of the object.
+/// @return Pointer to a kmem_obj structure.
+#define KMEM_OBJ_FROM_ADDR(addr) ((kmem_obj_t *)(addr))
+
+/// @brief Macro to get the address from a kmem_obj structure.
+/// @param object Pointer to the kmem_obj structure.
+/// @return Address of the object as a `void *`.
+#define ADDR_FROM_KMEM_OBJ(object) ((void *)(object))
+
+/// @brief List of all active memory caches in the system.
 static list_head kmem_caches_list;
-// Cache where we will store the data about caches.
+
+/// @brief Cache used for managing metadata about the memory caches themselves.
 static kmem_cache_t kmem_cache;
-// Caches for each order of the malloc.
+
+/// @brief Array of slab caches for different orders of kmalloc.
 static kmem_cache_t *malloc_blocks[MAX_KMALLOC_CACHE_ORDER];
 
+/// @brief Allocates and initializes a new slab page for a memory cache.
+/// @param cachep Pointer to the memory cache (`kmem_cache_t`) for which a new
+/// slab page is being allocated.
+/// @param flags Allocation flags (e.g., GFP_KERNEL) passed to control memory
+/// allocation behavior.
+/// @return 0 on success, -1 on failure.
 static int __alloc_slab_page(kmem_cache_t *cachep, gfp_t flags)
 {
-    // ALlocate the required number of pages.
+    // Allocate the required number of pages for the slab based on cache's
+    // gfp_order. The higher the gfp_order, the more pages are allocated.
     page_t *page = _alloc_pages(flags, cachep->gfp_order);
+
+    // Check if page allocation failed.
     if (!page) {
         pr_crit("Failed to allocate a new page from slab.\n");
         return -1;
     }
-    // Initialize the lists.
-    list_head_init(&page->slabs);
-    list_head_init(&page->slab_freelist);
-    // Save in the root page the kmem_cache_t pointer, to allow freeing
-    // arbitrary pointers.
+
+    // Initialize the linked lists for the slab page.
+    // These lists track which objects in the page are free and which are in use.
+    list_head_init(&page->slabs);         // Initialize the list of slabs (active objects).
+    list_head_init(&page->slab_freelist); // Initialize the free list (unused objects).
+
+    // Save a reference to the `kmem_cache_t` structure in the root page.
+    // This is necessary for freeing arbitrary pointers and tracking cache ownership.
     page[0].container.slab_cache = cachep;
-    // Update slab main pages of all child pages, to allow reconstructing which
-    // page handles a specified address
+
+    // Update the slab main page pointer for all child pages (in case the allocation
+    // consists of multiple pages) to point back to the root page.
+    // This helps in reconstructing the main slab page when dealing with subpages.
     for (unsigned int i = 1; i < (1U << cachep->gfp_order); i++) {
-        page[i].container.slab_main_page = page;
+        page[i].container.slab_main_page = page; // Link child pages to the main page.
     }
-    // Compute the slab size.
+
+    // Calculate the total size of the slab (in bytes) by multiplying the page size
+    // by the number of pages allocated (determined by the cache's gfp_order).
     unsigned int slab_size = PAGE_SIZE * (1U << cachep->gfp_order);
-    // Update the page objects counters.
-    page->slab_objcnt  = slab_size / cachep->size;
-    page->slab_objfree = page->slab_objcnt;
-    // Get the page address.
-    unsigned int pg_addr = get_lowmem_address_from_page(page);
-    // Build the objects structures
+
+    // Update object counters for the page.
+    // The total number of objects in the slab is determined by the slab size
+    // divided by the size of each object in the cache.
+    page->slab_objcnt  = slab_size / cachep->size; // Total number of objects.
+    page->slab_objfree = page->slab_objcnt;        // Initially, all objects are free.
+
+    // Get the starting physical address of the allocated slab page.
+    unsigned int pg_addr = get_virtual_address_from_page(page);
+
+    // Check if `get_lowmem_address_from_page` failed.
+    if (!pg_addr) {
+        pr_crit("Failed to get low memory address for slab page.\n");
+        return -1;
+    }
+
+    // Loop through each object in the slab and initialize its kmem_obj structure.
+    // Each object is inserted into the free list, indicating that it is available.
     for (unsigned int i = 0; i < page->slab_objcnt; i++) {
-        kmem_obj *obj = KMEM_OBJ(cachep, pg_addr + cachep->size * i);
+        // Calculate the object's address by adding the offset (i * object size) to the page address.
+        kmem_obj_t *obj = KMEM_OBJ_FROM_ADDR(pg_addr + cachep->size * i);
+
+        // Insert the object into the slab's free list, making it available for allocation.
         list_head_insert_after(&obj->objlist, &page->slab_freelist);
     }
-    // Add the page to the slab list and update the counters
+
+    // Insert the page into the cache's list of free slab pages.
     list_head_insert_after(&page->slabs, &cachep->slabs_free);
-    cachep->total_num += page->slab_objcnt;
-    cachep->free_num += page->slab_objcnt;
+
+    // Update the cache's total object counters to reflect the new slab.
+    cachep->total_num += page->slab_objcnt; // Increase the total number of objects in the cache.
+    cachep->free_num += page->slab_objcnt;  // Increase the number of free objects.
+
     return 0;
 }
 
-static void __kmem_cache_refill(kmem_cache_t *cachep, unsigned int free_num, gfp_t flags)
+/// @brief Refills a memory cache with new slab pages to reach a specified number of free objects.
+/// @details This function allocates new slab pages as needed until the cache has at least `free_num` free objects.
+/// If a page allocation fails, the refill process is aborted.
+/// @param cachep Pointer to the memory cache (`kmem_cache_t`) that needs to be refilled.
+/// @param free_num The desired number of free objects in the cache.
+/// @param flags Allocation flags used for controlling memory allocation behavior (e.g., GFP_KERNEL).
+/// @return 0 on success, -1 on failure.
+static int __kmem_cache_refill(kmem_cache_t *cachep, unsigned int free_num, gfp_t flags)
 {
+    // Continue allocating slab pages until the cache has at least `free_num`
+    // free objects.
     while (cachep->free_num < free_num) {
+        // Attempt to allocate a new slab page. If allocation fails, print a
+        // warning and abort the refill process.
         if (__alloc_slab_page(cachep, flags) < 0) {
-            pr_warning("Cannot allocate a page, abort refill\n");
-            break;
+            pr_crit("Failed to allocate a new slab page, aborting refill\n");
+            return -1; // Return -1 if page allocation fails.
         }
     }
+    return 0;
 }
 
-static void __compute_size_and_order(kmem_cache_t *cachep)
+/// @brief Computes and sets the size and gfp order for a memory cache.
+/// @details This function adjusts the size of objects in the cache based on
+/// padding and alignment requirements, and calculates the `gfp_order` (number
+/// of contiguous pages) needed for slab allocations.
+/// @param cachep Pointer to the memory cache (`kmem_cache_t`) whose size and
+/// order are being computed.
+/// @return 0 on success, -1 on failure.
+static int __compute_size_and_order(kmem_cache_t *cachep)
 {
-    // Align the whole object to the required padding.
+    // Check for invalid or uninitialized object sizes or alignment.
+    // If `object_size` or `align` is zero, the cache cannot be correctly
+    // configured.
+    if (cachep->object_size == 0) {
+        pr_crit("Object size is invalid (0), cannot compute cache size and order.\n");
+        return -1;
+    }
+    if (cachep->align == 0) {
+        pr_crit("Alignment is invalid (0), cannot compute cache size and order.\n");
+        return -1;
+    }
+
+    // Align the object size to the required padding.
+    // The object size is padded based on either the `KMEM_OBJ_OVERHEAD` or the
+    // provided alignment requirement. Ensure that the object size is at least
+    // as large as the overhead and is aligned to the cache's alignment.
     cachep->size = round_up(
-        max(cachep->object_size, KMEM_OBJ_OVERHEAD),
-        max(8, cachep->align));
-    // Compute the gfp order
+        max(cachep->object_size, KMEM_OBJ_OVERHEAD), // Ensure object size is larger than the overhead.
+        max(8, cachep->align));                      // Ensure alignment is at least 8 bytes for proper memory alignment.
+
+    // Check if the computed size is valid.
+    if (cachep->size == 0) {
+        pr_crit("Computed object size is invalid (0), cannot proceed with cache allocation.\n");
+        return -1;
+    }
+
+    // Compute the `gfp_order` based on the total object size and page size.
+    // The `gfp_order` determines how many contiguous pages will be allocated
+    // for the slab.
     unsigned int size = round_up(cachep->size, PAGE_SIZE) / PAGE_SIZE;
+
+    // Reset `gfp_order` to 0 before calculating.
+    cachep->gfp_order = 0;
+
+    // Calculate the order by determining how many divisions by 2 the size
+    // undergoes until it becomes smaller than or equal to 1.
     while ((size /= 2) > 0) {
         cachep->gfp_order++;
     }
+
+    // Check for a valid `gfp_order`. Ensure that it's within reasonable limits.
+    if (cachep->gfp_order > MAX_BUDDYSYSTEM_GFP_ORDER) {
+        pr_crit("Calculated gfp_order exceeds system limits (%d).\n", MAX_BUDDYSYSTEM_GFP_ORDER);
+        cachep->gfp_order = MAX_BUDDYSYSTEM_GFP_ORDER;
+    }
+
+    // Additional consistency check (optional):
+    // Verify that the calculated gfp_order leads to a valid page allocation size.
+    if ((cachep->gfp_order == 0) && (cachep->size > PAGE_SIZE)) {
+        pr_crit("Calculated gfp_order is 0, but object size exceeds one page. Potential issue in size computation.\n");
+        return -1;
+    }
+    return 0;
 }
 
-static void __kmem_cache_create(
-    kmem_cache_t *cachep,
-    const char *name,
-    unsigned int size,
-    unsigned int align,
-    slab_flags_t flags,
-    kmem_fun_t ctor,
-    kmem_fun_t dtor,
-    unsigned int start_count)
+/// @brief Initializes and creates a new memory cache.
+/// @details This function sets up a new memory cache (`kmem_cache_t`) with the provided parameters such as
+/// object size, alignment, constructor/destructor functions, and flags. It also initializes slab lists,
+/// computes the appropriate size and order, refills the cache with objects, and adds it to the global cache list.
+/// @param cachep Pointer to the memory cache structure to initialize.
+/// @param name Name of the cache.
+/// @param size Size of the objects to be allocated from the cache.
+/// @param align Alignment requirement for the objects.
+/// @param flags Slab allocation flags.
+/// @param ctor Constructor function to initialize objects (optional, can be NULL).
+/// @param dtor Destructor function to clean up objects (optional, can be NULL).
+/// @param start_count Initial number of objects to populate in the cache.
+/// @return 0 on success, -1 on failure.
+static int __kmem_cache_create(
+    kmem_cache_t *cachep,     // Pointer to the cache structure to be created.
+    const char *name,         // Name of the cache.
+    unsigned int size,        // Size of the objects in the cache.
+    unsigned int align,       // Object alignment.
+    slab_flags_t flags,       // Allocation flags.
+    kmem_fun_t ctor,          // Constructor function for cache objects.
+    kmem_fun_t dtor,          // Destructor function for cache objects.
+    unsigned int start_count) // Initial number of objects to populate in the cache.
 {
+    // Log the creation of a new cache.
     pr_info("Creating new cache `%s` with objects of size `%d`.\n", name, size);
 
+    // Input validation checks.
+    if (!cachep) {
+        pr_crit("Invalid cache pointer (NULL), cannot create cache.\n");
+        return -1;
+    }
+    if (!name || size == 0) {
+        pr_crit("Invalid cache name or object size (size = %d).\n", size);
+        return -1;
+    }
+
+    // Set up the basic properties of the cache.
     *cachep = (kmem_cache_t){
         .name        = name,
         .object_size = size,
@@ -118,77 +268,142 @@ static void __kmem_cache_create(
         .dtor        = dtor
     };
 
+    // Initialize the list heads for free, partial, and full slabs.
     list_head_init(&cachep->slabs_free);
     list_head_init(&cachep->slabs_partial);
     list_head_init(&cachep->slabs_full);
 
+    // Compute the object size and gfp_order for slab allocations.
+    // If there's an issue with size or order computation, this function should handle it internally.
     __compute_size_and_order(cachep);
 
+    // Refill the cache with `start_count` objects.
+    // If the refill fails (due to slab page allocation failure), a warning is logged.
     __kmem_cache_refill(cachep, start_count, flags);
 
+    // Insert the cache into the global list of caches.
+    // No error check needed here as list operations usually don't fail.
     list_head_insert_after(&cachep->cache_list, &kmem_caches_list);
+
+    return 0;
 }
 
+/// @brief Allocates an object from a specified slab page.
+/// @details This function retrieves a free object from the given slab page's free list.
+/// It decrements the count of free objects in both the slab page and the cache.
+/// If the constructor function is defined, it will be called to initialize the object.
+/// @param cachep Pointer to the cache from which the object is being allocated.
+/// @param slab_page Pointer to the slab page from which to allocate the object.
+/// @return Pointer to the allocated object, or NULL if allocation fails.
 static inline void *__kmem_cache_alloc_slab(kmem_cache_t *cachep, page_t *slab_page)
 {
+    // Retrieve and remove the first element from the slab's free list.
     list_head *elem_listp = list_head_pop(&slab_page->slab_freelist);
+
+    // Check if the free list is empty.
     if (!elem_listp) {
-        pr_warning("There are no FREE element inside the slab_freelist\n");
-        return NULL;
+        pr_crit("There are no FREE elements inside the slab_freelist\n");
+        return NULL; // Return NULL if no free elements are available.
     }
+
+    // Decrement the count of free objects in the slab page and the cache.
     slab_page->slab_objfree--;
     cachep->free_num--;
 
-    kmem_obj *obj = list_entry(elem_listp, kmem_obj, objlist);
+    // Get the kmem object from the list entry.
+    kmem_obj_t *object = list_entry(elem_listp, kmem_obj_t, objlist);
 
-    // Get the element from the kmem_obj object
-    void *elem = ADDR_FROM_KMEM_OBJ(cachep, obj);
+    // Check if the kmem object pointer is valid.
+    if (!object) {
+        pr_crit("The kmem object is invalid\n");
+        return NULL;
+    }
+
+    // Get the address of the allocated element from the kmem object.
+    void *elem = ADDR_FROM_KMEM_OBJ(object);
 
+    // Call the constructor function if it is defined to initialize the object.
     if (cachep->ctor) {
         cachep->ctor(elem);
     }
 
-    return elem;
+    return elem; // Return the pointer to the allocated object.
 }
 
-static inline void __kmem_cache_free_slab(kmem_cache_t *cachep, page_t *slab_page)
+/// @brief Frees a slab page and updates the associated cache statistics.
+/// @details This function updates the total and free object counts in the cache
+/// and resets the slab page's metadata to indicate that it is no longer in use.
+/// It also frees the memory associated with the slab page.
+/// @param cachep Pointer to the cache from which the slab page is being freed.
+/// @param slab_page Pointer to the slab page to be freed.
+/// @return Returns 0 on success, or -1 if an error occurs.
+static inline int __kmem_cache_free_slab(kmem_cache_t *cachep, page_t *slab_page)
 {
+    // Validate input parameters.
+    if (!cachep || !slab_page) {
+        pr_crit("Invalid cache or slab_page pointer (NULL).\n");
+        return -1; // Return error if either pointer is NULL.
+    }
+
+    // Update the free and total object counts in the cache.
     cachep->free_num -= slab_page->slab_objfree;
     cachep->total_num -= slab_page->slab_objcnt;
-    // Clear objcnt, used as a flag to check if the page belongs to the slab
+
+    // Clear the object count and reset the main page pointer as a flag to
+    // indicate the page is no longer active.
     slab_page->slab_objcnt              = 0;
     slab_page->container.slab_main_page = NULL;
 
-    // Reset all non-root slab pages
+    // Reset the main page pointers for all non-root slab pages. This loop
+    // assumes the first page is the root and resets pointers for child pages.
     for (unsigned int i = 1; i < (1U << cachep->gfp_order); i++) {
+        // Clear main page pointer for each child page.
         (slab_page + i)->container.slab_main_page = NULL;
     }
 
+    // Free the memory associated with the slab page.
     __free_pages(slab_page);
+
+    return 0; // Return success.
 }
 
-void kmem_cache_init(void)
+int kmem_cache_init(void)
 {
-    // Initialize the list of caches.
+    // Initialize the list of caches to keep track of all memory caches.
     list_head_init(&kmem_caches_list);
-    // Create a cache to store the data about caches.
-    __kmem_cache_create(
-        &kmem_cache,
-        "kmem_cache_t",
-        sizeof(kmem_cache_t),
-        alignof(kmem_cache_t),
-        GFP_KERNEL,
-        NULL,
-        NULL, 32);
+
+    // Create a cache to store metadata about kmem_cache_t structures.
+    if (__kmem_cache_create(
+            &kmem_cache,
+            "kmem_cache_t",
+            sizeof(kmem_cache_t),
+            alignof(kmem_cache_t),
+            GFP_KERNEL,
+            NULL,
+            NULL,
+            32) < 0) {
+        pr_crit("Failed to create kmem_cache for kmem_cache_t.\n");
+        return -1; // Early exit if kmem_cache creation fails.
+    }
+
+    // Create caches for different order sizes for kmalloc allocations.
     for (unsigned int i = 0; i < MAX_KMALLOC_CACHE_ORDER; i++) {
         malloc_blocks[i] = kmem_cache_create(
             "kmalloc",
-            1u << i,
-            1u << i,
+            1u << i, // Size of the allocation (2^i).
+            1u << i, // Alignment of the allocation.
             GFP_KERNEL,
-            NULL,
-            NULL);
+            NULL,  // Constructor (none).
+            NULL); // Destructor (none).
+
+        // Check if the cache was created successfully.
+        if (!malloc_blocks[i]) {
+            pr_crit("Failed to create kmalloc cache for order %u.\n", i);
+            return -1; // Early exit if kmem_cache creation fails.
+        }
     }
+
+    return 0; // Return success.
 }
 
 kmem_cache_t *kmem_cache_create(
@@ -199,35 +414,58 @@ kmem_cache_t *kmem_cache_create(
     kmem_fun_t ctor,
     kmem_fun_t dtor)
 {
+    // Allocate memory for a new kmem_cache_t structure.
     kmem_cache_t *cachep = (kmem_cache_t *)kmem_cache_alloc(&kmem_cache, GFP_KERNEL);
+
+    // Check if memory allocation for the cache failed.
     if (!cachep) {
-        return cachep;
+        pr_crit("Failed to allocate memory for kmem_cache_t.\n");
+        return NULL; // Return NULL to indicate failure.
     }
 
-    __kmem_cache_create(cachep, name, size, align, flags, ctor, dtor, KMEM_START_OBJ_COUNT);
+    // Initialize the kmem_cache_t structure.
+    if (__kmem_cache_create(cachep, name, size, align, flags, ctor, dtor, KMEM_START_OBJ_COUNT) < 0) {
+        pr_crit("Failed to initialize kmem_cache for '%s'.\n", name);
+        // Free allocated memory if initialization fails.
+        kmem_cache_free(cachep);
+        return NULL; // Return NULL to indicate failure.
+    }
 
-    return cachep;
+    return cachep; // Return the pointer to the newly created cache.
 }
 
-void kmem_cache_destroy(kmem_cache_t *cachep)
+int kmem_cache_destroy(kmem_cache_t *cachep)
 {
+    // Validate input parameter.
+    if (!cachep) {
+        pr_crit("Cannot destroy a NULL cache pointer.\n");
+        return -1; // Early exit if cache pointer is NULL.
+    }
+
+    // Free all slabs in the free list.
     while (!list_head_empty(&cachep->slabs_free)) {
         list_head *slab_list = list_head_pop(&cachep->slabs_free);
         __kmem_cache_free_slab(cachep, list_entry(slab_list, page_t, slabs));
     }
 
+    // Free all slabs in the partial list.
     while (!list_head_empty(&cachep->slabs_partial)) {
         list_head *slab_list = list_head_pop(&cachep->slabs_partial);
         __kmem_cache_free_slab(cachep, list_entry(slab_list, page_t, slabs));
     }
 
+    // Free all slabs in the full list.
     while (!list_head_empty(&cachep->slabs_full)) {
         list_head *slab_list = list_head_pop(&cachep->slabs_full);
         __kmem_cache_free_slab(cachep, list_entry(slab_list, page_t, slabs));
     }
 
+    // Free the cache structure itself.
     kmem_cache_free(cachep);
+    // Remove the cache from the global cache list.
     list_head_remove(&cachep->cache_list);
+
+    return 0; // Return success.
 }
 
 #ifdef ENABLE_CACHE_TRACE
@@ -236,39 +474,63 @@ void *pr_kmem_cache_alloc(const char *file, const char *fun, int line, kmem_cach
 void *kmem_cache_alloc(kmem_cache_t *cachep, gfp_t flags)
 #endif
 {
+    // Check if there are any partially filled slabs.
     if (list_head_empty(&cachep->slabs_partial)) {
+        // If no partial slabs, check for free slabs.
         if (list_head_empty(&cachep->slabs_free)) {
+            // If no flags are specified, use the cache's flags.
             if (flags == 0) {
                 flags = cachep->flags;
             }
-
-            // Refill the cache in an exponential fashion, capping at KMEM_MAX_REFILL_OBJ_COUNT to avoid
-            // too big allocations
-            __kmem_cache_refill(cachep, min(cachep->total_num, KMEM_MAX_REFILL_OBJ_COUNT), flags);
+            // Attempt to refill the cache, limiting the number of objects.
+            if (__kmem_cache_refill(cachep, min(cachep->total_num, KMEM_MAX_REFILL_OBJ_COUNT), flags) < 0) {
+                pr_crit("Failed to refill cache in `%s`\n", cachep->name);
+                return NULL; // Return NULL to indicate failure.
+            }
+            // If still no free slabs, log an error and return NULL.
             if (list_head_empty(&cachep->slabs_free)) {
                 pr_crit("Cannot allocate more slabs in `%s`\n", cachep->name);
-                return NULL;
+                return NULL; // Return NULL to indicate failure.
             }
         }
 
-        // Add a free slab to partial list because in any case an element will
-        // be removed before the function returns
+        // Move a free slab to the partial list since we're about to allocate from it.
         list_head *free_slab = list_head_pop(&cachep->slabs_free);
+        if (!free_slab) {
+            pr_crit("We retrieved an invalid slab from the free list.");
+            return NULL; // Return NULL to indicate failure.
+        }
         list_head_insert_after(free_slab, &cachep->slabs_partial);
     }
 
+    // Retrieve the slab page from the partial list.
     page_t *slab_page = list_entry(cachep->slabs_partial.next, page_t, slabs);
-    void *ptr         = __kmem_cache_alloc_slab(cachep, slab_page);
+    if (!slab_page) {
+        pr_crit("We retrieved an invalid slab from the partial list.");
+        return NULL; // Return NULL to indicate failure.
+    }
 
-    // If the slab is now full, add it to the full slabs list
+    // Allocate an object from the slab page.
+    void *ptr = __kmem_cache_alloc_slab(cachep, slab_page);
+    if (!ptr) {
+        pr_crit("We failed to allocate a slab.");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // If the slab is now full, move it to the full slabs list.
     if (slab_page->slab_objfree == 0) {
         list_head *slab_full_elem = list_head_pop(&cachep->slabs_partial);
+        if (!slab_full_elem) {
+            pr_crit("We retrieved an invalid slab from the partial list.");
+            return NULL; // Return NULL to indicate failure.
+        }
         list_head_insert_after(slab_full_elem, &cachep->slabs_full);
     }
+
 #ifdef ENABLE_CACHE_TRACE
-    pr_notice("CHACE-ALLOC 0x%p in %-20s at %s:%d\n", ptr, cachep->name, file, line);
+    pr_notice("CACHE-ALLOC 0x%p in %-20s at %s:%d\n", ptr, cachep->name, file, line);
 #endif
-    return ptr;
+    return ptr; // Return pointer to the allocated object.
 }
 
 #ifdef ENABLE_CACHE_TRACE
@@ -277,41 +539,45 @@ void pr_kmem_cache_free(const char *file, const char *fun, int line, void *ptr)
 void kmem_cache_free(void *ptr)
 #endif
 {
-    page_t *slab_page = get_lowmem_page_from_address((uint32_t)ptr);
+    // Get the slab page corresponding to the given pointer.
+    page_t *slab_page = get_page_from_virtual_address((uint32_t)ptr);
 
-    // If the slab main page is a lowmem page, change to it as it's the root page
+    // If the slab main page is a low memory page, update to the root page.
     if (is_lowmem_page_struct(slab_page->container.slab_main_page)) {
         slab_page = slab_page->container.slab_main_page;
     }
 
+    // Retrieve the cache pointer from the slab page.
     kmem_cache_t *cachep = slab_page->container.slab_cache;
 
 #ifdef ENABLE_CACHE_TRACE
-    pr_notice("CHACE-FREE  0x%p in %-20s at %s:%d\n", ptr, cachep->name, file, line);
+    pr_notice("CACHE-FREE  0x%p in %-20s at %s:%d\n", ptr, cachep->name, file, line);
 #endif
+    // Call the destructor if defined.
     if (cachep->dtor) {
         cachep->dtor(ptr);
     }
 
-    kmem_obj *obj = KMEM_OBJ(cachep, ptr);
+    // Get the kmem_obj from the pointer.
+    kmem_obj_t *obj = KMEM_OBJ_FROM_ADDR(ptr);
 
-    // Add object to the free list
+    // Add object to the free list of the slab.
     list_head_insert_after(&obj->objlist, &slab_page->slab_freelist);
     slab_page->slab_objfree++;
     cachep->free_num++;
 
-    // Now page is completely free
+    // If the slab is completely free, move it to the free list.
     if (slab_page->slab_objfree == slab_page->slab_objcnt) {
-        // Remove page from partial list
+        // Remove the page from the partial list.
         list_head_remove(&slab_page->slabs);
-        // Add page to free list
+        // Add the page to the free list.
         list_head_insert_after(&slab_page->slabs, &cachep->slabs_free);
     }
-    // Now page is not full, so change its list
+    // If the page is not full, update its list status.
     else if (slab_page->slab_objfree == 1) {
-        // Remove page from full list
+        // Remove the page from the full list.
         list_head_remove(&slab_page->slabs);
-        // Add page to partial list
+        // Add the page to the partial list.
         list_head_insert_after(&slab_page->slabs, &cachep->slabs_partial);
     }
 }
@@ -323,22 +589,25 @@ void *kmalloc(unsigned int size)
 #endif
 {
     unsigned int order = 0;
+
+    // Determine the order based on the size requested.
     while (size != 0) {
         order++;
         size /= 2;
     }
 
-    // If size does not fit in the maximum cache order, allocate raw pages
+    // Allocate memory. If size exceeds the maximum cache order, allocate raw pages.
     void *ptr;
     if (order >= MAX_KMALLOC_CACHE_ORDER) {
         ptr = (void *)__alloc_pages_lowmem(GFP_KERNEL, order - 12);
     } else {
         ptr = kmem_cache_alloc(malloc_blocks[order], GFP_KERNEL);
     }
+
 #ifdef ENABLE_ALLOC_TRACE
     pr_notice("KMALLOC 0x%p at %s:%d\n", ptr, file, line);
 #endif
-    return ptr;
+    return ptr; // Return pointer to the allocated memory.
 }
 
 #ifdef ENABLE_ALLOC_TRACE
@@ -350,12 +619,14 @@ void kfree(void *ptr)
 #ifdef ENABLE_ALLOC_TRACE
     pr_notice("KFREE   0x%p at %s:%d\n", ptr, file, line);
 #endif
-    page_t *page = get_lowmem_page_from_address((uint32_t)ptr);
+    // Get the slab page from the pointer's address.
+    page_t *page = get_page_from_virtual_address((uint32_t)ptr);
 
-    // If the address is part of the cache
+    // If the address belongs to a cache, free it using kmem_cache_free.
     if (page->container.slab_main_page) {
         kmem_cache_free(ptr);
     } else {
+        // Otherwise, free the raw pages.
         free_pages_lowmem((uint32_t)ptr);
     }
 }
diff --git a/mentos/src/mem/vmem_map.c b/mentos/src/mem/vmem_map.c
index ed427614..f71de53c 100644
--- a/mentos/src/mem/vmem_map.c
+++ b/mentos/src/mem/vmem_map.c
@@ -16,20 +16,24 @@
 /// Virtual addresses manager.
 static virt_map_page_manager_t virt_default_mapping;
 
-/// TODO: check.
+/// Number of virtual memory pages.
 #define VIRTUAL_MEMORY_PAGES_COUNT (VIRTUAL_MEMORY_SIZE_MB * 256)
-/// TODO: check.
+
+/// Base address for virtual memory mapping.
 #define VIRTUAL_MAPPING_BASE (PROCAREA_END_ADDR + 0x38000000)
-/// TODO: check.
-#define VIRT_PAGE_TO_ADDRESS(page) ((((page)-virt_pages) * PAGE_SIZE) + VIRTUAL_MAPPING_BASE)
-/// TODO: check.
-#define VIRT_ADDRESS_TO_PAGE(addr) ((((addr)-VIRTUAL_MAPPING_BASE) / PAGE_SIZE) + virt_pages)
+
+/// Converts a virtual page to its address.
+#define VIRT_PAGE_TO_ADDRESS(page) ((((page) - virt_pages) * PAGE_SIZE) + VIRTUAL_MAPPING_BASE)
+
+/// Converts an address to its corresponding virtual page.
+#define VIRT_ADDRESS_TO_PAGE(addr) ((((addr) - VIRTUAL_MAPPING_BASE) / PAGE_SIZE) + virt_pages)
 
 /// Array of virtual pages.
 virt_map_page_t virt_pages[VIRTUAL_MEMORY_PAGES_COUNT];
 
-void virt_init(void)
+int virt_init(void)
 {
+    // Initialize the buddy system for virtual memory management.
     buddy_system_init(
         &virt_default_mapping.bb_instance,
         "virt_manager",
@@ -38,44 +42,73 @@ void virt_init(void)
         sizeof(virt_map_page_t),
         VIRTUAL_MEMORY_PAGES_COUNT);
 
-    page_directory_t *mainpgd = paging_get_main_directory();
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return -1; // Return -1 to indicate failure.
+    }
 
+    // Calculate the starting page frame number, page table, and table index.
     uint32_t start_virt_pfn     = VIRTUAL_MAPPING_BASE / PAGE_SIZE;
     uint32_t start_virt_pgt     = start_virt_pfn / 1024;
     uint32_t start_virt_tbl_idx = start_virt_pfn % 1024;
 
     uint32_t pfn_num = VIRTUAL_MEMORY_PAGES_COUNT;
 
-    // Alloc all page tables inside the main directory, so they will be shared across
-    // all page directories of processes
+    // Allocate all page tables inside the main directory, so they will be
+    // shared across all page directories of processes.
+    page_dir_entry_t *entry;
+    page_table_t *table;
     for (uint32_t i = start_virt_pgt; i < 1024 && (pfn_num > 0); i++) {
-        page_dir_entry_t *entry = mainpgd->entries + i;
-
-        page_table_t *table;
-
-        // Alloc virtual page table
-        entry->present   = 1;
-        entry->rw        = 0;
-        entry->global    = 1;
-        entry->user      = 0;
-        entry->accessed  = 0;
-        entry->available = 1;
-        table            = kmem_cache_alloc(pgtbl_cache, GFP_KERNEL);
+        // Get the page directory entry.
+        entry = main_pgd->entries + i;
+
+        // Alloc virtual page table.
+        entry->present   = 1; // Mark the entry as present
+        entry->rw        = 0; // Read-only
+        entry->global    = 1; // Global page
+        entry->user      = 0; // Kernel mode
+        entry->accessed  = 0; // Not accessed
+        entry->available = 1; // Available for system use
+
+        // Allocate a new page table.
+        table = kmem_cache_alloc(pgtbl_cache, GFP_KERNEL);
+        // Error handling: failed to allocate page table.
+        if (!table) {
+            pr_crit("Failed to allocate page table\n");
+            return -1;
+        }
 
+        // Determine the starting page index.
         uint32_t start_page = (i == start_virt_pgt) ? start_virt_tbl_idx : 0;
 
+        // Initialize the pages in the table.
         for (uint32_t j = start_page; j < 1024 && (pfn_num > 0); j++, pfn_num--) {
-            table->pages[j].frame   = 0;
-            table->pages[j].rw      = 0;
-            table->pages[j].present = 0;
-            table->pages[j].global  = 1;
-            table->pages[j].user    = 0;
+            table->pages[j].frame   = 0; // No frame allocated
+            table->pages[j].rw      = 0; // Read-only
+            table->pages[j].present = 0; // Not present
+            table->pages[j].global  = 1; // Global page
+            table->pages[j].user    = 0; // Kernel mode
+        }
+
+        // Get the physical address of the allocated page table.
+        page_t *table_page = get_page_from_virtual_address((uint32_t)table);
+        // Error handling: failed to get low memory page from address.
+        if (!table_page) {
+            pr_crit("Failed to get low memory page from address\n");
+            return -1;
         }
 
-        page_t *table_page = get_lowmem_page_from_address((uint32_t)table);
-        uint32_t phy_addr  = get_physical_address_from_page(table_page);
-        entry->frame       = phy_addr >> 12u;
+        // Get the physical address.
+        uint32_t phy_addr = get_physical_address_from_page(table_page);
+
+        // Set the frame address in the page directory entry.
+        entry->frame = phy_addr >> 12u;
     }
+
+    return 0; // Return success.
 }
 
 /// @brief Allocates a virtual page, given the page frame count.
@@ -83,44 +116,107 @@ void virt_init(void)
 /// @return pointer to the virtual page.
 static virt_map_page_t *_alloc_virt_pages(uint32_t pfn_count)
 {
-    unsigned order         = find_nearest_order_greater(0, pfn_count << 12);
-    virt_map_page_t *vpage = PG_FROM_BBSTRUCT(bb_alloc_pages(&virt_default_mapping.bb_instance, order), virt_map_page_t, bbpage);
-    return vpage;
+    // Find the nearest order greater than or equal to the page frame count.
+    unsigned order = find_nearest_order_greater(0, pfn_count << 12);
+
+    // Allocate pages from the buddy system.
+    bb_page_t *bbpage = bb_alloc_pages(&virt_default_mapping.bb_instance, order);
+    // Error handling: failed to allocate pages from the buddy system.
+    if (!bbpage) {
+        pr_crit("Failed to allocate pages from the buddy system\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Convert the buddy system page to a virtual map page.
+    virt_map_page_t *vpage = PG_FROM_BBSTRUCT(bbpage, virt_map_page_t, bbpage);
+    // Error handling: failed to convert from buddy system page to virtual map page.
+    if (!vpage) {
+        pr_emerg("Failed to convert from buddy system page to virtual map page.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    return vpage; // Return the allocated virtual page.
 }
 
 uint32_t virt_map_physical_pages(page_t *page, int pfn_count)
 {
+    // Allocate virtual pages for the given page frame count.
     virt_map_page_t *vpage = _alloc_virt_pages(pfn_count);
+    // Error handling: failed to allocate virtual pages.
     if (!vpage) {
-        return 0;
+        pr_crit("Failed to allocate virtual pages\n");
+        return 0; // Return 0 to indicate failure.
     }
 
+    // Convert the virtual page to its corresponding virtual address.
     uint32_t virt_address = VIRT_PAGE_TO_ADDRESS(vpage);
-    uint32_t phy_address  = get_physical_address_from_page(page);
 
-    mem_upd_vm_area(paging_get_main_directory(), virt_address, phy_address,
-                    pfn_count * PAGE_SIZE, MM_PRESENT | MM_RW | MM_GLOBAL | MM_UPDADDR);
-    return virt_address;
+    // Get the physical address of the given page.
+    uint32_t phy_address = get_physical_address_from_page(page);
+
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Update the virtual memory area with the new mapping.
+    mem_upd_vm_area(
+        main_pgd, virt_address,
+        phy_address,
+        pfn_count * PAGE_SIZE,
+        MM_PRESENT | MM_RW | MM_GLOBAL | MM_UPDADDR);
+
+    return virt_address; // Return the virtual address of the mapped pages.
 }
 
 virt_map_page_t *virt_map_alloc(uint32_t size)
 {
+    // Calculate the number of pages required to cover the given size.
     uint32_t pages_count = (size + PAGE_SIZE - 1) / PAGE_SIZE;
-    return _alloc_virt_pages(pages_count);
+
+    // Allocate the required number of virtual pages.
+    virt_map_page_t *vpages = _alloc_virt_pages(pages_count);
+    // Error handling: failed to allocate virtual pages.
+    if (!vpages) {
+        pr_crit("Failed to allocate virtual pages for size %u\n", size);
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    return vpages; // Return the pointer to the allocated virtual pages.
 }
 
 uint32_t virt_map_vaddress(mm_struct_t *mm, virt_map_page_t *vpage, uint32_t vaddr, uint32_t size)
 {
+    // Error handling: ensure the memory management structure and page directory are valid.
+    if (!mm || !mm->pgd) {
+        pr_crit("Invalid memory management structure or page directory\n");
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Convert the virtual map page to its corresponding virtual address.
     uint32_t start_map_virt_address = VIRT_PAGE_TO_ADDRESS(vpage);
 
-    // Clone the source vaddr the the requested virtual memory portion
-    mem_clone_vm_area(mm->pgd,
-                      paging_get_main_directory(),
-                      vaddr,
-                      start_map_virt_address,
-                      size,
-                      MM_PRESENT | MM_RW | MM_GLOBAL | MM_UPDADDR);
-    return start_map_virt_address;
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Clone the source vaddr the the requested virtual memory portion.
+    mem_clone_vm_area(
+        mm->pgd,
+        main_pgd,
+        vaddr,
+        start_map_virt_address,
+        size,
+        MM_PRESENT | MM_RW | MM_GLOBAL | MM_UPDADDR);
+
+    return start_map_virt_address; // Return the starting virtual address of the mapped area.
 }
 
 int virtual_check_address(uint32_t addr)
@@ -128,55 +224,93 @@ int virtual_check_address(uint32_t addr)
     return addr >= VIRTUAL_MAPPING_BASE; // && addr < VIRTUAL_MAPPING_BASE + VIRTUAL_MEMORY_PAGES_COUNT * PAGE_SIZE;
 }
 
-void virt_unmap(uint32_t addr)
+int virt_unmap(uint32_t addr)
 {
+    // Convert the virtual address to its corresponding virtual map page.
     virt_map_page_t *page = VIRT_ADDRESS_TO_PAGE(addr);
+    // Error handling: ensure the page is valid.
+    if (!page) {
+        pr_crit("Failed to convert address %u to virtual map page\n", addr);
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Unmap the virtual map page.
     virt_unmap_pg(page);
+
+    return 0; // Return success.
 }
 
-void virt_unmap_pg(virt_map_page_t *page)
+int virt_unmap_pg(virt_map_page_t *page)
 {
+    // Error handling: ensure the page is valid.
+    if (!page) {
+        pr_crit("Invalid virtual map page\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Convert the virtual map page to its corresponding virtual address.
     uint32_t addr = VIRT_PAGE_TO_ADDRESS(page);
 
-    // Set all virtual pages as not present
-    mem_upd_vm_area(paging_get_main_directory(), addr, 0,
-                    (1 << page->bbpage.order) * PAGE_SIZE, MM_GLOBAL);
+    // Get the main page directory.
+    page_directory_t *main_pgd = paging_get_main_directory();
+    // Error handling: Failed to get the main page directory.
+    if (!main_pgd) {
+        pr_crit("Failed to get the main page directory\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Set all virtual pages as not present to avoid unwanted memory accesses by the kernel.
+    mem_upd_vm_area(main_pgd, addr, 0, (1 << page->bbpage.order) * PAGE_SIZE, MM_GLOBAL);
 
-    // and avoiding unwanted memory accesses by the kernel
+    // Free the pages in the buddy system.
     bb_free_pages(&virt_default_mapping.bb_instance, &page->bbpage);
+
+    return 0; // Return success.
 }
 
 // FIXME: Check if this function should support unaligned page-boundaries copy
 void virt_memcpy(mm_struct_t *dst_mm, uint32_t dst_vaddr, mm_struct_t *src_mm, uint32_t src_vaddr, uint32_t size)
 {
+    // Buffer size for copying.
     const uint32_t VMEM_BUFFER_SIZE = 65536;
 
+    // Determine the buffer size to use for copying.
     uint32_t buffer_size = min(VMEM_BUFFER_SIZE, size);
 
+    // Allocate virtual pages for the source and destination.
     virt_map_page_t *src_vpage = virt_map_alloc(size);
     virt_map_page_t *dst_vpage = virt_map_alloc(size);
 
+    // Error handling: ensure both source and destination virtual pages are allocated.
     if (!src_vpage || !dst_vpage) {
         kernel_panic("Cannot copy virtual memory address, unable to reserve vmem!");
     }
 
+    // Loop to copy memory in chunks.
     for (;;) {
+        // Map the source and destination virtual addresses to the allocated
+        // virtual pages.
         uint32_t src_map = virt_map_vaddress(src_mm, src_vpage, src_vaddr, buffer_size);
         uint32_t dst_map = virt_map_vaddress(dst_mm, dst_vpage, dst_vaddr, buffer_size);
 
+        // Determine the size to copy in this iteration.
         uint32_t cpy_size = min(buffer_size, size);
 
+        // Perform the memory copy.
         memcpy((void *)dst_map, (void *)src_map, cpy_size);
 
+        // Check if the entire size has been copied.
         if (size <= buffer_size) {
             break;
         }
 
+        // Update the remaining size and addresses for the next iteration.
         size -= cpy_size;
         src_vaddr += cpy_size;
         dst_vaddr += cpy_size;
     }
 
+    // Unmap the allocated virtual pages.
     virt_unmap_pg(src_vpage);
     virt_unmap_pg(dst_vpage);
 }
diff --git a/mentos/src/mem/zone_allocator.c b/mentos/src/mem/zone_allocator.c
index 61a3ddbe..7ba8b063 100644
--- a/mentos/src/mem/zone_allocator.c
+++ b/mentos/src/mem/zone_allocator.c
@@ -17,110 +17,301 @@
 #include "string.h"
 #include "sys/list_head.h"
 
-/// TODO: Comment.
+/// @brief Aligns the given address down to the nearest page boundary.
+/// @param addr The address to align.
+/// @return The aligned address.
 #define MIN_PAGE_ALIGN(addr) ((addr) & (~(PAGE_SIZE - 1)))
-/// TODO: Comment.
+
+/// @brief Aligns the given address up to the nearest page boundary.
+/// @param addr The address to align.
+/// @return The aligned address.
 #define MAX_PAGE_ALIGN(addr) (((addr) & (~(PAGE_SIZE - 1))) + PAGE_SIZE)
-/// TODO: Comment.
+
+/// @brief Aligns the given address down to the nearest order boundary.
+/// @param addr The address to align.
+/// @return The aligned address.
 #define MIN_ORDER_ALIGN(addr) ((addr) & (~((PAGE_SIZE << (MAX_BUDDYSYSTEM_GFP_ORDER - 1)) - 1)))
-/// TODO: Comment.
+
+/// @brief Aligns the given address up to the nearest order boundary.
+/// @param addr The address to align.
+/// @return The aligned address.
 #define MAX_ORDER_ALIGN(addr)                                             \
     (((addr) & (~((PAGE_SIZE << (MAX_BUDDYSYSTEM_GFP_ORDER - 1)) - 1))) + \
      (PAGE_SIZE << (MAX_BUDDYSYSTEM_GFP_ORDER - 1)))
 
-/// Array of all physical blocks
+/// @brief Array of all physical memory blocks (pages).
+/// @details This variable points to an array of `page_t` structures
+/// representing all physical memory blocks (pages) in the system. It is used to
+/// track the state of each page in memory.
 page_t *mem_map = NULL;
-/// Memory node.
+
+/// @brief Memory node descriptor for contiguous memory.
+/// @details This variable points to the `pg_data_t` structure, which represents
+/// a memory node (usually for NUMA systems). It typically describes the memory
+/// properties and zones for a contiguous block of physical memory.
 pg_data_t *contig_page_data = NULL;
-/// Low memory virtual base address.
+
+/// @brief Virtual base address of the low memory (lowmem) zone.
+/// @details This variable stores the base virtual address of the low memory
+/// region. The kernel uses this address to access low memory (directly
+/// addressable memory).
 uint32_t lowmem_virt_base = 0;
-/// Low memory base address.
+
+/// @brief Physical base address of the low memory (lowmem) zone.
+/// @details This variable stores the base physical address of the low memory
+/// region. It represents the starting point of the lowmem pages in physical
+/// memory.
 uint32_t lowmem_page_base = 0;
 
-page_t *get_lowmem_page_from_address(uint32_t addr)
+/// @brief Physical start address of low memory (lowmem) zone.
+/// @details This variable stores the physical address where the low memory
+/// (which is directly addressable by the kernel) begins.
+uint32_t lowmem_phy_start;
+
+/// @brief Virtual start address of low memory (lowmem) zone.
+/// @details This variable stores the virtual address corresponding to the start
+/// of the low memory region in the kernel's virtual address space.
+uint32_t lowmem_virt_start;
+
+/// @brief Total size of available physical memory in bytes.
+/// @details This variable holds the total amount of memory available on the
+/// system (both low and high memory).
+uint32_t mem_size;
+
+/// @brief Total number of memory frames (pages) available.
+/// @details The number of physical memory frames available in the system,
+/// calculated as the total memory divided by the size of a memory page.
+uint32_t mem_map_num;
+
+/// @brief Start address of the normal (lowmem) zone.
+/// @details This variable holds the starting physical address of the normal
+/// memory zone, also known as low memory, which is directly addressable by the
+/// kernel.
+uint32_t normal_start_addr;
+
+/// @brief End address of the normal (lowmem) zone.
+/// @details This variable holds the ending physical address of the normal
+/// memory zone (low memory), marking the boundary between lowmem and highmem.
+uint32_t normal_end_addr;
+
+/// @brief Total size of the normal (lowmem) zone.
+/// @details The size of the normal memory zone in bytes, which is the portion
+/// of memory directly addressable by the kernel.
+uint32_t normal_size;
+
+/// @brief Start address of the high memory (highmem) zone.
+/// @details This variable stores the starting physical address of the high
+/// memory zone, which is memory not directly addressable by the kernel and
+/// requires special handling.
+uint32_t high_start_addr;
+
+/// @brief End address of the high memory (highmem) zone.
+/// @details This variable holds the ending physical address of the high memory
+/// zone, which marks the limit of available physical memory.
+uint32_t high_end_addr;
+
+/// @brief Total size of the high memory (highmem) zone.
+/// @details The size of the high memory zone in bytes. High memory requires
+/// special handling as it is not directly accessible by the kernel's virtual
+/// address space.
+uint32_t high_size;
+
+uint32_t get_virtual_address_from_page(page_t *page)
 {
-    unsigned int offset = addr - lowmem_virt_base;
-    return mem_map + lowmem_page_base + (offset / PAGE_SIZE);
+    // Check for NULL page pointer. If it is NULL, print an error and return 0.
+    if (!page) {
+        pr_err("Invalid page pointer: NULL value provided.\n");
+        return 0; // Return 0 to indicate an error in retrieving the address.
+    }
+
+    // Calculate the index of the page in the memory map.
+    unsigned int page_index = page - mem_map;
+
+    // Check if the calculated page index is within valid bounds.
+    if ((page_index < lowmem_page_base) || (page_index >= mem_map_num)) {
+        pr_err("Page index %u is out of bounds. Valid range: %u to %u.\n",
+               page_index, lowmem_page_base, mem_map_num - 1);
+        return 0;
+    }
+
+    // Calculate the offset from the low memory base address.
+    unsigned int offset = page_index - lowmem_page_base;
+
+    // Return the corresponding low memory virtual address.
+    return lowmem_virt_base + (offset * PAGE_SIZE);
 }
 
-uint32_t get_lowmem_address_from_page(page_t *page)
+uint32_t get_physical_address_from_page(page_t *page)
 {
-    unsigned int offset = (page - mem_map) - lowmem_page_base;
-    return lowmem_virt_base + offset * PAGE_SIZE;
+    // Ensure the page pointer is not NULL. If it is NULL, print an error and return 0.
+    if (!page) {
+        pr_err("Invalid page pointer: NULL value provided.\n");
+        return 0; // Return 0 to indicate an error in retrieving the address.
+    }
+
+    // Calculate the index of the page in the memory map.
+    unsigned int page_index = page - mem_map;
+
+    // Check if the calculated page index is within valid bounds.
+    if ((page_index < lowmem_page_base) || (page_index >= mem_map_num)) {
+        pr_err("Page index %u is out of bounds. Valid range: %u to %u.\n",
+               page_index, lowmem_page_base, mem_map_num - 1);
+        return 0;
+    }
+
+    // Return the corresponding physical address by multiplying the index by the
+    // page size.
+    return page_index * PAGE_SIZE;
 }
 
-uint32_t get_physical_address_from_page(page_t *page)
+page_t *get_page_from_virtual_address(uint32_t vaddr)
 {
-    return (page - mem_map) * PAGE_SIZE;
+    // Ensure the address is within the valid range.
+    if (vaddr < lowmem_virt_base) {
+        pr_crit("Address is below low memory virtual base.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Calculate the offset from the low memory virtual base address.
+    unsigned int offset = vaddr - lowmem_virt_base;
+
+    // Determine the index of the corresponding page structure in the memory map.
+    unsigned int page_index = lowmem_page_base + (offset / PAGE_SIZE);
+
+    // Check if the page index exceeds the memory map limit.
+    if (page_index >= mem_map_num) {
+        pr_crit("Page index %u is out of bounds. Maximum allowed index is %u.\n",
+                page_index, mem_map_num - 1);
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Return the pointer to the page structure.
+    return mem_map + page_index;
 }
 
 page_t *get_page_from_physical_address(uint32_t phy_addr)
 {
-    return mem_map + (phy_addr / PAGE_SIZE);
+    // Ensure the physical address is valid and aligned to page boundaries.
+    if (phy_addr % PAGE_SIZE != 0) {
+        pr_crit("Address must be page-aligned. Received address: 0x%08x\n", phy_addr);
+        return NULL; // Return NULL to indicate failure due to misalignment.
+    }
+
+    // Calculate the index of the page in the memory map.
+    unsigned int page_index = phy_addr / PAGE_SIZE;
+
+    // Check if the calculated page index is within valid bounds.
+    if ((page_index < lowmem_page_base) || (page_index >= mem_map_num)) {
+        pr_err("Page index %u is out of bounds. Valid range: %u to %u.\n",
+               page_index, lowmem_page_base, mem_map_num - 1);
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Return the pointer to the corresponding page structure in the memory map.
+    return mem_map + page_index;
 }
 
 /// @brief Get the zone that contains a page frame.
-/// @param page A page descriptor.
-/// @return The zone requested.
+/// @param page A pointer to the page descriptor.
+/// @return A pointer to the zone containing the page, or NULL if the page is
+/// not within any zone.
 static zone_t *get_zone_from_page(page_t *page)
 {
-    zone_t *zone;
-    page_t *last_page;
-    // Iterate over all the zones.
+    // Validate the input parameter.
+    if (!page) {
+        pr_crit("Invalid input: page is NULL.\n");
+        return NULL; // Return NULL to indicate failure due to NULL input.
+    }
+
+    // Iterate over all the zones in the contiguous page data structure.
     for (int zone_index = 0; zone_index < contig_page_data->nr_zones; zone_index++) {
         // Get the zone at the given index.
-        zone = contig_page_data->node_zones + zone_index;
-        assert(zone && "Failed to retrieve the zone.");
-        // Get the last page of the zone.
-        last_page = zone->zone_mem_map + zone->size;
-        assert(last_page && "Failed to retrieve the last page of the zone.");
-        // Check if the page is before the last page of the zone.
-        if (page < last_page) {
-            return zone;
+        zone_t *zone = contig_page_data->node_zones + zone_index;
+
+        // Get the first and last page of the zone by adding the zone size to
+        // the base of the memory map.
+        page_t *first_page = zone->zone_mem_map;
+        page_t *last_page  = zone->zone_mem_map + zone->size;
+
+        // Check if the given page is within the current zone.
+        if ((page >= first_page) && (page < last_page)) {
+            return zone; // Return the zone if the page is within its range.
         }
     }
-    // Error: page is over memory size.
-    return (zone_t *)NULL;
+
+    pr_crit("page is over memory size or not part of any zone.");
+
+    // If no zone contains the page, return NULL.
+    return NULL;
 }
 
-/// @brief Get a zone from gfp_mask
-/// @param gfp_mask GFP_FLAG see gfp.h.
-/// @return The zone requested.
+/// @brief Get a zone from the specified GFP mask.
+/// @param gfp_mask GFP flags indicating the type of memory allocation request.
+/// @return A pointer to the requested zone, or NULL if the gfp_mask is not
+/// recognized.
 static zone_t *get_zone_from_flags(gfp_t gfp_mask)
 {
+    // Ensure that contig_page_data is initialized and valid.
+    if (!contig_page_data) {
+        pr_crit("contig_page_data is NULL.\n");
+        return NULL; // Return NULL to indicate failure due to uninitialized data.
+    }
+
+    // Determine the appropriate zone based on the given GFP mask.
     switch (gfp_mask) {
     case GFP_KERNEL:
     case GFP_ATOMIC:
     case GFP_NOFS:
     case GFP_NOIO:
     case GFP_NOWAIT:
+        // Return the normal zone for these GFP flags.
         return &contig_page_data->node_zones[ZONE_NORMAL];
+
     case GFP_HIGHUSER:
+        // Return the high memory zone for GFP_HIGHUSER.
         return &contig_page_data->node_zones[ZONE_HIGHMEM];
+
     default:
-        return (zone_t *)NULL;
+        // If the gfp_mask does not match any recognized flags, log an error and return NULL.
+        pr_crit("Unrecognized gfp_mask: %u.\n", gfp_mask);
+        return NULL; // Return NULL to indicate that the input was not valid.
     }
 }
 
-/// @brief Checks if the memory is clean.
-/// @param gfp_mask the mask which specifies the zone we are interested in.
-/// @return 1 if clean, 0 on error.
+/// @brief Checks if the specified memory zone is clean (i.e., all pages are free).
+/// @param gfp_mask The mask that specifies the zone of interest for memory allocation.
+/// @return 1 if the memory is clean, 0 if there is an error or if the memory is not clean.
 static int is_memory_clean(gfp_t gfp_mask)
 {
-    // Get the corresponding zone.
+    // Get the corresponding zone based on the gfp_mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    assert(zone && "Failed to retrieve the zone given the gfp_mask!");
+    if (!zone) {
+        pr_crit("Failed to retrieve the zone for gfp_mask: %u.\n", gfp_mask);
+        return 0; // Return 0 to indicate an error due to invalid zone.
+    }
+
     // Get the last free area list of the buddy system.
     bb_free_area_t *area = zone->buddy_system.free_area + (MAX_BUDDYSYSTEM_GFP_ORDER - 1);
-    assert(area && "Failed to retrieve the last free_area for the given zone!");
+    if (!area) {
+        pr_crit("Failed to retrieve the last free_area for the zone.\n");
+        return 0; // Return 0 to indicate an error due to invalid area.
+    }
+
     // Compute the total size of the zone.
     unsigned int total_size = (zone->size / (1UL << (MAX_BUDDYSYSTEM_GFP_ORDER - 1)));
-    // Check if the size of the zone is equal to the remaining pages inside the free area.
+
+    // Check if the size of the zone matches the number of free pages in the area.
     if (area->nr_free != total_size) {
         pr_crit("Number of blocks of free pages is different than expected (%d vs %d).\n", area->nr_free, total_size);
+
+        // Dump the current state of the buddy system for debugging purposes.
         buddy_system_dump(&zone->buddy_system);
+
+        // Return 0 to indicate an error.
         return 0;
     }
+
+    // Return 1 if the memory is clean (i.e., the sizes match).
     return 1;
 }
 
@@ -206,40 +397,78 @@ static int pmm_check(void)
     return 1;
 }
 
-/// @brief Initializes the memory attributes.
-/// @param name       Zone's name.
-/// @param zone_index Zone's index.
-/// @param adr_from   the lowest address of the zone
-/// @param adr_to     the highest address of the zone (not included!)
-static void zone_init(char *name, int zone_index, uint32_t adr_from, uint32_t adr_to)
+/// @brief Initializes the memory attributes for a specified zone.
+/// @param name The zone's name.
+/// @param zone_index The zone's index, which must be valid within the number of zones.
+/// @param adr_from The lowest address of the zone (inclusive).
+/// @param adr_to The highest address of the zone (exclusive).
+/// @return 0 on success, -1 on error.
+static int zone_init(char *name, int zone_index, uint32_t adr_from, uint32_t adr_to)
 {
-    assert((adr_from < adr_to) && "Inserted bad block addresses!");
-    assert(((adr_from & 0xfffff000) == adr_from) && "Inserted bad block addresses!");
-    assert(((adr_to & 0xfffff000) == adr_to) && "Inserted bad block addresses!");
-    assert((zone_index < contig_page_data->nr_zones) && "The index is above the number of zones.");
-    // Take the zone_t structure that correspondes to the zone_index.
+    // Ensure that the provided addresses are valid: adr_from must be less than adr_to.
+    if (adr_from >= adr_to) {
+        pr_crit("Invalid block addresses: adr_from (%u) must be less than adr_to (%u).\n", adr_from, adr_to);
+        return -1; // Return -1 to indicate an error.
+    }
+
+    // Ensure that adr_from is page-aligned.
+    if ((adr_from & 0xfffff000) != adr_from) {
+        pr_crit("adr_from (%u) must be page-aligned.\n", adr_from);
+        return -1; // Return -1 to indicate an error.
+    }
+
+    // Ensure that adr_to is page-aligned.
+    if ((adr_to & 0xfffff000) != adr_to) {
+        pr_crit("adr_to (%u) must be page-aligned.\n", adr_to);
+        return -1; // Return -1 to indicate an error.
+    }
+
+    // Ensure that the zone_index is within the valid range.
+    if ((zone_index < 0) || (zone_index >= contig_page_data->nr_zones)) {
+        pr_crit("The zone_index (%d) is out of bounds (max: %d).\n",
+                zone_index, contig_page_data->nr_zones - 1);
+        return -1; // Return -1 to indicate an error.
+    }
+
+    // Take the zone_t structure that corresponds to the zone_index.
     zone_t *zone = contig_page_data->node_zones + zone_index;
-    assert(zone && "Failed to retrieve the zone.");
-    // Number of page frames in the zone.
+
+    // Ensure that the zone was retrieved successfully.
+    if (!zone) {
+        pr_crit("Failed to retrieve the zone for zone_index: %d.\n", zone_index);
+        return -1; // Return -1 to indicate an error.
+    }
+
+    // Calculate the number of page frames in the zone.
     size_t num_page_frames = (adr_to - adr_from) / PAGE_SIZE;
-    // Index of the first page frame of the zone.
+
+    // Calculate the index of the first page frame of the zone.
     uint32_t first_page_frame = adr_from / PAGE_SIZE;
-    // Update zone info.
-    zone->name           = name;
-    zone->size           = num_page_frames;
-    zone->free_pages     = num_page_frames;
-    zone->zone_mem_map   = mem_map + first_page_frame;
-    zone->zone_start_pfn = first_page_frame;
-    // Set to zero all page structures.
+
+    // Update zone information.
+    zone->name           = name;                       // Set the zone's name.
+    zone->size           = num_page_frames;            // Set the total number of page frames.
+    zone->free_pages     = num_page_frames;            // Initialize free pages to the total number.
+    zone->zone_mem_map   = mem_map + first_page_frame; // Map the memory for the zone.
+    zone->zone_start_pfn = first_page_frame;           // Set the starting page frame number.
+
+    // Clear the page structures in the memory map.
     memset(zone->zone_mem_map, 0, zone->size * sizeof(page_t));
+
     // Initialize the buddy system for the new zone.
-    buddy_system_init(&zone->buddy_system,
-                      name,
-                      zone->zone_mem_map,
-                      BBSTRUCT_OFFSET(page_t, bbpage),
-                      sizeof(page_t),
-                      num_page_frames);
+    buddy_system_init(
+        &zone->buddy_system,             // Buddy system structure for the zone.
+        name,                            // Name of the zone.
+        zone->zone_mem_map,              // Pointer to the memory map of the zone.
+        BBSTRUCT_OFFSET(page_t, bbpage), // Offset for the buddy system structure.
+        sizeof(page_t),                  // Size of each page.
+        num_page_frames                  // Total number of page frames in the zone.
+    );
+
+    // Dump the current state of the buddy system for debugging purposes.
     buddy_system_dump(&zone->buddy_system);
+
+    return 0;
 }
 
 /*
@@ -250,25 +479,30 @@ static void zone_init(char *name, int zone_index, uint32_t adr_from, uint32_t ad
 
 unsigned int find_nearest_order_greater(uint32_t base_addr, uint32_t amount)
 {
+    // Calculate the starting page frame number (PFN) based on the base address.
     uint32_t start_pfn = base_addr / PAGE_SIZE;
-    uint32_t end_pfn   = (base_addr + amount + PAGE_SIZE - 1) / PAGE_SIZE;
-    // Get the number of pages.
+
+    // Calculate the ending page frame number (PFN) based on the base address and amount.
+    uint32_t end_pfn = (base_addr + amount + PAGE_SIZE - 1) / PAGE_SIZE;
+
+    // Ensure that the number of pages is positive.
+    assert(end_pfn > start_pfn && "Calculated number of pages must be greater than zero.");
+
+    // Calculate the number of pages required.
     uint32_t npages = end_pfn - start_pfn;
-    // Find the fitting order.
+
+    // Find the fitting order (power of two) that can accommodate the required
+    // number of pages.
     unsigned int order = 0;
     while ((1UL << order) < npages) {
         ++order;
     }
-    return order;
+
+    return order; // Return the calculated order.
 }
 
 int pmmngr_init(boot_info_t *boot_info)
 {
-    uint32_t lowmem_phy_start, lowmem_virt_start;
-    uint32_t mem_size, mem_num_frames;
-    uint32_t normal_start_addr, normal_end_addr, normal_size;
-    uint32_t high_start_addr, high_end_addr, high_size;
-
     //=======================================================================
     lowmem_phy_start = boot_info->lowmem_phy_start;
     // Now we have skipped all modules in physical space, is time to consider
@@ -282,15 +516,15 @@ int pmmngr_init(boot_info_t *boot_info)
     // Compute the size of memory.
     mem_size = boot_info->highmem_phy_end;
     // Total number of blocks (all lowmem+highmem RAM).
-    mem_num_frames = mem_size / PAGE_SIZE;
+    mem_map_num = mem_size / PAGE_SIZE;
     // Initialize each page_t.
-    for (unsigned i = 0; i < mem_num_frames; ++i) {
+    for (unsigned i = 0; i < mem_map_num; ++i) {
         // Mark page as free.
         set_page_count(&mem_map[i], 0);
     }
     // Skip memory space used for page_t[]
-    lowmem_phy_start += sizeof(page_t) * mem_num_frames;
-    lowmem_virt_start += sizeof(page_t) * mem_num_frames;
+    lowmem_phy_start += sizeof(page_t) * mem_map_num;
+    lowmem_virt_start += sizeof(page_t) * mem_map_num;
     //=======================================================================
 
     //==== Initialize contig_page_data node =================================
@@ -305,7 +539,7 @@ int pmmngr_init(boot_info_t *boot_info)
     // In UMA we have only one node.
     contig_page_data->node_next = NULL;
     // All the memory.
-    contig_page_data->node_size = mem_num_frames;
+    contig_page_data->node_size = mem_map_num;
     // mem_map[0].
     contig_page_data->node_start_mapnr = 0;
     // The first physical page.
@@ -344,10 +578,10 @@ int pmmngr_init(boot_info_t *boot_info)
     pr_debug("    LowMem  (phy): 0x%p to 0x%p\n", boot_info->lowmem_phy_start, boot_info->lowmem_phy_end);
     pr_debug("    HighMem (phy): 0x%p to 0x%p\n", boot_info->highmem_phy_start, boot_info->highmem_phy_end);
     pr_debug("    LowMem  (vrt): 0x%p to 0x%p\n", boot_info->lowmem_start, boot_info->lowmem_end);
-    pr_debug("Memory map  size      : %s\n", to_human_size(sizeof(page_t) * mem_num_frames));
+    pr_debug("Memory map  size      : %s\n", to_human_size(sizeof(page_t) * mem_map_num));
     pr_debug("Memory size           : %s\n", to_human_size(mem_size));
     pr_debug("Page size             : %s\n", to_human_size(PAGE_SIZE));
-    pr_debug("Number of page frames : %u\n", mem_num_frames);
+    pr_debug("Number of page frames : %u\n", mem_map_num);
     for (unsigned i = 0; i < __MAX_NR_ZONES; ++i) {
         zone_t *zone = &contig_page_data->node_zones[i];
         pr_debug("Zone %9s, first page: 0x%p, last page: 0x%p, # pages: %6d\n",
@@ -361,121 +595,267 @@ int pmmngr_init(boot_info_t *boot_info)
 
 page_t *alloc_page_cached(gfp_t gfp_mask)
 {
+    // Get the zone corresponding to the given GFP mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    return PG_FROM_BBSTRUCT(bb_alloc_page_cached(&zone->buddy_system), page_t, bbpage);
+
+    // Ensure the zone is valid.
+    if (!zone) {
+        pr_crit("Failed to get zone from GFP mask.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Allocate a page from the buddy system of the zone.
+    bb_page_t *bbpage = bb_alloc_page_cached(&zone->buddy_system);
+
+    // Ensure the allocation was successful.
+    if (!bbpage) {
+        pr_crit("Failed to allocate page from buddy system.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Convert the buddy system page structure to the page_t structure.
+    return PG_FROM_BBSTRUCT(bbpage, page_t, bbpage);
 }
 
-void free_page_cached(page_t *page)
+int free_page_cached(page_t *page)
 {
+    // Ensure the page pointer is not NULL.
+    if (!page) {
+        pr_crit("Invalid page pointer: NULL.\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Get the zone that contains the given page.
     zone_t *zone = get_zone_from_page(page);
+
+    // Ensure the zone is valid.
+    if (!zone) {
+        pr_crit("Failed to get zone from page.\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Free the page from the buddy system of the zone.
     bb_free_page_cached(&zone->buddy_system, &page->bbpage);
+
+    return 0; // Return success.
 }
 
 uint32_t __alloc_page_lowmem(gfp_t gfp_mask)
 {
-    return get_lowmem_address_from_page(alloc_page_cached(gfp_mask));
+    // Allocate a cached page based on the given GFP mask.
+    page_t *page = alloc_page_cached(gfp_mask);
+
+    // Ensure the page allocation was successful.
+    if (!page) {
+        pr_crit("Failed to allocate low memory page.\n");
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Get the low memory address from the allocated page.
+    return get_virtual_address_from_page(page);
 }
 
-void free_page_lowmem(uint32_t addr)
+int free_page_lowmem(uint32_t addr)
 {
-    page_t *page = get_lowmem_page_from_address(addr);
+    // Get the page corresponding to the given low memory address.
+    page_t *page = get_page_from_virtual_address(addr);
+
+    // Ensure the page retrieval was successful.
+    if (!page) {
+        pr_crit("Failed to retrieve page from address: 0x%x\n", addr);
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Free the cached page.
     free_page_cached(page);
+
+    return 0; // Return success.
 }
 
 uint32_t __alloc_pages_lowmem(gfp_t gfp_mask, uint32_t order)
 {
-    assert((order <= (MAX_BUDDYSYSTEM_GFP_ORDER - 1)) && gfp_mask == GFP_KERNEL && "Order is exceeding limit.");
+    // Ensure the order is within the valid range.
+    if (order >= MAX_BUDDYSYSTEM_GFP_ORDER) {
+        pr_emerg("Order exceeds the maximum limit.\n");
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Ensure the GFP mask is correct.
+    if (gfp_mask != GFP_KERNEL) {
+        pr_emerg("Invalid GFP mask. Expected GFP_KERNEL.\n");
+        return 0; // Return 0 to indicate failure.
+    }
 
+    // Allocate the pages based on the given GFP mask and order.
     page_t *page = _alloc_pages(gfp_mask, order);
 
-    // Get the index of the first page frame of the block.
-    uint32_t block_frame_adr = get_lowmem_address_from_page(page);
-    if (block_frame_adr == -1) {
-        pr_emerg("MEM. REQUEST FAILED");
+    // Ensure the page allocation was successful.
+    if (!page) {
+        pr_emerg("Page allocation failed.\n");
+        return 0; // Return 0 to indicate failure.
     }
-#if 0
-    else {
-        pr_debug("BS-G: addr: %p (page: %p order: %d)\n", block_frame_adr, page, order);
+
+    // Get the low memory address of the first page in the allocated block.
+    uint32_t block_frame_adr = get_virtual_address_from_page(page);
+
+    // Ensure the address retrieval was successful.
+    if (block_frame_adr == (uint32_t)-1) {
+        pr_emerg("Failed to get low memory address from page.\n");
+        return 0; // Return 0 to indicate failure.
     }
+#if 0
+    pr_debug("BS-G: addr: %p (page: %p order: %d)\n", block_frame_adr, page, order);
 #endif
+
+    // Return the low memory address of the first page in the allocated block.
     return block_frame_adr;
 }
 
 page_t *_alloc_pages(gfp_t gfp_mask, uint32_t order)
 {
+    // Calculate the block size based on the order.
     uint32_t block_size = 1UL << order;
 
+    // Get the zone corresponding to the given GFP mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    page_t *page = NULL;
 
-    // Search for a block of page frames by using the BuddySystem.
-    page = PG_FROM_BBSTRUCT(bb_alloc_pages(&zone->buddy_system, order), page_t, bbpage);
+    // Ensure the zone is valid.
+    if (!zone) {
+        pr_emerg("Failed to get zone from GFP mask.\n");
+        return NULL; // Return NULL to indicate failure.
+    }
+
+    // Allocate a page from the buddy system of the zone.
+    bb_page_t *bbpage = bb_alloc_pages(&zone->buddy_system, order);
 
-    // Set page counters
-    for (int i = 0; i < block_size; i++) {
-        set_page_count(&page[i], 1);
+    // Ensure the allocation was successful.
+    if (!bbpage) {
+        pr_crit("Failed to allocate page from buddy system.\n");
+        return NULL; // Return NULL to indicate failure.
     }
 
-    assert(page && "Cannot allocate pages.");
+    // Convert the buddy system page structure to the page_t structure.
+    page_t *page = PG_FROM_BBSTRUCT(bbpage, page_t, bbpage);
 
-    // Decrement the number of pages in the zone.
-    if (page) {
-        zone->free_pages -= block_size;
+    // Ensure the page allocation was successful.
+    if (!page) {
+        pr_emerg("Page allocation failed.\n");
+        return NULL; // Return NULL to indicate failure.
     }
 
+    // Set page counters for each page in the block.
+    for (uint32_t i = 0; i < block_size; i++) {
+        set_page_count(&page[i], 1);
+    }
+
+    // Decrement the number of free pages in the zone.
+    zone->free_pages -= block_size;
+
 #if 0
     pr_warning("BS-A: (page: %p order: %d)\n", page, order);
 #endif
+
+    // Return the pointer to the first page in the allocated block.
     return page;
 }
 
-void free_pages_lowmem(uint32_t addr)
+int free_pages_lowmem(uint32_t addr)
 {
-    page_t *page = get_lowmem_page_from_address(addr);
-    assert(page && "Page is over memory size.");
+    // Get the page corresponding to the given low memory address.
+    page_t *page = get_page_from_virtual_address(addr);
+
+    // Ensure the page retrieval was successful.
+    if (!page) {
+        pr_emerg("Failed to retrieve page from address: 0x%x. Page is over memory size.\n", addr);
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Free the pages starting from the given page.
     __free_pages(page);
+
+    return 0; // Return success.
 }
 
-void __free_pages(page_t *page)
+int __free_pages(page_t *page)
 {
+    // Get the zone that contains the given page.
     zone_t *zone = get_zone_from_page(page);
-    assert(zone && "Page is over memory size.");
 
-    assert(zone->zone_mem_map <= page && "Page is below the selected zone!");
+    // Ensure the zone retrieval was successful.
+    if (!zone) {
+        pr_emerg("Failed to get zone from page. Page is over memory size.\n");
+        return -1; // Return -1 to indicate failure.
+    }
+
+    // Ensure the page is within the selected zone.
+    if (zone->zone_mem_map > page) {
+        pr_emerg("Page is below the selected zone!\n");
+        return -1; // Return -1 to indicate failure.
+    }
 
+    // Get the order and block size of the page.
     uint32_t order      = page->bbpage.order;
     uint32_t block_size = 1UL << order;
 
-    for (int i = 0; i < block_size; i++) {
+    // Set page counters to 0 for each page in the block.
+    for (uint32_t i = 0; i < block_size; i++) {
         set_page_count(&page[i], 0);
     }
 
+    // Free the pages in the buddy system.
     bb_free_pages(&zone->buddy_system, &page->bbpage);
 
+    // Increment the number of free pages in the zone.
     zone->free_pages += block_size;
+
 #if 0
     pr_warning("BS-F: (page: %p order: %d)\n", page, order);
 #endif
-    //buddy_system_dump(&zone->buddy_system);
+
+    return 0; // Return success.
 }
 
 unsigned long get_zone_total_space(gfp_t gfp_mask)
 {
+    // Get the zone corresponding to the given GFP mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    assert(zone && "Cannot retrieve the correct zone.");
+
+    // Ensure the zone retrieval was successful.
+    if (!zone) {
+        pr_emerg("Cannot retrieve the correct zone for GFP mask: 0x%x.\n", gfp_mask);
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Return the total space of the zone.
     return buddy_system_get_total_space(&zone->buddy_system);
 }
 
 unsigned long get_zone_free_space(gfp_t gfp_mask)
 {
+    // Get the zone corresponding to the given GFP mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    assert(zone && "Cannot retrieve the correct zone.");
+
+    // Ensure the zone retrieval was successful.
+    if (!zone) {
+        pr_emerg("Cannot retrieve the correct zone for GFP mask: 0x%x.\n", gfp_mask);
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Return the free space of the zone.
     return buddy_system_get_free_space(&zone->buddy_system);
 }
 
 unsigned long get_zone_cached_space(gfp_t gfp_mask)
 {
+    // Get the zone corresponding to the given GFP mask.
     zone_t *zone = get_zone_from_flags(gfp_mask);
-    assert(zone && "Cannot retrieve the correct zone.");
+
+    // Ensure the zone retrieval was successful.
+    if (!zone) {
+        pr_emerg("Cannot retrieve the correct zone for GFP mask: 0x%x.\n", gfp_mask);
+        return 0; // Return 0 to indicate failure.
+    }
+
+    // Return the cached space of the zone.
     return buddy_system_get_cached_space(&zone->buddy_system);
 }
diff --git a/mentos/src/process/process.c b/mentos/src/process/process.c
index be9f408c..caf9d1a0 100644
--- a/mentos/src/process/process.c
+++ b/mentos/src/process/process.c
@@ -25,6 +25,7 @@
 #include "system/panic.h"
 #include "fs/vfs.h"
 #include "fs/namei.h"
+#include "sys/unistd.h"
 
 /// Cache for creating the task structs.
 static kmem_cache_t *task_struct_cache;
@@ -351,25 +352,25 @@ task_struct *process_create_init(const char *path)
     assert((init_proc->max_fd > 3) && "File descriptor list cannot contain the standard IOs.");
 
     // Create STDIN descriptor.
-    vfs_file_t *stdin = vfs_open("/proc/video", O_RDONLY, 0);
-    stdin->count++;
-    init_proc->fd_list[STDIN_FILENO].file_struct = stdin;
+    vfs_file_t *vfs_stdin = vfs_open("/proc/video", O_RDONLY, 0);
+    vfs_stdin->count++;
+    init_proc->fd_list[STDIN_FILENO].file_struct = vfs_stdin;
     init_proc->fd_list[STDIN_FILENO].flags_mask  = O_RDONLY;
-    pr_debug("`/proc/video` stdin  : %p\n", stdin);
+    pr_debug("`/proc/video` stdin  : %p\n", vfs_stdin);
 
     // Create STDOUT descriptor.
-    vfs_file_t *stdout = vfs_open("/proc/video", O_WRONLY, 0);
-    stdout->count++;
-    init_proc->fd_list[STDOUT_FILENO].file_struct = stdout;
+    vfs_file_t *vfs_stdout = vfs_open("/proc/video", O_WRONLY, 0);
+    vfs_stdout->count++;
+    init_proc->fd_list[STDOUT_FILENO].file_struct = vfs_stdout;
     init_proc->fd_list[STDOUT_FILENO].flags_mask  = O_WRONLY;
-    pr_debug("`/proc/video` stdout : %p\n", stdout);
+    pr_debug("`/proc/video` stdout : %p\n", vfs_stdout);
 
     // Create STDERR descriptor.
-    vfs_file_t *stderr = vfs_open("/proc/video", O_WRONLY, 0);
-    stderr->count++;
-    init_proc->fd_list[STDERR_FILENO].file_struct = stderr;
+    vfs_file_t *vfs_stderr = vfs_open("/proc/video", O_WRONLY, 0);
+    vfs_stderr->count++;
+    init_proc->fd_list[STDERR_FILENO].file_struct = vfs_stderr;
     init_proc->fd_list[STDERR_FILENO].flags_mask  = O_WRONLY;
-    pr_debug("`/proc/video` stderr : %p\n", stderr);
+    pr_debug("`/proc/video` stderr : %p\n", vfs_stderr);
     // ------------------------------------------------------------------------
 
     // == INITIALIZE TASK MEMORY ==============================================
diff --git a/programs/login.c b/programs/login.c
index a72c9134..1858125c 100644
--- a/programs/login.c
+++ b/programs/login.c
@@ -3,7 +3,14 @@
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
+// Setup the logging for this file (do this before any other include).
+#include "sys/kernel_levels.h"          // Include kernel log levels.
+#define __DEBUG_HEADER__ "[LOGIN ]"     ///< Change header.
+#define __DEBUG_LEVEL__  LOGLEVEL_DEBUG ///< Set log level.
+#include "io/debug.h"                   // Include debugging functions.
+
 #include <string.h>
+#include <ctype.h>
 #include <stdbool.h>
 #include <sys/unistd.h>
 #include <fcntl.h>
@@ -15,7 +22,6 @@
 #include <shadow.h>
 #include <strerror.h>
 #include <stdlib.h>
-#include <io/debug.h>
 #include <io/ansi_colors.h>
 
 #include <sys/mman.h>
@@ -26,170 +32,205 @@
 /// Maximum length of credentials.
 #define CREDENTIALS_LENGTH 50
 
-static inline int __setup_env(passwd_t *pwd)
-{
-    // Set the USER.
-    if (setenv("USER", pwd->pw_name, 1) == -1) {
-        printf("Failed to set env: `USER`\n");
-        return 0;
-    }
-    // Set the SHELL.
-    if (setenv("SHELL", pwd->pw_shell, 1) == -1) {
-        printf("Failed to set env: `SHELL`\n");
-        return 0;
-    }
-    // Set the HOME.
-    if (setenv("HOME", pwd->pw_dir, 1) == -1) {
-        printf("Failed to set env: `HOME`\n");
-        return 0;
-    }
-    return 1;
-}
-
-static inline void __set_io_flags(unsigned flag, bool_t active)
-{
-    struct termios _termios;
-    tcgetattr(STDIN_FILENO, &_termios);
-    if (active)
-        _termios.c_lflag |= flag;
-    else
-        _termios.c_lflag &= ~flag;
-    tcsetattr(STDIN_FILENO, 0, &_termios);
-}
-
+/// @brief Prints the contents of a message file to standard output.
+/// @param file The path to the file to be printed.
 static inline void __print_message_file(const char *file)
 {
-    char buffer[256];
-    ssize_t nbytes, total = 0;
-    int fd;
+    char buffer[256]; ///< Buffer to hold file contents
+    ssize_t nbytes;   ///< Number of bytes read from the file
+    int fd;           ///< File descriptor for the opened file
 
-    // Try to open the file.
+    // Try to open the file in read-only mode
     if ((fd = open(file, O_RDONLY, 0600)) == -1) {
+        perror("Error opening file"); // Print error if file can't be opened
         return;
     }
-    // Print the file.
-    while ((nbytes = read(fd, buffer, sizeof(char) * 256)) > 0) {
-        // Tap the string.
-        buffer[nbytes] = 0;
+
+    // Read and print the file contents
+    while ((nbytes = read(fd, buffer, sizeof(buffer) - 1)) > 0) {
+        buffer[nbytes] = '\0'; // Null-terminate the string
         // TODO: Parsing message files for special characters (such as `\t` for time).
-        write(STDOUT_FILENO, buffer, nbytes);
-        total += nbytes;
+        write(STDOUT_FILENO, buffer, nbytes); // Write to standard output.
     }
+
+    // Close the file descriptor
     close(fd);
-    if (total > 0)
+
+    // Print a newline if any content was read
+    if (nbytes > 0) {
         printf("\n");
+    }
 }
 
-/// @brief Gets the inserted command.
-static inline bool_t __get_input(char *input, size_t max_len, bool_t hide)
+/// @brief Reads user input into a buffer, supporting basic editing features.
+/// @param buffer The buffer to store the input string.
+/// @param size The maximum size of the buffer.
+/// @param show Flag to determine if input should be displayed.
+/// @return The length of the input read, or -1 if a special command (Ctrl+C) is
+/// detected.
+static inline int __read_input(char *buffer, size_t size, int show)
 {
-    size_t index = 0;
-    int c;
-    bool_t result = false;
+    int index = 0, c, length = 0, insert_active = 0;
 
-    __set_io_flags(ICANON, false);
-    if (hide)
-        __set_io_flags(ECHO, false);
+    // Clear the buffer at the start
+    memset(buffer, 0, size);
 
-    memset(input, 0, max_len);
     do {
-        c = getchar();
-        // Return Key
+        c = getchar(); // Read a character from input
+
+        // Ignore EOF and null or tab characters
+        if (c == EOF || c == 0 || c == '\t') {
+            continue;
+        }
+
+        // Handle newline character to finish input
         if (c == '\n') {
-            input[index] = 0;
-            result       = true;
-            break;
-        } else if (c == '\033') {
-            c = getchar();
+            if (show) {
+                putchar('\n'); // Display a newline
+            }
+            return length; // Return length of input
+        }
+
+        // Handle backspace for deletion
+        if (c == '\b') {
+            if (index > 0) {
+                --length; // Decrease length
+                --index;  // Move index back
+                // Shift the buffer left to remove the character
+                memmove(buffer + index, buffer + index + 1, length - index + 1);
+                if (show) { putchar('\b'); } // Show backspace action
+            }
+            continue;
+        }
+
+        // Handle space character
+        if (c == ' ') {
+            // Shift buffer to the right to insert space
+            memmove(buffer + index + 1, buffer + index, length - index + 1);
+            buffer[index++] = c; // Insert space
+            length++;
+            if (show) { putchar(c); } // Show space
+            continue;
+        }
+
+        // Handle escape sequences (for arrow keys, home, end, etc.)
+        if (c == '\033') {
+            c = getchar(); // Get the next character
             if (c == '[') {
-                getchar(); // Get the char, and ignore it.
+                // Get the direction key (Left, Right, Home, End, Insert, Delete)
+                c = getchar();
+
+                if (c == 'D') { // LEFT Arrow
+                    if (index > 0) {
+                        if (show) { puts("\033[1D"); } // Move the cursor left
+                        index--;                       // Decrease index
+                    }
+                } else if (c == 'C') { // RIGHT Arrow
+                    if (index < length) {
+                        if (show) { puts("\033[1C"); } // Move the cursor right
+                        index++;                       // Increase index
+                    }
+                } else if (c == '1') {                                // HOME
+                    if (show) { printf("\033[%dD", index); }          // Move cursor to the beginning
+                    index = 0;                                        // Set index to the start
+                } else if (c == '4') {                                // END
+                    if (show) { printf("\033[%dC", length - index); } // Move cursor to the end
+                    index = length;                                   // Set index to the end
+                } else if (c == '2') {                                // INSERT
+                    insert_active = !insert_active;                   // Toggle insert mode
+                } else if (c == '3') {                                // DELETE
+                    if (index < length) {
+                        --length;                    // Decrease length
+                        if (show) { putchar(0x7F); } // Show delete character
+                        // Shift left to remove character at index
+                        memmove(buffer + index, buffer + index + 1, length - index + 1);
+                    }
+                }
+
             } else if (c == '^') {
-                c = getchar(); // Get the char.
+                // Handle special commands (Ctrl+C, Ctrl+U)
+                c = getchar();
                 if (c == 'C') {
-                    // However, the ISR of the keyboard has already put the char.
-                    // Thus, delete it by using backspace.
-                    if (!hide) {
-                        putchar('\b');
-                        putchar('\b');
-                        putchar('\n');
-                    }
-                    result = false;
-                    break;
-                } else if (c == 'U') {
-                    if (!hide) {
-                        // However, the ISR of the keyboard has already put the char.
-                        // Thus, delete it by using backspace.
-                        putchar('\b');
-                        putchar('\b');
-                        // Clear the current command.
-                        for (size_t it = 0; it < index; ++it) {
-                            putchar('\b');
+                    memset(buffer, 0, size); // Clear buffer
+                    putchar('\n');
+                    return -1; // Return -1 on Ctrl+C
+                }
+
+                if (c == 'U') {
+                    memset(buffer, 0, size); // Clear the current command
+                    if (show) {
+                        // Clear the current command from display
+                        while (index--) {
+                            putchar('\b'); // Move cursor back
                         }
                     }
-                    index = 0;
+                    index = 0; // Reset index
                 }
             }
-        } else if (c == '\b') {
-            if (index > 0) {
-                if (!hide)
-                    putchar('\b');
-                --index;
+            continue;
+        }
+
+        // Handle alphanumeric input
+        if (isdigit(c) || isalpha(c)) {
+            // Handle insertion based on insert mode
+            if (!insert_active) {
+                // Shift buffer to the right to insert new character
+                memmove(buffer + index + 1, buffer + index, length - index + 1);
+            } else if (show && (index < length - 1)) {
+                puts("\033[1C"); // Move cursor right
+                putchar('\b');   // Prepare to delete the character
             }
-        } else if (c == 0) {
-            // Do nothing.
-        } else {
-            input[index++] = c;
-            if (index == (max_len - 1)) {
-                input[index] = 0;
-                result       = true;
-                break;
+
+            buffer[index++] = c; // Insert new character
+            length++;            // Increase length
+
+            if (show) { putchar(c); } // Show new character
+
+            // Check if we reached the buffer limit
+            if (index == (size - 1)) {
+                buffer[index] = 0; // Null-terminate the buffer
+                break;             // Exit loop if buffer is full
             }
         }
-    } while (index < max_len);
+    } while (length < size);
 
-    if (hide) {
-        __set_io_flags(ECHO, true);
-        putchar('\n');
-    }
-    __set_io_flags(ICANON, true);
-
-    return result;
+    return length; // Return total length of input
 }
 
 int main(int argc, char **argv)
 {
-#if 0
-    int *shared = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE,
-                       MAP_SHARED, -1, 0);
-    pid_t child;
-    int childstate;
-    pr_warning("[F] (%p) %d\n", shared, *shared);
-    if ((child = fork()) == 0) {
-        *shared = 1;
-        pr_warning("[C] (%p) %d\n", shared, *shared);
-        return 0;
-    }
-    waitpid(child, &childstate, 0);
-    pr_warning("[F] (%p) %d\n", shared, *shared);
-    return 0;
-    while (1) {}
-#endif
     // Print /etc/issue if it exists.
     __print_message_file("/etc/issue");
 
     passwd_t *pwd;
     char username[CREDENTIALS_LENGTH], password[CREDENTIALS_LENGTH];
+    struct termios _termios;
+
     do {
-        // Get the username.
-        do {
-            printf("Username: ");
-        } while (!__get_input(username, sizeof(username), false));
-        // Get the password.
+        // Get terminal attributes for input handling
+        tcgetattr(STDIN_FILENO, &_termios);
+        _termios.c_lflag &= ~(ICANON | ECHO | ISIG); // Disable canonical mode and echo
+        tcsetattr(STDIN_FILENO, 0, &_termios);       // Set modified attributes
+
+        // Prompt for username.
         do {
-            printf("Password: ");
-        } while (!__get_input(password, sizeof(password), true));
+            puts("Username: ");
+        } while (__read_input(username, CREDENTIALS_LENGTH, 1) <= 0);
+
+        // Prompt for password (hidden input).
+        printf("Password: ");
+        if (__read_input(password, CREDENTIALS_LENGTH, 0) < 0) {
+            fprintf(stderr, "Error reading password\n");
+            return EXIT_FAILURE;
+        }
+        putchar('\n');
 
-        // Check if we can find the user.
+        // Restore terminal attributes
+        tcgetattr(STDIN_FILENO, &_termios);
+        _termios.c_lflag |= (ICANON | ECHO | ISIG); // Re-enable canonical mode and echo
+        tcsetattr(STDIN_FILENO, 0, &_termios);
+
+        // Retrieve user information based on the username
         if ((pwd = getpwnam(username)) == NULL) {
             if (errno == ENOENT) {
                 printf("The given name was not found.\n");
@@ -198,73 +239,89 @@ int main(int argc, char **argv)
             } else {
                 printf("Unknown error (%s).\n", strerror(errno));
             }
-            continue;
+            continue; // Retry after error
         }
 
         struct spwd *spwd;
         if ((spwd = getspnam(username)) == NULL) {
-            printf("Could not retrieve the secret password of %s:%s\n", username, strerror(errno));
-            continue;
+            printf("Could not retrieve the secret password of %s: %s\n", username, strerror(errno));
+            continue; // Retry if unable to get shadow password
         }
 
+        // Hash the input password for verification
         unsigned char hash[SHA256_BLOCK_SIZE]       = { 0 };
         char hash_string[SHA256_BLOCK_SIZE * 2 + 1] = { 0 };
         SHA256_ctx_t ctx;
         sha256_init(&ctx);
-        for (unsigned i = 0; i < 100000; ++i)
+        for (unsigned i = 0; i < 100000; ++i) {
             sha256_update(&ctx, (unsigned char *)password, strlen(password));
+        }
         sha256_final(&ctx, hash);
         sha256_bytes_to_hex(hash, SHA256_BLOCK_SIZE, hash_string, SHA256_BLOCK_SIZE * 2 + 1);
 
-        // Check if the password is correct.
+        // Verify the password against the stored hash
         if (strcmp(spwd->sp_pwdp, hash_string) != 0) {
             printf("Wrong password.\n");
-            continue;
+            continue; // Retry on incorrect password
         }
 
-        break;
+        break; // Successful authentication
+
     } while (true);
 
-    // If there is not shell set for the user, should we rollback to standard shell?
+    // Check if a shell is set for the user
     if (pwd->pw_shell == NULL) {
         printf("login: There is no shell set for the user `%s`.\n", pwd->pw_name);
+        return 1; // Exit with error if no shell
+    }
+
+    // Set the USER.
+    if (setenv("USER", pwd->pw_name, 1) == -1) {
+        printf("login: Failed to setup the environmental variable `USER`.\n");
         return 1;
     }
 
-    // Set the standard environmental variables.
-    if (!__setup_env(pwd)) {
-        printf("login: Failed to setup the environmental variables.\n");
+    // Set the SHELL.
+    if (setenv("SHELL", pwd->pw_shell, 1) == -1) {
+        printf("login: Failed to setup the environmental variable `SHELL`.\n");
+        return 1;
+    }
+
+    // Set the HOME.
+    if (setenv("HOME", pwd->pw_dir, 1) == -1) {
+        printf("login: Failed to setup the environmental variable `HOME`.\n");
         return 1;
     }
 
-    // Set the group id.
+    // Change the group ID
     if (setgid(pwd->pw_gid) < 0) {
         printf("login: Failed to change group id: %s\n", strerror(errno));
-        return 1;
+        return 1; // Exit with error on group ID change failure
     }
 
-    // Set the user id.
+    // Change the user ID
     if (setuid(pwd->pw_uid) < 0) {
         printf("login: Failed to change user id: %s\n", strerror(errno));
-        return 1;
+        return 1; // Exit with error on user ID change failure
     }
 
     printf("\n");
 
-    // Print /etc/motd if it exists.
+    // Print /etc/motd if it exists
     __print_message_file("/etc/motd");
 
-    // Welcome the user.
+    // Welcome the user
     puts(BG_WHITE FG_BLACK);
-    printf("Welcome " FG_RED "%s" FG_BLACK "...\n", pwd->pw_name);
+    printf("\nWelcome " FG_RED "%s" FG_BLACK "...\n", pwd->pw_name);
     puts(BG_BLACK FG_WHITE_BRIGHT);
 
-    // Call the shell.
+    // Execute the user's shell
     char *_argv[] = { pwd->pw_shell, (char *)NULL };
     if (execv(pwd->pw_shell, _argv) == -1) {
         printf("login: Failed to execute the shell.\n");
         printf("login: %s.\n", strerror(errno));
-        return 1;
+        return 1; // Exit with error on shell execution failure
     }
-    return 0;
+
+    return 0; // Normal exit
 }
diff --git a/programs/runtests.c b/programs/runtests.c
index 6459631d..56520b4b 100644
--- a/programs/runtests.c
+++ b/programs/runtests.c
@@ -70,7 +70,7 @@ static char *all_tests[] = {
 };
 
 static char **tests = &all_tests[0];
-static int testsc   = sizeof(all_tests) / sizeof(all_tests[0]);
+static int testsc   = count_of(all_tests);
 
 static char buf[4096];
 static char *bufpos = buf;
@@ -122,7 +122,7 @@ static int test_ok(int test, int success, const char *restrict format, ...)
     if (!success) {
         append("not ");
     }
-    append("ok %d - %s", test, tests[test - 1]);
+    append("ok %2d - %s", test, tests[test - 1]);
     if (format) {
         append(": ");
         va_list ap;
@@ -223,7 +223,7 @@ int runtests_main(int argc, char **argv)
 
     char *test_argv[32];
     for (int i = 0; i < testsc; i++) {
-        pr_info("Running test (%2d/%2d): %s\n", i, testsc, tests[i]);
+        pr_info("Running test (%2d/%2d): %s\n", i + 1, testsc, tests[i]);
         run_test(i + 1, tests[i]);
     }
 
diff --git a/programs/tests/t_abort.c b/programs/tests/t_abort.c
index b29ea936..c0a20458 100644
--- a/programs/tests/t_abort.c
+++ b/programs/tests/t_abort.c
@@ -1,5 +1,5 @@
 /// @file t_abort.c
-/// @brief
+/// @brief Demonstrates handling of the SIGABRT signal.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -16,16 +16,17 @@ void sig_handler(int sig)
 {
     printf("handler(%d) : Starting handler.\n", sig);
     if (sig == SIGABRT) {
-
         static int counter = 0;
         counter += 1;
 
         printf("handler(%d) : Correct signal. ABRT (%d/3)\n", sig, counter);
-        if (counter < 3)
+        if (counter < 3) {
+            // Re-trigger the abort signal up to 3 times.
             abort();
-        else
-            exit(0);
-
+        } else {
+            // Exit the program after handling the signal 3 times.
+            exit(EXIT_SUCCESS);
+        }
     } else {
         printf("handler(%d) : Wrong signal.\n", sig);
     }
@@ -38,10 +39,17 @@ int main(int argc, char *argv[])
     memset(&action, 0, sizeof(action));
     action.sa_handler = sig_handler;
 
+    // Set up the signal handler for SIGABRT.
     if (sigaction(SIGABRT, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGABRT, strerror(errno));
-        return 1;
+        perror("signal setup failed");
+        exit(EXIT_FAILURE);
     }
 
+    // Trigger the SIGABRT signal.
     abort();
+
+    // This point should never be reached.
+    perror("abort() failed to terminate the process");
+
+    return EXIT_FAILURE;
 }
diff --git a/programs/tests/t_alarm.c b/programs/tests/t_alarm.c
index 06111bc0..ce5f067c 100644
--- a/programs/tests/t_alarm.c
+++ b/programs/tests/t_alarm.c
@@ -1,31 +1,43 @@
 /// @file t_alarm.c
-/// @brief
+/// @brief Demonstrates handling of the SIGALRM signal.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <sys/unistd.h>
-#include <signal.h>
+#include <sys/wait.h>
+#include <strerror.h>
 #include <stdlib.h>
-#include <stdio.h>
 #include <string.h>
-#include <strerror.h>
-#include <sys/wait.h>
+#include <signal.h>
+#include <stdio.h>
+#include <time.h>
 
+/// @brief Signal handler for SIGALRM.
+/// @param sig The signal number.
 void alarm_handler(int sig)
 {
     printf("handler(%d) : Starting handler.\n", sig);
     if (sig == SIGALRM) {
-        printf("handler(%d) : Correct signal.\n", sig);
-
+        // Set an alarm to go off after 5 seconds.
         alarm(5);
+
+        // Set another alarm to go off after 5 seconds and get the remaining time of the previous alarm.
         int rest = alarm(5);
+
+        // Expected value:  5 (since the previous alarm was just set to 5 seconds).
         printf("handler(%d) : alarm(5) result: %d.\n", sig, rest);
 
+        // Cancel the alarm and get the remaining time of the previous alarm.
         rest = alarm(0);
-        printf("handler(%d) : alarm(0) result: %d.\n", sig, rest);
 
-        exit(0);
+        // Expected value: ~4 (since the previous alarm was just set to 5
+        // seconds again). This small delay between the two alarm calls is why
+        // you see the value 4 instead of 5. The exact value can vary slightly
+        // depending on the system’s execution speed and the time taken to
+        // execute the intermediate code.
+        printf("handler(%d) : alarm(0) result: %d.\n", sig, rest);
 
+        exit(EXIT_SUCCESS);
     } else {
         printf("handler(%d) : Wrong signal.\n", sig);
     }
@@ -37,14 +49,18 @@ int main(int argc, char *argv[])
     sigaction_t action;
     memset(&action, 0, sizeof(action));
     action.sa_handler = alarm_handler;
-    if (sigaction(SIGALRM, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGALRM, strerror(errno));
-        return 1;
-    }
 
+    // Set up the signal handler for SIGALRM.
+    if (sigaction(SIGALRM, &action, NULL) < 0) {
+        perror("signal setup failed");
+        exit(EXIT_FAILURE);
+    }
 
+    // Set an alarm to go off after 5 seconds.
     alarm(5);
-    while(1) { }
 
-    return 0;
+    // Infinite loop to keep the program running until the alarm signal is received.
+    while (1) {}
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_big_write.c b/programs/tests/t_big_write.c
index 6b2b0215..8b0e0ccd 100644
--- a/programs/tests/t_big_write.c
+++ b/programs/tests/t_big_write.c
@@ -1,18 +1,17 @@
 /// @file t_big_write.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
 /// @brief Test writing a big file.
-/// @copyright (c) 2024 This file is distributed under the MIT License.
+/// @details This program tests writing a large amount of data to a file by
+/// repeatedly writing a buffer filled with characters.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <strerror.h>
 #include <string.h>
+#include <strerror.h>
 #include <sys/stat.h>
 #include <sys/unistd.h>
-#include <math.h>
-#include <io/debug.h>
 
 int main(int argc, char *argv[])
 {
@@ -20,25 +19,47 @@ int main(int argc, char *argv[])
     mode_t mode             = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
     char *filename          = "/home/user/test.txt";
     char buffer[4 * BUFSIZ] = { 0 };
-    // Open the file.
+
+    // Open the file with specified flags and mode.
     int fd = open(filename, flags, mode);
     if (fd < 0) {
-        printf("Failed to open file %s: %s\n", filename, strerror(errno));
+        // Error handling for file open failure.
+        fprintf(STDERR_FILENO, "Failed to open file %s: %s\n", filename, strerror(errno));
         return EXIT_FAILURE;
     }
-    // Write the content.
+
+    // Write the content to the file.
     for (unsigned times = 0; times < 128; ++times) {
         for (unsigned i = 'A'; i < 'z'; ++i) {
+            // Fill the buffer with the character 'i'.
             memset(buffer, i, 4 * BUFSIZ);
+            // Write the buffer to the file.
             if (write(fd, buffer, 4 * BUFSIZ) < 0) {
-                printf("Writing on file %s failed: %s\n", filename, strerror(errno));
-                close(fd);
-                unlink(filename);
+                // Error handling for write failure.
+                fprintf(STDERR_FILENO, "Writing to file %s failed: %s\n", filename, strerror(errno));
+                // Close the file descriptor.
+                if (close(fd) < 0) {
+                    fprintf(STDERR_FILENO, "Failed to close file %s: %s\n", filename, strerror(errno));
+                }
+                // Delete the file.
+                if (unlink(filename) < 0) {
+                    fprintf(STDERR_FILENO, "Failed to delete file %s: %s\n", filename, strerror(errno));
+                }
                 return EXIT_FAILURE;
             }
         }
     }
-    close(fd);
-    // unlink(filename);
+
+    // Close the file descriptor.
+    if (close(fd) < 0) {
+        fprintf(STDERR_FILENO, "Failed to close file %s: %s\n", filename, strerror(errno));
+        return EXIT_FAILURE;
+    }
+    // Delete the file.
+    if (unlink(filename) < 0) {
+        fprintf(STDERR_FILENO, "Failed to delete file %s: %s\n", filename, strerror(errno));
+        return EXIT_FAILURE;
+    }
+
     return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_creat.c b/programs/tests/t_creat.c
index 638e29ef..94ce2e5b 100644
--- a/programs/tests/t_creat.c
+++ b/programs/tests/t_creat.c
@@ -1,39 +1,87 @@
 /// @file t_creat.c
-/// @brief test the creat syscall
-/// @copyright (c) 2024 This file is distributed under the MIT License.
+/// @brief Test the creat syscall.
+/// @details This program tests the `creat` system call by creating a file,
+/// writing to it, checking its size, and then removing it.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <strerror.h>
-#include <sys/errno.h>
 #include <sys/stat.h>
 #include <sys/unistd.h>
 
 int main(int argc, char *argv[])
 {
-    int fd = creat("foo", 0660);
+    char *filename      = "/home/user/t_creat.txt";
+    char *content       = "Hello world!";
+    size_t content_size = strlen(content);
+
+    // Create the file with read and write permissions for the owner and group.
+    int fd = creat(filename, 0660);
     if (fd < 0) {
-        printf("creat: foo: %s\n", strerror(errno));
+        // Error handling for file creation failure.
+        fprintf(STDERR_FILENO, "creat: %s: %s\n", filename, strerror(errno));
         exit(EXIT_FAILURE);
     }
-    if (write(fd, "foo", 3) != 3) {
-        printf("write: foo: %s\n", strerror(errno));
+
+    // Write the string to the file.
+    if (write(fd, content, content_size) != content_size) {
+        // Error handling for write failure.
+        fprintf(STDERR_FILENO, "write: %s: %s\n", filename, strerror(errno));
+        // Close the file descriptor.
+        if (close(fd) < 0) {
+            fprintf(STDERR_FILENO, "close: %s: %s\n", filename, strerror(errno));
+        }
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    // Close the file descriptor.
+    if (close(fd) < 0) {
+        // Error handling for close failure.
+        fprintf(STDERR_FILENO, "close: %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
         exit(EXIT_FAILURE);
     }
 
-    struct stat_t st;
-    if (stat("foo", &st) < 0) {
-        printf("stat: foo: %s\n", strerror(errno));
+    // Structure to hold file status information.
+    struct stat st;
+    // Get the status of the file filename.
+    if (stat(filename, &st) < 0) {
+        // Error handling for stat failure.
+        fprintf(STDERR_FILENO, "stat: %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
         exit(EXIT_FAILURE);
     }
 
-    if (st.st_size != 3) {
-        printf("Wrong file size. (expected: 3, is: %u)\n", st.st_size);
+    // Check if the file size is correct.
+    if (st.st_size != content_size) {
+        fprintf(STDERR_FILENO, "Wrong file size. (expected: %ld, is: %ld)\n", content_size, st.st_size);
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
         exit(EXIT_FAILURE);
     }
+
     // Remove the file.
-    unlink("foo");
-    return 0;
+    if (unlink(filename) < 0) {
+        // Error handling for unlink failure.
+        fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        exit(EXIT_FAILURE);
+    }
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_dup.c b/programs/tests/t_dup.c
index 5bc2171e..75dad88b 100644
--- a/programs/tests/t_dup.c
+++ b/programs/tests/t_dup.c
@@ -1,6 +1,9 @@
 /// @file t_dup.c
-/// @brief Test the dup syscall
-/// @copyright (c) 2024 This file is distributed under the MIT License.
+/// @brief Test the dup syscall.
+/// @details This program tests the `dup` system call by duplicating a file
+/// descriptor, writing to both descriptors, reading the content, and verifying
+/// the result.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <fcntl.h>
@@ -13,53 +16,140 @@
 
 int main(int argc, char *argv[])
 {
-    const char *file        = "t_dup_file";
+    char *filename = "/home/user/t_dup.txt";
     int fd1, fd2;
-    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+    int flags   = O_WRONLY | O_CREAT | O_TRUNC;
     mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
 
-    fd1 = open(file, flags, mode);
+    // Open the file with specified flags and mode.
+    fd1 = open(filename, flags, mode);
     if (fd1 < 0) {
-        printf("Failed to open file %s: %s\n", file, strerror(errno));
-        exit(1);
+        fprintf(STDERR_FILENO, "Failed to open file %s: %s\n", filename, strerror(errno));
+        exit(EXIT_FAILURE);
     }
 
+    // Duplicate the file descriptor.
     fd2 = dup(fd1);
     if (fd2 < 0) {
-        printf("Failed to dup fd %d: %s\n", fd1, strerror(errno));
-        exit(1);
+        fprintf(STDERR_FILENO, "Failed to dup fd %d: %s\n", fd1, strerror(errno));
+        // Close the file descriptor.
+        if (close(fd1) < 0) {
+            fprintf(STDERR_FILENO, "close fd1: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
     }
 
+    // Write "foo" to the first file descriptor.
     if (write(fd1, "foo", 3) != 3) {
-        printf("Writing to fd %d failed: %s\n", fd1, strerror(errno));
-        exit(1);
+        fprintf(STDERR_FILENO, "Writing to fd %d failed: %s\n", fd1, strerror(errno));
+        // Close the file descriptor.
+        if (close(fd1) < 0) {
+            fprintf(STDERR_FILENO, "close fd1: %s: %s\n", filename, strerror(errno));
+        }
+        if (close(fd2) < 0) {
+            fprintf(STDERR_FILENO, "close fd2: %s: %s\n", filename, strerror(errno));
+        }
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
     }
-    close(fd1);
 
+    // Close the file descriptor.
+    if (close(fd1) < 0) {
+        // Error handling for close failure.
+        fprintf(STDERR_FILENO, "close fd1: %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    // Write "bar" to the duplicated file descriptor.
     if (write(fd2, "bar", 3) != 3) {
-        printf("Writing to fd %d failed: %s\n", fd2, strerror(errno));
-        exit(1);
+        // Error handling for write failure.
+        fprintf(STDERR_FILENO, "Writing to fd %d failed: %s\n", fd2, strerror(errno));
+        // Close the file descriptor.
+        if (close(fd2) < 0) {
+            fprintf(STDERR_FILENO, "close fd2: %s: %s\n", filename, strerror(errno));
+        }
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
     }
-    close(fd2);
 
-    fd1 = open(file, O_RDONLY, 0);
+    // Close the file descriptor.
+    if (close(fd2) < 0) {
+        // Error handling for close failure.
+        fprintf(STDERR_FILENO, "close fd2: %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    // Reopen the file for reading.
+    fd1 = open(filename, O_RDONLY, mode);
     if (fd1 < 0) {
-        printf("Failed to open file %s: %s\n", file, strerror(errno));
-        exit(1);
+        // Error handling for file open failure.
+        fprintf(STDERR_FILENO, "Failed to open file %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
     }
 
-    char buf[7];
-    buf[6] = 0;
-    if (read(fd1, &buf, 6) < 0) {
-        printf("Reading from fd %d failed: %s\n", fd1, strerror(errno));
-        exit(1);
+    // Buffer to read the file content.
+    char buf[7] = { 0 };
+
+    // Read the content of the file.
+    if (read(fd1, buf, 6) < 0) {
+        // Error handling for read failure.
+        fprintf(STDERR_FILENO, "Reading from fd %d failed: %s\n", fd1, strerror(errno));
+        // Close the file descriptor.
+        if (close(fd1) < 0) {
+            fprintf(STDERR_FILENO, "close fd1: %s: %s\n", filename, strerror(errno));
+        }
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
     }
 
+    // Close the file descriptor.
+    if (close(fd1) < 0) {
+        // Error handling for close failure.
+        fprintf(STDERR_FILENO, "close fd1: %s: %s\n", filename, strerror(errno));
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    // Check if the file content is as expected.
     if (strcmp(buf, "foobar") != 0) {
-        printf("Unexpected file content: %s\n", buf);
-        exit(1);
+        fprintf(STDERR_FILENO, "Unexpected file content: %s\n", buf);
+        // Remove the file.
+        if (unlink(filename) < 0) {
+            fprintf(STDERR_FILENO, "unlink: %s: %s\n", filename, strerror(errno));
+        }
+        exit(EXIT_FAILURE);
+    }
+
+    // Remove the file.
+    if (unlink(filename) < 0) {
+        // Error handling for unlink failure.
+        fprintf(STDERR_FILENO, "Failed to delete file %s: %s\n", filename, strerror(errno));
+        exit(EXIT_FAILURE);
     }
 
-    unlink(file);
     return 0;
 }
diff --git a/programs/tests/t_fork.c b/programs/tests/t_fork.c
index 12ba484d..5b7a7970 100644
--- a/programs/tests/t_fork.c
+++ b/programs/tests/t_fork.c
@@ -1,5 +1,9 @@
 /// @file t_fork.c
-/// @brief
+/// @brief Test the fork syscall.
+/// @details This program tests the `fork` system call by creating child
+/// processes and having them execute in a loop until a specified number of
+/// processes is reached. Each process waits for its child to finish before
+/// exiting.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -11,55 +15,42 @@
 
 int main(int argc, char *argv[])
 {
+    // Check if the correct number of arguments is provided.
     if (argc != 2) {
-        return 1;
+        fprintf(STDERR_FILENO, "Usage: %s <number_of_processes>\n", argv[0]);
+        return EXIT_FAILURE;
     }
-    char *ptr;
-    int N;
-    N = strtol(argv[1], &ptr, 10);
-    pid_t cpid, mypid;
-#if 0
-    char buffer[256];
-
-    N = strtol(argv[1], &ptr, 10);
 
-    char *_argv[] = {
-        "/bin/tests/t_fork",
-        itoa(buffer, N - 1, 10),
-        NULL
-    };
-
-    printf("N = %d\n", N);
-    if (N > 1) {
-
-        printf("Keep caling (N = %d)\n", N);
+    // Convert the argument to an integer.
+    char *ptr;
+    int N = strtol(argv[1], &ptr, 10);
+    // Check if the conversion was successful and the number is non-negative.
+    if (*ptr != '\0' || N < 0) {
+        fprintf(STDERR_FILENO, "Invalid number: %s\n", argv[1]);
+        return EXIT_FAILURE;
+    }
 
-        if ((cpid = fork()) == 0) {
-            
-            printf("I'm the child (pid = %d, N = %d)!\n", getpid(), N);
+    pid_t cpid, mypid;
 
-            execv(_argv[0], _argv);
-            
-        }
-        printf("Will wait for %d\n", N, cpid);
-        while (wait(NULL) != -1) continue;
-    }
-#else
     while (1) {
-        mypid = getpid();
+        mypid = getpid(); // Get the current process ID.
         if (N > 0) {
+            // Fork a new process.
             if ((cpid = fork()) == 0) {
+                // In the child process, decrement N and continue the loop.
                 N -= 1;
                 continue;
             }
+            // In the parent process, print a message and wait for the child to finish.
             printf("I'm %d and I will wait for %d (N = %d)!\n", mypid, cpid, N);
             while (wait(NULL) != -1) continue;
             printf("I'm %d and I waited for %d (N = %d)!\n", mypid, cpid, N);
         } else {
+            // If N is 0, print a message and exit the loop.
             printf("I'm %d and I will not wait!\n", mypid);
         }
         break;
     }
-#endif
-    return 0;
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_getenv.c b/programs/tests/t_getenv.c
index 2c88e1bb..0a6dc215 100644
--- a/programs/tests/t_getenv.c
+++ b/programs/tests/t_getenv.c
@@ -1,20 +1,26 @@
 /// @file t_getenv.c
-/// @brief
+/// @brief Test the getenv function.
+/// @details This program tests the `getenv` function by retrieving the value of
+/// an environment variable and printing it. If the environment variable is not
+/// set, it prints an error message and exits with a failure status.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <strerror.h>
 #include <sys/unistd.h>
-#include <sys/wait.h>
 
 int main(int argc, char *argv[])
 {
-    char *ENV_VAR = getenv("ENV_VAR");
-    if (ENV_VAR == NULL) {
-        printf("Failed to get env: `ENV_VAR`\n");
-        return 1;
+    // Retrieve the value of the environment variable "ENV_VAR".
+    char *env_var = getenv("ENV_VAR");
+    if (env_var == NULL) {
+        fprintf(STDERR_FILENO, "Failed to get env: `ENV_VAR`: %s\n", strerror(errno));
+        return EXIT_FAILURE;
     }
-    printf("ENV_VAR = %s\n", ENV_VAR);
-    return 0;
+
+    // Print the value of the environment variable.
+    printf("ENV_VAR = %s\n", env_var);
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_gid.c b/programs/tests/t_gid.c
index 4d3ef723..13abd2ac 100644
--- a/programs/tests/t_gid.c
+++ b/programs/tests/t_gid.c
@@ -1,26 +1,31 @@
 /// @file t_gid.c
-/// @brief
+/// @brief Test group-related functions.
+/// @details This program tests various group-related functions such as listing all groups,
+/// resetting the group list, and retrieving group information by group ID and name.
+/// It prints the details of each group and verifies the correctness of the `getgrgid` and `getgrnam` functions.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
-#include "grp.h"
-#include "stdlib.h"
-#include "string.h"
+#include <grp.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strerror.h>
+#include <sys/unistd.h>
 
+/// @brief List all groups and their members.
 static void list_groups(void)
 {
-    group_t *iter;
+    struct group *iter;
     while ((iter = getgrent()) != NULL) {
-        printf("Group\n\tname: %s\n\tpasswd: %s\n\tnames:\n", iter->gr_name, iter->gr_passwd);
-
+        printf("Group name: \"%12s\", passwd: \"%12s\"\n", iter->gr_name, iter->gr_passwd);
+        puts("Names: [ ");
         size_t count = 0;
         while (iter->gr_mem[count] != NULL) {
-            printf("\t\t%s\n", iter->gr_mem[count]);
+            printf("%s ", iter->gr_mem[count]);
             count += 1;
         }
-
-        printf("\n");
+        puts("]\n\n");
     }
 }
 
@@ -28,25 +33,39 @@ int main(int argc, char **argv)
 {
     printf("List of all groups:\n");
 
+    // List all groups.
     list_groups();
+    // Reset the group list to the beginning.
     setgrent();
 
     printf("List all groups again:\n");
 
+    // List all groups again.
     list_groups();
+    // Close the group list.
     endgrent();
 
-    group_t *root_group = getgrgid(0);
+    // Get the group information for the group with GID 0.
+    struct group *root_group = getgrgid(0);
+    if (root_group == NULL) {
+        fprintf(STDERR_FILENO, "Error in getgrgid function: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
     if (strcmp(root_group->gr_name, "root") != 0) {
-        printf("Error in getgrgid function.");
-        return 1;
+        fprintf(STDERR_FILENO, "Error: Expected group name 'root', got '%s'\n", root_group->gr_name);
+        return EXIT_FAILURE;
     }
 
+    // Get the group information for the group named "root".
     root_group = getgrnam("root");
+    if (root_group == NULL) {
+        fprintf(STDERR_FILENO, "Error in getgrnam function: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
     if (root_group->gr_gid != 0) {
-        printf("Error in getgrnam function.");
-        return 1;
+        fprintf(STDERR_FILENO, "Error: Expected GID 0, got %d\n", root_group->gr_gid);
+        return EXIT_FAILURE;
     }
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_groups.c b/programs/tests/t_groups.c
index d735353c..1c155f63 100644
--- a/programs/tests/t_groups.c
+++ b/programs/tests/t_groups.c
@@ -1,5 +1,10 @@
 /// @file t_groups.c
-/// @brief
+/// @brief Test process group and session IDs.
+/// @details This program tests the retrieval of process IDs, group IDs, and
+/// session IDs. It forks multiple child processes, each of which prints its own
+/// IDs and those of its parent. The parent process waits for all child
+/// processes to finish before exiting. This demonstrates the relationship
+/// between parent and child processes in terms of IDs.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -11,28 +16,35 @@
 
 int main(int argc, char **argv)
 {
+    // Get the group ID, process ID, and session ID of the current process.
     pid_t gid = getgid();
     pid_t pid = getpid();
     pid_t sid = getsid(0);
 
+    // Print the IDs of the current process.
     printf("pid: %d, gid: %d, sid: %d\n\n", pid, gid, sid);
+
+    // Fork 5 child processes.
     for (int i = 0; i < 5; ++i) {
         if (fork() == 0) {
-            pid_t gid_child = getgid();
-            pid_t pid_child = getpid();
-
+            // In the child process, get the group ID, process ID, parent process ID, and session ID.
+            pid_t gid_child  = getgid();
+            pid_t pid_child  = getpid();
             pid_t ppid_child = getppid();
             pid_t sid_child  = getsid(ppid_child);
 
+            // Sleep for a number of seconds based on the loop index.
             sleep(i + 1);
-            
+
+            // Print the IDs of the child process and its parent.
             printf("%d) pid_child: %d, gid_child: %d, ppid_child: %d, sid_child: %d\n",
                    i, pid_child, gid_child, ppid_child, sid_child);
-            exit(0);
+            exit(EXIT_SUCCESS);
         }
     }
 
+    // Wait for all child processes to finish.
     while (wait(NULL) != -1) {}
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_grp.c b/programs/tests/t_grp.c
index de842c01..3949d62a 100644
--- a/programs/tests/t_grp.c
+++ b/programs/tests/t_grp.c
@@ -1,38 +1,61 @@
 /// @file t_pwd.c
-/// @brief Test the libc grp.h interface
+/// @brief Test the libc grp.h interface.
+/// @details This program tests the `getgrnam` and `getgrgid` functions from the
+/// libc `grp.h` interface. It verifies that the functions correctly handle both
+/// existing and non-existent group names and GIDs. If any test fails, the
+/// program exits with an error message and a failure status.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <grp.h>
 #include <err.h>
-#include <sys/unistd.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <strerror.h>
+#include <sys/unistd.h>
 
-static void __test_getgrnam(void) {
-    // Test that getpwnam matches the whole group name literally
-    if (getgrnam("r") != NULL)
+/// @brief Test the getgrnam function.
+/// @details This function tests that `getgrnam` correctly handles both existing
+/// and non-existent group names.
+static void __test_getgrnam(void)
+{
+    // Test that getgrnam returns NULL for a non-existent group name.
+    if (getgrnam("r") != NULL) {
         errx(EXIT_FAILURE, "Group entry for non-existent group \"r\" found");
+    }
 
-    if (getgrnam("root") == NULL)
+    // Test that getgrnam returns a valid entry for the "root" group.
+    if (getgrnam("root") == NULL) {
         errx(EXIT_FAILURE, "Group entry for root group not found");
+    }
 }
 
-static void __test_getgrgid(void) {
-    if (getgrgid(1337) != NULL)
+/// @brief Test the getgrgid function.
+/// @details This function tests that `getgrgid` correctly handles both existing
+/// and non-existent GIDs.
+static void __test_getgrgid(void)
+{
+    // Test that getgrgid returns NULL for a non-existent GID.
+    if (getgrgid(1337) != NULL) {
         errx(EXIT_FAILURE, "Group entry for non-existent gid 1337 found");
+    }
 
-    int gids[] = {0, 1000};
+    // Test that getgrgid returns a valid entry for existing GIDs.
+    int gids[] = { 0, 1000 };
     for (int i = 0; i < sizeof(gids) / sizeof(int); i++) {
-        if (getgrgid(gids[i]) == NULL)
+        if (getgrgid(gids[i]) == NULL) {
             errx(EXIT_FAILURE, "Group entry for gid %d not found", gids[i]);
+        }
     }
 }
 
 int main(int argc, char *argv[])
 {
+    // Test the getgrnam function.
     __test_getgrnam();
+    // Test the getgrgid function.
     __test_getgrgid();
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_itimer.c b/programs/tests/t_itimer.c
index 09c1da14..379f22c9 100644
--- a/programs/tests/t_itimer.c
+++ b/programs/tests/t_itimer.c
@@ -1,41 +1,49 @@
 /// @file t_itimer.c
-/// @brief
+/// @brief Test the interval timer (itimerval) functionality.
+/// @details This program sets an interval timer that triggers a signal handler
+/// every second. The signal handler counts the number of times it is called and
+/// stops the timer after 4 calls. It demonstrates the use of `setitimer` and
+/// `getitimer` functions to manage interval timers.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
-#include <sys/unistd.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <time.h>
 #include <strerror.h>
 #include <sys/wait.h>
-#include <time.h>
+#include <sys/unistd.h>
 
+/// @brief Signal handler for SIGALRM.
+/// @param sig The signal number.
 void alarm_handler(int sig)
 {
     printf("handler(%d) : Starting handler.\n", sig);
     if (sig == SIGALRM) {
-
-        itimerval val = { 0 };
-        getitimer(ITIMER_REAL, &val);
-        printf("(sec: %d, usec: %d)\n", val.it_interval.tv_sec, val.it_interval.tv_usec);
+        struct itimerval val = { 0 };
+        // Get the current value of the interval timer.
+        if (getitimer(ITIMER_REAL, &val) == -1) {
+            perror("getitimer failed");
+            exit(EXIT_FAILURE);
+        }
+        printf("(sec: %ld, usec: %ld)\n", val.it_interval.tv_sec, val.it_interval.tv_usec);
 
         static int counter = 0;
         counter += 1;
 
         printf("handler(%d) : Correct signal x%d\n", sig, counter);
-        if (counter == 4)
-        {
-            itimerval interval = { 0 }, prev = { 0 };
-            interval.it_interval.tv_sec = 0;
-
-            setitimer(ITIMER_REAL, &interval, &prev);
-            printf("prev: (sec: %d, usec: %d)", prev.it_interval.tv_sec, prev.it_interval.tv_usec);
-
-            exit(0);
+        if (counter == 4) {
+            struct itimerval interval = { 0 }, prev = { 0 };
+            // Stop the interval timer.
+            if (setitimer(ITIMER_REAL, &interval, &prev) == -1) {
+                perror("setitimer failed");
+                exit(EXIT_FAILURE);
+            }
+            printf("prev: (sec: %ld, usec: %ld)\n", prev.it_interval.tv_sec, prev.it_interval.tv_usec);
+            exit(EXIT_SUCCESS);
         }
-
     } else {
         printf("handler(%d) : Wrong signal.\n", sig);
     }
@@ -44,18 +52,34 @@ void alarm_handler(int sig)
 
 int main(int argc, char *argv[])
 {
-    sigaction_t action;
+    struct sigaction action;
+    struct itimerval timer;
+
     memset(&action, 0, sizeof(action));
+    memset(&timer, 0, sizeof(timer));
+
     action.sa_handler = alarm_handler;
+
+    // Set up the signal handler for SIGALRM.
     if (sigaction(SIGALRM, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGALRM, strerror(errno));
-        return 1;
+        fprintf(STDERR_FILENO, "Failed to set signal handler: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    // Configure the timer to expire after 1 second and then every 1 second.
+    timer.it_value.tv_sec     = 1; // Initial delay.
+    timer.it_value.tv_usec    = 0;
+    timer.it_interval.tv_sec  = 1; // Interval for periodic timer.
+    timer.it_interval.tv_usec = 0;
+
+    // Start the interval timer.
+    if (setitimer(ITIMER_REAL, &timer, NULL) == -1) {
+        perror("setitimer failed");
+        return EXIT_FAILURE;
     }
 
-    itimerval interval = { 0 };
-    interval.it_interval.tv_sec = 1;
-    setitimer(ITIMER_REAL, &interval, NULL);
+    // Infinite loop to keep the program running until the timer stops.
+    while (1) {}
 
-    while(1) { }
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_kill.c b/programs/tests/t_kill.c
index 3612f3c6..47ed23d2 100644
--- a/programs/tests/t_kill.c
+++ b/programs/tests/t_kill.c
@@ -1,17 +1,24 @@
 /// @file t_kill.c
-/// @brief
+/// @brief Test the kill and signal handling functionality.
+/// @details This program demonstrates the use of `fork`, `kill`, and signal
+/// handling. It creates a child process, sets up a signal handler for `SIGUSR1`
+/// in the child, and sends signals from the parent to the child. The child
+/// process handles the signals and prints messages accordingly. The parent
+/// process waits for the child to terminate before exiting.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
-#include <sys/unistd.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <time.h>
 #include <strerror.h>
 #include <sys/wait.h>
-#include <time.h>
+#include <sys/unistd.h>
 
+/// @brief Signal handler for SIGUSR1 in the child process.
+/// @param sig The signal number.
 void child_sigusr1_handler(int sig)
 {
     printf("handler(sig: %d) : Starting handler (pid: %d).\n", sig, getpid());
@@ -21,28 +28,63 @@ void child_sigusr1_handler(int sig)
 int main(int argc, char *argv[])
 {
     printf("main : Creating child!\n");
-    pid_t ppid;
-    if ((ppid = fork()) == 0) {
-        printf("I'm the child (%d)!\n", ppid);
-        sigaction_t action;
-        memset(&action, 0, sizeof(action));
-        action.sa_handler = child_sigusr1_handler;
+
+    // Fork the process to create a child
+    pid_t cpid = fork();
+
+    if (cpid == 0) {
+        // Child process
+        cpid = getpid(); // Get the child PID
+        printf("I'm the child (pid: %d)!\n", cpid);
+
+        // Set up a signal handler for SIGUSR1 in the child
+        struct sigaction action;
+        memset(&action, 0, sizeof(action));        // Clear the action structure
+        action.sa_handler = child_sigusr1_handler; // Set handler function
+
+        // Check if setting up the signal handler fails
         if (sigaction(SIGUSR1, &action, NULL) == -1) {
-            printf("Failed to set signal handler (%s).\n", SIGUSR1, strerror(errno));
-            return 1;
+            fprintf(STDERR_FILENO, "Failed to set signal handler for SIGUSR1: %s\n", strerror(errno));
+            return EXIT_FAILURE; // Return failure if handler setup fails
         }
+
+        // Child process loop - waiting for signals
         while (1) {
-            printf("I'm the child (%d): I'm playing around!\n", getpid());
-            sleep(1);
+            printf("I'm the child (pid: %d): I'm waiting...\n", cpid);
+            sleep(1); // Sleep for 1 second in each loop iteration
         }
+
+    } else if (cpid > 0) {
+        // Parent process
+        printf("I'm the parent (pid: %d)!\n", getpid());
+        sleep(2); // Wait before sending the signal to the child
+
+        // Send SIGUSR1 to the child process
+        if (kill(cpid, SIGUSR1) == -1) {
+            fprintf(STDERR_FILENO, "Failed to send SIGUSR1 to child: %s\n", strerror(errno));
+            return EXIT_FAILURE; // Return failure if signal sending fails
+        }
+
+        sleep(2); // Wait before terminating the child process
+
+        // Send SIGTERM to the child process to terminate it
+        if (kill(cpid, SIGTERM) == -1) {
+            fprintf(STDERR_FILENO, "Failed to send SIGTERM to child: %s\n", strerror(errno));
+            return EXIT_FAILURE; // Return failure if termination fails
+        }
+
+        // Wait for the child process to terminate
+        if (wait(NULL) == -1) {
+            fprintf(STDERR_FILENO, "Failed to wait for child process: %s\n", strerror(errno));
+            return EXIT_FAILURE; // Return failure if wait fails
+        }
+        printf("main : Child has terminated. End of parent process.\n");
+
     } else {
-        printf("I'm the parent (%d)!\n", ppid);
+        // Fork failed
+        fprintf(STDERR_FILENO, "Failed to fork: %s\n", strerror(errno));
+        return EXIT_FAILURE; // Return failure if fork fails
     }
-    sleep(2);
-    kill(ppid, SIGUSR1);
-    sleep(2);
-    kill(ppid, SIGTERM);
-    wait(NULL);
-    printf("main : end\n");
-    return 0;
+
+    return EXIT_SUCCESS; // Return success if everything runs correctly
 }
diff --git a/programs/tests/t_mem.c b/programs/tests/t_mem.c
index 6d6c4ace..ba3dd29d 100644
--- a/programs/tests/t_mem.c
+++ b/programs/tests/t_mem.c
@@ -1,52 +1,105 @@
 /// @file t_mem.c
-/// @brief
+/// @brief Memory allocation, writing, and deallocation example.
+/// @details This program allocates memory for a 2D array, writes to it, and
+/// then frees the memory. It demonstrates basic dynamic memory management in C,
+/// including error handling for memory allocation failures.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
-#include "io/debug.h"
-#include "time.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/unistd.h>
 #include <sys/wait.h>
+#include <io/debug.h>
+#include <time.h>
 
 int main(int argc, char *argv[])
 {
+    // Ensure the program is provided with exactly 2 arguments (row and column size)
     if (argc != 3) {
-        printf("%s: You must provide 2 dimensions.\n", argv[0]);
-        return 1;
+        fprintf(STDERR_FILENO, "%s: You must provide 2 dimensions (rows and columns).\n", argv[0]);
+        return EXIT_FAILURE;
     }
+
     char *ptr;
+    // Convert the first argument (rows) to an integer and validate it
     int rows = strtol(argv[1], &ptr, 10);
+    if (*ptr != '\0' || rows <= 0) {
+        fprintf(STDERR_FILENO, "Invalid number of rows: %s\n", argv[1]);
+        return EXIT_FAILURE;
+    }
+
+    // Convert the second argument (columns) to an integer and validate it
     int cols = strtol(argv[2], &ptr, 10);
+    if (*ptr != '\0' || cols <= 0) {
+        fprintf(STDERR_FILENO, "Invalid number of columns: %s\n", argv[2]);
+        return EXIT_FAILURE;
+    }
 
     printf("Allocating memory!\n");
     pr_warning("Allocating memory!\n");
+
+    // Allocate memory for an array of row pointers (rows x cols matrix)
     int **M = (int **)malloc(rows * sizeof(int *));
-    for (int i = 0; i < rows; ++i)
+    if (M == NULL) {
+        perror("Failed to allocate memory for row pointers");
+        return EXIT_FAILURE;
+    }
+
+    // Allocate memory for each row (array of integers) and check for allocation errors
+    for (int i = 0; i < rows; ++i) {
         M[i] = (int *)malloc(cols * sizeof(int));
+        if (M[i] == NULL) {
+            perror("Failed to allocate memory for columns");
+            // Free any previously allocated memory to prevent memory leaks
+            for (int j = 0; j < i; ++j) {
+                free(M[j]);
+            }
+            free(M);
+            return EXIT_FAILURE;
+        }
+    }
 
+    // Simulate delay for demonstration purposes
     sleep(5);
     printf("Writing memory!\n");
     pr_warning("Writing memory!\n");
-    for (int i = 0; i < rows; ++i)
-        for (int j = 0; j < cols; ++j)
+
+    // Write values to the 2D array (fill with i + j)
+    for (int i = 0; i < rows; ++i) {
+        for (int j = 0; j < cols; ++j) {
             M[i][j] = i + j;
+        }
+    }
 
+    // Simulate delay for demonstration purposes
     sleep(5);
     printf("Freeing memory (1)!\n");
     pr_warning("Freeing memory (1)!\n");
-    for (int i = 0; i < rows; ++i)
-        if (i % 2 != 0)
+
+    // Free the memory for odd-indexed rows
+    for (int i = 0; i < rows; ++i) {
+        if (i % 2 != 0) {
             free(M[i]);
+        }
+    }
+
     printf("Freeing memory (2)!\n");
     pr_warning("Freeing memory (2)!\n");
-    for (int i = 0; i < rows; ++i)
-        if (i % 2 == 0)
+
+    // Free the memory for even-indexed rows
+    for (int i = 0; i < rows; ++i) {
+        if (i % 2 == 0) {
             free(M[i]);
+        }
+    }
+
+    // Free the memory allocated for the row pointers array
     free(M);
 
+    // Simulate delay before exiting
     sleep(5);
     pr_warning("Exiting!\n");
-    return 0;
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_mkdir.c b/programs/tests/t_mkdir.c
index 4003bdff..9ce53dde 100644
--- a/programs/tests/t_mkdir.c
+++ b/programs/tests/t_mkdir.c
@@ -1,5 +1,7 @@
 /// @file t_mkdir.c
 /// @brief Test directory creation
+/// @details This program tests the creation, checking, and removal of directories.
+/// It demonstrates basic directory management in C, including error handling for directory operations.
 /// @copyright (c) 2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -13,50 +15,66 @@
 #include <sys/stat.h>
 #include <sys/unistd.h>
 
+/// @brief Create a directory.
+/// @param parent_directory The parent directory path.
+/// @param directory_name The name of the directory to create.
+/// @param mode The permissions to set for the new directory.
+/// @return EXIT_SUCCESS on success, EXIT_FAILURE on failure.
 int create_dir(const char *parent_directory, const char *directory_name, mode_t mode)
 {
     char path[PATH_MAX];
     memset(path, 0, PATH_MAX);
     strcat(path, parent_directory);
     strcat(path, directory_name);
-    pr_notice("Creating directory `%s`...\n", path);
     if (mkdir(path, mode) < 0) {
-        pr_err("Failed to create directory %s: %s\n", path, strerror(errno));
+        fprintf(STDERR_FILENO, "Failed to create directory %s: %s\n", path, strerror(errno));
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
+/// @brief Remove a directory.
+/// @param parent_directory The parent directory path.
+/// @param directory_name The name of the directory to remove.
+/// @return EXIT_SUCCESS on success, EXIT_FAILURE on failure.
 int remove_dir(const char *parent_directory, const char *directory_name)
 {
     char path[PATH_MAX];
     memset(path, 0, PATH_MAX);
     strcat(path, parent_directory);
     strcat(path, directory_name);
-    pr_notice("Removing directory `%s`...\n", path);
     if (rmdir(path) < 0) {
-        pr_err("Failed to remove directory %s: %s\n", path, strerror(errno));
+        fprintf(STDERR_FILENO, "Failed to remove directory %s: %s\n", path, strerror(errno));
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
+/// @brief Check if a directory exists.
+/// @param parent_directory The parent directory path.
+/// @param directory_name The name of the directory to check.
+/// @return EXIT_SUCCESS if the directory exists, EXIT_FAILURE otherwise.
 int check_dir(const char *parent_directory, const char *directory_name)
 {
     char path[PATH_MAX];
     memset(path, 0, PATH_MAX);
     strcat(path, parent_directory);
     strcat(path, directory_name);
-    pr_notice("Checking directory `%s`...\n", path);
-    stat_t buffer;
-    stat(path, &buffer);
+    struct stat buffer;
+    if (stat(path, &buffer) < 0) {
+        fprintf(STDERR_FILENO, "Failed to check directory `%s`: %s\n", path, strerror(errno));
+        return EXIT_FAILURE;
+    }
     if (!S_ISDIR(buffer.st_mode)) {
-        pr_err("Failed to check directory `%s` : %s.\n", path, strerror(errno));
+        fprintf(STDERR_FILENO, "Path `%s` is not a directory.\n", path);
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
+/// @brief Test the creation, checking, and removal of consecutive directories.
+/// @param parent_directory The parent directory path.
+/// @return EXIT_SUCCESS on success, EXIT_FAILURE on failure.
 int test_consecutive_dirs(const char *parent_directory)
 {
     int ret = EXIT_SUCCESS;
@@ -72,7 +90,7 @@ int test_consecutive_dirs(const char *parent_directory)
         remove_dir(parent_directory, "/t_mkdir");
         return EXIT_FAILURE;
     }
-    // Check if both directories are present.
+    // Check if all directories are present.
     if ((ret = check_dir(parent_directory, "/t_mkdir")) == EXIT_SUCCESS) {
         if ((ret = check_dir(parent_directory, "/t_mkdir/outer")) == EXIT_SUCCESS) {
             ret = check_dir(parent_directory, "/t_mkdir/outer/inner");
@@ -93,7 +111,6 @@ int test_consecutive_dirs(const char *parent_directory)
 
 int main(int argc, char *argv[])
 {
-    pr_notice("Running `test_consecutive_dirs`...\n");
     if (test_consecutive_dirs("")) {
         return EXIT_FAILURE;
     }
diff --git a/programs/tests/t_msgget.c b/programs/tests/t_msgget.c
index e4f2e5bb..ef4a76f3 100644
--- a/programs/tests/t_msgget.c
+++ b/programs/tests/t_msgget.c
@@ -1,5 +1,11 @@
 /// @file t_msgget.c
-/// @brief This program creates a message queue.
+/// @brief This program creates a message queue and demonstrates sending and
+/// receiving messages using System V message queues.
+/// @details This program creates a message queue, sends and receives messages,
+/// and then deletes the message queue. It demonstrates basic message queue
+/// operations in C, including error handling for message queue operations. The
+/// program also includes a child process that sends a message to the parent
+/// process.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -15,12 +21,17 @@
 
 #define MESSAGE_LEN 100
 
-// structure for message queue
+/// @brief Structure for message queue.
 typedef struct {
-    long mesg_type;
-    char mesg_text[MESSAGE_LEN];
+    long mesg_type;              ///< Message type.
+    char mesg_text[MESSAGE_LEN]; ///< Message text.
 } message_t;
 
+/// @brief Send a message to the message queue.
+/// @param msqid The message queue identifier.
+/// @param mtype The message type.
+/// @param message The message structure.
+/// @param msg The message text.
 static inline void __send_message(int msqid, long mtype, message_t *message, const char *msg)
 {
     // Set the type.
@@ -35,6 +46,10 @@ static inline void __send_message(int msqid, long mtype, message_t *message, con
     }
 }
 
+/// @brief Receive a message from the message queue.
+/// @param msqid The message queue identifier.
+/// @param mtype The message type.
+/// @param message The message structure.
 static inline void __receive_message(int msqid, long mtype, message_t *message)
 {
     // Clear the user-defined message.
@@ -59,7 +74,7 @@ int main(int argc, char *argv[])
     key = ftok("/README", 5);
     if (key < 0) {
         perror("Failed to generate key using ftok");
-        return 1;
+        return EXIT_FAILURE;
     }
     printf("Generated key using ftok (key = %d)\n", key);
 
@@ -68,7 +83,7 @@ int main(int argc, char *argv[])
     msqid = msgget(key, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
     if (msqid < 0) {
         perror("Failed to create message queue");
-        return 1;
+        return EXIT_FAILURE;
     }
     printf("Created message queue (id : %d)\n", msqid);
 
@@ -82,30 +97,32 @@ int main(int argc, char *argv[])
         sleep(3);
         // Send the message.
         __send_message(msqid, 1, &message, "General Kenobi...");
-        return 0;
+        return EXIT_SUCCESS;
     }
     // Receive the message.
     __receive_message(msqid, 1, &message);
     sleep(3);
 
     // ========================================================================
-    // Send the message.
+    // Send multiple messages.
     __send_message(msqid, 7, &message, "course, ");
     __send_message(msqid, 9, &message, "cheers!");
     __send_message(msqid, 1, &message, "From the operating");
     __send_message(msqid, 3, &message, "systems");
 
-    // Receive the message.
+    // Receive multiple messages.
     __receive_message(msqid, 1, &message);
     __receive_message(msqid, -8, &message);
     __receive_message(msqid, -8, &message);
     __receive_message(msqid, 0, &message);
 
+    // ========================================================================
     // Delete the message queue.
     ret = msgctl(msqid, IPC_RMID, NULL);
     if (ret < 0) {
         perror("Failed to remove message queue.");
+        return EXIT_FAILURE;
     }
     printf("Correctly removed message queue.\n");
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_periodic1.c b/programs/tests/t_periodic1.c
index ec86cd87..24f1a2f9 100644
--- a/programs/tests/t_periodic1.c
+++ b/programs/tests/t_periodic1.c
@@ -1,5 +1,9 @@
 /// @file t_periodic1.c
-/// @brief
+/// @brief Test program for periodic scheduling.
+/// @details This program sets periodic scheduling parameters for the current process,
+/// forks two child processes to execute other programs, and periodically prints a counter.
+/// It demonstrates the use of `sched_getparam`, `sched_setparam`, and `waitperiod` functions
+/// for managing periodic tasks in a real-time system.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -7,40 +11,62 @@
 #include <sched.h>
 #include <sys/unistd.h>
 #include <strerror.h>
+#include <stdlib.h>
 
 int main(int argc, char *argv[])
 {
     pid_t cpid = getpid();
-    sched_param_t param;
-    // Get current parameters.
-    sched_getparam(cpid, &param);
-    // Change parameters.
-    param.period      = 5000;
-    param.deadline    = 5000;
-    param.is_periodic = true;
-    // Set modified parameters.
-    sched_setparam(cpid, &param);
-    int counter   = 0;
+    struct sched_param param;
+
+    // Get current scheduling parameters.
+    if (sched_getparam(cpid, &param) == -1) {
+        fprintf(STDERR_FILENO, "Failed to get scheduling parameters: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    // Change scheduling parameters.
+    param.sched_priority = 1;    // Set priority (example value, adjust as needed).
+    param.period         = 5000; // Set period to 5000 ms.
+    param.deadline       = 5000; // Set deadline to 5000 ms.
+    param.is_periodic    = 1;    // Set as periodic task.
+
+    // Set modified scheduling parameters.
+    if (sched_setparam(cpid, &param) == -1) {
+        fprintf(STDERR_FILENO, "Failed to set scheduling parameters: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    int counter = 0;
+
+    // Fork the first child process.
     if (fork() == 0) {
         char *_argv[] = { "/bin/tests/t_periodic2", NULL };
         execv(_argv[0], _argv);
-        printf("This is bad, I should not be here! EXEC NOT WORKING\n");
+        fprintf(STDERR_FILENO, "Failed to execute %s: %s\n", _argv[0], strerror(errno));
+        return EXIT_FAILURE;
     }
+
+    // Fork the second child process.
     if (fork() == 0) {
         char *_argv[] = { "/bin/tests/t_periodic3", NULL };
         execv(_argv[0], _argv);
-        printf("This is bad, I should not be here! EXEC NOT WORKING\n");
+        fprintf(STDERR_FILENO, "Failed to execute %s: %s\n", _argv[0], strerror(errno));
+        return EXIT_FAILURE;
     }
 
+    // Periodically print the counter.
     while (1) {
         if (++counter == 10) {
             counter = 0;
         }
-        printf("[periodic1]counter %d\n",counter);
+        printf("[periodic1] counter %d\n", counter);
+
+        // Wait for the next period.
         if (waitperiod() == -1) {
-            printf("[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
+            fprintf(STDERR_FILENO, "[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
             break;
         }
     }
-    return 0;
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_periodic2.c b/programs/tests/t_periodic2.c
index cda291e8..11e12c41 100644
--- a/programs/tests/t_periodic2.c
+++ b/programs/tests/t_periodic2.c
@@ -1,5 +1,9 @@
 /// @file t_periodic2.c
-/// @brief
+/// @brief Test program for periodic scheduling.
+/// @details This program sets periodic scheduling parameters for the current process
+/// and periodically prints a counter. It demonstrates the use of `sched_getparam`,
+/// `sched_setparam`, and `waitperiod` functions for managing periodic tasks in a real-time system.
+/// The program runs until the counter reaches 10 or an error occurs in `waitperiod`.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -7,28 +11,46 @@
 #include <sched.h>
 #include <sys/unistd.h>
 #include <strerror.h>
+#include <stdlib.h>
 
 int main(int argc, char *argv[])
 {
     pid_t cpid = getpid();
-    sched_param_t param;
-    // Get current parameters.
-    sched_getparam(cpid, &param);
-    // Change parameters.
-    param.period      = 4000;
-    param.deadline    = 4000;
-    param.is_periodic = true;
-    // Set modified parameters.
-    sched_setparam(cpid, &param);
+    struct sched_param param;
+
+    // Get current scheduling parameters.
+    if (sched_getparam(cpid, &param) == -1) {
+        fprintf(STDERR_FILENO, "Failed to get scheduling parameters: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    // Change scheduling parameters.
+    param.sched_priority = 1; // Set priority (example value, adjust as needed).
+    param.period = 4000;      // Set period to 4000 ms.
+    param.deadline = 4000;    // Set deadline to 4000 ms.
+    param.is_periodic = 1;    // Set as periodic task.
+
+    // Set modified scheduling parameters.
+    if (sched_setparam(cpid, &param) == -1) {
+        fprintf(STDERR_FILENO, "Failed to set scheduling parameters: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
     int counter = 0;
+
+    // Periodically print the counter.
     while (1) {
-        if (++counter == 10)
+        if (++counter == 10) {
             break;
-        printf("[priodic2] counter: %d\n", counter);
+        }
+        printf("[periodic2] counter: %d\n", counter);
+
+        // Wait for the next period.
         if (waitperiod() == -1) {
-            printf("[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
+            fprintf(STDERR_FILENO, "[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
             break;
         }
     }
-    return 0;
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_periodic3.c b/programs/tests/t_periodic3.c
index 8d9e5cbc..90034207 100644
--- a/programs/tests/t_periodic3.c
+++ b/programs/tests/t_periodic3.c
@@ -1,34 +1,64 @@
 /// @file t_periodic3.c
-/// @brief
+/// @brief Periodic task scheduling demonstration using custom scheduler
+/// parameters.
+/// @details This program demonstrates the use of periodic task scheduling with
+/// custom parameters such as period, deadline, and periodicity. It uses
+/// `sched_getparam` and `sched_setparam` to modify and apply scheduling
+/// parameters for a process, and repeatedly waits for the next period using the
+/// `waitperiod` function.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <stdio.h>
 #include <sched.h>
 #include <sys/unistd.h>
+#include <string.h>
 #include <strerror.h>
+#include <stdlib.h>
 
 int main(int argc, char *argv[])
 {
-    pid_t cpid = getpid();
-    sched_param_t param;
-    // Get current parameters.
-    sched_getparam(cpid, &param);
-    // Change parameters.
-    param.period      = 3000;
-    param.deadline    = 3000;
-    param.is_periodic = true;
-    // Set modified parameters.
-    sched_setparam(cpid, &param);
-    int counter = 0;
+    pid_t cpid = getpid(); // Get the process ID of the current process
+    sched_param_t param;   // Define a structure to hold scheduling parameters
+
+    // Get the current scheduling parameters for this process
+    if (sched_getparam(cpid, &param) == -1) {
+        // If fetching parameters fails, print an error message and exit
+        fprintf(stderr, "[%s] Error in sched_getparam: %s\n", argv[0], strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    // Modify the scheduling parameters
+    param.period      = 3000; // Set period to 3000 ms (3 seconds)
+    param.deadline    = 3000; // Set deadline to 3000 ms (3 seconds)
+    param.is_periodic = true; // Set the task to be periodic
+
+    // Set the new scheduling parameters for this process
+    if (sched_setparam(cpid, &param) == -1) {
+        // If setting parameters fails, print an error message and exit
+        fprintf(stderr, "[%s] Error in sched_setparam: %s\n", argv[0], strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    int counter = 0; // Initialize a counter for the periodic loop
+
+    // Enter a loop that runs for 10 iterations
     while (1) {
+        // Increment the counter and break out of the loop after 10 iterations
         if (++counter == 10)
             break;
+
+        // Print the current counter value
         printf("[periodic3] counter: %d\n", counter);
+
+        // Wait for the next period and check for errors
         if (waitperiod() == -1) {
-            printf("[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
+            // If waitperiod fails, print an error message and break out of the loop
+            fprintf(stderr, "[%s] Error in waitperiod: %s\n", argv[0], strerror(errno));
             break;
         }
     }
-    return 0;
+
+    // Return success if the program completes without errors
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_pwd.c b/programs/tests/t_pwd.c
index 09efdb16..61aa3480 100644
--- a/programs/tests/t_pwd.c
+++ b/programs/tests/t_pwd.c
@@ -1,5 +1,8 @@
 /// @file t_pwd.c
-/// @brief Test the libc pwd.h interface
+/// @brief Test the libc pwd.h interface for user and group management.
+/// @details This program tests the password database interface provided by
+/// libc's pwd.h. It checks for valid and invalid user names and UIDs, ensuring
+/// proper functionality of `getpwnam` and `getpwuid`.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -11,25 +14,58 @@
 #include <string.h>
 #include <strerror.h>
 
-static void __test_getpwnam(void) {
-    // Test that getpwnam matches the whole user name literally
-    if (getpwnam("r") != NULL)
+/// @brief Test `getpwnam` for valid and invalid user names.
+/// @details This function checks if `getpwnam` correctly handles non-existent users
+/// and retrieves the correct information for an existing user like "root".
+static void __test_getpwnam(void)
+{
+    // Check for a non-existent user
+    if (getpwnam("r") != NULL) {
+        // If "r" is found, which is unexpected, exit with an error
         errx(EXIT_FAILURE, "Password entry for non-existent user \"r\" found");
+    }
 
-    if (getpwnam("root") == NULL)
+    // Check for the root user, which should always exist
+    if (getpwnam("root") == NULL) {
+        // If "root" is not found, exit with an error
         errx(EXIT_FAILURE, "Password entry for root user not found");
+    } else {
+        // If the root entry is found, print confirmation for debugging purposes
+        printf("Password entry for root user found.\n");
+    }
 }
 
-static void __test_getpwuid(void) {
-    if (getpwuid(1337) != NULL)
-        errx(EXIT_FAILURE, "Password entry for non-existent uid 1337 found");
+/// @brief Test `getpwuid` for valid and invalid user IDs.
+/// @details This function checks if `getpwuid` correctly handles non-existent UIDs
+/// and retrieves the correct information for a valid UID like 0 (root).
+static void __test_getpwuid(void)
+{
+    // Check for a non-existent UID
+    if (getpwuid(1337) != NULL) {
+        // If UID 1337 is found, which is unexpected, exit with an error
+        errx(EXIT_FAILURE, "Password entry for non-existent UID 1337 found");
+    }
 
-    if (getpwuid(0) == NULL)
-        errx(EXIT_FAILURE, "Password entry for uid 0 not found");
+    // Check for the root UID, which should always exist
+    if (getpwuid(0) == NULL) {
+        // If UID 0 is not found, exit with an error
+        errx(EXIT_FAILURE, "Password entry for UID 0 (root) not found");
+    } else {
+        // If the UID 0 entry is found, print confirmation for debugging purposes
+        printf("Password entry for UID 0 (root) found.\n");
+    }
 }
 
+/// @brief Main function that runs the tests for `getpwnam` and `getpwuid`.
+/// @return Returns EXIT_SUCCESS if all tests pass, otherwise exits with failure.
 int main(int argc, char *argv[])
 {
+    // Run the test for `getpwnam` function
     __test_getpwnam();
+
+    // Run the test for `getpwuid` function
     __test_getpwuid();
+
+    // If both tests pass, return success
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_schedfb.c b/programs/tests/t_schedfb.c
index 45071c34..06833796 100644
--- a/programs/tests/t_schedfb.c
+++ b/programs/tests/t_schedfb.c
@@ -1,22 +1,61 @@
 /// @file t_schedfb.c
-/// @brief Start the scheduler feedback session.
+/// @brief Start the scheduler feedback session by running multiple child
+/// processes.
+/// @details This program forks several child processes to execute the `t_alarm`
+/// test. It demonstrates basic process creation and execution control using
+/// `fork`, `execl`, and `wait`. Each child process runs the `t_alarm` program,
+/// but will sleep, hence, they will not be scheduled immediately.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
 #include <sys/unistd.h>
 #include <sys/wait.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <strerror.h>
 
 int main(int argc, char *argv[])
 {
     pid_t cpid;
-    printf("First test, the child will sleep, thus, they will not be scheduled.\n");
+
+    printf("First test: The child processes will sleep, so they will not be scheduled immediately.\n");
+
+    // Fork 10 child processes to run the t_alarm test.
     for (int i = 0; i < 10; ++i) {
-        if ((cpid = fork()) == 0) {
-            execl("/bin/tests/t_alarm", "t_alarm", NULL);
+        // Fork a new process
+        if ((cpid = fork()) == -1) {
+            // Fork failed, print the error and exit.
+            fprintf(stderr, "Failed to fork process: %s\n", strerror(errno));
+            return EXIT_FAILURE;
+        }
+
+        // Child process
+        if (cpid == 0) {
+            // Execute the t_alarm program in the child process.
+            // execl replaces the current process image with the one specified ("/bin/tests/t_alarm").
+            if (execl("/bin/tests/t_alarm", "t_alarm", NULL) == -1) {
+                // If execl fails, print the error and exit the child process.
+                fprintf(stderr, "Failed to exec t_alarm: %s\n", strerror(errno));
+                return EXIT_FAILURE;
+            }
+            // Child process exits after executing the command.
             return 0;
         }
     }
-    while (wait(NULL) != -1) continue;
-    return 0;
+
+    // Parent process waits for all child processes to terminate.
+    while (wait(NULL) != -1) {
+        // Continue waiting until all child processes finish.
+        continue;
+    }
+
+    // If wait returns -1 and errno is not ECHILD, print an error.
+    if (errno != ECHILD) {
+        fprintf(stderr, "Error occurred while waiting for child processes: %s\n", strerror(errno));
+        return EXIT_FAILURE;
+    }
+
+    printf("All child processes have completed.\n");
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_semflg.c b/programs/tests/t_semflg.c
index a20822ab..b4b01064 100644
--- a/programs/tests/t_semflg.c
+++ b/programs/tests/t_semflg.c
@@ -1,7 +1,12 @@
 /// @file t_semflg.c
-/// @brief Tests some of the IPC flags.
-/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
-/// See LICENSE.md for details.
+/// @brief Tests the use of semaphores and some IPC flags.
+/// @details This program creates a semaphore set, performs operations on the
+/// semaphore from both parent and child processes, and demonstrates basic IPC
+/// mechanisms using semaphores. The parent and child process modify and check
+/// the semaphore value. The semaphore set is deleted once the operations are
+/// complete.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
 
 #include <sys/unistd.h>
 #include <sys/errno.h>
@@ -11,101 +16,102 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <stdio.h>
+#include <string.h>
+#include <strerror.h>
 
 int main(int argc, char *argv[])
 {
-    struct sembuf op[1];
-    union semun arg;
-    long ret, semid;
+    struct sembuf op[1]; // Operation structure for semaphore operations.
+    union semun arg;     // Union to store semaphore values.
+    long ret, semid;     // Return values and semaphore ID.
 
     // ========================================================================
-    // Create the first semaphore.
+    // Create a semaphore set with one semaphore.
     semid = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
     if (semid < 0) {
         perror("Failed to create semaphore set");
-        return 1;
+        return EXIT_FAILURE;
     }
-    printf("[father] Created semaphore set (semid : %d)\n", semid);
+    printf("[parent] Created semaphore set (semid: %ld)\n", semid);
 
     // ========================================================================
-    // Set the value of the semaphore in the structure.
+    // Set the value of the semaphore to 1.
     arg.val = 1;
-    // Setting the semaphore value.
-    ret = semctl(semid, 0, SETVAL, &arg);
+    ret     = semctl(semid, 0, SETVAL, &arg);
     if (ret < 0) {
         perror("Failed to set value of semaphore");
-        return 1;
+        return EXIT_FAILURE;
     }
-    printf("[father] Set semaphore value (id : %d, value : %d == 1)\n", semid, arg.val);
+    printf("[parent] Set semaphore value to 1 (semid: %ld)\n", semid);
 
     // ========================================================================
-    // Check if we successfully set the value of the semaphore.
+    // Get and verify the semaphore value.
     ret = semctl(semid, 0, GETVAL, NULL);
     if (ret < 0) {
-        perror("Failed to get the value of semaphore set");
-        return 1;
+        perror("Failed to get value of semaphore");
+        return EXIT_FAILURE;
     }
-    printf("[father] Get semaphore value (id : %d, value : %d == 1)\n", semid, ret);
+    printf("[parent] Semaphore value is %ld (expected: 1)\n", ret);
 
     // ========================================================================
-    // Create child process.
-    if (!fork()) {
+    // Fork a child process to manipulate the semaphore.
+    if (fork() == 0) {
         struct sembuf op_child;
-        // Initialize the operation structure.
+        // Initialize the operation to increment the semaphore by 1.
         op_child.sem_num = 0; // Operate on semaphore 0.
-        op_child.sem_op  = 1; // Increment value by 1.
-        op_child.sem_flg = 0; // No flags.
+        op_child.sem_op  = 1; // Increment by 1.
+        op_child.sem_flg = 0; // No special flags.
 
-        sleep(3);
+        sleep(3); // Simulate delay before child performs the operation.
 
-        // ====================================================================
-        // Increment semaphore value.
+        // Perform the increment operation on the semaphore.
         if (semop(semid, &op_child, 1) < 0) {
-            perror("Failed to perform first child operation");
-            return 1;
+            perror("[child] Failed to perform semaphore operation");
+            return EXIT_FAILURE;
         }
-        printf("[child] Succesfully performed opeation (id : %d)\n", semid);
+        printf("[child] Successfully incremented semaphore (semid: %ld)\n", semid);
 
-        // ====================================================================
-        // Check if we successfully set the value of the semaphore.
+        // Check the updated value of the semaphore.
         ret = semctl(semid, 0, GETVAL, NULL);
         if (ret < 0) {
-            perror("Failed to get the value of semaphore set");
-            return 1;
+            perror("[child] Failed to get value of semaphore");
+            return EXIT_FAILURE;
         }
-        printf("[child] Get semaphore value (id : %d, value : %d == 1)\n", semid, ret);
-        printf("[child] Exit, now.\n", semid, ret);
-        return 0;
+        printf("[child] Semaphore value is %ld (expected: 2)\n", ret);
+        printf("[child] Exiting now.\n");
+        return EXIT_SUCCESS;
     }
 
-    op[0].sem_num = 0;
-    op[0].sem_op  = -2;
-    op[0].sem_flg = 0;
+    // Parent process prepares to perform a decrement operation on the semaphore.
+    op[0].sem_num = 0;  // Operate on semaphore 0.
+    op[0].sem_op  = -2; // Decrement by 2 (this will block if the semaphore value is less than 2).
+    op[0].sem_flg = 0;  // No special flags.
 
     // ========================================================================
-    // Perform the operation.
+    // Perform the decrement operation on the semaphore.
     if (semop(semid, op, 1) < 0) {
-        perror("Failed to perform operation");
-        return 1;
+        perror("[parent] Failed to perform semaphore operation");
+        return EXIT_FAILURE;
     }
-    printf("[father] Performed semaphore operations (id : %d)\n", semid);
+    printf("[parent] Successfully performed semaphore operations (semid: %ld)\n", semid);
 
     // ========================================================================
-    // Check if we successfully set the value of the semaphore.
+    // Get and verify the final value of the semaphore.
     ret = semctl(semid, 0, GETVAL, NULL);
     if (ret < 0) {
-        perror("Failed to get the value of semaphore set");
-        return 1;
+        perror("[parent] Failed to get value of semaphore");
+        return EXIT_FAILURE;
     }
-    printf("[father] Get semaphore value (id : %d, value : %d == 1)\n", semid, ret);
+    printf("[parent] Semaphore value is %ld (expected: 0)\n", ret);
 
     // ========================================================================
-    // Delete the semaphore set.
+    // Remove the semaphore set.
     ret = semctl(semid, 0, IPC_RMID, 0);
     if (ret < 0) {
-        perror("Failed to remove semaphore set");
+        perror("[parent] Failed to remove semaphore set");
+        return EXIT_FAILURE;
     }
-    printf("[father] Correctly removed semaphore set.\n");
+    printf("[parent] Successfully removed semaphore set (semid: %ld)\n", semid);
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_semget.c b/programs/tests/t_semget.c
index a38e546c..8e13dc73 100644
--- a/programs/tests/t_semget.c
+++ b/programs/tests/t_semget.c
@@ -1,13 +1,16 @@
 /// @file t_semget.c
-/// @brief This program creates a son and then performs a blocking operation on
-/// a semaphore. The son sleeps for  five seconds and then it wakes up his
-/// father and then it deletes the semaphore.
-/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
-/// See LICENSE.md for details.
+/// @brief This program demonstrates semaphore operations between a parent and
+/// child process. The child process increments a semaphore after sleeping,
+/// which unblocks the parent process. Finally, the semaphore is deleted by the
+/// child process before exiting.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
 
 #include <sys/unistd.h>
 #include <sys/errno.h>
 #include <sys/stat.h>
+#include <strerror.h>
+#include <sys/wait.h>
 #include <sys/sem.h>
 #include <sys/ipc.h>
 #include <stdlib.h>
@@ -16,133 +19,137 @@
 
 int main(int argc, char *argv[])
 {
-    struct sembuf op_child;
-    struct sembuf op_father[3];
-    union semun arg;
-    long ret, semid;
-    key_t key;
+    struct sembuf op_child;     // Semaphore operation for the child.
+    struct sembuf op_father[3]; // Semaphore operations for the father.
+    union semun arg;            // Union for semctl operations.
+    long ret, semid;            // Return values and semaphore ID.
+    key_t key;                  // Key for semaphore.
 
     // ========================================================================
-    // Generating a key using ftok
+    // Generate a unique key using ftok.
     key = ftok("/README", 5);
     if (key < 0) {
-        perror("Failed to generate key using ftok.");
+        perror("Failed to generate key using ftok");
         return 1;
     }
     printf("Generated key using ftok (key = %d)\n", key);
 
     // ========================================================================
-    // Create the first semaphore.
+    // Create a semaphore set with one semaphore.
     semid = semget(key, 1, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
     if (semid < 0) {
-        perror("Failed to create semaphore set.");
+        perror("Failed to create semaphore set");
         return 1;
     }
     printf("[father] Created semaphore set (id : %d)\n", semid);
 
     // ========================================================================
-    // Set the value of the semaphore in the structure.
+    // Set the value of the semaphore to 1.
     arg.val = 1;
-    // Setting the semaphore value.
-    ret = semctl(semid, 0, SETVAL, &arg);
+    ret     = semctl(semid, 0, SETVAL, &arg);
     if (ret < 0) {
-        perror("Failed to set value of semaphore.");
+        perror("Failed to set semaphore value");
         return 1;
     }
-    printf("[father] Set semaphore value (id : %d, value : %d == 1)\n", semid, arg.val);
+    printf("[father] Set semaphore value to 1 (id : %d)\n", semid);
 
     // ========================================================================
-    // Check if we successfully set the value of the semaphore.
+    // Verify that the semaphore value is set correctly.
     ret = semctl(semid, 0, GETVAL, NULL);
     if (ret < 0) {
-        perror("Failed to get the value of semaphore set.");
+        perror("Failed to get semaphore value");
         return 1;
     }
-    printf("[father] Get semaphore value (id : %d, value : %d == 1)\n", semid, ret);
+    printf("[father] Semaphore value is %d (expected: 1)\n", ret);
 
     // ========================================================================
-    // Create child process.
-    if (!fork()) {
-        // Initialize the operation structure.
+    // Fork a child process.
+    if (fork() == 0) {
+        // Child process setup.
         op_child.sem_num = 0; // Operate on semaphore 0.
-        op_child.sem_op  = 1; // Increment value by 1.
-        op_child.sem_flg = 0; // No flags.
+        op_child.sem_op  = 1; // Increment semaphore by 1.
+        op_child.sem_flg = 0; // No special flags.
 
-        // Semaphore has value 1.
-        sleep(3);
+        sleep(3); // Simulate some work before modifying the semaphore.
+
+        // Increment the semaphore, unblocking the parent.
         if (semop(semid, &op_child, 1) < 0) {
-            perror("Failed to perform first child operation.");
+            perror("Failed to perform child semaphore operation");
             return 1;
         }
-        printf("[child] Succesfully performed opeation (id : %d)\n", semid);
+        printf("[child] Performed first semaphore operation (id: %d)\n", semid);
 
-        // Check if we successfully set the value of the semaphore.
+        // Verify the updated semaphore value.
         ret = semctl(semid, 0, GETVAL, NULL);
         if (ret < 0) {
-            perror("Failed to get the value of semaphore set.");
+            perror("Failed to get semaphore value in child");
             return 1;
         }
-        printf("[child] Get semaphore value (id : %d, value : %d == 0)\n", semid, ret);
+        printf("[child] Semaphore value is %d (expected: 2)\n", ret);
 
-        // Semaphore has value 2, now the father can continue.
+        // Sleep and perform another increment operation.
         sleep(3);
         if (semop(semid, &op_child, 1) < 0) {
-            perror("Failed to perform second child operation.");
+            perror("Failed to perform second child semaphore operation");
             return 1;
         }
-        printf("[child] Succesfully performed opeation (id : %d)\n", semid);
+        printf("[child] Performed second semaphore operation (id: %d)\n", semid);
 
-        // Check if we successfully set the value of the semaphore.
+        // Check final semaphore value.
         ret = semctl(semid, 0, GETVAL, NULL);
         if (ret < 0) {
-            perror("Failed to get the value of semaphore set.");
+            perror("Failed to get final semaphore value in child");
             return 1;
         }
-        printf("[child] Get semaphore value (id : %d, value : %d == 0)\n", semid, ret);
+        printf("[child] Final semaphore value is %d\n", ret);
 
-        printf("[child] Exit, now.\n", semid, ret);
+        // Delete the semaphore set.
+        ret = semctl(semid, 0, IPC_RMID, 0);
+        if (ret < 0) {
+            perror("Failed to remove semaphore set in child");
+            return 1;
+        }
+        printf("[child] Removed semaphore set (id: %d)\n", semid);
 
-        // Exit with the child process.
+        // Exit the child process.
         return 0;
     }
 
     // ========================================================================
-    // Initialize the operation structure.
+    // Parent process: Prepare operations to decrement semaphore.
     op_father[0].sem_num = 0;  // Operate on semaphore 0.
-    op_father[0].sem_op  = -1; // Decrement value by 1.
-    op_father[0].sem_flg = 0;  // No flags.
+    op_father[0].sem_op  = -1; // Decrement by 1.
+    op_father[0].sem_flg = 0;  // No special flags.
+
     op_father[1].sem_num = 0;  // Operate on semaphore 0.
-    op_father[1].sem_op  = -1; // Decrement value by 1.
-    op_father[1].sem_flg = 0;  // No flags.
+    op_father[1].sem_op  = -1; // Decrement by 1.
+    op_father[1].sem_flg = 0;  // No special flags.
+
     op_father[2].sem_num = 0;  // Operate on semaphore 0.
-    op_father[2].sem_op  = -1; // Decrement value by 1.
-    op_father[2].sem_flg = 0;  // No flags.
+    op_father[2].sem_op  = -1; // Decrement by 1.
+    op_father[2].sem_flg = 0;  // No special flags.
 
     // ========================================================================
-    // Perform the operations.
+    // Perform the blocking semaphore operations.
     if (semop(semid, op_father, 3) < 0) {
-        perror("Failed to perform father operation.");
+        perror("Failed to perform parent semaphore operations");
         return 1;
     }
+    printf("[father] Performed semaphore operations (id: %d)\n", semid);
 
-    sleep(2);
-
-    printf("[father] Performed semaphore operations (id : %d)\n", semid);
-
-    // Check if we successfully set the value of the semaphore.
+    // Verify that the semaphore value is updated correctly.
     ret = semctl(semid, 0, GETVAL, NULL);
     if (ret < 0) {
-        perror("Failed to get the value of semaphore set.");
+        perror("Failed to get semaphore value in parent");
         return 1;
     }
-    printf("[father] Get semaphore value (id : %d, value : %d == 0)\n", semid, ret);
+    printf("[father] Semaphore value is %d (expected: 0)\n", ret);
 
-    // Delete the semaphore set.
-    ret = semctl(semid, 0, IPC_RMID, 0);
-    if (ret < 0) {
-        perror("Failed to remove semaphore set.");
+    // Wait for the child process to terminate.
+    if (wait(NULL) == -1) {
+        fprintf(stderr, "Failed to wait for child process: %s\n", strerror(errno));
+        return EXIT_FAILURE; // Return failure if wait fails.
     }
-    printf("[father] Correctly removed semaphore set.\n");
 
     return 0;
 }
diff --git a/programs/tests/t_semop.c b/programs/tests/t_semop.c
index 022cdc48..262a841c 100644
--- a/programs/tests/t_semop.c
+++ b/programs/tests/t_semop.c
@@ -1,7 +1,8 @@
 /// @file t_semop.c
-/// @brief Tests semop between processes.
-/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
-/// See LICENSE.md for details.
+/// @brief Demonstrates the use of semaphores between processes using semop.
+/// Each process modifies a semaphore and outputs part of a message in order.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
 
 #include <sys/unistd.h>
 #include <sys/errno.h>
@@ -15,75 +16,105 @@
 
 int main(int argc, char *argv[])
 {
+    // Define semaphore operations for the different processes
     struct sembuf sops[6];
+
+    // Process 1 (decrement semaphore 0)
     sops[0].sem_num = 0;
     sops[0].sem_op  = -1;
     sops[0].sem_flg = 0;
 
+    // Process 2 (decrement semaphore 1)
     sops[1].sem_num = 1;
     sops[1].sem_op  = -1;
     sops[1].sem_flg = 0;
 
+    // Process 3 (decrement semaphore 2)
     sops[2].sem_num = 2;
     sops[2].sem_op  = -1;
     sops[2].sem_flg = 0;
 
+    // Process 2 (increment semaphore 0)
     sops[3].sem_num = 0;
     sops[3].sem_op  = 1;
     sops[3].sem_flg = 0;
 
+    // Process 3 (increment semaphore 1)
     sops[4].sem_num = 1;
     sops[4].sem_op  = 1;
     sops[4].sem_flg = 0;
 
+    // Process 4 (increment semaphore 2)
     sops[5].sem_num = 2;
     sops[5].sem_op  = 1;
     sops[5].sem_flg = 0;
 
     int status;
 
-    //create a semaphore set
+    // ========================================================================
+    // Create a semaphore set with 4 semaphores.
     int semid = semget(17, 4, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+    if (semid == -1) {
+        perror("Failed to create semaphore set");
+        return 1;
+    }
 
-    //set the values of the semaphores
-    unsigned short values[] = { 0, 0, 0, 1 };
-
+    // ========================================================================
+    // Set initial semaphore values: {0, 0, 0, 1}
+    unsigned short values[] = { 0, 0, 0, 1 }; // Last semaphore is initialized to 1 for control.
     union semun arg;
     arg.array = values;
 
     if (semctl(semid, 0, SETALL, &arg) == -1) {
-        perror("Failed to set semaphores");
+        perror("Failed to set semaphore values");
         return 1;
     }
 
+    // ========================================================================
+    // Create child processes and perform semaphore operations.
+
+    // Process 1: Wait for semaphore 0 to decrement, then print "cheers!"
     if (!fork()) {
         semop(semid, &sops[0], 1);
         printf("cheers!\n");
         exit(0);
     }
+
+    // Process 2: Wait for semaphore 1, print "course, ", then increment semaphore 0
     if (!fork()) {
         semop(semid, &sops[1], 1);
         printf("course, ");
-        semop(semid, &sops[3], 1);
+        semop(semid, &sops[3], 1); // Increment semaphore 0 to signal Process 1.
         exit(0);
     }
+
+    // Process 3: Wait for semaphore 2, print "systems ", then increment semaphore 1
     if (!fork()) {
         semop(semid, &sops[2], 1);
         printf("systems ");
-        semop(semid, &sops[4], 1);
+        semop(semid, &sops[4], 1); // Increment semaphore 1 to signal Process 2.
         exit(0);
     }
+
+    // Process 4: Print "From the operating ", then increment semaphore 2 to start Process 3
     if (!fork()) {
         printf("From the operating ");
-        semop(semid, &sops[5], 1);
+        semop(semid, &sops[5], 1); // Increment semaphore 2 to signal Process 3.
         exit(0);
     }
+
+    // ========================================================================
+    // Wait for all child processes to finish.
     for (int n = 0; n < 4; n++) {
         wait(&status);
     }
+
+    // ========================================================================
+    // Remove the semaphore set after all processes are done.
     if (semctl(semid, 0, IPC_RMID, 0) == -1) {
-        perror("Failed to remove IPC");
+        perror("Failed to remove semaphore set");
         return 1;
     }
+
     return 0;
 }
diff --git a/programs/tests/t_setenv.c b/programs/tests/t_setenv.c
index 5be8dcf5..e79e49b2 100644
--- a/programs/tests/t_setenv.c
+++ b/programs/tests/t_setenv.c
@@ -1,7 +1,10 @@
 /// @file t_setenv.c
-/// @brief
-/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
-/// See LICENSE.md for details.
+/// @brief Demonstrates the use of `setenv` to set an environment variable and
+/// fork a child process that inherits the environment variable. The child
+/// executes a different program (`t_getenv`) to verify the environment variable
+/// is passed.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,19 +13,51 @@
 
 int main(int argc, char *argv[])
 {
+    // Arguments to pass to the child process (t_getenv)
     char *_argv[] = { "/bin/tests/t_getenv", NULL };
     int status;
 
+    // ========================================================================
+    // Set environment variable "ENV_VAR" to "pwd0" without overwriting if it exists.
     if (setenv("ENV_VAR", "pwd0", 0) == -1) {
-        printf("Failed to set env: `PWD`\n");
+        perror("Failed to set environment variable `ENV_VAR`");
         return 1;
     }
+    printf("Environment variable `ENV_VAR` set to `pwd0`\n");
 
-    if (fork() == 0) {
+    // ========================================================================
+    // Fork a child process to execute t_getenv.
+    pid_t pid = fork();
+    if (pid < 0) {
+        perror("Failed to fork");
+        return 1;
+    }
+
+    // Child process
+    if (pid == 0) {
+        // Execute t_getenv to check the environment variable in the child.
         execv(_argv[0], _argv);
-        printf("This is bad, I should not be here! EXEC NOT WORKING\n");
+
+        // If execv returns, something went wrong.
+        perror("Exec failed");
+        return 1; // Terminate the child process with error if execv fails.
+    }
+
+    // ========================================================================
+    // Parent process waits for the child to complete.
+    if (wait(&status) == -1) {
+        perror("Failed to wait for child process");
+        return 1;
+    }
+
+    // Check the status of the child process
+    if (WIFEXITED(status)) {
+        printf("Child process exited with status: %d\n", WEXITSTATUS(status));
+    } else if (WIFSIGNALED(status)) {
+        printf("Child process was terminated by signal: %d\n", WTERMSIG(status));
+    } else {
+        printf("Child process did not exit normally.\n");
     }
 
-    wait(&status);
     return 0;
 }
diff --git a/programs/tests/t_shm_read.c b/programs/tests/t_shm_read.c
index 31f89d1f..8b4549fe 100644
--- a/programs/tests/t_shm_read.c
+++ b/programs/tests/t_shm_read.c
@@ -1,56 +1,81 @@
+/// @file t_shm_read.c
+/// @brief A program that reads data from a shared memory segment using a key
+/// generated from a file and an id.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
+#include <sys/unistd.h>
 
 int main(int argc, char *argv[])
 {
     key_t key;
     int shmid, id;
     char *str, *ptr;
+    ;
     char *path;
+
+    // Ensure the correct number of command-line arguments are provided.
     if (argc != 3) {
-        printf("%s: You must provide a file and the id to generate the key.\n", argv[0]);
-        return 1;
+        fprintf(stderr, "%s: You must provide a file and the id to generate the key.\n", argv[0]);
+        return EXIT_FAILURE;
     }
-    // Get the file.
+
+    // Get the file path and the id from the command-line arguments.
     path = argv[1];
-    // Get the id.
-    id = strtol(argv[2], &ptr, 10);
-    // Generate the key.
+    id   = strtol(argv[2], &ptr, 10);
+    // Check if the conversion was successful and the number is non-negative.
+    if (*ptr != '\0' || id < 0) {
+        fprintf(STDERR_FILENO, "Invalid number: %s\n", argv[1]);
+        return EXIT_FAILURE;
+    }
+
+    // Generate the IPC key using ftok with the provided file and id.
     key = ftok(path, id);
     if (key == -1) {
         perror("ftok");
         return EXIT_FAILURE;
     }
     printf("id = %d; key = %d\n", id, key);
-    // Create shared memory.
+
+    // Create or locate a shared memory segment based on the key. The size is
+    // set to 1024 bytes, and 0666 allows read/write permissions.
     shmid = shmget(key, 1024, 0666);
     if (shmid == -1) {
         perror("shmget");
         return EXIT_FAILURE;
     }
     printf("shmid = %d;\n", shmid);
-    // Attach the shared memory.
+
+    // Attach the process to the shared memory segment in read-only mode (SHM_RDONLY).
     str = (char *)shmat(shmid, NULL, SHM_RDONLY);
-    if (str == NULL) {
+    if (str == (char *)-1) {
         perror("shmat");
         return EXIT_FAILURE;
     }
-    // Print the message.
+
     printf("Data read from memory: %s (%p)\n", str, str);
-    str[0] = 'H';
-    // Detatch the shared memory.
+
+    // Attempting to modify shared memory here would fail due to SHM_RDONLY mode.
+    // The following line is commented out as it will cause an error:
+    // str[0] = 'H'; // Would trigger a memory access violation
+
+    // Detach the process from the shared memory segment after use.
     if (shmdt(str) < 0) {
         perror("shmdt");
         return EXIT_FAILURE;
     }
-    // Remove the shared memory.
+
+    // Mark the shared memory segment for removal (IPC_RMID).
     if (shmctl(shmid, IPC_RMID, NULL) == -1) {
         perror("shmctl");
         return EXIT_FAILURE;
     }
+
     printf("Exiting.\n");
-    return EXIT_SUCCESS;
+    return EXIT_SUCCESS; // Return success
 }
diff --git a/programs/tests/t_shm_write.c b/programs/tests/t_shm_write.c
index 761deaa1..760a381f 100644
--- a/programs/tests/t_shm_write.c
+++ b/programs/tests/t_shm_write.c
@@ -1,8 +1,15 @@
+/// @file t_shm_write.c
+/// @brief A program that writes data to a shared memory segment using a key
+/// generated from a file and an id.
+/// @copyright (c) 2014-2024
+/// This file is distributed under the MIT License. See LICENSE.md for details.
+
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
+#include <sys/unistd.h>
 
 int main(int argc, char *argv[])
 {
@@ -10,44 +17,58 @@ int main(int argc, char *argv[])
     int shmid, id;
     char *str, *ptr;
     char *path;
+
+    // Ensure the correct number of command-line arguments are provided.
     if (argc != 3) {
-        printf("%s: You must provide a file and the id to generate the key.\n", argv[0]);
-        return 1;
+        fprintf(stderr, "%s: You must provide a file and the id to generate the key.\n", argv[0]);
+        return EXIT_FAILURE;
     }
-    // Get the file.
+
+    // Get the file path and the id from command-line arguments.
     path = argv[1];
-    // Get the id.
-    id = strtol(argv[2], &ptr, 10);
-    // Generate the key.
+    id   = strtol(argv[2], &ptr, 10);
+
+    // Validate that the provided id is a valid integer.
+    if (*ptr != '\0') {
+        fprintf(stderr, "%s: Invalid id: '%s'. Please provide a valid integer.\n", argv[0], argv[2]);
+        return EXIT_FAILURE;
+    }
+
+    // Generate a System V IPC key using the provided file path and id.
     key = ftok(path, id);
     if (key == -1) {
         perror("ftok");
         return EXIT_FAILURE;
     }
-    printf("id = %d; key = %d\n", id, key);
-    // Create shared memory.
+
+    // Create a shared memory segment with the generated key, size of 1024
+    // bytes, and permissions 0666.
     shmid = shmget(key, 1024, IPC_CREAT | 0666);
     if (shmid == -1) {
         perror("shmget");
         return EXIT_FAILURE;
     }
-    printf("shmid = %d;\n", shmid);
-    // Attach the shared memory.
+
+    // Attach the shared memory segment to the process's address space.
     str = (char *)shmat(shmid, NULL, 0);
-    if (str == NULL) {
+    // Ensure the shared memory was attached correctly.
+    if (str == (char *)-1) {
         perror("shmat");
         return EXIT_FAILURE;
     }
-    // Read the message.
-    // printf("Write Data : ");
-    // gets(str);
-    strcpy(str, "Hello there!\n");
-    // Print the message.
-    printf("Data written in memory: %s\n", str);
-    // Detatch the shared memory.
+
+    // Write a message to the shared memory, ensuring no buffer overflow using strncpy.
+    const char *message = "Hello there!\n";
+    // Copy the message to shared memory.
+    strncpy(str, message, 1024);
+    // Ensure the string is null-terminated.
+    str[1023] = '\0';
+
+    // Detach the shared memory segment from the process's address space.
     if (shmdt(str) < 0) {
         perror("shmdt");
         return EXIT_FAILURE;
     }
+
     return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_shmget.c b/programs/tests/t_shmget.c
index ba72196d..099e1f88 100644
--- a/programs/tests/t_shmget.c
+++ b/programs/tests/t_shmget.c
@@ -1,3 +1,8 @@
+/// @file t_shmget.c
+/// @brief Demonstrates the creation and usage of shared memory between a parent
+/// and child process.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
+/// See LICENSE.md for details.
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -7,6 +12,7 @@
 #include <sys/unistd.h>
 #include <sys/wait.h>
 
+/// Define the size of shared memory to hold two integers.
 #define MEM_SIZE sizeof(int) * 2
 
 int main(void)
@@ -15,7 +21,7 @@ int main(void)
     pid_t cpid;
     int *array;
 
-    // Create shared memory.
+    // Create shared memory segment with IPC_PRIVATE key and specified memory size.
     shmid = shmget(IPC_PRIVATE, MEM_SIZE, IPC_CREAT | 0600);
     if (shmid == -1) {
         perror("shmget");
@@ -43,10 +49,10 @@ int main(void)
         perror("shmat");
         return EXIT_FAILURE;
     }
-    
+
     // Wait for the child to finish.
     while (wait(NULL) != -1) continue;
-    
+
     printf("F: %p\n", array);
     array[1] = 2;
 
diff --git a/programs/tests/t_sigaction.c b/programs/tests/t_sigaction.c
index 051aab1f..4c713bb6 100644
--- a/programs/tests/t_sigaction.c
+++ b/programs/tests/t_sigaction.c
@@ -1,5 +1,8 @@
 /// @file t_sigaction.c
-/// @brief
+/// @brief Demonstrates signal handling using `sigaction` to handle SIGUSR1.
+/// @details The program sets up a handler for SIGUSR1 using `sigaction`, then
+/// sends SIGUSR1 to itself using `kill`. After the handler is executed, it
+/// prints the values allocated in the signal handler.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -11,38 +14,71 @@
 #include <strerror.h>
 #include <sys/wait.h>
 
+/// Pointer to store dynamically allocated values.
 static int *values = NULL;
 
+/// @brief Handler for SIGUSR1 signal.
+/// @details Allocates memory for an array of integers and populates it with
+/// values 0 to 3. Prints the values before and after memory allocation.
+/// @param sig Signal number (in this case, SIGUSR1).
 void sigusr1_handler(int sig)
 {
     printf("handler(sig: %d) : Starting handler.\n", sig);
-    printf("handler(sig: %d) : value : %d\n", sig, values);
+    printf("handler(sig: %d) : values pointer (before allocation): %p\n", sig, (void *)values);
+
+    // Allocate memory for an array of 4 integers.
     values = malloc(sizeof(int) * 4);
+    if (!values) {
+        perror("Failed to allocate memory in signal handler");
+        return;
+    }
+
+    // Populate the array with values and print them.
     for (int i = 0; i < 4; ++i) {
         values[i] = i;
         printf("values[%d] : `%d`\n", i, values[i]);
     }
-    printf("handler(sig: %d) : value : %d\n", sig, values);
+
+    printf("handler(sig: %d) : values pointer (after allocation): %p\n", sig, (void *)values);
     printf("handler(sig: %d) : Ending handler.\n", sig);
 }
 
 int main(int argc, char *argv[])
 {
-    sigaction_t action;
+    struct sigaction action;
     memset(&action, 0, sizeof(action));
-    action.sa_handler = sigusr1_handler;
+    action.sa_handler = sigusr1_handler; // Set handler for SIGUSR1.
+
+    // Set the SIGUSR1 handler using sigaction.
     if (sigaction(SIGUSR1, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGUSR1, strerror(errno));
+        fprintf(stderr, "Failed to set signal handler for SIGUSR1: %s\n", strerror(errno));
         return 1;
     }
 
-    printf("main : Calling handler (%d).\n", SIGUSR1);
-    printf("main : value : %d\n", values);
+    // Display initial state before signal is sent.
+    printf("main : Calling handler (signal %d).\n", SIGUSR1);
+    printf("main : values pointer (before signal): %p\n", (void *)values);
+
+    // Send SIGUSR1 to the current process.
     int ret = kill(getpid(), SIGUSR1);
-    printf("main : Returning from handler (%d): %d.\n", SIGUSR1, ret);
-    printf("main : value : %d\n", values);
-    for (int i = 0; i < 4; ++i)
-        printf("values[%d] : `%d`\n", i, values[i]);
+    if (ret == -1) {
+        perror("Failed to send SIGUSR1");
+        return 1;
+    }
+
+    // Display state after signal handler execution.
+    printf("main : Returning from handler (signal %d): %d.\n", SIGUSR1, ret);
+    printf("main : values pointer (after signal): %p\n", (void *)values);
+
+    // Print the array populated in the signal handler.
+    if (values != NULL) {
+        for (int i = 0; i < 4; ++i) {
+            printf("values[%d] : `%d`\n", i, values[i]);
+        }
+    }
+
+    // Free the allocated memory.
     free(values);
+
     return 0;
 }
diff --git a/programs/tests/t_sigfpe.c b/programs/tests/t_sigfpe.c
index b67efd31..2f1810f9 100644
--- a/programs/tests/t_sigfpe.c
+++ b/programs/tests/t_sigfpe.c
@@ -1,5 +1,14 @@
 /// @file t_sigfpe.c
-/// @brief
+/// @brief Demonstrates handling of a SIGFPE (floating-point exception) signal
+/// using sigaction. The program intentionally triggers a division by zero to
+/// cause the SIGFPE signal.
+/// @details
+/// This program sets a signal handler for the SIGFPE signal, which is raised
+/// when a floating-point exception occurs (in this case, division by zero).
+/// When the signal is received, the handler function is invoked, which catches
+/// the exception, displays relevant messages, and then exits. The program
+/// contains a section that deliberately divides by zero to trigger this signal.
+///
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -12,6 +21,7 @@
 #include <sys/wait.h>
 #include <time.h>
 
+/// Signal handler function that catches and handles SIGFPE.
 void sig_handler(int sig)
 {
     printf("handler(%d) : Starting handler.\n", sig);
@@ -31,6 +41,7 @@ int main(int argc, char *argv[])
     memset(&action, 0, sizeof(action));
     action.sa_handler = sig_handler;
 
+    // Set the SIGUSR1 handler using sigaction.
     if (sigaction(SIGFPE, &action, NULL) == -1) {
         printf("Failed to set signal handler (%s).\n", SIGFPE, strerror(errno));
         return 1;
@@ -45,4 +56,6 @@ int main(int argc, char *argv[])
     d /= e;
     e -= 1;
     printf("d: %d, e: %d\n", d, e);
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_siginfo.c b/programs/tests/t_siginfo.c
index 8ad52d7f..844695f6 100644
--- a/programs/tests/t_siginfo.c
+++ b/programs/tests/t_siginfo.c
@@ -1,5 +1,6 @@
 /// @file t_siginfo.c
-/// @brief
+/// @brief Demonstrates handling SIGFPE with siginfo structure to get detailed
+/// signal information.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -12,40 +13,71 @@
 #include <sys/wait.h>
 #include <time.h>
 
+/// @brief Signal handler for SIGFPE that uses siginfo_t to get more information
+/// about the signal.
+/// @param sig Signal number.
+/// @param siginfo Pointer to siginfo_t structure containing detailed
+/// information about the signal.
 void sig_handler_info(int sig, siginfo_t *siginfo)
 {
     printf("handler(%d, %p) : Starting handler.\n", sig, siginfo);
+
+    // Check if the received signal is SIGFPE.
     if (sig == SIGFPE) {
         printf("handler(%d, %p) : Correct signal.\n", sig, siginfo);
+
+        // Print additional information from the siginfo structure.
         printf("handler(%d, %p) : Code : %d\n", sig, siginfo, siginfo->si_code);
         printf("handler(%d, %p) : Exiting\n", sig, siginfo);
-        exit(0);
-    } else {
-        printf("handler(%d, %p) : Wrong signal.\n", sig, siginfo);
+
+        // Exit the process after handling the signal.
+        exit(EXIT_SUCCESS);
     }
-    printf("handler(%d, %p) : Ending handler.\n", sig, siginfo);
+
+    // Handle unexpected signals.
+    printf("handler(%d, %p) : Wrong signal.\n", sig, siginfo);
+    exit(EXIT_FAILURE);
 }
 
 int main(int argc, char *argv[])
 {
     sigaction_t action;
+
+    // Initialize the sigaction structure with zeros.
     memset(&action, 0, sizeof(action));
 
+    // Set the handler function and indicate that we want detailed information
+    // (SA_SIGINFO).
     action.sa_handler = (sighandler_t)sig_handler_info;
     action.sa_flags   = SA_SIGINFO;
 
+    // Attempt to set the signal handler for SIGFPE.
     if (sigaction(SIGFPE, &action, NULL) == -1) {
+        // Print error message if sigaction fails.
         printf("Failed to set signal handler (%s).\n", SIGFPE, strerror(errno));
         return 1;
     }
 
     printf("Diving by zero (unrecoverable)...\n");
 
-    // Should trigger ALU error, fighting the compiler...
+    // Perform a division that will eventually cause a divide-by-zero error to
+    // trigger SIGFPE.
     int d = 1, e = 1;
+
+    // Enter an infinite loop to progressively decrement e and eventually
+    // trigger SIGFPE.
     while (1) {
+        // Check to prevent division by zero for safety in other environments.
+        if (e == 0) {
+            fprintf(stderr, "Attempt to divide by zero.\n");
+            break;
+        }
         d /= e;
         e -= 1;
     }
+
+    // This line will not be reached if SIGFPE is triggered.
     printf("d: %d, e: %d\n", d, e);
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_sigmask.c b/programs/tests/t_sigmask.c
index 41d3496f..0d8739b6 100644
--- a/programs/tests/t_sigmask.c
+++ b/programs/tests/t_sigmask.c
@@ -1,5 +1,6 @@
 /// @file t_sigmask.c
-/// @brief
+/// @brief Demonstrates signal masking and unmasking using sigprocmask and
+/// handling SIGUSR1.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -11,9 +12,12 @@
 #include <strerror.h>
 #include <sys/wait.h>
 
+/// @brief Handler for SIGUSR1 signal.
+/// @param sig Signal number (should be SIGUSR1).
 void sigusr1_handler(int sig)
 {
     printf("handler(sig: %d) : Starting handler.\n", sig);
+    // Perform any necessary actions in the handler here.
     printf("handler(sig: %d) : Ending handler.\n", sig);
 }
 
@@ -21,29 +25,68 @@ int main(int argc, char *argv[])
 {
     int ret;
     sigaction_t action;
+
+    // Initialize sigaction structure and set the handler for SIGUSR1.
     memset(&action, 0, sizeof(action));
     action.sa_handler = sigusr1_handler;
+
+    // Set the signal handler for SIGUSR1.
     if (sigaction(SIGUSR1, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%d, %s).\n", SIGUSR1, strerror(errno));
-        return 1;
+        // Print error message if sigaction fails.
+        fprintf(stderr, "Failed to set signal handler (%d, %s).\n", SIGUSR1, strerror(errno));
+        return EXIT_FAILURE;
     }
 
     printf("main : Blocking signal (%d).\n", SIGUSR1);
+
+    // Define a signal set and initialize it to empty.
     sigset_t mask;
-    sigemptyset(&mask);
-    sigaddset(&mask, SIGUSR1);
-    sigprocmask(SIG_BLOCK, &mask, NULL);
+    if (sigemptyset(&mask) == -1) { // Check for error in sigemptyset.
+        perror("sigemptyset");
+        return EXIT_FAILURE;
+    }
+
+    // Add SIGUSR1 to the signal mask.
+    if (sigaddset(&mask, SIGUSR1) == -1) { // Check for error in sigaddset.
+        perror("sigaddset");
+        return EXIT_FAILURE;
+    }
+
+    // Block SIGUSR1 signal.
+    if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) { // Check for error in sigprocmask.
+        perror("sigprocmask (blocking)");
+        return EXIT_FAILURE;
+    }
 
     printf("main : Calling handler (%d).\n", SIGUSR1);
+
+    // Send SIGUSR1 to the current process.
     ret = kill(getpid(), SIGUSR1);
+    if (ret == -1) { // Check for error in kill.
+        perror("kill");
+        return EXIT_FAILURE;
+    }
+
     printf("main : Returning from handler (%d): %d.\n", SIGUSR1, ret);
 
     printf("main : Unblocking signal (%d).\n", SIGUSR1);
-    sigprocmask(SIG_UNBLOCK, &mask, NULL);
+
+    // Unblock SIGUSR1 signal.
+    if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1) { // Check for error in sigprocmask (unblocking).
+        perror("sigprocmask (unblocking)");
+        return EXIT_FAILURE;
+    }
 
     printf("main : Calling handler (%d).\n", SIGUSR1);
+
+    // Send SIGUSR1 to the current process again after unblocking.
     ret = kill(getpid(), SIGUSR1);
+    if (ret == -1) { // Check for error in kill.
+        perror("kill");
+        return EXIT_FAILURE;
+    }
+
     printf("main : Returning from handler (%d): %d.\n", SIGUSR1, ret);
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_sigusr.c b/programs/tests/t_sigusr.c
index 768e9cca..775cf304 100644
--- a/programs/tests/t_sigusr.c
+++ b/programs/tests/t_sigusr.c
@@ -1,5 +1,7 @@
 /// @file t_sigusr.c
-/// @brief
+/// @brief Demonstrates handling of SIGUSR1 and SIGUSR2 signals using a shared
+/// signal handler. The program exits after receiving SIGUSR1 twice or SIGUSR2
+/// once.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -12,44 +14,71 @@
 #include <sys/wait.h>
 #include <time.h>
 
+/// @brief Signal handler for SIGUSR1 and SIGUSR2.
+/// @param sig Signal number (should be SIGUSR1 or SIGUSR2).
 void sig_handler(int sig)
 {
     printf("handler(%d) : Starting handler.\n", sig);
-    
+
+    // Static variable to count the number of SIGUSR1 signals received.
     static int counter = 0;
+
     if (sig == SIGUSR1 || sig == SIGUSR2) {
         printf("handler(%d) : Correct signal. SIGUSER\n", sig);
+        // Increment the counter for received signals.
         counter += 1;
 
-        if (counter == 2)
-            exit(0);
-
+        // Exit if SIGUSR1 has been received twice.
+        if (counter == 2) {
+            exit(EXIT_SUCCESS); // Exit program when SIGUSR1 has been received twice.
+        }
     } else {
+        // Handle unexpected signals.
         printf("handler(%d) : Wrong signal.\n", sig);
+        exit(EXIT_FAILURE);
     }
+
     printf("handler(%d) : Ending handler.\n", sig);
 }
 
 int main(int argc, char *argv[])
 {
     sigaction_t action;
+
+    // Initialize sigaction structure to zero.
     memset(&action, 0, sizeof(action));
     action.sa_handler = sig_handler;
 
+    // Set the signal handler for SIGUSR1.
     if (sigaction(SIGUSR1, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGUSR1, strerror(errno));
-        return 1;
+        printf("Failed to set signal handler for SIGUSR1 (%s).\n", strerror(errno));
+        return EXIT_FAILURE;
     }
 
+    // Set the signal handler for SIGUSR2.
     if (sigaction(SIGUSR2, &action, NULL) == -1) {
-        printf("Failed to set signal handler (%s).\n", SIGUSR2, strerror(errno));
-        return 1;
+        printf("Failed to set signal handler for SIGUSR2 (%s).\n", strerror(errno));
+        return EXIT_FAILURE;
     }
 
-    kill(getpid(), SIGUSR1);
+    // Send SIGUSR1 signal to the current process.
+    if (kill(getpid(), SIGUSR1) == -1) {
+        perror("kill SIGUSR1");
+        return EXIT_FAILURE;
+    }
+
+    // Pause for a short period before sending the next signal.
     sleep(2);
-    kill(getpid(), SIGUSR2);
 
-    while(1) { };
-    return 1;
+    // Send SIGUSR2 signal to the current process.
+    if (kill(getpid(), SIGUSR2) == -1) {
+        perror("kill SIGUSR2");
+        return EXIT_FAILURE;
+    }
+
+    // Infinite loop to keep the program running and waiting for signals.
+    while (1) {}
+
+    // This point will never be reached due to the infinite loop.
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_sleep.c b/programs/tests/t_sleep.c
index 4d8438b7..fccad5f6 100644
--- a/programs/tests/t_sleep.c
+++ b/programs/tests/t_sleep.c
@@ -1,5 +1,6 @@
 /// @file t_sleep.c
-/// @brief
+/// @brief Demonstrates the use of the sleep function to pause program execution
+/// for a specified duration.
 /// @copyright (c) 2014-2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -14,8 +15,15 @@
 int main(int argc, char *argv[])
 {
     printf("Sleeping for 4 seconds... ");
-    sleep(4);
+
+    // Pause the program execution for 4 seconds. Error checking is included to
+    // ensure that sleep is successful.
+    if (sleep(4) != 0) {
+        perror("sleep");
+        return EXIT_FAILURE;
+    }
+
     printf("COMPLETED.\n");
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_spwd.c b/programs/tests/t_spwd.c
index b3273206..f42e7000 100644
--- a/programs/tests/t_spwd.c
+++ b/programs/tests/t_spwd.c
@@ -1,8 +1,11 @@
 /// @file t_spwd.c
-/// @author Enrico Fraccaroli (enry.frak@gmail.com)
-/// @brief
+/// @brief This program generates a SHA-256 hash for a given key or retrieves
+/// hashed user password information from the shadow password database.
+/// @copyright (c) 2014-2024 This file is distributed under the MIT License.
+/// See LICENSE.md for details.
 
 #include <shadow.h>
+#include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <math.h>
@@ -12,40 +15,70 @@
 
 int main(int argc, char *argv[])
 {
+    // Check if the correct number of arguments is provided.
     if (argc != 3) {
         printf("You can either:\n");
         printf("    -g, --generate <key> : prints the hashed key.\n");
         printf("    -l, --load <user>    : prints the hashed key stored for the given user.\n");
-        return 1;
+        return EXIT_FAILURE;
     }
+
+    // Generate SHA-256 hash for the provided key.
     if (!strcmp(argv[1], "--generate") || !strcmp(argv[1], "-g")) {
+        // Buffer to hold the hashed output.
         unsigned char buffer[SHA256_BLOCK_SIZE] = { 0 };
-        char output[SHA256_BLOCK_SIZE * 2 + 1]  = { 0 };
+        // Buffer to hold the hexadecimal representation of the hash.
+        char output[SHA256_BLOCK_SIZE * 2 + 1] = { 0 };
+        // SHA-256 context.
         SHA256_ctx_t ctx;
 
+        // Initialize the SHA-256 context.
         sha256_init(&ctx);
-        for (unsigned i = 0; i < 100000; ++i)
+
+        // Perform the hashing operation 100,000 times for security.
+        for (unsigned i = 0; i < 100000; ++i) {
             sha256_update(&ctx, (unsigned char *)argv[2], strlen(argv[2]));
+        }
+
+        // Finalize the hashing.
         sha256_final(&ctx, buffer);
 
+        // Convert the hash bytes to a hexadecimal string.
         sha256_bytes_to_hex(buffer, SHA256_BLOCK_SIZE, output, SHA256_BLOCK_SIZE * 2 + 1);
+
+        // Print the hashed key.
         printf("%s\n", output);
 
-    } else if (!strcmp(argv[1], "--load") || !strcmp(argv[1], "-l")) {
+    }
+    // Load and display information for the specified user from the shadow password database.
+    else if (!strcmp(argv[1], "--load") || !strcmp(argv[1], "-l")) {
+        // Retrieve the shadow password entry for the user.
         struct spwd *spbuf = getspnam(argv[2]);
-        tm_t *tm;
+
+        // Check if the user exists in the shadow password database.
         if (spbuf) {
+            // Retrieve the last change time.
             time_t lstchg = (time_t)spbuf->sp_lstchg;
-            tm            = localtime(&lstchg);
+            // Convert to local time structure.
+            tm_t *tm = localtime(&lstchg);
+
+            // Print the user information (month is zero-based).
             printf("name         : %s\n", spbuf->sp_namp);
             printf("password     :\n%s\n", spbuf->sp_pwdp);
-            printf("lastchange   : %02d/%02d %02d:%02d\n", tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
+            printf("lastchange   : %02d/%02d %02d:%02d\n", tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min);
             printf("days allowed : %d\n", spbuf->sp_min);
             printf("days req.    : %d\n", spbuf->sp_max);
             printf("days warning : %d\n", spbuf->sp_warn);
             printf("days inact   : %d\n", spbuf->sp_inact);
             printf("days expire  : %d\n", spbuf->sp_expire);
+        } else {
+            printf("User '%s' not found in the shadow password database.\n", argv[2]);
+            return EXIT_FAILURE;
         }
+    } else {
+        printf("Invalid option. Use -g/--generate or -l/--load.\n");
+        return EXIT_FAILURE;
     }
-    return 0;
+
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_stopcont.c b/programs/tests/t_stopcont.c
index de576922..75c665c5 100644
--- a/programs/tests/t_stopcont.c
+++ b/programs/tests/t_stopcont.c
@@ -4,54 +4,77 @@
 /// See LICENSE.md for details.
 
 #include <sys/unistd.h>
-#include <signal.h>
+#include <sys/wait.h>
 #include <stdlib.h>
+#include <signal.h>
 #include <stdio.h>
-#include <string.h>
 #include <time.h>
-#include "stdlib.h"
-#include <sys/wait.h>
-
-int child_pid;
 
-void wait_for_child(int signr)
+/// @brief Signal handler for SIGCONT.
+/// @param sig The signal number.
+void handle_signal(int sig)
 {
-    printf("Signal received: %s\n", strsignal(signr));
-    sleep(8);
-
-    printf("Sending continue sig to child\n");
-    if (kill(child_pid, SIGCONT) == -1)
-        printf("Error sending signal\n");
+    if (sig == SIGCONT) {
+        printf("Received SIGCONT, continuing execution...\n");
+    }
 }
 
 int main(int argc, char *argv[])
 {
-    sigaction_t action;
-    memset(&action, 0, sizeof(action));
-    action.sa_handler = wait_for_child;
-    if (sigaction(SIGCHLD, &action, NULL) == -1) {
-        printf("Failed to set signal handler. %d\n", SIGCHLD);
-        return 1;
-    }
+    pid_t pid = fork();
 
-    child_pid = fork();
-    if (child_pid != 0) {
-        printf("Child PID: %d\n", child_pid);
+    if (pid < 0) {
+        // Error handling for fork failure.
+        perror("fork failed");
+        exit(EXIT_FAILURE);
 
-        sleep(2);
-        printf("Sending stop sig to child\n");
+    } else if (pid == 0) { // Child process.
+
+        // Error handling for signal setup failure.
+        if (signal(SIGCONT, handle_signal) == SIG_ERR) {
+            perror("signal setup failed");
+            exit(EXIT_FAILURE);
+        }
 
-        if (kill(child_pid, SIGSTOP) == -1)
-            printf("Error sending signal\n");
+        printf("Child process (PID: %d) started.\n", getpid());
 
-        wait(NULL);
-    } else {
-        for (int c = 0; c < 5; c++) {
-            printf("c: %d\n", c);
+        while (1) {
+            printf("Child process running...\n");
             sleep(1);
         }
-        exit(0);
+
+    } else { // Parent process.
+
+        // Let the child process run for a bit.
+        sleep(3);
+        if (kill(pid, SIGSTOP) == -1) {
+            perror("failed to send SIGSTOP");
+            exit(EXIT_FAILURE);
+        }
+        printf("Parent sending SIGSTOP to child (PID: %d).\n", pid);
+
+        // Wait for a bit before continuing the child process.
+        sleep(3);
+        if (kill(pid, SIGCONT) == -1) {
+            perror("failed to send SIGCONT");
+            exit(EXIT_FAILURE);
+        }
+        printf("Parent sending SIGCONT to child (PID: %d).\n", pid);
+
+        // Wait for a bit before terminating the child process.
+        sleep(3);
+        if (kill(pid, SIGTERM) == -1) {
+            perror("failed to send SIGTERM");
+            exit(EXIT_FAILURE);
+        }
+        printf("Parent sending SIGTERM to child (PID: %d).\n", pid);
+
+        // Wait for the child process to finish.
+        if (wait(NULL) == -1) {
+            perror("wait failed");
+            exit(EXIT_FAILURE);
+        }
     }
 
-    return 0;
+    return EXIT_SUCCESS;
 }
diff --git a/programs/tests/t_write_read.c b/programs/tests/t_write_read.c
index c491d6e3..cff9e9af 100644
--- a/programs/tests/t_write_read.c
+++ b/programs/tests/t_write_read.c
@@ -1,5 +1,5 @@
 /// @file t_write_read.c
-/// @brief Test consecutive writes
+/// @brief Test consecutive writes and file operations.
 /// @copyright (c) 2024 This file is distributed under the MIT License.
 /// See LICENSE.md for details.
 
@@ -12,6 +12,10 @@
 #include <sys/unistd.h>
 #include <math.h>
 
+/// @brief Creates a file with the specified name and mode.
+/// @param filename The name of the file to create.
+/// @param mode The permissions for the file.
+/// @return EXIT_SUCCESS on success, or EXIT_FAILURE on failure.
 int create_file(const char *filename, mode_t mode)
 {
     int fd = creat(filename, mode);
@@ -23,64 +27,95 @@ int create_file(const char *filename, mode_t mode)
     return EXIT_SUCCESS;
 }
 
+/// @brief Checks the content of a file against the expected content.
+/// @param filename The name of the file to check.
+/// @param content The expected content of the file.
+/// @param length The length of the expected content.
+/// @return EXIT_SUCCESS on matching content, or EXIT_FAILURE on failure.
 int check_content(const char *filename, const char *content, int length)
 {
     char buffer[256];
+    // Clear the buffer.
     memset(buffer, 0, 256);
-    // Open the file.
+
+    // Open the file for reading.
     int fd = open(filename, O_RDONLY, 0);
     if (fd < 0) {
         printf("Failed to open file %s: %s\n", filename, strerror(errno));
         return EXIT_FAILURE;
     }
-    // Read the content.
-    if (read(fd, &buffer, max(min(length, 256), 0)) < 0) {
+
+    // Read the content from the file.
+    if (read(fd, &buffer, max(min(length, 256), 0)) < 0) { // Ensure not to exceed buffer size.
         printf("Reading from file %s failed: %s\n", filename, strerror(errno));
         close(fd);
         return EXIT_FAILURE;
     }
+
+    // Compare the read content with the expected content.
     if (strcmp(buffer, content) != 0) {
         printf("Unexpected file content `%s`, expecting `%s`.\n", buffer, content);
         close(fd);
         return EXIT_FAILURE;
     }
+
+    // Close the file descriptor after reading.
     close(fd);
     return EXIT_SUCCESS;
 }
 
+/// @brief Writes content to a file with specified options.
+/// @param filename The name of the file to write to.
+/// @param content The content to write to the file.
+/// @param length The length of the content to write.
+/// @param truncate Flag to indicate if the file should be truncated.
+/// @param append Flag to indicate if content should be appended.
+/// @return EXIT_SUCCESS on success, or EXIT_FAILURE on failure.
 int write_content(const char *filename, const char *content, int length, int truncate, int append)
 {
+    // Set write options.
     int flags = O_WRONLY | (truncate ? O_TRUNC : append ? O_APPEND :
                                                           0);
-    // Open the file.
+
+    // Open the file with the specified flags.
     int fd = open(filename, flags, 0);
     if (fd < 0) {
         printf("Failed to open file %s: %s\n", filename, strerror(errno));
         return EXIT_FAILURE;
     }
-    // Read the content.
+
+    // Write the content to the file.
     if (write(fd, content, length) < 0) {
         printf("Writing on file %s failed: %s\n", filename, strerror(errno));
         close(fd);
         return EXIT_FAILURE;
     }
+
+    // Close the file descriptor after writing.
     close(fd);
     return EXIT_SUCCESS;
 }
 
+/// @brief Tests writing and reading operations on a file.
+/// @param filename The name of the file to test.
+/// @return EXIT_SUCCESS on success, or EXIT_FAILURE on failure.
 int test_write_read(const char *filename)
 {
-    char buf[7] = { 0 };
+    char buf[7] = { 0 }; // Buffer for reading content.
+
     // Create the file.
     if (create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) {
         return EXIT_FAILURE;
     }
-    // Open the file.
+
+    // Open the file for writing.
     int fd = open(filename, O_WRONLY, 0);
     if (fd < 0) {
         printf("Failed to open file %s: %s\n", filename, strerror(errno));
         return EXIT_FAILURE;
     }
+
+    // Write content to the file.
     if (write(fd, "foo", 3) != 3) {
         printf("First write to %s failed: %s\n", filename, strerror(errno));
         close(fd);
@@ -91,81 +126,122 @@ int test_write_read(const char *filename)
         close(fd);
         return EXIT_FAILURE;
     }
-    // Close the file.
+
+    // Close the file after writing.
     close(fd);
-    // Check the content.
+
+    // Check the content of the file.
     if (check_content(filename, "foobar", 6)) {
         return EXIT_FAILURE;
     }
+
     return EXIT_SUCCESS;
 }
 
+/// @brief Tests truncating and overwriting file content.
+/// @param filename The name of the file to test.
+/// @return EXIT_SUCCESS on success, or EXIT_FAILURE on failure.
 int test_truncate(const char *filename)
 {
+    // Create the file.
     if (create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) {
         return EXIT_FAILURE;
     }
+
+    // Write initial content.
     if (write_content(filename, "foobar", 6, 0, 0)) {
         return EXIT_FAILURE;
     }
+
+    // Check the initial content.
     if (check_content(filename, "foobar", 6)) {
         return EXIT_FAILURE;
     }
+
+    // Overwrite part of the file.
     if (write_content(filename, "bark", 4, 0, 0)) {
         return EXIT_FAILURE;
     }
+
+    // Check the content after overwriting.
     if (check_content(filename, "barkar", 6)) {
         return EXIT_FAILURE;
     }
+
+    // Truncate the file and write new content.
     if (write_content(filename, "barf", 4, 1, 0)) {
         return EXIT_FAILURE;
     }
+
+    // Check the content after truncation and write.
     if (check_content(filename, "barf", 6)) {
         return EXIT_FAILURE;
     }
+
     return EXIT_SUCCESS;
 }
 
+/// @brief Tests appending content to a file.
+/// @param filename The name of the file to test.
+/// @return EXIT_SUCCESS on success, or EXIT_FAILURE on failure.
 int test_append(const char *filename)
 {
+    // Create the file.
     if (create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) {
         return EXIT_FAILURE;
     }
+
+    // Write initial content.
     if (write_content(filename, "fusro", 5, 0, 0)) {
         return EXIT_FAILURE;
     }
+
+    // Append new content.
     if (write_content(filename, "dah", 3, 0, 1)) {
         return EXIT_FAILURE;
     }
+
+    // Check the final content of the file.
     if (check_content(filename, "fusrodah", 8)) {
         return EXIT_FAILURE;
     }
+
     return EXIT_SUCCESS;
 }
 
 int main(int argc, char *argv[])
 {
-    char *filename = "/home/user/test.txt";
+    // Specify the file name.
+    char *filename = "/home/user/t_write_read.txt";
 
+    // Test write and read operations.
     printf("Running `test_write_read`...\n");
     if (test_write_read(filename)) {
+        // Clean up if there was an error.
         unlink(filename);
         return EXIT_FAILURE;
     }
+    // Clean up.
     unlink(filename);
 
+    // Test truncating and overwriting content.
     printf("Running `test_truncate`...\n");
     if (test_truncate(filename)) {
+        // Clean up if there was an error.
         unlink(filename);
         return EXIT_FAILURE;
     }
+    // Clean up.
     unlink(filename);
 
+    // Test appending content.
     printf("Running `test_append`...\n");
     if (test_append(filename)) {
+        // Clean up if there was an error.
         unlink(filename);
         return EXIT_FAILURE;
     }
+    // Clean up.
     unlink(filename);
 
     return EXIT_SUCCESS;