lib: chunkio: upgrade to v1.5.4

Signed-off-by: Eduardo Silva <[email protected]>

Author: edsiper

lib/chunkio/.github/workflows/ci.yaml

@@ -15,15 +15,20 @@ jobs:
       max-parallel: 48
       fail-fast: false
       matrix:
-        os: [windows-latest, windows-2019]
+        os: [windows-2025, windows-2022]
     steps:
       - uses: actions/checkout@v2
-      - name: Build on ${{ matrix.os }} with vs-2019
+      - name: Set up with Developer Command Prompt for Microsoft Visual C++
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: amd64
+      - name: Build on ${{ matrix.os }} with MSVC
         run: |
-          .\scripts\win_build.bat
+          cmake -G "NMake Makefiles" -DCIO_TESTS=On .
+          cmake --build .
       - name: Run unit tests.
         run: |
-          ctest --rerun-failed --output-on-failure -C Debug --test-dir .
+          ctest . --rerun-failed --output-on-failure --test-dir .
   build-unix:
     name: Build sources on amd64 for ${{ matrix.os }} - ${{ matrix.compiler }}
     runs-on: ${{ matrix.os }}

lib/chunkio/CMakeLists.txt

@@ -3,7 +3,7 @@ project(chunk-io C)
 
 set(CIO_VERSION_MAJOR  1)
 set(CIO_VERSION_MINOR  5)
-set(CIO_VERSION_PATCH  3)
+set(CIO_VERSION_PATCH  4)
 set(CIO_VERSION_STR "${CIO_VERSION_MAJOR}.${CIO_VERSION_MINOR}.${CIO_VERSION_PATCH}")
 
 # CFLAGS

lib/chunkio/include/chunkio/cio_file.h

@@ -40,6 +40,7 @@ struct cio_file {
     size_t realloc_size;      /* chunk size to increase alloc */
     char *path;               /* root path + stream   */
     char *map;                /* map of data          */
+    struct cio_ctx *ctx;      /* owning context */
 #ifdef _WIN32
     HANDLE backing_file;
     HANDLE backing_mapping;
@@ -49,6 +50,8 @@ struct cio_file {
     char *st_content;
     crc_t crc_cur;            /* crc: current value calculated */
     int crc_reset;            /* crc: must recalculate from the beginning ? */
+    int auto_remap_warned;    /* has sync auto-remap warning been emitted? */
+    int map_truncated_warned; /* has RO truncation warning been emitted? */
 };
 
 size_t cio_file_real_size(struct cio_file *cf);

lib/chunkio/src/cio_file.c

@@ -324,7 +324,10 @@ static int munmap_file(struct cio_ctx *ctx, struct cio_chunk *ch)
     }
 
     /* Unmap file */
-    cio_file_native_unmap(cf);
+    ret = cio_file_native_unmap(cf);
+    if (ret != CIO_OK) {
+        return -1;
+    }
 
     cf->data_size = 0;
     cf->alloc_size = 0;
@@ -343,6 +346,7 @@ static int mmap_file(struct cio_ctx *ctx, struct cio_chunk *ch, size_t size)
 {
     ssize_t          content_size;
     size_t           fs_size;
+    size_t           requested_map_size;
     int              ret;
     struct cio_file *cf;
 
@@ -413,6 +417,7 @@ static int mmap_file(struct cio_ctx *ctx, struct cio_chunk *ch, size_t size)
     cf->alloc_size = size;
 
     /* Map the file */
+    requested_map_size = cf->alloc_size;
     ret = cio_file_native_map(cf, cf->alloc_size);
 
     if (ret != CIO_OK) {
@@ -421,6 +426,21 @@ static int mmap_file(struct cio_ctx *ctx, struct cio_chunk *ch, size_t size)
         return CIO_ERROR;
     }
 
+    if ((cf->flags & CIO_OPEN_RD) && requested_map_size != cf->alloc_size) {
+        if (cf->map_truncated_warned == CIO_FALSE) {
+            cio_log_warn(ctx,
+                         "[cio file] truncated read-only map from %zu to %zu bytes: %s/%s",
+                         requested_map_size,
+                         cf->alloc_size,
+                         ch->st->name,
+                         ch->name);
+            cf->map_truncated_warned = CIO_TRUE;
+        }
+    }
+    else {
+        cf->map_truncated_warned = CIO_FALSE;
+    }
+
     /* check content data size */
     if (fs_size > 0) {
         content_size = cio_file_st_get_content_len(cf->map,
@@ -664,6 +684,9 @@ struct cio_file *cio_file_open(struct cio_ctx *ctx,
     cf->crc_cur = cio_crc32_init();
     cf->path = path;
     cf->map = NULL;
+    cf->ctx = ctx;
+    cf->auto_remap_warned = CIO_FALSE;
+    cf->map_truncated_warned = CIO_FALSE;
     ch->backend = cf;
 
 #ifdef _WIN32
@@ -801,9 +824,9 @@ static int _cio_file_up(struct cio_chunk *ch, int enforced)
         return CIO_ERROR;
     }
 
-    if (cf->fd > 0) {
+    if (cio_file_native_is_open(cf)) {
         cio_log_error(ch->ctx, "[cio file] file descriptor already exists: "
-                      "[fd=%i] %s:%s", cf->fd, ch->st->name, ch->name);
+                      "%s:%s", ch->st->name, ch->name);
         return CIO_ERROR;
     }
 
@@ -908,7 +931,11 @@ int cio_file_down(struct cio_chunk *ch)
     }
 
     /* unmap memory */
-    munmap_file(ch->ctx, ch);
+    ret = munmap_file(ch->ctx, ch);
+
+    if (ret != 0) {
+        return -1;
+    }
 
     /* Allocated map size is zero */
     cf->alloc_size = 0;
@@ -921,7 +948,12 @@ int cio_file_down(struct cio_chunk *ch)
     }
 
     /* Close file descriptor */
-    cio_file_native_close(cf);
+    ret = cio_file_native_close(cf);
+
+    if (ret != CIO_OK) {
+        cio_errno();
+        return -1;
+    }
 
     return 0;
 }
@@ -1047,7 +1079,6 @@ int cio_file_write_metadata(struct cio_chunk *ch, char *buf, size_t size)
     char *cur_content_data;
     char *new_content_data;
     size_t new_size;
-    size_t content_av;
     size_t meta_av;
     struct cio_file *cf;
 
@@ -1082,13 +1113,11 @@ int cio_file_write_metadata(struct cio_chunk *ch, char *buf, size_t size)
      * where we need to increase the memory map size, move the content area
      * bytes to a different position and write the metadata.
      *
-     * Calculate the available space in the content area.
+     * Check if resize is needed before calculating content_av to avoid
+     * unsigned underflow. We need: header + new_metadata + content_data <= alloc_size
      */
-    content_av = cf->alloc_size - cf->data_size;
-
-    /* If there is no enough space, increase the file size and it memory map */
-    if (content_av < size) {
-        new_size = (size - meta_av) + cf->data_size + CIO_FILE_HEADER_MIN;
+    if (cf->alloc_size < CIO_FILE_HEADER_MIN + size + cf->data_size) {
+        new_size = CIO_FILE_HEADER_MIN + size + cf->data_size;
 
         ret = cio_file_resize(cf, new_size);
 
@@ -1106,7 +1135,7 @@ int cio_file_write_metadata(struct cio_chunk *ch, char *buf, size_t size)
     /* set new position for the content data */
     cur_content_data = cio_file_st_get_content(cf->map);
     new_content_data = meta + size;
-    memmove(new_content_data, cur_content_data, size);
+    memmove(new_content_data, cur_content_data, cf->data_size);
 
     /* copy new metadata */
     memcpy(meta, buf, size);
@@ -1138,6 +1167,12 @@ int cio_file_sync(struct cio_chunk *ch)
         return 0;
     }
 
+    /* If chunk is down (unmapped), there's nothing to sync */
+    /* You can only write to a chunk when it's up, so if it's down, no pending changes exist */
+    if (!cio_file_native_is_mapped(cf)) {
+        return 0;
+    }
+
     if (cf->synced == CIO_TRUE) {
         return 0;
     }

lib/chunkio/src/cio_file_unix.c

@@ -66,6 +66,7 @@ int cio_file_native_unmap(struct cio_file *cf)
 
     cf->alloc_size = 0;
     cf->map = NULL;
+    cf->map_truncated_warned = CIO_FALSE;
 
     return CIO_OK;
 }

lib/chunkio/src/cio_file_win32.c

@@ -38,14 +38,14 @@ int cio_file_native_unmap(struct cio_file *cf)
         return CIO_ERROR;
     }
 
-    if (!cio_file_native_is_open(cf)) {
-        return CIO_OK;
-    }
-
+    /* Check if already unmapped first */
     if (!cio_file_native_is_mapped(cf)) {
         return CIO_OK;
     }
 
+    /* On Windows, we can unmap even if file handle is closed */
+    /* The mapping handle maintains the reference */
+
     result = UnmapViewOfFile(cf->map);
 
     if (result == 0) {
@@ -54,11 +54,18 @@ int cio_file_native_unmap(struct cio_file *cf)
         return CIO_ERROR;
     }
 
-    CloseHandle(cf->backing_mapping);
+    result = CloseHandle(cf->backing_mapping);
+
+    if (result == 0) {
+        cio_file_native_report_os_error();
+
+        return CIO_ERROR;
+    }
 
     cf->backing_mapping = INVALID_HANDLE_VALUE;
     cf->alloc_size = 0;
     cf->map = NULL;
+    cf->map_truncated_warned = CIO_FALSE;
 
     return CIO_OK;
 }
@@ -67,6 +74,9 @@ int cio_file_native_map(struct cio_file *cf, size_t map_size)
 {
     DWORD desired_protection;
     DWORD desired_access;
+    size_t file_size;
+    size_t actual_map_size;
+    int ret;
 
     if (cf == NULL) {
         return CIO_ERROR;
@@ -92,17 +102,48 @@ int cio_file_native_map(struct cio_file *cf, size_t map_size)
         return CIO_ERROR;
     }
 
+    /* Get current file size to ensure we don't map beyond it for read-only files */
+    ret = cio_file_native_get_size(cf, &file_size);
+    if (ret != CIO_OK) {
+        return CIO_ERROR;
+    }
+
+    /* For read-only files, we cannot map beyond the file size */
+    /* For read-write files, if map_size > file_size, we should resize first */
+    if (cf->flags & CIO_OPEN_RD) {
+        if (map_size > file_size) {
+            actual_map_size = file_size;
+        }
+        else {
+            actual_map_size = map_size;
+        }
+    }
+    else {
+        /* For RW files, if map_size > file_size, resize the file first */
+        if (map_size > file_size) {
+            ret = cio_file_native_resize(cf, map_size);
+            if (ret != CIO_OK) {
+                return CIO_ERROR;
+            }
+        }
+        actual_map_size = map_size;
+    }
+
+    /* CreateFileMappingA requires size as two DWORDs (high and low) */
+    /* Use actual_map_size to ensure consistency */
     cf->backing_mapping = CreateFileMappingA(cf->backing_file, NULL,
                                              desired_protection,
-                                             0, 0, NULL);
+                                             (DWORD)(actual_map_size >> 32),
+                                             (DWORD)(actual_map_size & 0xFFFFFFFFUL),
+                                             NULL);
 
     if (cf->backing_mapping == NULL) {
         cio_file_native_report_os_error();
 
         return CIO_ERROR;
     }
 
-    cf->map = MapViewOfFile(cf->backing_mapping, desired_access, 0, 0, map_size);
+    cf->map = MapViewOfFile(cf->backing_mapping, desired_access, 0, 0, actual_map_size);
 
     if (cf->map == NULL) {
         cio_file_native_report_os_error();
@@ -114,7 +155,7 @@ int cio_file_native_map(struct cio_file *cf, size_t map_size)
         return CIO_ERROR;
     }
 
-    cf->alloc_size = map_size;
+    cf->alloc_size = actual_map_size;
 
     return CIO_OK;
 }
@@ -474,6 +515,38 @@ int cio_file_native_delete(struct cio_file *cf)
 {
     int result;
 
+    if (cf == NULL) {
+        return CIO_ERROR;
+    }
+
+    if (cio_file_native_is_mapped(cf)) {
+        if (cf->ctx != NULL) {
+            cio_log_warn(cf->ctx,
+                         "[cio file] auto-unmapping chunk prior to delete: %s",
+                         cf->path);
+        }
+
+        result = cio_file_native_unmap(cf);
+
+        if (result != CIO_OK) {
+            return result;
+        }
+    }
+
+    if (cio_file_native_is_open(cf)) {
+        if (cf->ctx != NULL) {
+            cio_log_warn(cf->ctx,
+                         "[cio file] closing handle prior to delete: %s",
+                         cf->path);
+        }
+
+        result = cio_file_native_close(cf);
+
+        if (result != CIO_OK) {
+            return result;
+        }
+    }
+
     result = DeleteFileA(cf->path);
 
     if (result == 0) {
@@ -489,6 +562,10 @@ int cio_file_native_sync(struct cio_file *cf, int sync_mode)
 {
     int result;
 
+    if (!cio_file_native_is_mapped(cf)) {
+        return CIO_ERROR;
+    }
+
     result = FlushViewOfFile(cf->map, cf->alloc_size);
 
     if (result == 0) {

lib/chunkio/tests/CMakeLists.txt

@@ -9,6 +9,15 @@ if(CIO_BACKEND_FILESYSTEM)
   set(UNIT_TESTS_FILES
     ${UNIT_TESTS_FILES}
     fs.c
+    metadata_update.c
+    )
+endif()
+
+# Windows-specific inconsistency tests
+if(WIN32 AND CIO_BACKEND_FILESYSTEM)
+  set(UNIT_TESTS_FILES
+    ${UNIT_TESTS_FILES}
+    fs_windows.c
     )
 endif()
 
@@ -35,7 +44,7 @@ foreach(source_file ${UNIT_TESTS_FILES})
   add_test(${source_file_we} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${source_file_we})
 endforeach()
 
-# Perf tests for dev purposes: note these tests are not registered, they need to 
+# Perf tests for dev purposes: note these tests are not registered, they need to
 # be executed manually
 set(UNIT_PERF_TESTS
   fs_perf.c