Fix memory leak

This commit adds proper cleanup on allocation failure and iterator
safety by saving next pointer before callback execution. In addition,
unlikely() branch prediction hints are added for better performance.

Author: jserv

include/lib/list.h

@@ -1,16 +1,17 @@
 /* Singly-linked list
  * – Two sentinel nodes (head and tail) eliminate edge-case tests.
  * – The list stores generic data pointers ('void *').
- * – All primitives are defined `static inline` so they can live entirely
+ * – All primitives are defined 'static inline' so they can live entirely
  *   in the header without multiple-definition issues.
- * – Comments follow C style and use concise American English.
  */
 
 #pragma once
 
 #include <lib/libc.h>
 #include <lib/malloc.h>
 
+#include "private/utils.h"
+
 /* List node */
 typedef struct list_node {
     struct list_node *next;
@@ -26,12 +27,18 @@ typedef struct {
 
 static inline list_t *list_create(void)
 {
-    list_t *list = malloc(sizeof(list_t));
-    list_node_t *head = malloc(sizeof(list_node_t));
-    list_node_t *tail = malloc(sizeof(list_node_t));
+    list_t *list = malloc(sizeof(*list));
+    if (unlikely(!list))
+        return NULL;
+
+    list_node_t *head = malloc(sizeof(*head));
+    if (unlikely(!head)) {
+        free(list);
+        return NULL;
+    }
 
-    if (!list || !head || !tail) { /* cleanup on failure */
-        free(tail);
+    list_node_t *tail = malloc(sizeof(*tail));
+    if (unlikely(!tail)) {
         free(head);
         free(list);
         return NULL;
@@ -64,7 +71,7 @@ static inline list_node_t *list_next(const list_node_t *node)
 static inline list_node_t *list_cnext(const list_t *list,
                                       const list_node_t *node)
 {
-    if (!list || !node)
+    if (unlikely(!list || !node))
         return NULL;
     return (node->next == list->tail) ? list->head->next : node->next;
 }
@@ -73,17 +80,15 @@ static inline list_node_t *list_cnext(const list_t *list,
 
 static inline list_node_t *list_pushback(list_t *list, void *data)
 {
-    if (!list)
+    if (unlikely(!list))
         return NULL;
 
-    list_node_t *node = malloc(sizeof(list_node_t));
-    if (!node)
+    list_node_t *node = malloc(sizeof(*node));
+    if (unlikely(!node))
         return NULL;
 
     node->data = data;
     node->next = list->tail;
-    list->tail->data = NULL; /* head and tail sentinels never hold data */
-    list->head->data = NULL;
 
     /* Insert before tail sentinel */
     list_node_t *prev = list->head;
@@ -97,7 +102,7 @@ static inline list_node_t *list_pushback(list_t *list, void *data)
 
 static inline void *list_pop(list_t *list)
 {
-    if (list_is_empty(list))
+    if (unlikely(list_is_empty(list)))
         return NULL;
 
     list_node_t *first = list->head->next;
@@ -112,14 +117,14 @@ static inline void *list_pop(list_t *list)
 /* Remove a specific node; returns its data */
 static inline void *list_remove(list_t *list, list_node_t *target)
 {
-    if (!list || !target || list_is_empty(list))
+    if (unlikely(!list || !target || list_is_empty(list)))
         return NULL;
 
     list_node_t *prev = list->head;
     while (prev->next != list->tail && prev->next != target)
         prev = prev->next;
 
-    if (prev->next != target)
+    if (unlikely(prev->next != target))
         return NULL; /* node not found */
 
     prev->next = target->next;
@@ -137,15 +142,16 @@ static inline list_node_t *list_foreach(list_t *list,
                                                            void *),
                                         void *arg)
 {
-    if (!list || !cb)
+    if (unlikely(!list || !cb))
         return NULL;
 
     list_node_t *node = list->head->next;
     while (node != list->tail) {
+        list_node_t *next = node->next; /* Save next before callback */
         list_node_t *res = cb(node, arg);
         if (res)
             return res;
-        node = node->next;
+        node = next;
     }
     return NULL;
 }
@@ -154,7 +160,7 @@ static inline list_node_t *list_foreach(list_t *list,
 
 static inline void list_clear(list_t *list)
 {
-    if (!list)
+    if (unlikely(!list))
         return;
     while (!list_is_empty(list))
         list_pop(list);