mirror of
https://github.com/eledio-devices/thirdparty-littlefs.git
synced 2025-10-31 08:42:40 +01:00
aeca7667b3
Instead of storing files in an arbitrary order, we now store files in ascending lexicographical order by filename. Although a big change, this actually has little impact on how littlefs works internally. We need to support file insertion, and compare file names to find our position. But since we already need to scan the entire directory block, this adds relatively little overhead. What this does allow, is the potential to add B-tree support in the future in a backwards compatible manner. How could you add B-trees to littlefs? 1. Add an optional "child" tag with a pointer that allows you to skip to a position in the metadata-pair list that composes the directory 2. When splitting a metadata-pair (sound familiar?), we either insert a second child tag in our parent, or we create a new root containing the child tags. 3. Each layer needs a bit stored in the tail-pointer to indicate if we're going to the next layer. This can be created trivially when we create a new root. 4. During lookup we keep two pointers containing the bounds of our search. We may need to iterate through multiple metadata-pairs in our linked-list, but this gives us a O(log n) lookup cost in a balanced tree. 5. During deletion we also delete any children pointers. Note that children pointers must come before the actual file entry. This gives us a B-tree implementation that is compatible with the current directory layout (assuming the files are ordered). This means that B-trees could be supported by a host PC and ignored on a small device. And during power-loss, we never end up with a broken filesystem, just a less-than-optimal tree. Note that we don't handle removes, so it's possible for a tree to become unbalanced. But worst case that's the same as the current linked-list implementation. All we need to do now is keep directories ordered. If we decide to drop B-tree support in the future or the B-tree implementation turns out inherently flawed, we can just drop the ordered requirement without breaking compatibility and recover the code cost.
159 lines
4.4 KiB
Bash
Executable File
159 lines
4.4 KiB
Bash
Executable File
#!/bin/bash
|
|
set -eu
|
|
|
|
SMALLSIZE=32
|
|
MEDIUMSIZE=8192
|
|
LARGESIZE=262144
|
|
|
|
echo "=== File tests ==="
|
|
rm -rf blocks
|
|
tests/test.py << TEST
|
|
lfs_format(&lfs, &cfg) => 0;
|
|
TEST
|
|
|
|
echo "--- Simple file test ---"
|
|
tests/test.py << TEST
|
|
lfs_mount(&lfs, &cfg) => 0;
|
|
lfs_file_open(&lfs, &file[0], "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
|
size = strlen("Hello World!\n");
|
|
memcpy(wbuffer, "Hello World!\n", size);
|
|
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
|
lfs_file_close(&lfs, &file[0]) => 0;
|
|
|
|
lfs_file_open(&lfs, &file[0], "hello", LFS_O_RDONLY) => 0;
|
|
size = strlen("Hello World!\n");
|
|
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
|
memcmp(rbuffer, wbuffer, size) => 0;
|
|
lfs_file_close(&lfs, &file[0]) => 0;
|
|
lfs_unmount(&lfs) => 0;
|
|
TEST
|
|
|
|
w_test() {
|
|
tests/test.py ${4:-} << TEST
|
|
size = $1;
|
|
lfs_size_t chunk = 31;
|
|
srand(0);
|
|
lfs_mount(&lfs, &cfg) => 0;
|
|
lfs_file_open(&lfs, &file[0], "$2",
|
|
${3:-LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC}) => 0;
|
|
for (lfs_size_t i = 0; i < size; i += chunk) {
|
|
chunk = (chunk < size - i) ? chunk : size - i;
|
|
for (lfs_size_t b = 0; b < chunk; b++) {
|
|
buffer[b] = rand() & 0xff;
|
|
}
|
|
lfs_file_write(&lfs, &file[0], buffer, chunk) => chunk;
|
|
}
|
|
lfs_file_close(&lfs, &file[0]) => 0;
|
|
lfs_unmount(&lfs) => 0;
|
|
TEST
|
|
}
|
|
|
|
r_test() {
|
|
tests/test.py << TEST
|
|
size = $1;
|
|
lfs_size_t chunk = 29;
|
|
srand(0);
|
|
lfs_mount(&lfs, &cfg) => 0;
|
|
lfs_stat(&lfs, "$2", &info) => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => size;
|
|
lfs_file_open(&lfs, &file[0], "$2", ${3:-LFS_O_RDONLY}) => 0;
|
|
for (lfs_size_t i = 0; i < size; i += chunk) {
|
|
chunk = (chunk < size - i) ? chunk : size - i;
|
|
lfs_file_read(&lfs, &file[0], buffer, chunk) => chunk;
|
|
for (lfs_size_t b = 0; b < chunk && i+b < size; b++) {
|
|
buffer[b] => rand() & 0xff;
|
|
}
|
|
}
|
|
lfs_file_close(&lfs, &file[0]) => 0;
|
|
lfs_unmount(&lfs) => 0;
|
|
TEST
|
|
}
|
|
|
|
echo "--- Small file test ---"
|
|
w_test $SMALLSIZE smallavacado
|
|
r_test $SMALLSIZE smallavacado
|
|
|
|
echo "--- Medium file test ---"
|
|
w_test $MEDIUMSIZE mediumavacado
|
|
r_test $MEDIUMSIZE mediumavacado
|
|
|
|
echo "--- Large file test ---"
|
|
w_test $LARGESIZE largeavacado
|
|
r_test $LARGESIZE largeavacado
|
|
|
|
echo "--- Zero file test ---"
|
|
w_test 0 noavacado
|
|
r_test 0 noavacado
|
|
|
|
echo "--- Truncate small test ---"
|
|
w_test $SMALLSIZE mediumavacado
|
|
r_test $SMALLSIZE mediumavacado
|
|
w_test $MEDIUMSIZE mediumavacado
|
|
r_test $MEDIUMSIZE mediumavacado
|
|
|
|
echo "--- Truncate zero test ---"
|
|
w_test $SMALLSIZE noavacado
|
|
r_test $SMALLSIZE noavacado
|
|
w_test 0 noavacado
|
|
r_test 0 noavacado
|
|
|
|
echo "--- Non-overlap check ---"
|
|
r_test $SMALLSIZE smallavacado
|
|
r_test $MEDIUMSIZE mediumavacado
|
|
r_test $LARGESIZE largeavacado
|
|
r_test 0 noavacado
|
|
|
|
echo "--- Dir check ---"
|
|
tests/test.py << TEST
|
|
lfs_mount(&lfs, &cfg) => 0;
|
|
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
strcmp(info.name, "hello") => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => strlen("Hello World!\n");
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
strcmp(info.name, "largeavacado") => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => $LARGESIZE;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
strcmp(info.name, "mediumavacado") => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => $MEDIUMSIZE;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
strcmp(info.name, "noavacado") => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => 0;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
|
strcmp(info.name, "smallavacado") => 0;
|
|
info.type => LFS_TYPE_REG;
|
|
info.size => $SMALLSIZE;
|
|
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
|
lfs_dir_close(&lfs, &dir[0]) => 0;
|
|
lfs_unmount(&lfs) => 0;
|
|
TEST
|
|
|
|
echo "--- Many file test ---"
|
|
tests/test.py << TEST
|
|
lfs_format(&lfs, &cfg) => 0;
|
|
TEST
|
|
tests/test.py << TEST
|
|
// Create 300 files of 6 bytes
|
|
lfs_mount(&lfs, &cfg) => 0;
|
|
lfs_mkdir(&lfs, "directory") => 0;
|
|
for (unsigned i = 0; i < 300; i++) {
|
|
snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
|
|
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
|
size = 6;
|
|
memcpy(wbuffer, "Hello", size);
|
|
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
|
lfs_file_close(&lfs, &file[0]) => 0;
|
|
}
|
|
lfs_unmount(&lfs) => 0;
|
|
TEST
|
|
|
|
echo "--- Results ---"
|
|
tests/stats.py
|