test: extend coverage of sfsTest
This commit is contained in:
dualfroz committed
1 parent
fe18aab0a9
commit
ae47c8258f
1 file changed
+162
+162
@@ -943,3 +943,165 @@ KTEST(sfsRemoveSymlinkDoesNotAffectTarget)
|
|||||||
KT_EQ(t, memcmp(back, "untouched", 9), 0);
|
KT_EQ(t, memcmp(back, "untouched", 9), 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
KTEST(sfsSymlinkPersistsAcrossUnmountRemount)
|
||||||
|
{
|
||||||
|
if (!KT_TRUE(t, sfsFormat()))
|
||||||
|
return;
|
||||||
|
|
||||||
|
int32 f = sfsCreateFile("real.txt");
|
||||||
|
KT_TRUE(t, f > 0);
|
||||||
|
KT_EQ(t, sfsWriteAt(f, 0, "on disk for real", 17), 17);
|
||||||
|
int32 link = sfsCreateSymlink("link.txt", "real.txt");
|
||||||
|
KT_TRUE(t, link > 0);
|
||||||
|
|
||||||
|
sfsUnmount();
|
||||||
|
KT_TRUE(t, sfsMount());
|
||||||
|
|
||||||
|
KT_EQ(t, sfsLookup("link.txt"), f);
|
||||||
|
KT_EQ(t, sfsLookupNoFollow("link.txt"), link);
|
||||||
|
KT_EQ(t, sfsTypeOf(link), sfsTypeSymlink);
|
||||||
|
|
||||||
|
char target[32];
|
||||||
|
memset(target, 0, sizeof(target));
|
||||||
|
KT_TRUE(t, sfsReadlink(link, target, sizeof(target)));
|
||||||
|
KT_STREQ(t, target, "real.txt");
|
||||||
|
}
|
||||||
|
|
||||||
|
KTEST(sfsFileGrowsThroughDoubleIndirectBlock)
|
||||||
|
{
|
||||||
|
if (!KT_TRUE(t, sfsFormat()))
|
||||||
|
return;
|
||||||
|
|
||||||
|
int32 f = sfsCreateFile("huge.bin");
|
||||||
|
KT_TRUE(t, f > 0);
|
||||||
|
|
||||||
|
/* sfsDirectBlocks (10) + sfsPtrsPerBlock (128) = 138 logical blocks are
|
||||||
|
reachable through direct + single indirect addressing; block 138
|
||||||
|
onward can only be reached through the double indirect block added
|
||||||
|
in this wave. Starting a few blocks before that boundary and writing
|
||||||
|
past it exercises the crossing and the double-indirect-only region
|
||||||
|
in one write (sfsWriteAt zero-fills 0..134 first, all still within
|
||||||
|
single-indirect range, before this pattern lands on 135..144). */
|
||||||
|
#define sfsDoubleSpanBlocks 10
|
||||||
|
#define sfsDoubleStartBlock 135
|
||||||
|
#define sfsDoubleSpan (sfsDoubleSpanBlocks * sfsBlockSize)
|
||||||
|
uint8* pattern = (uint8*)kmalloc(sfsDoubleSpan);
|
||||||
|
uint8* verify = (uint8*)kmalloc(sfsDoubleSpan);
|
||||||
|
KT_NOTNULL(t, pattern);
|
||||||
|
KT_NOTNULL(t, verify);
|
||||||
|
if (!pattern || !verify) {
|
||||||
|
kfree(pattern);
|
||||||
|
kfree(verify);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for (int i = 0; i < sfsDoubleSpan; i++)
|
||||||
|
pattern[i] = (uint8)(i * 17 + 3);
|
||||||
|
|
||||||
|
uint64 offset = (uint64)sfsDoubleStartBlock * sfsBlockSize;
|
||||||
|
KT_EQ(t, sfsWriteAt(f, offset, pattern, sfsDoubleSpan), sfsDoubleSpan);
|
||||||
|
KT_EQ(t, sfsSizeOf(f), offset + sfsDoubleSpan);
|
||||||
|
|
||||||
|
memset(verify, 0, sfsDoubleSpan);
|
||||||
|
KT_EQ(t, sfsReadAt(f, offset, verify, sfsDoubleSpan), sfsDoubleSpan);
|
||||||
|
KT_EQ(t, memcmp(verify, pattern, sfsDoubleSpan), 0);
|
||||||
|
|
||||||
|
/* Patch a window straddling the single-indirect/double-indirect
|
||||||
|
boundary itself (logical block 137/138) and confirm only that slice
|
||||||
|
changed -- the same "boundary patch" shape as
|
||||||
|
sfsFileGrowsThroughIndirectBlock, one level deeper. */
|
||||||
|
uint8 patch[48];
|
||||||
|
memset(patch, 0xCC, sizeof(patch));
|
||||||
|
uint64 patchOffset = 138 * sfsBlockSize - 24;
|
||||||
|
KT_EQ(t, sfsWriteAt(f, patchOffset, patch, sizeof(patch)), (int64)sizeof(patch));
|
||||||
|
|
||||||
|
KT_EQ(t, sfsReadAt(f, offset, verify, sfsDoubleSpan), sfsDoubleSpan);
|
||||||
|
uint64 patchInSpan = patchOffset - offset;
|
||||||
|
KT_EQ(t, memcmp(verify + patchInSpan, patch, sizeof(patch)), 0);
|
||||||
|
KT_EQ(t, memcmp(verify, pattern, patchInSpan), 0);
|
||||||
|
|
||||||
|
kfree(pattern);
|
||||||
|
kfree(verify);
|
||||||
|
#undef sfsDoubleSpan
|
||||||
|
#undef sfsDoubleStartBlock
|
||||||
|
#undef sfsDoubleSpanBlocks
|
||||||
|
}
|
||||||
|
|
||||||
|
KTEST(sfsTruncateFreesDoubleIndirectBlocks)
|
||||||
|
{
|
||||||
|
if (!KT_TRUE(t, sfsFormat()))
|
||||||
|
return;
|
||||||
|
|
||||||
|
int32 f = sfsCreateFile("hugeshrink.bin");
|
||||||
|
KT_TRUE(t, f > 0);
|
||||||
|
|
||||||
|
/* Baseline is taken AFTER creating the file, not before: creating the
|
||||||
|
very first entry in a previously-empty root directory grows the
|
||||||
|
root's own data block permanently (it is a directory entry, not file
|
||||||
|
content, and stays even after truncating the FILE back to empty) --
|
||||||
|
that is correct, unrelated bookkeeping this test must not conflate
|
||||||
|
with whether truncating hugeshrink.bin's own content gives its
|
||||||
|
blocks back. */
|
||||||
|
uint64 baseline = sfsFreeDataBlocks();
|
||||||
|
KT_GT(t, baseline, 0);
|
||||||
|
|
||||||
|
#define sfsShrinkSpanBlocks 8
|
||||||
|
#define sfsShrinkStartBlock 136
|
||||||
|
#define sfsShrinkSpan (sfsShrinkSpanBlocks * sfsBlockSize)
|
||||||
|
uint8* chunk = (uint8*)kmalloc(sfsShrinkSpan);
|
||||||
|
KT_NOTNULL(t, chunk);
|
||||||
|
if (!chunk)
|
||||||
|
return;
|
||||||
|
memset(chunk, 0x91, sfsShrinkSpan);
|
||||||
|
uint64 offset = (uint64)sfsShrinkStartBlock * sfsBlockSize;
|
||||||
|
KT_EQ(t, sfsWriteAt(f, offset, chunk, sfsShrinkSpan), sfsShrinkSpan);
|
||||||
|
kfree(chunk);
|
||||||
|
#undef sfsShrinkSpan
|
||||||
|
#undef sfsShrinkStartBlock
|
||||||
|
#undef sfsShrinkSpanBlocks
|
||||||
|
|
||||||
|
/* This file now owns: 10 direct + 1 single-indirect holder + 128
|
||||||
|
single-indirect data blocks + 1 double-indirect holder + 1 inner
|
||||||
|
indirect holder + a handful of double-indirect data blocks. Every
|
||||||
|
one of those must come back. */
|
||||||
|
KT_LT(t, sfsFreeDataBlocks(), baseline);
|
||||||
|
|
||||||
|
KT_TRUE(t, sfsTruncate(f, 0));
|
||||||
|
KT_EQ(t, sfsSizeOf(f), 0);
|
||||||
|
KT_EQU(t, sfsFreeDataBlocks(), baseline);
|
||||||
|
|
||||||
|
/* And the inode itself must still be usable afterward, not left in some
|
||||||
|
half-truncated state. */
|
||||||
|
KT_EQ(t, sfsWriteAt(f, 0, "reused", 6), 6);
|
||||||
|
KT_EQ(t, sfsSizeOf(f), 6);
|
||||||
|
}
|
||||||
|
|
||||||
|
KTEST(sfsFileGrowsThroughTripleIndirectBlock)
|
||||||
|
{
|
||||||
|
if (!KT_TRUE(t, sfsFormat()))
|
||||||
|
return;
|
||||||
|
|
||||||
|
int32 f = sfsCreateFile("huger.bin");
|
||||||
|
KT_TRUE(t, f > 0);
|
||||||
|
|
||||||
|
/* sfsDirectBlocks (10) + sfsPtrsPerBlock (128) + sfsPtrsPerBlock^2
|
||||||
|
(16384) = 16522 logical blocks are reachable through direct + single
|
||||||
|
+ double indirect addressing; block 16522 onward can only be reached
|
||||||
|
through the triple indirect block added in this wave. Physically
|
||||||
|
reaching that boundary with real writes from offset 0 would mean
|
||||||
|
sfsWriteAt zero-filling ~8 MiB of real leading blocks first (its own
|
||||||
|
"no sparse holes" contract, see its doc comment) -- correct, but far
|
||||||
|
too slow for a headless boot-time gate. sfsTruncate's own grow path
|
||||||
|
is a genuine sparse hole instead (see sfsTruncateInode: growing only
|
||||||
|
ever rewrites the size field, no block is touched), the same
|
||||||
|
lseek-past-EOF-then-write shape a real filesystem's holes have -- so
|
||||||
|
pre-growing with it reaches the boundary for free, in O(1), then a
|
||||||
|
real write of a handful of blocks exercises the actual double/triple
|
||||||
|
crossing without paying for the untouched blocks in between. */
|
||||||
|
#define sfsTripleBoundaryBlock 16522
|
||||||
|
#define sfsTripleSpanBlocks 12
|
||||||
|
#define sfsTripleStartBlock (sfsTripleBoundaryBlock - 6)
|
||||||
|
#define sfsTripleSpan (sfsTripleSpanBlocks * sfsBlockSize)
|
||||||
|
uint64 startOffset = (uint64)sfsTripleStartBlock * sfsBlockSize;
|
||||||
|
KT_TRUE(t, sfsTruncate(f, startOffset));
|
||||||
|
KT_EQ(t, sfsSizeOf(f), startOffset);
|
||||||
|
|
||||||
Reference in new issue
Block a user