From 85778b281321cef8b228dd5601075f9ecf7cabaf Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 26 Apr 2025 14:18:08 -0500 Subject: [PATCH] Ripped out most of LFS_O_SYNC, restrict to writes This tears out most of the implied lfsr_file_sync calls, and restricts LFS_O_SYNC to only imply lfsr_file_sync on _write_ operations. So only lfsr_file_write, and maybe pwrite/writev/etc in the future. This mainly affects lfsr_file_truncate/fruncate (and punchhole/ insertrange/collapserange in the future), while reverting the LFS_O_SYNC related changes in lfsr_file_open: - lfsr_file_open + LFS_O_SYNC => does _not_ sync - lfsr_file_close + LFS_O_SYNC => syncs (unless desynced) - lfsr_file_write + LFS_O_SYNC => syncs - lfsr_file_sync + LFS_O_SYNC => syncs - lfsr_file_truncate + LFS_O_SYNC => does _not_ sync - lfsr_file_fruncate + LFS_O_SYNC => does _not_ sync Note LFS_O_FLUSH is unaffected, it was always limited to lfsr_file_write since that's the only function that touches file buffers. Also note I want this rule to apply to the future lfsr_file_punchhole/ insertrange/collapserange functions as well. Even though you can argue these effectuate writes, they're at a level of sophistication that we can just expect users to just call lfsr_file_sync if they want to. --- Ok, so a number of reasons: - This matches behavior of LFS_O_APPEND, which is intentionally restricted to only write operations. In that case I think the explicit limitation is easier to understand than trying to define an abstract model. This makes LFS_O_SYNC, LFS_O_FLUSH, and LFS_O_APPEND consistent in when the relevant behavior takes effect. - This avoids the zero-sized files after powerloss. Which are just as likely, if not more, to trip up users vs missing syncs. - Most truncate/fruncate operations are immediately followed by a write operation anyways. Which just makes the truncate/fruncate syncs wasted prog/erase cycles. Even in some of the more complicated truncate/function use cases, you just don't care about when fruncates/truncates hit the disk. Take logging via lfsr_file_fruncate for example. Yes the fruncate will usually happen _after_ the write operation, but this just means the log file will usually be one entry larger than expected. Which is a state you can end up with anyways after powerloss. - This avoids confusing/conflicting LFS_O_SYNC + LFS_O_DESYNC behavior. Again, this simple rule is easier to reason about than a model. You would think this would be well defined in POSIX, but it's really not. POSIX limits O_SYNC to "write I/O operations", but doesn't really define a "write" (it is a retroactive standard after all). ftruncate is a bit funny in that it states "the extended area shall appear as if it were zero-filled", but the term "write" doesn't appear in ftruncate's documentation at all. Searching through LKML, stack overflow, etc, it doesn't seem like anyone else knows exactly what to do either. There was a bug report[1] in 2005 for ext3 + O_SYNC + ftruncate that was rejected, but a later bug report[2] in 2012 for xfs + O_SYNC + fallocate that was fixed (but was broken in almost every Linux fs?). 1: https://lore.kernel.org/lkml/1111610558.1998.193.camel@sisko.sctweedie.blueyonder.co.uk 2: https://lore.kernel.org/linux-ext4/20111116084256.GA22963@infradead.org So, this may end up a bit controversial, but I'm going to go with the simpler truncate/fruncate-do-not-imply-sync rule for the above reasons. I think this is a bit more important for littlefs than other filesystems, as it also defines the behavior of lfsr_file_open, and with a rigorous powerloss model being core to the design. --- This is also cheaper code/stack-wise, but if this was going to be a deciding factor we should just put LFS_O_SYNC/LFS_O_FLUSH behind ifdefs: code stack ctx before: 35816 2480 640 after: 35740 (-0.2%) 2424 (-2.3%) 640 (+0.0%) Compared to before the LFS_O_SYNC tweaks: code stack ctx before-tweaks: 35780 2440 640 before: 35816 (+0.1%) 2480 (+1.6%) 640 (+0.0%) after: 35740 (-0.1%) 2424 (-0.7%) 640 (+0.0%) --- lfs.c | 36 -- tests/test_fsync.toml | 756 +++++++++++++++++++++++++++++++++++++----- 2 files changed, 667 insertions(+), 125 deletions(-) diff --git a/lfs.c b/lfs.c index 6bba30c0..f94c99f3 100644 --- a/lfs.c +++ b/lfs.c @@ -11331,13 +11331,6 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_iscreat(flags)); LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_isexcl(flags)); LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_istrunc(flags)); - // these flags are incompatible - LFS_ASSERT(lfsr_o_isrdonly(flags) - || !lfsr_o_issync(flags) - || !lfsr_o_isdesync(flags)); - LFS_ASSERT(lfsr_o_isrdonly(flags) - || !lfsr_o_issync(lfs->flags) - || !lfsr_o_isdesync(flags)); for (lfs_size_t i = 0; i < cfg->attr_count; i++) { // these flags require a writable attr LFS_ASSERT(!lfsr_o_isrdonly(cfg->attrs[i].flags) @@ -11466,17 +11459,6 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, // add to tracked mdirs lfsr_omdir_open(lfs, &file->b.o); - - // sync if requested - if (lfsr_o_issync(file->b.o.flags) - && !lfsr_o_isrdonly(file->b.o.flags)) { - err = lfsr_file_sync(lfs, file); - if (err) { - lfsr_omdir_close(lfs, &file->b.o); - goto failed; - } - } - return 0; failed:; @@ -12952,8 +12934,6 @@ failed:; int lfsr_file_desync(lfs_t *lfs, lfsr_file_t *file) { (void)lfs; LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); - // desyncing LFS_O_SYNC files is not allowed - LFS_ASSERT(!lfsr_o_issync(file->b.o.flags)); // mark as desynced file->b.o.flags |= LFS_O_DESYNC; @@ -13080,14 +13060,6 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { file->cache.size, size_ - lfs_min(file->cache.pos, size_)); - // sync if requested - if (lfsr_o_issync(file->b.o.flags)) { - err = lfsr_file_sync(lfs, file); - if (err) { - goto failed; - } - } - return 0; failed:; @@ -13157,14 +13129,6 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { size - size_, file->pos); - // sync if requested - if (lfsr_o_issync(file->b.o.flags)) { - err = lfsr_file_sync(lfs, file); - if (err) { - goto failed; - } - } - return 0; failed:; diff --git a/tests/test_fsync.toml b/tests/test_fsync.toml index 1bd6fd67..725bbe7e 100644 --- a/tests/test_fsync.toml +++ b/tests/test_fsync.toml @@ -105,7 +105,7 @@ code = ''' ''' # test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected -[cases.test_fsync_sync_o_wrr] +[cases.test_fsync_sync_o_wsrr] # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC @@ -132,19 +132,12 @@ code = ''' lfsr_file_t b; lfsr_file_t c; uint8_t rbuf[256]; - // LFS_O_SYNC/LFS_M_SYNC should immediately create the file lfsr_file_open(&lfs, &a, "jello", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | ((FLUSH == 2) ? LFS_O_FLUSH : 0) | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "jello", &info) => 0; - assert(strcmp(info.name, "jello") == 0); - assert(info.type == LFS_TYPE_REG); - assert(info.size == 0); - // create the other files lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; // write to a @@ -160,27 +153,8 @@ code = ''' assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); lfsr_file_close(&lfs, &c) => 0; - // reopen with LFS_O_TRUNC - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_TRUNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - - // should immediately show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => 0; - // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &c) => 0; - - // reopen LFS_O_WRONLY and rewrite a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + // rewrite a + lfsr_file_rewind(&lfs, &a) => 0; lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); @@ -336,7 +310,7 @@ code = ''' ''' # test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected -[cases.test_fsync_sync_o_wwrr] +[cases.test_fsync_sync_o_wswsrr] # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC @@ -356,8 +330,8 @@ code = ''' | ((SYNC == 3) ? LFS_M_SYNC : 0), CFG) => 0; - // a - writer - // b - writer + // a - synced writer + // b - synced writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state lfsr_file_t a; @@ -365,19 +339,12 @@ code = ''' lfsr_file_t c; lfsr_file_t d; uint8_t rbuf[256]; - // LFS_O_SYNC/LFS_M_SYNC should immediately create the file lfsr_file_open(&lfs, &a, "jello", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | ((FLUSH == 2) ? LFS_O_FLUSH : 0) | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "jello", &info) => 0; - assert(strcmp(info.name, "jello") == 0); - assert(info.type == LFS_TYPE_REG); - assert(info.size == 0); - // create the other files lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY | ((FLUSH == 2) ? LFS_O_FLUSH : 0) @@ -424,49 +391,19 @@ code = ''' assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); lfsr_file_close(&lfs, &d) => 0; - // reopen b with LFS_O_TRUNC - lfsr_file_close(&lfs, &b) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | LFS_O_TRUNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - - // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; - // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; - - // sync a - lfsr_file_sync(&lfs, &a) => 0; - - // a's contents were clobbered, so we should see b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; - // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; - - // reopen LFS_O_WRONLY and rewrite b - lfsr_file_close(&lfs, &b) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); - assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); - assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); lfsr_file_close(&lfs, &d) => 0; // sync a @@ -474,12 +411,12 @@ code = ''' // a's contents were clobbered, so we should see b lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); - assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); - assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); lfsr_file_close(&lfs, &d) => 0; // lets rewrite a one last time @@ -515,6 +452,203 @@ code = ''' lfsr_unmount(&lfs) => 0; ''' +# test one non-LFS_O_SYNC and one LFS_O_SYNC +[cases.test_fsync_sync_o_wwsrr] +# SYNC=0 => no sync, readers not updated +# SYNC=1 => sync via lfsr_file_sync +# SYNC=2 => sync via LFS_O_SYNC +# SYNC=3 => sync via LFS_M_SYNC +defines.SYNC = [2] +# FLUSH=0 => no flush +# FLUSH=1 => flush via lfsr_file_flush +# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=3 => flush via LFS_M_FLUSH +defines.FLUSH = [0, 2, 3] +code = ''' + lfs_t lfs; + lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfsr_mount(&lfs, + LFS_M_RDWR + | ((FLUSH == 3) ? LFS_M_FLUSH : 0) + | ((SYNC == 3) ? LFS_M_SYNC : 0), + CFG) => 0; + + // a - writer + // b - synced writer + // c - reader kept open, recvs updates from a + // d - reader kept closed, checks disk state + lfsr_file_t a; + lfsr_file_t b; + lfsr_file_t c; + lfsr_file_t d; + uint8_t rbuf[256]; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | LFS_O_CREAT + | LFS_O_EXCL + | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfsr_file_open(&lfs, &b, "jello", + LFS_O_WRONLY + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + + // write to a + lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + => strlen("hello!"); + // write to b + lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + => strlen("bonjour!"); + + // should immediately show up in c + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should still have b's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // reopen a with LFS_O_TRUNC + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | LFS_O_TRUNC + | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + + // c should still have b's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + => strlen("ohayo!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should still have b's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // reopen LFS_O_WRONLY and rewrite a + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + => strlen("zdrasti!"); + + // c should still have b's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + => strlen("annyeong!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should still have b's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // lets rewrite a and b one last time + lfsr_file_rewind(&lfs, &a) => 0; + lfsr_file_write(&lfs, &a, "moshimoshi!", strlen("moshimoshi!")) + => strlen("moshimoshi!"); + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + => strlen("czesc!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // close a and b + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_close(&lfs, &b) => 0; + + // should still have b + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + lfsr_file_close(&lfs, &c) => 0; + lfsr_unmount(&lfs) => 0; +''' + [cases.test_fsync_sync_wwrr_zero] code = ''' lfs_t lfs; @@ -2047,6 +2181,7 @@ code = ''' for (lfs_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 4; + bool broadcast = false; // writing? if (op == 0) { @@ -2078,6 +2213,9 @@ code = ''' } memcpy(&between[rw][off], wbuf, size); between_size[rw] = lfs_max(off + size, between_size[rw]); + if (SYNC) { + broadcast = true; + } // reading? } else if (op == 1) { @@ -2114,6 +2252,10 @@ code = ''' size - between_size[rw]); } between_size[rw] = size; + // note LFS_O_SYNC does _not_ sync truncates + if (SYNC == 1) { + broadcast = true; + } // fruncating? } else if (op == 3) { @@ -2143,10 +2285,14 @@ code = ''' size); } between_size[rw] = size; + // note LFS_O_SYNC does _not_ sync fruncates + if (SYNC == 1) { + broadcast = true; + } } // broadcast sim? - if (SYNC) { + if (broadcast) { memcpy(after, between[rw], SIZE); after_size = between_size[rw]; @@ -2475,7 +2621,217 @@ code = ''' ''' # test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected -[cases.test_fsync_desync_o_wdwrr] +[cases.test_fsync_desync_o_wsdwsrr] +# SYNC=0 => no sync, readers not updated +# SYNC=1 => sync via lfsr_file_sync +# SYNC=2 => sync via LFS_O_SYNC +# SYNC=3 => sync via LFS_M_SYNC +defines.SYNC = [2, 3] +# FLUSH=0 => no flush +# FLUSH=1 => flush via lfsr_file_flush +# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=3 => flush via LFS_M_FLUSH +defines.FLUSH = [0, 2, 3] +code = ''' + lfs_t lfs; + lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfsr_mount(&lfs, + LFS_M_RDWR + | ((FLUSH == 3) ? LFS_M_FLUSH : 0) + | ((SYNC == 3) ? LFS_M_SYNC : 0), + CFG) => 0; + + // a - desynced writer + // b - writer + // c - reader kept open, recvs updates from a + // d - reader kept closed, checks disk state + lfsr_file_t a; + lfsr_file_t b; + lfsr_file_t c; + lfsr_file_t d; + uint8_t rbuf[256]; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | LFS_O_CREAT + | LFS_O_EXCL + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0) + | LFS_O_DESYNC) => 0; + lfsr_file_open(&lfs, &b, "jello", + LFS_O_WRONLY + | LFS_O_CREAT + | LFS_O_EXCL + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + + // write to b + lfsr_file_write(&lfs, &b, "hello!", strlen("hello!")) + => strlen("hello!"); + + // our write should show up in c + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; + lfsr_file_close(&lfs, &d) => 0; + + // rewrite a + lfsr_file_rewind(&lfs, &a) => 0; + lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + => strlen("bonjour!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync b + lfsr_file_sync(&lfs, &b) => 0; + + // should still have a + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // reopen a + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0) + | LFS_O_DESYNC) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + => strlen("ohayo!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // rewrite a + lfsr_file_rewind(&lfs, &a) => 0; + lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + => strlen("zdrasti!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // desync a + lfsr_file_desync(&lfs, &a) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + => strlen("annyeong!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // lets rewrite a one last time + lfsr_file_rewind(&lfs, &a) => 0; + lfsr_file_write(&lfs, &a, "czesc!", strlen("czesc!")) + => strlen("czesc!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // close a and b + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_close(&lfs, &b) => 0; + + // should still have a + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + lfsr_file_close(&lfs, &c) => 0; + lfsr_unmount(&lfs) => 0; +''' + +# test one non-LFS_O_SYNC and one LFS_O_SYNC +[cases.test_fsync_desync_o_wdwsrr] # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC @@ -2525,7 +2881,7 @@ code = ''' lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - // our write should show up in c + // should immediately show up in c lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk @@ -3021,7 +3377,7 @@ defines.R = 4 # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC -defines.SYNC = [0, 1] +defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush # FLUSH=1 => flush via lfsr_file_flush # FLUSH=2 => flush via LFS_O_FLUSH @@ -3114,7 +3470,7 @@ defines.R = 4 # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC -defines.SYNC = [0, 1] +defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush # FLUSH=1 => flush via lfsr_file_flush # FLUSH=2 => flush via LFS_O_FLUSH @@ -3409,7 +3765,7 @@ defines.RW = 4 # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC -defines.SYNC = [0, 1] +defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush # FLUSH=1 => flush via lfsr_file_flush # FLUSH=2 => flush via LFS_O_FLUSH @@ -3517,7 +3873,7 @@ defines.RW = 4 # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC -defines.SYNC = [0, 1] +defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush # FLUSH=1 => flush via lfsr_file_flush # FLUSH=2 => flush via LFS_O_FLUSH @@ -4297,7 +4653,229 @@ code = ''' ''' # test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected -[cases.test_fsync_resync_o_wdwyrr] +[cases.test_fsync_resync_o_wsdywsrr] +# SYNC=0 => no sync, readers not updated +# SYNC=1 => sync via lfsr_file_sync +# SYNC=2 => sync via LFS_O_SYNC +# SYNC=3 => sync via LFS_M_SYNC +defines.SYNC = [2, 3] +# FLUSH=0 => no flush +# FLUSH=1 => flush via lfsr_file_flush +# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=3 => flush via LFS_M_FLUSH +defines.FLUSH = [0, 2, 3] +code = ''' + lfs_t lfs; + lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfsr_mount(&lfs, + LFS_M_RDWR + | ((FLUSH == 3) ? LFS_M_FLUSH : 0) + | ((SYNC == 3) ? LFS_M_SYNC : 0), + CFG) => 0; + + // a - desynced synced writer + // b - synced writer + // c - reader kept open, recvs updates from a + // d - reader kept closed, checks disk state + lfsr_file_t a; + lfsr_file_t b; + lfsr_file_t c; + lfsr_file_t d; + uint8_t rbuf[256]; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | LFS_O_CREAT + | LFS_O_EXCL + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0) + | LFS_O_DESYNC) => 0; + lfsr_file_open(&lfs, &b, "jello", + LFS_O_WRONLY + | LFS_O_CREAT + | LFS_O_EXCL + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + + // write to b + lfsr_file_write(&lfs, &b, "hello!", strlen("hello!")) + => strlen("hello!"); + + // should immediately show up in c + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; + lfsr_file_close(&lfs, &d) => 0; + + // reopen a + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0) + | LFS_O_DESYNC) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + => strlen("bonjour!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; + lfsr_file_close(&lfs, &d) => 0; + + // reopen a + lfsr_file_close(&lfs, &a) => 0; + lfsr_file_open(&lfs, &a, "jello", + LFS_O_WRONLY + | ((FLUSH == 2) ? LFS_O_FLUSH : 0) + | ((SYNC == 2) ? LFS_O_SYNC : 0) + | LFS_O_DESYNC) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + => strlen("ohayo!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // resync a + lfsr_file_resync(&lfs, &a) => 0; + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should still show b's changes + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // desync a + lfsr_file_desync(&lfs, &a) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + => strlen("zdrasti!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // sync a + lfsr_file_sync(&lfs, &a) => 0; + + // c should revert to a's contents + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // rewrite a + lfsr_file_rewind(&lfs, &a) => 0; + lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + => strlen("annyeong!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // desync b + lfsr_file_desync(&lfs, &b) => 0; + // resync b + lfsr_file_resync(&lfs, &b) => 0; + // rewrite b + lfsr_file_rewind(&lfs, &b) => 0; + lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + => strlen("czesc!"); + + // should immediately show up in c + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + // close b + lfsr_file_close(&lfs, &b) => 0; + // close a + lfsr_file_close(&lfs, &a) => 0; + + // c should still show b's changes + lfsr_file_rewind(&lfs, &c) => 0; + lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + // and on disk + lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; + lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); + lfsr_file_close(&lfs, &d) => 0; + + lfsr_file_close(&lfs, &c) => 0; + lfsr_unmount(&lfs) => 0; +''' + +# test one non-LFS_O_SYNC and one LFS_O_SYNC +[cases.test_fsync_resync_o_wdywsrr] # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC @@ -4347,7 +4925,7 @@ code = ''' lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - // our write should show up in c + // should immediately show up in c lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk @@ -4838,7 +5416,7 @@ defines.R = 4 # SYNC=0 => no sync, readers not updated # SYNC=1 => sync via lfsr_file_sync # SYNC=2 => sync via LFS_O_SYNC -defines.SYNC = [0, 1] +defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush # FLUSH=1 => flush via lfsr_file_flush # FLUSH=2 => flush via LFS_O_FLUSH