/* test_pack_overlay.c — overlay backend: copy-up, whiteout deletion of a * lower-layer entry (Section 4.2), compaction (Section 4.1/5.3), * cross-restart durability via journal replay (Section 4.4), and pack * integrity validation rejecting a corrupted file (Section 7). */ #include #include #include #include #include #include "packfs.h" #include "internal.h" /* white-box: verifies Section 9.2 dedup actually shares data_off, not just "doesn't crash" */ #include "test_harness.h" static char *tmp_pack_path(void) { static char path[512]; snprintf(path, sizeof(path), "/tmp/packfs_test_pack_%d.img", (int)getpid()); return path; } int main(void) { char *pack_path = tmp_pack_path(); unlink(pack_path); char jpath[600]; snprintf(jpath, sizeof(jpath), "%s.jnl", pack_path); unlink(jpath); /* --- phase 1: build an initial pack directly (as if shipped) --- */ Vfs *v = vfs_new(); Backend *mem = backend_mem_new(); int oerr = 0; Backend *ov = backend_overlay_new(pack_path, mem, &oerr); CHECK(ov != NULL); CHECK_EQ_INT(vfs_mount(v, "/", ov), VFS_OK); int err = 0; VfsFile *f = vfs_open(v, "/a.txt", VFS_O_WRONLY | VFS_O_CREAT, &err); CHECK(f != NULL); CHECK_EQ_INT(vfs_write(f, "AAAA", 4), 4); CHECK_EQ_INT(vfs_close(f), VFS_OK); f = vfs_open(v, "/dup.txt", VFS_O_WRONLY | VFS_O_CREAT, &err); CHECK(f != NULL); CHECK_EQ_INT(vfs_write(f, "AAAA", 4), 4); /* same content as a.txt: exercises dedup (Section 9.2) */ CHECK_EQ_INT(vfs_close(f), VFS_OK); f = vfs_open(v, "/b.txt", VFS_O_WRONLY | VFS_O_CREAT, &err); CHECK(f != NULL); CHECK_EQ_INT(vfs_write(f, "BBBBBB", 6), 6); CHECK_EQ_INT(vfs_close(f), VFS_OK); CHECK_EQ_INT(vfs_sync(v, "/"), VFS_OK); /* compaction */ /* Section 9.2 dedup, actually verified (not just exercised): /a.txt * and /dup.txt have identical content and must share one data_off * in the compacted pack; /b.txt has different content and must not * share either's. Catches both "dedup silently stopped happening" * (a real, previously-unasserted gap) and "dedup over-matched two * different files onto the same bytes" (the hash-collision-without- * memcmp-verification bug fixed alongside the O(n^2) compaction * cost — see pack.c's DedupSlot comment). */ { Pack *p = NULL; int lerr = 0; CHECK_EQ_INT(pack_load(pack_path, &p, &lerr), 0); if (p) { const PackIndexEntry *ea = NULL, *edup = NULL, *eb = NULL; CHECK(pack_find(p, "/a.txt", &ea)); CHECK(pack_find(p, "/dup.txt", &edup)); CHECK(pack_find(p, "/b.txt", &eb)); if (ea && edup) CHECK_EQ_INT(ea->data_off, edup->data_off); if (ea && eb) CHECK(ea->data_off != eb->data_off); pack_close(p); } } /* read-only open straight from the freshly-compacted pack */ f = vfs_open(v, "/a.txt", VFS_O_RDONLY, &err); CHECK(f != NULL); char buf[16] = {0}; CHECK_EQ_INT(vfs_read(f, buf, sizeof(buf)), 4); CHECK_STR_EQ(buf, "AAAA"); CHECK_EQ_INT(vfs_close(f), VFS_OK); /* --- copy-up on write intent, whiteout on delete (Section 4.2) --- */ f = vfs_open(v, "/a.txt", VFS_O_RDWR, &err); /* triggers copy-up */ CHECK(f != NULL); CHECK_EQ_INT(vfs_write(f, "ZZZZ", 4), 4); CHECK_EQ_INT(vfs_close(f), VFS_OK); f = vfs_open(v, "/a.txt", VFS_O_RDONLY, &err); memset(buf, 0, sizeof(buf)); CHECK_EQ_INT(vfs_read(f, buf, sizeof(buf)), 4); CHECK_STR_EQ(buf, "ZZZZ"); CHECK_EQ_INT(vfs_close(f), VFS_OK); CHECK_EQ_INT(vfs_unlink(v, "/b.txt"), VFS_OK); /* whiteout: b.txt only existed in the pack */ VfsStat st; CHECK_EQ_INT(vfs_stat(v, "/b.txt", &st), VFS_ERR_NOENT); /* --- durability: a fresh Vfs replays the journal without compacting --- */ vfs_unmount(v, "/"); backend_free(ov); backend_free(mem); vfs_free(v); Vfs *v2 = vfs_new(); Backend *mem2 = backend_mem_new(); Backend *ov2 = backend_overlay_new(pack_path, mem2, &oerr); CHECK(ov2 != NULL); CHECK_EQ_INT(vfs_mount(v2, "/", ov2), VFS_OK); CHECK_EQ_INT(vfs_stat(v2, "/b.txt", &st), VFS_ERR_NOENT); /* whiteout replayed */ f = vfs_open(v2, "/a.txt", VFS_O_RDONLY, &err); CHECK(f != NULL); memset(buf, 0, sizeof(buf)); CHECK_EQ_INT(vfs_read(f, buf, sizeof(buf)), 4); CHECK_STR_EQ(buf, "ZZZZ"); /* the post-compaction write survived via the journal */ CHECK_EQ_INT(vfs_close(f), VFS_OK); CHECK_EQ_INT(vfs_sync(v2, "/"), VFS_OK); /* compact again to fold the journal in */ vfs_unmount(v2, "/"); backend_free(ov2); backend_free(mem2); vfs_free(v2); /* --- standalone read-only pack backend (Section 2.1/3.1), no overlay --- */ Vfs *v4 = vfs_new(); int perr = 0; Backend *ro = backend_pack_new(pack_path, &perr); CHECK(ro != NULL); CHECK_EQ_INT(vfs_mount(v4, "/", ro), VFS_OK); f = vfs_open(v4, "/a.txt", VFS_O_RDONLY, &err); CHECK(f != NULL); memset(buf, 0, sizeof(buf)); CHECK_EQ_INT(vfs_read(f, buf, sizeof(buf)), 4); CHECK_STR_EQ(buf, "ZZZZ"); CHECK_EQ_INT(vfs_close(f), VFS_OK); /* read-only: every mutation is rejected, not silently absorbed */ CHECK_EQ_INT(vfs_mkdir(v4, "/nope"), VFS_ERR_PERM); CHECK_EQ_INT(vfs_unlink(v4, "/a.txt"), VFS_ERR_PERM); f = vfs_open(v4, "/new.txt", VFS_O_WRONLY | VFS_O_CREAT, &err); CHECK(f == NULL); CHECK_EQ_INT(err, VFS_ERR_PERM); CHECK_EQ_INT(vfs_sync(v4, "/"), VFS_ERR_PERM); VfsDir rdir; CHECK_EQ_INT(vfs_readdir(v4, "/", &rdir), VFS_OK); CHECK(rdir.count > 0); vfs_dir_free(&rdir); vfs_unmount(v4, "/"); backend_free(ro); vfs_free(v4); /* --- pack integrity validation (Section 7): a corrupted pack is rejected --- */ int fd = open(pack_path, O_RDWR); CHECK(fd >= 0); unsigned char one; CHECK_EQ_INT(pread(fd, &one, 1, 40), 1); /* somewhere inside the header/offsets region */ one = (unsigned char)(one ^ 0xFF); CHECK_EQ_INT(pwrite(fd, &one, 1, 40), 1); close(fd); Vfs *v3 = vfs_new(); Backend *mem3 = backend_mem_new(); int oerr3 = 0; Backend *ov3 = backend_overlay_new(pack_path, mem3, &oerr3); CHECK(ov3 == NULL); CHECK_EQ_INT(oerr3, VFS_ERR_CORRUPT); backend_free(mem3); vfs_free(v3); unlink(pack_path); unlink(jpath); TEST_MAIN_END(); }