From 3ae2f13610f07d3cf159583f18edd899a4c92a73 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 2 Nov 2025 13:24:18 +0000
Subject: [PATCH 1/2] Fix all Valgrind errors: uninitialized values and memory
 leak

This commit resolves all Valgrind errors reported in the test run:

1. Fixed uninitialized 'removed' array in tcp_translate_events (tcp.c:179)
   - Added memset to initialize the array to zero before use

2. Fixed uninitialized RequestQueue in client initialization (client.c)
   - Added initialization of metadata_server.reqs and chunk_servers[].reqs
   - Added forward declaration of request_queue_init function

3. Fixed uninitialized descriptor generation field (system.c:324)
   - Initialize generation to 0 when creating process descriptors
   - Prevents uninitialized value errors in handle_to_desc

4. Fixed 34-byte memory leak in tcp_context_free (tcp.c:91-103)
   - Added cleanup of connection byte queues when freeing TCP context
   - Frees both input and output ByteQueues for all connections

All Valgrind errors have been resolved:
- ERROR SUMMARY: 0 errors from 0 contexts
- All heap blocks freed - no leaks possible
---
 src/client.c | 15 +++++++++++++++
 src/system.c |  4 +++-
 src/tcp.c    |  9 +++++++++
 3 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/client.c b/src/client.c
index 1886900..344a20e 100644
--- a/src/client.c
+++ b/src/client.c
@@ -91,6 +91,9 @@ struct TinyDFS {
     Operation operations[MAX_OPERATIONS];
 };
 
+// Forward declaration
+static void request_queue_init(RequestQueue *reqs);
+
 TinyDFS *tinydfs_init(char *addr, uint16_t port)
 {
     TinyDFS *tdfs = sys_malloc(sizeof(TinyDFS));
@@ -118,6 +121,18 @@ TinyDFS *tinydfs_init(char *addr, uint16_t port)
     for (int i = 0; i < MAX_OPERATIONS; i++)
         tdfs->operations[i].type = OPERATION_TYPE_FREE;
 
+    // Initialize metadata server
+    tdfs->metadata_server.used = true;
+    tdfs->metadata_server.addr = addr2;
+    request_queue_init(&tdfs->metadata_server.reqs);
+
+    // Initialize chunk servers
+    tdfs->num_chunk_servers = 0;
+    for (int i = 0; i < MAX_CHUNK_SERVERS; i++) {
+        tdfs->chunk_servers[i].used = false;
+        request_queue_init(&tdfs->chunk_servers[i].reqs);
+    }
+
     return tdfs;
 }
 
diff --git a/src/system.c b/src/system.c
index e7fa456..762464c 100644
--- a/src/system.c
+++ b/src/system.c
@@ -319,8 +319,10 @@ int spawn_simulated_process(char *args)
     process->num_desc = 0;
     process->num_allocs = 0;
 
-    for (int i = 0; i < MAX_DESCRIPTORS; i++)
+    for (int i = 0; i < MAX_DESCRIPTORS; i++) {
         process->desc[i].type = DESC_EMPTY;
+        process->desc[i].generation = 0;
+    }
 
     void *contexts[MAX_CONNS+1];
     struct pollfd polled[MAX_CONNS+1];
diff --git a/src/tcp.c b/src/tcp.c
index 16a7f66..87e6747 100644
--- a/src/tcp.c
+++ b/src/tcp.c
@@ -90,6 +90,14 @@ void tcp_context_init(TCP *tcp)
 
 void tcp_context_free(TCP *tcp)
 {
+    // Free all connection byte queues without closing sockets
+    // (sockets are managed by the simulation and will be cleaned up separately)
+    for (int i = 0; i < tcp->num_conns; i++) {
+        byte_queue_free(&tcp->conns[i].input);
+        byte_queue_free(&tcp->conns[i].output);
+    }
+    tcp->num_conns = 0;
+
     if (tcp->listen_fd != INVALID_SOCKET)
         CLOSE_SOCKET(tcp->listen_fd);
 }
@@ -177,6 +185,7 @@ int tcp_register_events(TCP *tcp, void **contexts, struct pollfd *polled)
 int tcp_translate_events(TCP *tcp, Event *events, void **contexts, struct pollfd *polled, int num_polled)
 {
     bool removed[MAX_CONNS+1];
+    memset(removed, 0, sizeof(removed));
 
     int num_events = 0;
     for (int i = 0; i < num_polled; i++) {

From 5adf1337cfe580155aeebd009f406c9446c91f47 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 2 Nov 2025 13:33:39 +0000
Subject: [PATCH 2/2] Move chunk server RequestQueue initialization to
 connection time

The RequestQueue for chunk servers should be initialized when the
connection is actually established in get_chunk_server_connection(),
not ahead of time during tinydfs_init().

The metadata server RequestQueue initialization remains in tinydfs_init()
since the metadata server connection is established during initialization.

Changes:
- Removed premature RequestQueue initialization for chunk servers
- Added clarifying comments about initialization timing
- RequestQueue is initialized in get_chunk_server_connection() (line 227)
---
 src/client.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/client.c b/src/client.c
index 344a20e..4d745b8 100644
--- a/src/client.c
+++ b/src/client.c
@@ -121,16 +121,16 @@ TinyDFS *tinydfs_init(char *addr, uint16_t port)
     for (int i = 0; i < MAX_OPERATIONS; i++)
         tdfs->operations[i].type = OPERATION_TYPE_FREE;
 
-    // Initialize metadata server
+    // Initialize metadata server (connected during init)
     tdfs->metadata_server.used = true;
     tdfs->metadata_server.addr = addr2;
     request_queue_init(&tdfs->metadata_server.reqs);
 
-    // Initialize chunk servers
+    // Initialize chunk servers array (connections created on demand)
     tdfs->num_chunk_servers = 0;
     for (int i = 0; i < MAX_CHUNK_SERVERS; i++) {
         tdfs->chunk_servers[i].used = false;
-        request_queue_init(&tdfs->chunk_servers[i].reqs);
+        // Note: RequestQueue initialized in get_chunk_server_connection()
     }
 
     return tdfs;