You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by je...@apache.org on 2023/06/16 06:03:02 UTC
[mynewt-core] branch master updated (0ab0a22e1 -> a20166fac)
This is an automated email from the ASF dual-hosted git repository.
jerzy pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-core.git
from 0ab0a22e1 hw/mcu/dialog: Fix build for newlib-nano
new ac583ddc0 fs/littlefs: Use external repository
new a20166fac apps/fs_test: Fix includes
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
apps/fs_test/src/littlefs.c | 2 +-
fs/littlefs/DESIGN.md | 2173 ----------------
fs/littlefs/LICENSE.md | 25 -
fs/littlefs/README.md | 258 --
fs/littlefs/SPEC.md | 787 ------
fs/littlefs/pkg.yml | 15 +
fs/littlefs/src/lfs.c | 5819 -------------------------------------------
fs/littlefs/src/lfs.h | 701 ------
fs/littlefs/src/lfs_util.c | 34 -
fs/littlefs/src/lfs_util.h | 245 --
10 files changed, 16 insertions(+), 10043 deletions(-)
delete mode 100644 fs/littlefs/DESIGN.md
delete mode 100644 fs/littlefs/LICENSE.md
delete mode 100644 fs/littlefs/README.md
delete mode 100644 fs/littlefs/SPEC.md
delete mode 100644 fs/littlefs/src/lfs.c
delete mode 100644 fs/littlefs/src/lfs.h
delete mode 100644 fs/littlefs/src/lfs_util.c
delete mode 100644 fs/littlefs/src/lfs_util.h
[mynewt-core] 01/02: fs/littlefs: Use external repository
Posted by je...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jerzy pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-core.git
commit ac583ddc0fd5d9a88b921d09601395b4df07f2f3
Author: Jerzy Kasenberg <je...@codecoup.pl>
AuthorDate: Wed Jun 14 23:48:44 2023 +0200
fs/littlefs: Use external repository
---
fs/littlefs/DESIGN.md | 2173 -----------------
fs/littlefs/LICENSE.md | 25 -
fs/littlefs/README.md | 258 --
fs/littlefs/SPEC.md | 787 ------
fs/littlefs/pkg.yml | 15 +
fs/littlefs/src/lfs.c | 5819 --------------------------------------------
fs/littlefs/src/lfs.h | 701 ------
fs/littlefs/src/lfs_util.c | 34 -
fs/littlefs/src/lfs_util.h | 245 --
9 files changed, 15 insertions(+), 10042 deletions(-)
diff --git a/fs/littlefs/DESIGN.md b/fs/littlefs/DESIGN.md
deleted file mode 100644
index 1d02ba3bf..000000000
--- a/fs/littlefs/DESIGN.md
+++ /dev/null
@@ -1,2173 +0,0 @@
-## The design of littlefs
-
-A little fail-safe filesystem designed for microcontrollers.
-
-```
- | | | .---._____
- .-----. | |
---|o |---| littlefs |
---| |---| |
- '-----' '----------'
- | | |
-```
-
-littlefs was originally built as an experiment to learn about filesystem design
-in the context of microcontrollers. The question was: How would you build a
-filesystem that is resilient to power-loss and flash wear without using
-unbounded memory?
-
-This document covers the high-level design of littlefs, how it is different
-than other filesystems, and the design decisions that got us here. For the
-low-level details covering every bit on disk, check out [SPEC.md](SPEC.md).
-
-## The problem
-
-The embedded systems littlefs targets are usually 32-bit microcontrollers with
-around 32 KiB of RAM and 512 KiB of ROM. These are often paired with SPI NOR
-flash chips with about 4 MiB of flash storage. These devices are too small for
-Linux and most existing filesystems, requiring code written specifically with
-size in mind.
-
-Flash itself is an interesting piece of technology with its own quirks and
-nuance. Unlike other forms of storage, writing to flash requires two
-operations: erasing and programming. Programming (setting bits to 0) is
-relatively cheap and can be very granular. Erasing however (setting bits to 1),
-requires an expensive and destructive operation which gives flash its name.
-[Wikipedia][wikipedia-flash] has more information on how exactly flash works.
-
-To make the situation more annoying, it's very common for these embedded
-systems to lose power at any time. Usually, microcontroller code is simple and
-reactive, with no concept of a shutdown routine. This presents a big challenge
-for persistent storage, where an unlucky power loss can corrupt the storage and
-leave a device unrecoverable.
-
-This leaves us with three major requirements for an embedded filesystem.
-
-1. **Power-loss resilience** - On these systems, power can be lost at any time.
- If a power loss corrupts any persistent data structures, this can cause the
- device to become unrecoverable. An embedded filesystem must be designed to
- recover from a power loss during any write operation.
-
-1. **Wear leveling** - Writing to flash is destructive. If a filesystem
- repeatedly writes to the same block, eventually that block will wear out.
- Filesystems that don't take wear into account can easily burn through blocks
- used to store frequently updated metadata and cause a device's early death.
-
-1. **Bounded RAM/ROM** - If the above requirements weren't enough, these
- systems also have very limited amounts of memory. This prevents many
- existing filesystem designs, which can lean on relatively large amounts of
- RAM to temporarily store filesystem metadata.
-
- For ROM, this means we need to keep our design simple and reuse code paths
- were possible. For RAM we have a stronger requirement, all RAM usage is
- bounded. This means RAM usage does not grow as the filesystem changes in
- size or number of files. This creates a unique challenge as even presumably
- simple operations, such as traversing the filesystem, become surprisingly
- difficult.
-
-## Existing designs?
-
-So, what's already out there? There are, of course, many different filesystems,
-however they often share and borrow feature from each other. If we look at
-power-loss resilience and wear leveling, we can narrow these down to a handful
-of designs.
-
-1. First we have the non-resilient, block based filesystems, such as [FAT] and
- [ext2]. These are the earliest filesystem designs and often the most simple.
- Here storage is divided into blocks, with each file being stored in a
- collection of blocks. Without modifications, these filesystems are not
- power-loss resilient, so updating a file is a simple as rewriting the blocks
- in place.
-
- ```
- .--------.
- | root |
- | |
- | |
- '--------'
- .-' '-.
- v v
- .--------. .--------.
- | A | | B |
- | | | |
- | | | |
- '--------' '--------'
- .-' .-' '-.
- v v v
- .--------. .--------. .--------.
- | C | | D | | E |
- | | | | | |
- | | | | | |
- '--------' '--------' '--------'
- ```
-
- Because of their simplicity, these filesystems are usually both the fastest
- and smallest. However the lack of power resilience is not great, and the
- binding relationship of storage location and data removes the filesystem's
- ability to manage wear.
-
-2. In a completely different direction, we have logging filesystems, such as
- [JFFS], [YAFFS], and [SPIFFS], storage location is not bound to a piece of
- data, instead the entire storage is used for a circular log which is
- appended with every change made to the filesystem. Writing appends new
- changes, while reading requires traversing the log to reconstruct a file.
- Some logging filesystems cache files to avoid the read cost, but this comes
- at a tradeoff of RAM.
-
- ```
- v
- .--------.--------.--------.--------.--------.--------.--------.--------.
- | C | new B | new A | | A | B |
- | | | |-> | | |
- | | | | | | |
- '--------'--------'--------'--------'--------'--------'--------'--------'
- ```
-
- Logging filesystem are beautifully elegant. With a checksum, we can easily
- detect power-loss and fall back to the previous state by ignoring failed
- appends. And if that wasn't good enough, their cyclic nature means that
- logging filesystems distribute wear across storage perfectly.
-
- The main downside is performance. If we look at garbage collection, the
- process of cleaning up outdated data from the end of the log, I've yet to
- see a pure logging filesystem that does not have one of these two costs:
-
- 1. _O(n²)_ runtime
- 2. _O(n)_ RAM
-
- SPIFFS is a very interesting case here, as it uses the fact that repeated
- programs to NOR flash is both atomic and masking. This is a very neat
- solution, however it limits the type of storage you can support.
-
-3. Perhaps the most common type of filesystem, a journaling filesystem is the
- offspring that happens when you mate a block based filesystem with a logging
- filesystem. [ext4] and [NTFS] are good examples. Here, we take a normal
- block based filesystem and add a bounded log where we note every change
- before it occurs.
-
- ```
- journal
- .--------.--------.
- .--------. | C'| D'| | E'|
- | root |-->| | |-> | |
- | | | | | | |
- | | '--------'--------'
- '--------'
- .-' '-.
- v v
- .--------. .--------.
- | A | | B |
- | | | |
- | | | |
- '--------' '--------'
- .-' .-' '-.
- v v v
- .--------. .--------. .--------.
- | C | | D | | E |
- | | | | | |
- | | | | | |
- '--------' '--------' '--------'
- ```
-
-
- This sort of filesystem takes the best from both worlds. Performance can be
- as fast as a block based filesystem (though updating the journal does have
- a small cost), and atomic updates to the journal allow the filesystem to
- recover in the event of a power loss.
-
- Unfortunately, journaling filesystems have a couple of problems. They are
- fairly complex, since there are effectively two filesystems running in
- parallel, which comes with a code size cost. They also offer no protection
- against wear because of the strong relationship between storage location
- and data.
-
-4. Last but not least we have copy-on-write (COW) filesystems, such as
- [btrfs] and [ZFS]. These are very similar to other block based filesystems,
- but instead of updating block inplace, all updates are performed by creating
- a copy with the changes and replacing any references to the old block with
- our new block. This recursively pushes all of our problems upwards until we
- reach the root of our filesystem, which is often stored in a very small log.
-
- ```
- .--------. .--------.
- | root | write |new root|
- | | ==> | |
- | | | |
- '--------' '--------'
- .-' '-. | '-.
- | .-------|------------------' v
- v v v .--------.
- .--------. .--------. | new B |
- | A | | B | | |
- | | | | | |
- | | | | '--------'
- '--------' '--------' .-' |
- .-' .-' '-. .------------|------'
- | | | | v
- v v v v .--------.
- .--------. .--------. .--------. | new D |
- | C | | D | | E | | |
- | | | | | | | |
- | | | | | | '--------'
- '--------' '--------' '--------'
- ```
-
- COW filesystems are interesting. They offer very similar performance to
- block based filesystems while managing to pull off atomic updates without
- storing data changes directly in a log. They even disassociate the storage
- location of data, which creates an opportunity for wear leveling.
-
- Well, almost. The unbounded upwards movement of updates causes some
- problems. Because updates to a COW filesystem don't stop until they've
- reached the root, an update can cascade into a larger set of writes than
- would be needed for the original data. On top of this, the upward motion
- focuses these writes into the block, which can wear out much earlier than
- the rest of the filesystem.
-
-## littlefs
-
-So what does littlefs do?
-
-If we look at existing filesystems, there are two interesting design patterns
-that stand out, but each have their own set of problems. Logging, which
-provides independent atomicity, has poor runtime performance. And COW data
-structures, which perform well, push the atomicity problem upwards.
-
-Can we work around these limitations?
-
-Consider logging. It has either a _O(n²)_ runtime or _O(n)_ RAM cost. We
-can't avoid these costs, _but_ if we put an upper bound on the size we can at
-least prevent the theoretical cost from becoming problem. This relies on the
-super secret computer science hack where you can pretend any algorithmic
-complexity is _O(1)_ by bounding the input.
-
-In the case of COW data structures, we can try twisting the definition a bit.
-Let's say that our COW structure doesn't copy after a single write, but instead
-copies after _n_ writes. This doesn't change most COW properties (assuming you
-can write atomically!), but what it does do is prevent the upward motion of
-wear. This sort of copy-on-bounded-writes (CObW) still focuses wear, but at
-each level we divide the propagation of wear by _n_. With a sufficiently
-large _n_ (> branching factor) wear propagation is no longer a problem.
-
-See where this is going? Separate, logging and COW are imperfect solutions and
-have weaknesses that limit their usefulness. But if we merge the two they can
-mutually solve each other's limitations.
-
-This is the idea behind littlefs. At the sub-block level, littlefs is built
-out of small, two block logs that provide atomic updates to metadata anywhere
-on the filesystem. At the super-block level, littlefs is a CObW tree of blocks
-that can be evicted on demand.
-
-```
- root
- .--------.--------.
- | A'| B'| |
- | | |-> |
- | | | |
- '--------'--------'
- .----' '--------------.
- A v B v
- .--------.--------. .--------.--------.
- | C'| D'| | | E'|new| |
- | | |-> | | | E'|-> |
- | | | | | | | |
- '--------'--------' '--------'--------'
- .-' '--. | '------------------.
- v v .-' v
-.--------. .--------. v .--------.
-| C | | D | .--------. write | new E |
-| | | | | E | ==> | |
-| | | | | | | |
-'--------' '--------' | | '--------'
- '--------' .-' |
- .-' '-. .-------------|------'
- v v v v
- .--------. .--------. .--------.
- | F | | G | | new F |
- | | | | | |
- | | | | | |
- '--------' '--------' '--------'
-```
-
-There are still some minor issues. Small logs can be expensive in terms of
-storage, in the worst case a small log costs 4x the size of the original data.
-CObW structures require an efficient block allocator since allocation occurs
-every _n_ writes. And there is still the challenge of keeping the RAM usage
-constant.
-
-## Metadata pairs
-
-Metadata pairs are the backbone of littlefs. These are small, two block logs
-that allow atomic updates anywhere in the filesystem.
-
-Why two blocks? Well, logs work by appending entries to a circular buffer
-stored on disk. But remember that flash has limited write granularity. We can
-incrementally program new data onto erased blocks, but we need to erase a full
-block at a time. This means that in order for our circular buffer to work, we
-need more than one block.
-
-We could make our logs larger than two blocks, but the next challenge is how
-do we store references to these logs? Because the blocks themselves are erased
-during writes, using a data structure to track these blocks is complicated.
-The simple solution here is to store a two block addresses for every metadata
-pair. This has the added advantage that we can change out blocks in the
-metadata pair independently, and we don't reduce our block granularity for
-other operations.
-
-In order to determine which metadata block is the most recent, we store a
-revision count that we compare using [sequence arithmetic][wikipedia-sna]
-(very handy for avoiding problems with integer overflow). Conveniently, this
-revision count also gives us a rough idea of how many erases have occurred on
-the block.
-
-```
-metadata pair pointer: {block 0, block 1}
- | '--------------------.
- '-. |
-disk v v
-.--------.--------.--------.--------.--------.--------.--------.--------.
-| | |metadata| |metadata| |
-| | |block 0 | |block 1 | |
-| | | | | | |
-'--------'--------'--------'--------'--------'--------'--------'--------'
- '--. .----'
- v v
- metadata pair .----------------.----------------.
- | revision 11 | revision 12 |
- block 1 is |----------------|----------------|
- most recent | A | A'' |
- |----------------|----------------|
- | checksum | checksum |
- |----------------|----------------|
- | B | A''' | <- most recent A
- |----------------|----------------|
- | A'' | checksum |
- |----------------|----------------|
- | checksum | | |
- |----------------| v |
- '----------------'----------------'
-```
-
-So how do we atomically update our metadata pairs? Atomicity (a type of
-power-loss resilience) requires two parts: redundancy and error detection.
-Error detection can be provided with a checksum, and in littlefs's case we
-use a 32-bit [CRC][wikipedia-crc]. Maintaining redundancy, on the other hand,
-requires multiple stages.
-
-1. If our block is not full and the program size is small enough to let us
- append more entries, we can simply append the entries to the log. Because
- we don't overwrite the original entries (remember rewriting flash requires
- an erase), we still have the original entries if we lose power during the
- append.
-
- ```
- commit A
- .----------------.----------------. .----------------.----------------.
- | revision 1 | revision 0 | => | revision 1 | revision 0 |
- |----------------|----------------| |----------------|----------------|
- | | | | | A | |
- | v | | |----------------| |
- | | | | checksum | |
- | | | |----------------| |
- | | | | | | |
- | | | | v | |
- | | | | | |
- | | | | | |
- | | | | | |
- | | | | | |
- '----------------'----------------' '----------------'----------------'
- ```
-
- Note that littlefs doesn't maintain a checksum for each entry. Many logging
- filesystems do this, but it limits what you can update in a single atomic
- operation. What we can do instead is group multiple entries into a commit
- that shares a single checksum. This lets us update multiple unrelated pieces
- of metadata as long as they reside on the same metadata pair.
-
- ```
- commit B and A'
- .----------------.----------------. .----------------.----------------.
- | revision 1 | revision 0 | => | revision 1 | revision 0 |
- |----------------|----------------| |----------------|----------------|
- | A | | | A | |
- |----------------| | |----------------| |
- | checksum | | | checksum | |
- |----------------| | |----------------| |
- | | | | | B | |
- | v | | |----------------| |
- | | | | A' | |
- | | | |----------------| |
- | | | | checksum | |
- | | | |----------------| |
- '----------------'----------------' '----------------'----------------'
- ```
-
-2. If our block _is_ full of entries, we need to somehow remove outdated
- entries to make space for new ones. This process is called garbage
- collection, but because littlefs has multiple garbage collectors, we
- also call this specific case compaction.
-
- Compared to other filesystems, littlefs's garbage collector is relatively
- simple. We want to avoid RAM consumption, so we use a sort of brute force
- solution where for each entry we check to see if a newer entry has been
- written. If the entry is the most recent we append it to our new block. This
- is where having two blocks becomes important, if we lose power we still have
- everything in our original block.
-
- During this compaction step we also erase the metadata block and increment
- the revision count. Because we can commit multiple entries at once, we can
- write all of these changes to the second block without worrying about power
- loss. It's only when the commit's checksum is written that the compacted
- entries and revision count become committed and readable.
-
- ```
- commit B', need to compact
- .----------------.----------------. .----------------.----------------.
- | revision 1 | revision 0 | => | revision 1 | revision 2 |
- |----------------|----------------| |----------------|----------------|
- | A | | | A | A' |
- |----------------| | |----------------|----------------|
- | checksum | | | checksum | B' |
- |----------------| | |----------------|----------------|
- | B | | | B | checksum |
- |----------------| | |----------------|----------------|
- | A' | | | A' | | |
- |----------------| | |----------------| v |
- | checksum | | | checksum | |
- |----------------| | |----------------| |
- '----------------'----------------' '----------------'----------------'
- ```
-
-3. If our block is full of entries _and_ we can't find any garbage, then what?
- At this point, most logging filesystems would return an error indicating no
- more space is available, but because we have small logs, overflowing a log
- isn't really an error condition.
-
- Instead, we split our original metadata pair into two metadata pairs, each
- containing half of the entries, connected by a tail pointer. Instead of
- increasing the size of the log and dealing with the scalability issues
- associated with larger logs, we form a linked list of small bounded logs.
- This is a tradeoff as this approach does use more storage space, but at the
- benefit of improved scalability.
-
- Despite writing to two metadata pairs, we can still maintain power
- resilience during this split step by first preparing the new metadata pair,
- and then inserting the tail pointer during the commit to the original
- metadata pair.
-
- ```
- commit C and D, need to split
- .----------------.----------------. .----------------.----------------.
- | revision 1 | revision 2 | => | revision 3 | revision 2 |
- |----------------|----------------| |----------------|----------------|
- | A | A' | | A' | A' |
- |----------------|----------------| |----------------|----------------|
- | checksum | B' | | B' | B' |
- |----------------|----------------| |----------------|----------------|
- | B | checksum | | tail ---------------------.
- |----------------|----------------| |----------------|----------------| |
- | A' | | | | checksum | | |
- |----------------| v | |----------------| | |
- | checksum | | | | | | |
- |----------------| | | v | | |
- '----------------'----------------' '----------------'----------------' |
- .----------------.---------'
- v v
- .----------------.----------------.
- | revision 1 | revision 0 |
- |----------------|----------------|
- | C | |
- |----------------| |
- | D | |
- |----------------| |
- | checksum | |
- |----------------| |
- | | | |
- | v | |
- | | |
- | | |
- '----------------'----------------'
- ```
-
-There is another complexity the crops up when dealing with small logs. The
-amortized runtime cost of garbage collection is not only dependent on its
-one time cost (_O(n²)_ for littlefs), but also depends on how often
-garbage collection occurs.
-
-Consider two extremes:
-
-1. Log is empty, garbage collection occurs once every _n_ updates
-2. Log is full, garbage collection occurs **every** update
-
-Clearly we need to be more aggressive than waiting for our metadata pair to
-be full. As the metadata pair approaches fullness the frequency of compactions
-grows very rapidly.
-
-Looking at the problem generically, consider a log with ![n] bytes for each
-entry, ![d] dynamic entries (entries that are outdated during garbage
-collection), and ![s] static entries (entries that need to be copied during
-garbage collection). If we look at the amortized runtime complexity of updating
-this log we get this formula:
-
-![cost = n + n (s / d+1)][metadata-formula1]
-
-If we let ![r] be the ratio of static space to the size of our log in bytes, we
-find an alternative representation of the number of static and dynamic entries:
-
-![s = r (size/n)][metadata-formula2]
-
-![d = (1 - r) (size/n)][metadata-formula3]
-
-Substituting these in for ![d] and ![s] gives us a nice formula for the cost of
-updating an entry given how full the log is:
-
-![cost = n + n (r (size/n) / ((1-r) (size/n) + 1))][metadata-formula4]
-
-Assuming 100 byte entries in a 4 KiB log, we can graph this using the entry
-size to find a multiplicative cost:
-
-![Metadata pair update cost graph][metadata-cost-graph]
-
-So at 50% usage, we're seeing an average of 2x cost per update, and at 75%
-usage, we're already at an average of 4x cost per update.
-
-To avoid this exponential growth, instead of waiting for our metadata pair
-to be full, we split the metadata pair once we exceed 50% capacity. We do this
-lazily, waiting until we need to compact before checking if we fit in our 50%
-limit. This limits the overhead of garbage collection to 2x the runtime cost,
-giving us an amortized runtime complexity of _O(1)_.
-
----
-
-If we look at metadata pairs and linked-lists of metadata pairs at a high
-level, they have fairly nice runtime costs. Assuming _n_ metadata pairs,
-each containing _m_ metadata entries, the _lookup_ cost for a specific
-entry has a worst case runtime complexity of _O(nm)_. For _updating_ a specific
-entry, the worst case complexity is _O(nm²)_, with an amortized complexity
-of only _O(nm)_.
-
-However, splitting at 50% capacity does mean that in the best case our
-metadata pairs will only be 1/2 full. If we include the overhead of the second
-block in our metadata pair, each metadata entry has an effective storage cost
-of 4x the original size. I imagine users would not be happy if they found
-that they can only use a quarter of their original storage. Metadata pairs
-provide a mechanism for performing atomic updates, but we need a separate
-mechanism for storing the bulk of our data.
-
-## CTZ skip-lists
-
-Metadata pairs provide efficient atomic updates but unfortunately have a large
-storage cost. But we can work around this storage cost by only using the
-metadata pairs to store references to more dense, copy-on-write (COW) data
-structures.
-
-[Copy-on-write data structures][wikipedia-cow], also called purely functional
-data structures, are a category of data structures where the underlying
-elements are immutable. Making changes to the data requires creating new
-elements containing a copy of the updated data and replacing any references
-with references to the new elements. Generally, the performance of a COW data
-structure depends on how many old elements can be reused after replacing parts
-of the data.
-
-littlefs has several requirements of its COW structures. They need to be
-efficient to read and write, but most frustrating, they need to be traversable
-with a constant amount of RAM. Notably this rules out
-[B-trees][wikipedia-B-tree], which can not be traversed with constant RAM, and
-[B+-trees][wikipedia-B+-tree], which are not possible to update with COW
-operations.
-
----
-
-So, what can we do? First let's consider storing files in a simple COW
-linked-list. Appending a block, which is the basis for writing files, means we
-have to update the last block to point to our new block. This requires a COW
-operation, which means we need to update the second-to-last block, and then the
-third-to-last, and so on until we've copied out the entire file.
-
-```
-A linked-list
-.--------. .--------. .--------. .--------. .--------. .--------.
-| data 0 |->| data 1 |->| data 2 |->| data 4 |->| data 5 |->| data 6 |
-| | | | | | | | | | | |
-| | | | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-To avoid a full copy during appends, we can store the data backwards. Appending
-blocks just requires adding the new block and no other blocks need to be
-updated. If we update a block in the middle, we still need to copy the
-following blocks, but can reuse any blocks before it. Since most file writes
-are linear, this design gambles that appends are the most common type of data
-update.
-
-```
-A backwards linked-list
-.--------. .--------. .--------. .--------. .--------. .--------.
-| data 0 |<-| data 1 |<-| data 2 |<-| data 4 |<-| data 5 |<-| data 6 |
-| | | | | | | | | | | |
-| | | | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-However, a backwards linked-list does have a rather glaring problem. Iterating
-over a file _in order_ has a runtime cost of _O(n²)_. A quadratic runtime
-just to read a file! That's awful.
-
-Fortunately we can do better. Instead of a singly linked list, littlefs
-uses a multilayered linked-list often called a
-[skip-list][wikipedia-skip-list]. However, unlike the most common type of
-skip-list, littlefs's skip-lists are strictly deterministic built around some
-interesting properties of the count-trailing-zeros (CTZ) instruction.
-
-The rules CTZ skip-lists follow are that for every _n_‍th block where _n_
-is divisible by 2‍_ˣ_, that block contains a pointer to block
-_n_-2‍_ˣ_. This means that each block contains anywhere from 1 to
-log₂_n_ pointers that skip to different preceding elements of the
-skip-list.
-
-The name comes from heavy use of the [CTZ instruction][wikipedia-ctz], which
-lets us calculate the power-of-two factors efficiently. For a give block _n_,
-that block contains ctz(_n_)+1 pointers.
-
-```
-A backwards CTZ skip-list
-.--------. .--------. .--------. .--------. .--------. .--------.
-| data 0 |<-| data 1 |<-| data 2 |<-| data 3 |<-| data 4 |<-| data 5 |
-| |<-| |--| |<-| |--| | | |
-| |<-| |--| |--| |--| | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-The additional pointers let us navigate the data-structure on disk much more
-efficiently than in a singly linked list.
-
-Consider a path from data block 5 to data block 1. You can see how data block 3
-was completely skipped:
-```
-.--------. .--------. .--------. .--------. .--------. .--------.
-| data 0 | | data 1 |<-| data 2 | | data 3 | | data 4 |<-| data 5 |
-| | | | | |<-| |--| | | |
-| | | | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-The path to data block 0 is even faster, requiring only two jumps:
-```
-.--------. .--------. .--------. .--------. .--------. .--------.
-| data 0 | | data 1 | | data 2 | | data 3 | | data 4 |<-| data 5 |
-| | | | | | | | | | | |
-| |<-| |--| |--| |--| | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-We can find the runtime complexity by looking at the path to any block from
-the block containing the most pointers. Every step along the path divides
-the search space for the block in half, giving us a runtime of _O(log n)_.
-To get _to_ the block with the most pointers, we can perform the same steps
-backwards, which puts the runtime at _O(2 log n)_ = _O(log n)_. An interesting
-note is that this optimal path occurs naturally if we greedily choose the
-pointer that covers the most distance without passing our target.
-
-So now we have a [COW] data structure that is cheap to append with a runtime
-of _O(1)_, and can be read with a worst case runtime of _O(n log n)_. Given
-that this runtime is also divided by the amount of data we can store in a
-block, this cost is fairly reasonable.
-
----
-
-This is a new data structure, so we still have several questions. What is the
-storage overhead? Can the number of pointers exceed the size of a block? How do
-we store a CTZ skip-list in our metadata pairs?
-
-To find the storage overhead, we can look at the data structure as multiple
-linked-lists. Each linked-list skips twice as many blocks as the previous,
-or from another perspective, each linked-list uses half as much storage as
-the previous. As we approach infinity, the storage overhead forms a geometric
-series. Solving this tells us that on average our storage overhead is only
-2 pointers per block.
-
-![lim,n->inf((1/n)sum,i,0->n(ctz(i)+1)) = sum,i,0->inf(1/2^i) = 2][ctz-formula1]
-
-Because our file size is limited the word width we use to store sizes, we can
-also solve for the maximum number of pointers we would ever need to store in a
-block. If we set the overhead of pointers equal to the block size, we get the
-following equation. Note that both a smaller block size (![B][bigB]) and larger
-word width (![w]) result in more storage overhead.
-
-![B = (w/8)ceil(log2(2^w / (B-2w/8)))][ctz-formula2]
-
-Solving the equation for ![B][bigB] gives us the minimum block size for some
-common word widths:
-
-1. 32-bit CTZ skip-list => minimum block size of 104 bytes
-2. 64-bit CTZ skip-list => minimum block size of 448 bytes
-
-littlefs uses a 32-bit word width, so our blocks can only overflow with
-pointers if they are smaller than 104 bytes. This is an easy requirement, as
-in practice, most block sizes start at 512 bytes. As long as our block size
-is larger than 104 bytes, we can avoid the extra logic needed to handle
-pointer overflow.
-
-This last question is how do we store CTZ skip-lists? We need a pointer to the
-head block, the size of the skip-list, the index of the head block, and our
-offset in the head block. But it's worth noting that each size maps to a unique
-index + offset pair. So in theory we can store only a single pointer and size.
-
-However, calculating the index + offset pair from the size is a bit
-complicated. We can start with a summation that loops through all of the blocks
-up until our given size. Let ![B][bigB] be the block size in bytes, ![w] be the
-word width in bits, ![n] be the index of the block in the skip-list, and
-![N][bigN] be the file size in bytes:
-
-![N = sum,i,0->n(B-(w/8)(ctz(i)+1))][ctz-formula3]
-
-This works quite well, but requires _O(n)_ to compute, which brings the full
-runtime of reading a file up to _O(n² log n)_. Fortunately, that summation
-doesn't need to touch the disk, so the practical impact is minimal.
-
-However, despite the integration of a bitwise operation, we can actually reduce
-this equation to a _O(1)_ form. While browsing the amazing resource that is
-the [On-Line Encyclopedia of Integer Sequences (OEIS)][oeis], I managed to find
-[A001511], which matches the iteration of the CTZ instruction,
-and [A005187], which matches its partial summation. Much to my
-surprise, these both result from simple equations, leading us to a rather
-unintuitive property that ties together two seemingly unrelated bitwise
-instructions:
-
-![sum,i,0->n(ctz(i)+1) = 2n-popcount(n)][ctz-formula4]
-
-where:
-
-1. ctz(![x]) = the number of trailing bits that are 0 in ![x]
-2. popcount(![x]) = the number of bits that are 1 in ![x]
-
-Initial tests of this surprising property seem to hold. As ![n] approaches
-infinity, we end up with an average overhead of 2 pointers, which matches our
-assumption from earlier. During iteration, the popcount function seems to
-handle deviations from this average. Of course, just to make sure I wrote a
-quick script that verified this property for all 32-bit integers.
-
-Now we can substitute into our original equation to find a more efficient
-equation for file size:
-
-![N = Bn - (w/8)(2n-popcount(n))][ctz-formula5]
-
-Unfortunately, the popcount function is non-injective, so we can't solve this
-equation for our index. But what we can do is solve for an ![n'] index that
-is greater than ![n] with error bounded by the range of the popcount function.
-We can repeatedly substitute ![n'] into the original equation until the error
-is smaller than our integer resolution. As it turns out, we only need to
-perform this substitution once, which gives us this formula for our index:
-
-![n = floor((N-(w/8)popcount(N/(B-2w/8))) / (B-2w/8))][ctz-formula6]
-
-Now that we have our index ![n], we can just plug it back into the above
-equation to find the offset. We run into a bit of a problem with integer
-overflow, but we can avoid this by rearranging the equation a bit:
-
-![off = N - (B-2w/8)n - (w/8)popcount(n)][ctz-formula7]
-
-Our solution requires quite a bit of math, but computers are very good at math.
-Now we can find both our block index and offset from a size in _O(1)_, letting
-us store CTZ skip-lists with only a pointer and size.
-
-CTZ skip-lists give us a COW data structure that is easily traversable in
-_O(n)_, can be appended in _O(1)_, and can be read in _O(n log n)_. All of
-these operations work in a bounded amount of RAM and require only two words of
-storage overhead per block. In combination with metadata pairs, CTZ skip-lists
-provide power resilience and compact storage of data.
-
-```
- .--------.
- .|metadata|
- || |
- || |
- |'--------'
- '----|---'
- v
-.--------. .--------. .--------. .--------.
-| data 0 |<-| data 1 |<-| data 2 |<-| data 3 |
-| |<-| |--| | | |
-| | | | | | | |
-'--------' '--------' '--------' '--------'
-
-write data to disk, create copies
-=>
- .--------.
- .|metadata|
- || |
- || |
- |'--------'
- '----|---'
- v
-.--------. .--------. .--------. .--------.
-| data 0 |<-| data 1 |<-| data 2 |<-| data 3 |
-| |<-| |--| | | |
-| | | | | | | |
-'--------' '--------' '--------' '--------'
- ^ ^ ^
- | | | .--------. .--------. .--------. .--------.
- | | '----| new |<-| new |<-| new |<-| new |
- | '----------------| data 2 |<-| data 3 |--| data 4 | | data 5 |
- '------------------| |--| |--| | | |
- '--------' '--------' '--------' '--------'
-
-commit to metadata pair
-=>
- .--------.
- .|new |
- ||metadata|
- || |
- |'--------'
- '----|---'
- |
-.--------. .--------. .--------. .--------. |
-| data 0 |<-| data 1 |<-| data 2 |<-| data 3 | |
-| |<-| |--| | | | |
-| | | | | | | | |
-'--------' '--------' '--------' '--------' |
- ^ ^ ^ v
- | | | .--------. .--------. .--------. .--------.
- | | '----| new |<-| new |<-| new |<-| new |
- | '----------------| data 2 |<-| data 3 |--| data 4 | | data 5 |
- '------------------| |--| |--| | | |
- '--------' '--------' '--------' '--------'
-```
-
-## The block allocator
-
-So we now have the framework for an atomic, wear leveling filesystem. Small two
-block metadata pairs provide atomic updates, while CTZ skip-lists provide
-compact storage of data in COW blocks.
-
-But now we need to look at the [elephant] in the room. Where do all these
-blocks come from?
-
-Deciding which block to use next is the responsibility of the block allocator.
-In filesystem design, block allocation is often a second-class citizen, but in
-a COW filesystem its role becomes much more important as it is needed for
-nearly every write to the filesystem.
-
-Normally, block allocation involves some sort of free list or bitmap stored on
-the filesystem that is updated with free blocks. However, with power
-resilience, keeping these structures consistent becomes difficult. It doesn't
-help that any mistake in updating these structures can result in lost blocks
-that are impossible to recover.
-
-littlefs takes a cautious approach. Instead of trusting a free list on disk,
-littlefs relies on the fact that the filesystem on disk is a mirror image of
-the free blocks on the disk. The block allocator operates much like a garbage
-collector in a scripting language, scanning for unused blocks on demand.
-
-```
- .----.
- |root|
- | |
- '----'
- v-------' '-------v
-.----. . . .----.
-| A | . . | B |
-| | . . | |
-'----' . . '----'
-. . . . v--' '------------v---------v
-. . . .----. . .----. .----.
-. . . | C | . | D | | E |
-. . . | | . | | | |
-. . . '----' . '----' '----'
-. . . . . . . . . .
-.----.----.----.----.----.----.----.----.----.----.----.----.
-| A | |root| C | B | | D | | E | |
-| | | | | | | | | | |
-'----'----'----'----'----'----'----'----'----'----'----'----'
- ^ ^ ^ ^ ^
- '-------------------'----'-------------------'----'-- free blocks
-```
-
-While this approach may sound complicated, the decision to not maintain a free
-list greatly simplifies the overall design of littlefs. Unlike programming
-languages, there are only a handful of data structures we need to traverse.
-And block deallocation, which occurs nearly as often as block allocation,
-is simply a noop. This "drop it on the floor" strategy greatly reduces the
-complexity of managing on disk data structures, especially when handling
-high-risk error conditions.
-
----
-
-Our block allocator needs to find free blocks efficiently. You could traverse
-through every block on storage and check each one against our filesystem tree;
-however, the runtime would be abhorrent. We need to somehow collect multiple
-blocks per traversal.
-
-Looking at existing designs, some larger filesystems that use a similar "drop
-it on the floor" strategy store a bitmap of the entire storage in [RAM]. This
-works well because bitmaps are surprisingly compact. We can't use the same
-strategy here, as it violates our constant RAM requirement, but we may be able
-to modify the idea into a workable solution.
-
-```
-.----.----.----.----.----.----.----.----.----.----.----.----.
-| A | |root| C | B | | D | | E | |
-| | | | | | | | | | |
-'----'----'----'----'----'----'----'----'----'----'----'----'
- 1 0 1 1 1 0 0 1 0 1 0 0
- \---------------------------+----------------------------/
- v
- bitmap: 0xb94 (0b101110010100)
-```
-
-The block allocator in littlefs is a compromise between a disk-sized bitmap and
-a brute force traversal. Instead of a bitmap the size of storage, we keep track
-of a small, fixed-size bitmap called the lookahead buffer. During block
-allocation, we take blocks from the lookahead buffer. If the lookahead buffer
-is empty, we scan the filesystem for more free blocks, populating our lookahead
-buffer. In each scan we use an increasing offset, circling the storage as
-blocks are allocated.
-
-Here's what it might look like to allocate 4 blocks on a decently busy
-filesystem with a 32 bit lookahead and a total of 128 blocks (512 KiB
-of storage if blocks are 4 KiB):
-```
-boot... lookahead:
- fs blocks: fffff9fffffffffeffffffffffff0000
-scanning... lookahead: fffff9ff
- fs blocks: fffff9fffffffffeffffffffffff0000
-alloc = 21 lookahead: fffffdff
- fs blocks: fffffdfffffffffeffffffffffff0000
-alloc = 22 lookahead: ffffffff
- fs blocks: fffffffffffffffeffffffffffff0000
-scanning... lookahead: fffffffe
- fs blocks: fffffffffffffffeffffffffffff0000
-alloc = 63 lookahead: ffffffff
- fs blocks: ffffffffffffffffffffffffffff0000
-scanning... lookahead: ffffffff
- fs blocks: ffffffffffffffffffffffffffff0000
-scanning... lookahead: ffffffff
- fs blocks: ffffffffffffffffffffffffffff0000
-scanning... lookahead: ffff0000
- fs blocks: ffffffffffffffffffffffffffff0000
-alloc = 112 lookahead: ffff8000
- fs blocks: ffffffffffffffffffffffffffff8000
-```
-
-This lookahead approach has a runtime complexity of _O(n²)_ to completely
-scan storage; however, bitmaps are surprisingly compact, and in practice only
-one or two passes are usually needed to find free blocks. Additionally, the
-performance of the allocator can be optimized by adjusting the block size or
-size of the lookahead buffer, trading either write granularity or RAM for
-allocator performance.
-
-## Wear leveling
-
-The block allocator has a secondary role: wear leveling.
-
-Wear leveling is the process of distributing wear across all blocks in the
-storage to prevent the filesystem from experiencing an early death due to
-wear on a single block in the storage.
-
-littlefs has two methods of protecting against wear:
-1. Detection and recovery from bad blocks
-2. Evenly distributing wear across dynamic blocks
-
----
-
-Recovery from bad blocks doesn't actually have anything to do with the block
-allocator itself. Instead, it relies on the ability of the filesystem to detect
-and evict bad blocks when they occur.
-
-In littlefs, it is fairly straightforward to detect bad blocks at write time.
-All writes must be sourced by some form of data in RAM, so immediately after we
-write to a block, we can read the data back and verify that it was written
-correctly. If we find that the data on disk does not match the copy we have in
-RAM, a write error has occurred and we most likely have a bad block.
-
-Once we detect a bad block, we need to recover from it. In the case of write
-errors, we have a copy of the corrupted data in RAM, so all we need to do is
-evict the bad block, allocate a new, hopefully good block, and repeat the write
-that previously failed.
-
-The actual act of evicting the bad block and replacing it with a new block is
-left up to the filesystem's copy-on-bounded-writes (CObW) data structures. One
-property of CObW data structures is that any block can be replaced during a
-COW operation. The bounded-writes part is normally triggered by a counter, but
-nothing prevents us from triggering a COW operation as soon as we find a bad
-block.
-
-```
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----.
-| A | | B |
-| | | |
-'----' '----'
-. . v---' .
-. . .----. .
-. . | C | .
-. . | | .
-. . '----' .
-. . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| | C | B | |
-| | | | | | |
-'----'----'----'----'----'----'----'----'----'----'
-
-update C
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----.
-| A | | B |
-| | | |
-'----' '----'
-. . v---' .
-. . .----. .
-. . |bad | .
-. . |blck| .
-. . '----' .
-. . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| |bad | B | |
-| | | |blck| | |
-'----'----'----'----'----'----'----'----'----'----'
-
-oh no! bad block! relocate C
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----.
-| A | | B |
-| | | |
-'----' '----'
-. . v---' .
-. . .----. .
-. . |bad | .
-. . |blck| .
-. . '----' .
-. . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| |bad | B |bad | |
-| | | |blck| |blck| |
-'----'----'----'----'----'----'----'----'----'----'
- --------->
-oh no! bad block! relocate C
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----.
-| A | | B |
-| | | |
-'----' '----'
-. . v---' .
-. . .----. . .----.
-. . |bad | . | C' |
-. . |blck| . | |
-. . '----' . '----'
-. . . . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| |bad | B |bad | C' | |
-| | | |blck| |blck| | |
-'----'----'----'----'----'----'----'----'----'----'
- -------------->
-successfully relocated C, update B
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----.
-| A | |bad |
-| | |blck|
-'----' '----'
-. . v---' .
-. . .----. . .----.
-. . |bad | . | C' |
-. . |blck| . | |
-. . '----' . '----'
-. . . . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| |bad |bad |bad | C' | |
-| | | |blck|blck|blck| | |
-'----'----'----'----'----'----'----'----'----'----'
-
-oh no! bad block! relocate B
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----. .----.
-| A | |bad | |bad |
-| | |blck| |blck|
-'----' '----' '----'
-. . v---' . . .
-. . .----. . .----. .
-. . |bad | . | C' | .
-. . |blck| . | | .
-. . '----' . '----' .
-. . . . . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| |bad |bad |bad | C' |bad |
-| | | |blck|blck|blck| |blck|
-'----'----'----'----'----'----'----'----'----'----'
- -------------->
-oh no! bad block! relocate B
-=>
- .----.
- |root|
- | |
- '----'
- v--' '----------------------v
-.----. .----. .----.
-| A | | B' | |bad |
-| | | | |blck|
-'----' '----' '----'
-. . . | . .---' .
-. . . '--------------v-------------v
-. . . . .----. . .----.
-. . . . |bad | . | C' |
-. . . . |blck| . | |
-. . . . '----' . '----'
-. . . . . . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| B' | |bad |bad |bad | C' |bad |
-| | | | |blck|blck|blck| |blck|
-'----'----'----'----'----'----'----'----'----'----'
-------------> ------------------
-successfully relocated B, update root
-=>
- .----.
- |root|
- | |
- '----'
- v--' '--v
-.----. .----.
-| A | | B' |
-| | | |
-'----' '----'
-. . . '---------------------------v
-. . . . .----.
-. . . . | C' |
-. . . . | |
-. . . . '----'
-. . . . . .
-.----.----.----.----.----.----.----.----.----.----.
-| A |root| B' | |bad |bad |bad | C' |bad |
-| | | | |blck|blck|blck| |blck|
-'----'----'----'----'----'----'----'----'----'----'
-```
-
-We may find that the new block is also bad, but hopefully after repeating this
-cycle we'll eventually find a new block where a write succeeds. If we don't,
-that means that all blocks in our storage are bad, and we've reached the end of
-our device's usable life. At this point, littlefs will return an "out of space"
-error. This is technically true, as there are no more good blocks, but as an
-added benefit it also matches the error condition expected by users of
-dynamically sized data.
-
----
-
-Read errors, on the other hand, are quite a bit more complicated. We don't have
-a copy of the data lingering around in RAM, so we need a way to reconstruct the
-original data even after it has been corrupted. One such mechanism for this is
-[error-correction-codes (ECC)][wikipedia-ecc].
-
-ECC is an extension to the idea of a checksum. Where a checksum such as CRC can
-detect that an error has occurred in the data, ECC can detect and actually
-correct some amount of errors. However, there is a limit to how many errors ECC
-can detect: the [Hamming bound][wikipedia-hamming-bound]. As the number of
-errors approaches the Hamming bound, we may still be able to detect errors, but
-can no longer fix the data. If we've reached this point the block is
-unrecoverable.
-
-littlefs by itself does **not** provide ECC. The block nature and relatively
-large footprint of ECC does not work well with the dynamically sized data of
-filesystems, correcting errors without RAM is complicated, and ECC fits better
-with the geometry of block devices. In fact, several NOR flash chips have extra
-storage intended for ECC, and many NAND chips can even calculate ECC on the
-chip itself.
-
-In littlefs, ECC is entirely optional. Read errors can instead be prevented
-proactively by wear leveling. But it's important to note that ECC can be used
-at the block device level to modestly extend the life of a device. littlefs
-respects any errors reported by the block device, allowing a block device to
-provide additional aggressive error detection.
-
----
-
-To avoid read errors, we need to be proactive, as opposed to reactive as we
-were with write errors.
-
-One way to do this is to detect when the number of errors in a block exceeds
-some threshold, but is still recoverable. With ECC we can do this at write
-time, and treat the error as a write error, evicting the block before fatal
-read errors have a chance to develop.
-
-A different, more generic strategy, is to proactively distribute wear across
-all blocks in the storage, with the hope that no single block fails before the
-rest of storage is approaching the end of its usable life. This is called
-wear leveling.
-
-Generally, wear leveling algorithms fall into one of two categories:
-
-1. [Dynamic wear leveling][wikipedia-dynamic-wear-leveling], where we
- distribute wear over "dynamic" blocks. The can be accomplished by
- only considering unused blocks.
-
-2. [Static wear leveling][wikipedia-static-wear-leveling], where we
- distribute wear over both "dynamic" and "static" blocks. To make this work,
- we need to consider all blocks, including blocks that already contain data.
-
-As a tradeoff for code size and complexity, littlefs (currently) only provides
-dynamic wear leveling. This is a best effort solution. Wear is not distributed
-perfectly, but it is distributed among the free blocks and greatly extends the
-life of a device.
-
-On top of this, littlefs uses a statistical wear leveling algorithm. What this
-means is that we don’t actively track wear, instead we rely on a uniform
-distribution of wear across storage to approximate a dynamic wear leveling
-algorithm. Despite the long name, this is actually a simplification of dynamic
-wear leveling.
-
-The uniform distribution of wear is left up to the block allocator, which
-creates a uniform distribution in two parts. The easy part is when the device
-is powered, in which case we allocate the blocks linearly, circling the device.
-The harder part is what to do when the device loses power. We can't just
-restart the allocator at the beginning of storage, as this would bias the wear.
-Instead, we start the allocator as a random offset every time we mount the
-filesystem. As long as this random offset is uniform, the combined allocation
-pattern is also a uniform distribution.
-
-![Cumulative wear distribution graph][wear-distribution-graph]
-
-Initially, this approach to wear leveling looks like it creates a difficult
-dependency on a power-independent random number generator, which must return
-different random numbers on each boot. However, the filesystem is in a
-relatively unique situation in that it is sitting on top of a large of amount
-of entropy that persists across power loss.
-
-We can actually use the data on disk to directly drive our random number
-generator. In practice, this is implemented by xoring the checksums of each
-metadata pair, which is already calculated to fetch and mount the filesystem.
-
-```
- .--------. \ probably random
- .|metadata| | ^
- || | +-> crc ----------------------> xor
- || | | ^
- |'--------' / |
- '---|--|-' |
- .-' '-------------------------. |
- | | |
- | .--------------> xor ------------> xor
- | | ^ | ^
- v crc crc v crc
- .--------. \ ^ .--------. \ ^ .--------. \ ^
- .|metadata|-|--|-->|metadata| | | .|metadata| | |
- || | +--' || | +--' || | +--'
- || | | || | | || | |
- |'--------' / |'--------' / |'--------' /
- '---|--|-' '----|---' '---|--|-'
- .-' '-. | .-' '-.
- v v v v v
-.--------. .--------. .--------. .--------. .--------.
-| data | | data | | data | | data | | data |
-| | | | | | | | | |
-| | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------'
-```
-
-Note that this random number generator is not perfect. It only returns unique
-random numbers when the filesystem is modified. This is exactly what we want
-for distributing wear in the allocator, but means this random number generator
-is not useful for general use.
-
----
-
-Together, bad block detection and dynamic wear leveling provide a best effort
-solution for avoiding the early death of a filesystem due to wear. Importantly,
-littlefs's wear leveling algorithm provides a key feature: You can increase the
-life of a device simply by increasing the size of storage. And if more
-aggressive wear leveling is desired, you can always combine littlefs with a
-[flash translation layer (FTL)][wikipedia-ftl] to get a small power resilient
-filesystem with static wear leveling.
-
-## Files
-
-Now that we have our building blocks out of the way, we can start looking at
-our filesystem as a whole.
-
-The first step: How do we actually store our files?
-
-We've determined that CTZ skip-lists are pretty good at storing data compactly,
-so following the precedent found in other filesystems we could give each file
-a skip-list stored in a metadata pair that acts as an inode for the file.
-
-
-```
- .--------.
- .|metadata|
- || |
- || |
- |'--------'
- '----|---'
- v
-.--------. .--------. .--------. .--------.
-| data 0 |<-| data 1 |<-| data 2 |<-| data 3 |
-| |<-| |--| | | |
-| | | | | | | |
-'--------' '--------' '--------' '--------'
-```
-
-However, this doesn't work well when files are small, which is common for
-embedded systems. Compared to PCs, _all_ data in an embedded system is small.
-
-Consider a small 4-byte file. With a two block metadata-pair and one block for
-the CTZ skip-list, we find ourselves using a full 3 blocks. On most NOR flash
-with 4 KiB blocks, this is 12 KiB of overhead. A ridiculous 3072x increase.
-
-```
-file stored as inode, 4 bytes costs ~12 KiB
-
- .----------------. \
-.| revision | |
-||----------------| \ |
-|| skiplist ---. +- metadata |
-||----------------| | / 4x8 bytes |
-|| checksum | | 32 bytes |
-||----------------| | |
-|| | | | +- metadata pair
-|| v | | | 2x4 KiB
-|| | | | 8 KiB
-|| | | |
-|| | | |
-|| | | |
-|'----------------' | |
-'----------------' | /
- .--------'
- v
- .----------------. \ \
- | data | +- data |
- |----------------| / 4 bytes |
- | | |
- | | |
- | | |
- | | +- data block
- | | | 4 KiB
- | | |
- | | |
- | | |
- | | |
- | | |
- '----------------' /
-```
-
-We can make several improvements. First, instead of giving each file its own
-metadata pair, we can store multiple files in a single metadata pair. One way
-to do this is to directly associate a directory with a metadata pair (or a
-linked list of metadata pairs). This makes it easy for multiple files to share
-the directory's metadata pair for logging and reduces the collective storage
-overhead.
-
-The strict binding of metadata pairs and directories also gives users
-direct control over storage utilization depending on how they organize their
-directories.
-
-```
-multiple files stored in metadata pair, 4 bytes costs ~4 KiB
-
- .----------------.
- .| revision |
- ||----------------|
- || A name |
- || A skiplist -----.
- ||----------------| | \
- || B name | | +- metadata
- || B skiplist ---. | | 4x8 bytes
- ||----------------| | | / 32 bytes
- || checksum | | |
- ||----------------| | |
- || | | | |
- || v | | |
- |'----------------' | |
- '----------------' | |
- .----------------' |
- v v
-.----------------. .----------------. \ \
-| A data | | B data | +- data |
-| | |----------------| / 4 bytes |
-| | | | |
-| | | | |
-| | | | |
-| | | | + data block
-| | | | | 4 KiB
-| | | | |
-|----------------| | | |
-| | | | |
-| | | | |
-| | | | |
-'----------------' '----------------' /
-```
-
-The second improvement we can make is noticing that for very small files, our
-attempts to use CTZ skip-lists for compact storage backfires. Metadata pairs
-have a ~4x storage cost, so if our file is smaller than 1/4 the block size,
-there's actually no benefit in storing our file outside of our metadata pair.
-
-In this case, we can store the file directly in our directory's metadata pair.
-We call this an inline file, and it allows a directory to store many small
-files quite efficiently. Our previous 4 byte file now only takes up a
-theoretical 16 bytes on disk.
-
-```
-inline files stored in metadata pair, 4 bytes costs ~16 bytes
-
- .----------------.
-.| revision |
-||----------------|
-|| A name |
-|| A skiplist ---.
-||----------------| | \
-|| B name | | +- data
-|| B data | | | 4x4 bytes
-||----------------| | / 16 bytes
-|| checksum | |
-||----------------| |
-|| | | |
-|| v | |
-|'----------------' |
-'----------------' |
- .---------'
- v
- .----------------.
- | A data |
- | |
- | |
- | |
- | |
- | |
- | |
- | |
- |----------------|
- | |
- | |
- | |
- '----------------'
-```
-
-Once the file exceeds 1/4 the block size, we switch to a CTZ skip-list. This
-means that our files never use more than 4x storage overhead, decreasing as
-the file grows in size.
-
-![File storage cost graph][file-cost-graph]
-
-## Directories
-
-Now we just need directories to store our files. As mentioned above we want
-a strict binding of directories and metadata pairs, but there are a few
-complications we need to sort out.
-
-On their own, each directory is a linked-list of metadata pairs. This lets us
-store an unlimited number of files in each directory, and we don't need to
-worry about the runtime complexity of unbounded logs. We can store other
-directory pointers in our metadata pairs, which gives us a directory tree, much
-like what you find on other filesystems.
-
-```
- .--------.
- .| root |
- || |
- || |
- |'--------'
- '---|--|-'
- .-' '-------------------------.
- v v
- .--------. .--------. .--------.
- .| dir A |------->| dir A | .| dir B |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '---|--|-' '----|---' '---|--|-'
- .-' '-. | .-' '-.
- v v v v v
-.--------. .--------. .--------. .--------. .--------.
-| file C | | file D | | file E | | file F | | file G |
-| | | | | | | | | |
-| | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------'
-```
-
-The main complication is, once again, traversal with a constant amount of
-[RAM]. The directory tree is a tree, and the unfortunate fact is you can't
-traverse a tree with constant RAM.
-
-Fortunately, the elements of our tree are metadata pairs, so unlike CTZ
-skip-lists, we're not limited to strict COW operations. One thing we can do is
-thread a linked-list through our tree, explicitly enabling cheap traversal
-over the entire filesystem.
-
-```
- .--------.
- .| root |-.
- || | |
- .-------|| |-'
- | |'--------'
- | '---|--|-'
- | .-' '-------------------------.
- | v v
- | .--------. .--------. .--------.
- '->| dir A |------->| dir A |------->| dir B |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '---|--|-' '----|---' '---|--|-'
- .-' '-. | .-' '-.
- v v v v v
-.--------. .--------. .--------. .--------. .--------.
-| file C | | file D | | file E | | file F | | file G |
-| | | | | | | | | |
-| | | | | | | | | |
-'--------' '--------' '--------' '--------' '--------'
-```
-
-Unfortunately, not sticking to pure COW operations creates some problems. Now,
-whenever we want to manipulate the directory tree, multiple pointers need to be
-updated. If you're familiar with designing atomic data structures this should
-set off a bunch of red flags.
-
-To work around this, our threaded linked-list has a bit of leeway. Instead of
-only containing metadata pairs found in our filesystem, it is allowed to
-contain metadata pairs that have no parent because of a power loss. These are
-called orphaned metadata pairs.
-
-With the possibility of orphans, we can build power loss resilient operations
-that maintain a filesystem tree threaded with a linked-list for traversal.
-
-Adding a directory to our tree:
-
-```
- .--------.
- .| root |-.
- || | |
-.-------|| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-.
-| v v
-| .--------. .--------.
-'->| dir A |->| dir C |
- || | || |
- || | || |
- |'--------' |'--------'
- '--------' '--------'
-
-allocate dir B
-=>
- .--------.
- .| root |-.
- || | |
-.-------|| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-.
-| v v
-| .--------. .--------.
-'->| dir A |--->| dir C |
- || | .->| |
- || | | || |
- |'--------' | |'--------'
- '--------' | '--------'
- |
- .--------. |
- .| dir B |-'
- || |
- || |
- |'--------'
- '--------'
-
-insert dir B into threaded linked-list, creating an orphan
-=>
- .--------.
- .| root |-.
- || | |
-.-------|| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-------------.
-| v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || orphan!| || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-
-add dir B to parent directory
-=>
- .--------.
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-```
-
-Removing a directory:
-
-```
- .--------.
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-
-remove dir B from parent directory, creating an orphan
-=>
- .--------.
- .| root |-.
- || | |
-.-------|| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-------------.
-| v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || orphan!| || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-
-remove dir B from threaded linked-list, returning dir B to free blocks
-=>
- .--------.
- .| root |-.
- || | |
-.-------|| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-.
-| v v
-| .--------. .--------.
-'->| dir A |->| dir C |
- || | || |
- || | || |
- |'--------' |'--------'
- '--------' '--------'
-```
-
-In addition to normal directory tree operations, we can use orphans to evict
-blocks in a metadata pair when the block goes bad or exceeds its allocated
-erases. If we lose power while evicting a metadata block we may end up with
-a situation where the filesystem references the replacement block while the
-threaded linked-list still contains the evicted block. We call this a
-half-orphan.
-
-```
- .--------.
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-
-try to write to dir B
-=>
- .--------.
- .| root |-.
- || | |
-.----------------|| |-'
-| |'--------'
-| '-|-||-|-'
-| .--------' || '-----.
-| v |v v
-| .--------. .--------. .--------.
-'->| dir A |---->| dir B |->| dir C |
- || |-. | | || |
- || | | | | || |
- |'--------' | '--------' |'--------'
- '--------' | v '--------'
- | .--------.
- '->| dir B |
- | bad |
- | block! |
- '--------'
-
-oh no! bad block detected, allocate replacement
-=>
- .--------.
- .| root |-.
- || | |
-.----------------|| |-'
-| |'--------'
-| '-|-||-|-'
-| .--------' || '-------.
-| v |v v
-| .--------. .--------. .--------.
-'->| dir A |---->| dir B |--->| dir C |
- || |-. | | .->| |
- || | | | | | || |
- |'--------' | '--------' | |'--------'
- '--------' | v | '--------'
- | .--------. |
- '->| dir B | |
- | bad | |
- | block! | |
- '--------' |
- |
- .--------. |
- | dir B |--'
- | |
- | |
- '--------'
-
-insert replacement in threaded linked-list, creating a half-orphan
-=>
- .--------.
- .| root |-.
- || | |
-.----------------|| |-'
-| |'--------'
-| '-|-||-|-'
-| .--------' || '-------.
-| v |v v
-| .--------. .--------. .--------.
-'->| dir A |---->| dir B |--->| dir C |
- || |-. | | .->| |
- || | | | | | || |
- |'--------' | '--------' | |'--------'
- '--------' | v | '--------'
- | .--------. |
- | | dir B | |
- | | bad | |
- | | block! | |
- | '--------' |
- | |
- | .--------. |
- '->| dir B |--'
- | half |
- | orphan!|
- '--------'
-
-fix reference in parent directory
-=>
- .--------.
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-```
-
-Finding orphans and half-orphans is expensive, requiring a _O(n²)_
-comparison of every metadata pair with every directory entry. But the tradeoff
-is a power resilient filesystem that works with only a bounded amount of RAM.
-Fortunately, we only need to check for orphans on the first allocation after
-boot, and a read-only littlefs can ignore the threaded linked-list entirely.
-
-If we only had some sort of global state, then we could also store a flag and
-avoid searching for orphans unless we knew we were specifically interrupted
-while manipulating the directory tree (foreshadowing!).
-
-## The move problem
-
-We have one last challenge: the move problem. Phrasing the problem is simple:
-
-How do you atomically move a file between two directories?
-
-In littlefs we can atomically commit to directories, but we can't create
-an atomic commit that spans multiple directories. The filesystem must go
-through a minimum of two distinct states to complete a move.
-
-To make matters worse, file moves are a common form of synchronization for
-filesystems. As a filesystem designed for power-loss, it's important we get
-atomic moves right.
-
-So what can we do?
-
-- We definitely can't just let power-loss result in duplicated or lost files.
- This could easily break users' code and would only reveal itself in extreme
- cases. We were only able to be lazy about the threaded linked-list because
- it isn't user facing and we can handle the corner cases internally.
-
-- Some filesystems propagate COW operations up the tree until a common parent
- is found. Unfortunately this interacts poorly with our threaded tree and
- brings back the issue of upward propagation of wear.
-
-- In a previous version of littlefs we tried to solve this problem by going
- back and forth between the source and destination, marking and unmarking the
- file as moving in order to make the move atomic from the user perspective.
- This worked, but not well. Finding failed moves was expensive and required
- a unique identifier for each file.
-
-In the end, solving the move problem required creating a new mechanism for
-sharing knowledge between multiple metadata pairs. In littlefs this led to the
-introduction of a mechanism called "global state".
-
----
-
-Global state is a small set of state that can be updated from _any_ metadata
-pair. Combining global state with metadata pairs' ability to update multiple
-entries in one commit gives us a powerful tool for crafting complex atomic
-operations.
-
-How does global state work?
-
-Global state exists as a set of deltas that are distributed across the metadata
-pairs in the filesystem. The actual global state can be built out of these
-deltas by xoring together all of the deltas in the filesystem.
-
-```
- .--------. .--------. .--------. .--------. .--------.
-.| |->| gdelta |->| |->| gdelta |->| gdelta |
-|| | || 0x23 | || | || 0xff | || 0xce |
-|| | || | || | || | || |
-|'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '----|---' '--------' '----|---' '----|---'
- v v v
- 0x00 --> xor ------------------> xor ------> xor --> gstate 0x12
-```
-
-To update the global state from a metadata pair, we take the global state we
-know and xor it with both our changes and any existing delta in the metadata
-pair. Committing this new delta to the metadata pair commits the changes to
-the filesystem's global state.
-
-```
- .--------. .--------. .--------. .--------. .--------.
-.| |->| gdelta |->| |->| gdelta |->| gdelta |
-|| | || 0x23 | || | || 0xff | || 0xce |
-|| | || | || | || | || |
-|'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '----|---' '--------' '--|---|-' '----|---'
- v v | v
- 0x00 --> xor ----------------> xor -|------> xor --> gstate = 0x12
- | |
- | |
-change gstate to 0xab --> xor <------------|--------------------------'
-=> | v
- '------------> xor
- |
- v
- .--------. .--------. .--------. .--------. .--------.
-.| |->| gdelta |->| |->| gdelta |->| gdelta |
-|| | || 0x23 | || | || 0x46 | || 0xce |
-|| | || | || | || | || |
-|'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '----|---' '--------' '----|---' '----|---'
- v v v
- 0x00 --> xor ------------------> xor ------> xor --> gstate = 0xab
-```
-
-To make this efficient, we always keep a copy of the global state in RAM. We
-only need to iterate over our metadata pairs and build the global state when
-the filesystem is mounted.
-
-You may have noticed that global state is very expensive. We keep a copy in
-RAM and a delta in an unbounded number of metadata pairs. Even if we reset
-the global state to its initial value, we can't easily clean up the deltas on
-disk. For this reason, it's very important that we keep the size of global
-state bounded and extremely small. But, even with a strict budget, global
-state is incredibly valuable.
-
----
-
-Now we can solve the move problem. We can create global state describing our
-move atomically with the creation of the new file, and we can clear this move
-state atomically with the removal of the old file.
-
-```
- .--------. gstate = no move
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '----|---' '--------' '--------'
- v
- .--------.
- | file D |
- | |
- | |
- '--------'
-
-begin move, add reference in dir C, change gstate to have move
-=>
- .--------. gstate = moving file D in dir A (m1)
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || | || | || gdelta |
- || | || | || =m1 |
- |'--------' |'--------' |'--------'
- '----|---' '--------' '----|---'
- | .----------------'
- v v
- .--------.
- | file D |
- | |
- | |
- '--------'
-
-complete move, remove reference in dir A, change gstate to no move
-=>
- .--------. gstate = no move (m1^~m1)
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || gdelta | || | || gdelta |
- || =~m1 | || | || =m1 |
- |'--------' |'--------' |'--------'
- '--------' '--------' '----|---'
- v
- .--------.
- | file D |
- | |
- | |
- '--------'
-```
-
-
-If, after building our global state during mount, we find information
-describing an ongoing move, we know we lost power during a move and the file
-is duplicated in both the source and destination directories. If this happens,
-we can resolve the move using the information in the global state to remove
-one of the files.
-
-```
- .--------. gstate = moving file D in dir A (m1)
- .| root |-. ^
- || |------------> xor
-.---------------|| |-' ^
-| |'--------' |
-| '--|-|-|-' |
-| .--------' | '---------. |
-| | | | |
-| | .----------> xor --------> xor
-| v | v ^ v ^
-| .--------. | .--------. | .--------. |
-'->| dir A |-|->| dir B |-|->| dir C | |
- || |-' || |-' || gdelta |-'
- || | || | || =m1 |
- |'--------' |'--------' |'--------'
- '----|---' '--------' '----|---'
- | .---------------------'
- v v
- .--------.
- | file D |
- | |
- | |
- '--------'
-```
-
-We can also move directories the same way we move files. There is the threaded
-linked-list to consider, but leaving the threaded linked-list unchanged works
-fine as the order doesn't really matter.
-
-```
- .--------. gstate = no move (m1^~m1)
- .| root |-.
- || | |
-.-------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .------' | '-------.
-| v v v
-| .--------. .--------. .--------.
-'->| dir A |->| dir B |->| dir C |
- || gdelta | || | || gdelta |
- || =~m1 | || | || =m1 |
- |'--------' |'--------' |'--------'
- '--------' '--------' '----|---'
- v
- .--------.
- | file D |
- | |
- | |
- '--------'
-
-begin move, add reference in dir C, change gstate to have move
-=>
- .--------. gstate = moving dir B in root (m1^~m1^m2)
- .| root |-.
- || | |
-.--------------|| |-'
-| |'--------'
-| '--|-|-|-'
-| .-------' | '----------.
-| v | v
-| .--------. | .--------.
-'->| dir A |-. | .->| dir C |
- || gdelta | | | | || gdelta |
- || =~m1 | | | | || =m1^m2 |
- |'--------' | | | |'--------'
- '--------' | | | '---|--|-'
- | | .-------' |
- | v v | v
- | .--------. | .--------.
- '->| dir B |-' | file D |
- || | | |
- || | | |
- |'--------' '--------'
- '--------'
-
-complete move, remove reference in root, change gstate to no move
-=>
- .--------. gstate = no move (m1^~m1^m2^~m2)
- .| root |-.
- || gdelta | |
-.-----------|| =~m2 |-'
-| |'--------'
-| '---|--|-'
-| .-----' '-----.
-| v v
-| .--------. .--------.
-'->| dir A |-. .->| dir C |
- || gdelta | | | || gdelta |
- || =~m1 | | '-|| =m1^m2 |-------.
- |'--------' | |'--------' |
- '--------' | '---|--|-' |
- | .-' '-. |
- | v v |
- | .--------. .--------. |
- '->| dir B |--| file D |-'
- || | | |
- || | | |
- |'--------' '--------'
- '--------'
-```
-
-Global state gives us a powerful tool we can use to solve the move problem.
-And the result is surprisingly performant, only needing the minimum number
-of states and using the same number of commits as a naive move. Additionally,
-global state gives us a bit of persistent state we can use for some other
-small improvements.
-
-## Conclusion
-
-And that's littlefs, thanks for reading!
-
-
-[wikipedia-flash]: https://en.wikipedia.org/wiki/Flash_memory
-[wikipedia-sna]: https://en.wikipedia.org/wiki/Serial_number_arithmetic
-[wikipedia-crc]: https://en.wikipedia.org/wiki/Cyclic_redundancy_check
-[wikipedia-cow]: https://en.wikipedia.org/wiki/Copy-on-write
-[wikipedia-B-tree]: https://en.wikipedia.org/wiki/B-tree
-[wikipedia-B+-tree]: https://en.wikipedia.org/wiki/B%2B_tree
-[wikipedia-skip-list]: https://en.wikipedia.org/wiki/Skip_list
-[wikipedia-ctz]: https://en.wikipedia.org/wiki/Count_trailing_zeros
-[wikipedia-ecc]: https://en.wikipedia.org/wiki/Error_correction_code
-[wikipedia-hamming-bound]: https://en.wikipedia.org/wiki/Hamming_bound
-[wikipedia-dynamic-wear-leveling]: https://en.wikipedia.org/wiki/Wear_leveling#Dynamic_wear_leveling
-[wikipedia-static-wear-leveling]: https://en.wikipedia.org/wiki/Wear_leveling#Static_wear_leveling
-[wikipedia-ftl]: https://en.wikipedia.org/wiki/Flash_translation_layer
-
-[oeis]: https://oeis.org
-[A001511]: https://oeis.org/A001511
-[A005187]: https://oeis.org/A005187
-
-[fat]: https://en.wikipedia.org/wiki/Design_of_the_FAT_file_system
-[ext2]: http://e2fsprogs.sourceforge.net/ext2intro.html
-[jffs]: https://www.sourceware.org/jffs2/jffs2-html
-[yaffs]: https://yaffs.net/documents/how-yaffs-works
-[spiffs]: https://github.com/pellepl/spiffs/blob/master/docs/TECH_SPEC
-[ext4]: https://ext4.wiki.kernel.org/index.php/Ext4_Design
-[ntfs]: https://en.wikipedia.org/wiki/NTFS
-[btrfs]: https://btrfs.wiki.kernel.org/index.php/Btrfs_design
-[zfs]: https://en.wikipedia.org/wiki/ZFS
-
-[cow]: https://upload.wikimedia.org/wikipedia/commons/0/0c/Cow_female_black_white.jpg
-[elephant]: https://upload.wikimedia.org/wikipedia/commons/3/37/African_Bush_Elephant.jpg
-[ram]: https://upload.wikimedia.org/wikipedia/commons/9/97/New_Mexico_Bighorn_Sheep.JPG
-
-[metadata-formula1]: https://latex.codecogs.com/svg.latex?cost%20%3D%20n%20+%20n%20%5Cfrac%7Bs%7D%7Bd+1%7D
-[metadata-formula2]: https://latex.codecogs.com/svg.latex?s%20%3D%20r%20%5Cfrac%7Bsize%7D%7Bn%7D
-[metadata-formula3]: https://latex.codecogs.com/svg.latex?d%20%3D%20%281-r%29%20%5Cfrac%7Bsize%7D%7Bn%7D
-[metadata-formula4]: https://latex.codecogs.com/svg.latex?cost%20%3D%20n%20+%20n%20%5Cfrac%7Br%5Cfrac%7Bsize%7D%7Bn%7D%7D%7B%281-r%29%5Cfrac%7Bsize%7D%7Bn%7D+1%7D
-
-[ctz-formula1]: https://latex.codecogs.com/svg.latex?%5Clim_%7Bn%5Cto%5Cinfty%7D%5Cfrac%7B1%7D%7Bn%7D%5Csum_%7Bi%3D0%7D%5E%7Bn%7D%5Cleft%28%5Ctext%7Bctz%7D%28i%29+1%5Cright%29%20%3D%20%5Csum_%7Bi%3D0%7D%5Cfrac%7B1%7D%7B2%5Ei%7D%20%3D%202
-[ctz-formula2]: https://latex.codecogs.com/svg.latex?B%20%3D%20%5Cfrac%7Bw%7D%7B8%7D%5Cleft%5Clceil%5Clog_2%5Cleft%28%5Cfrac%7B2%5Ew%7D%7BB-2%5Cfrac%7Bw%7D%7B8%7D%7D%5Cright%29%5Cright%5Crceil
-[ctz-formula3]: https://latex.codecogs.com/svg.latex?N%20%3D%20%5Csum_i%5En%5Cleft%5BB-%5Cfrac%7Bw%7D%7B8%7D%5Cleft%28%5Ctext%7Bctz%7D%28i%29+1%5Cright%29%5Cright%5D
-[ctz-formula4]: https://latex.codecogs.com/svg.latex?%5Csum_i%5En%5Cleft%28%5Ctext%7Bctz%7D%28i%29+1%5Cright%29%20%3D%202n-%5Ctext%7Bpopcount%7D%28n%29
-[ctz-formula5]: https://latex.codecogs.com/svg.latex?N%20%3D%20Bn%20-%20%5Cfrac%7Bw%7D%7B8%7D%5Cleft%282n-%5Ctext%7Bpopcount%7D%28n%29%5Cright%29
-[ctz-formula6]: https://latex.codecogs.com/svg.latex?n%20%3D%20%5Cleft%5Clfloor%5Cfrac%7BN-%5Cfrac%7Bw%7D%7B8%7D%5Cleft%28%5Ctext%7Bpopcount%7D%5Cleft%28%5Cfrac%7BN%7D%7BB-2%5Cfrac%7Bw%7D%7B8%7D%7D-1%5Cright%29+2%5Cright%29%7D%7BB-2%5Cfrac%7Bw%7D%7B8%7D%7D%5Cright%5Crfloor
-[ctz-formula7]: https://latex.codecogs.com/svg.latex?%5Cmathit%7Boff%7D%20%3D%20N%20-%20%5Cleft%28B-2%5Cfrac%7Bw%7D%7B8%7D%5Cright%29n%20-%20%5Cfrac%7Bw%7D%7B8%7D%5Ctext%7Bpopcount%7D%28n%29
-
-[bigB]: https://latex.codecogs.com/svg.latex?B
-[d]: https://latex.codecogs.com/svg.latex?d
-[m]: https://latex.codecogs.com/svg.latex?m
-[bigN]: https://latex.codecogs.com/svg.latex?N
-[n]: https://latex.codecogs.com/svg.latex?n
-[n']: https://latex.codecogs.com/svg.latex?n%27
-[r]: https://latex.codecogs.com/svg.latex?r
-[s]: https://latex.codecogs.com/svg.latex?s
-[w]: https://latex.codecogs.com/svg.latex?w
-[x]: https://latex.codecogs.com/svg.latex?x
-
-[metadata-cost-graph]: https://raw.githubusercontent.com/geky/littlefs/gh-images/metadata-cost.svg?sanitize=true
-[wear-distribution-graph]: https://raw.githubusercontent.com/geky/littlefs/gh-images/wear-distribution.svg?sanitize=true
-[file-cost-graph]: https://raw.githubusercontent.com/geky/littlefs/gh-images/file-cost.svg?sanitize=true
diff --git a/fs/littlefs/LICENSE.md b/fs/littlefs/LICENSE.md
deleted file mode 100644
index e6c3a7bac..000000000
--- a/fs/littlefs/LICENSE.md
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2022, The littlefs authors.
-Copyright (c) 2017, Arm Limited. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-- Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-- Redistributions in binary form must reproduce the above copyright notice, this
- list of conditions and the following disclaimer in the documentation and/or
- other materials provided with the distribution.
-- Neither the name of ARM nor the names of its contributors may be used to
- endorse or promote products derived from this software without specific prior
- written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/fs/littlefs/README.md b/fs/littlefs/README.md
deleted file mode 100644
index 584ada39d..000000000
--- a/fs/littlefs/README.md
+++ /dev/null
@@ -1,258 +0,0 @@
-## littlefs
-
-A little fail-safe filesystem designed for microcontrollers.
-
-```
- | | | .---._____
- .-----. | |
---|o |---| littlefs |
---| |---| |
- '-----' '----------'
- | | |
-```
-
-**Power-loss resilience** - littlefs is designed to handle random power
-failures. All file operations have strong copy-on-write guarantees and if
-power is lost the filesystem will fall back to the last known good state.
-
-**Dynamic wear leveling** - littlefs is designed with flash in mind, and
-provides wear leveling over dynamic blocks. Additionally, littlefs can
-detect bad blocks and work around them.
-
-**Bounded RAM/ROM** - littlefs is designed to work with a small amount of
-memory. RAM usage is strictly bounded, which means RAM consumption does not
-change as the filesystem grows. The filesystem contains no unbounded
-recursion and dynamic memory is limited to configurable buffers that can be
-provided statically.
-
-## Example
-
-Here's a simple example that updates a file named `boot_count` every time
-main runs. The program can be interrupted at any time without losing track
-of how many times it has been booted and without corrupting the filesystem:
-
-``` c
-#include "lfs.h"
-
-// variables used by the filesystem
-lfs_t lfs;
-lfs_file_t file;
-
-// configuration of the filesystem is provided by this struct
-const struct lfs_config cfg = {
- // block device operations
- .read = user_provided_block_device_read,
- .prog = user_provided_block_device_prog,
- .erase = user_provided_block_device_erase,
- .sync = user_provided_block_device_sync,
-
- // block device configuration
- .read_size = 16,
- .prog_size = 16,
- .block_size = 4096,
- .block_count = 128,
- .cache_size = 16,
- .lookahead_size = 16,
- .block_cycles = 500,
-};
-
-// entry point
-int main(void) {
- // mount the filesystem
- int err = lfs_mount(&lfs, &cfg);
-
- // reformat if we can't mount the filesystem
- // this should only happen on the first boot
- if (err) {
- lfs_format(&lfs, &cfg);
- lfs_mount(&lfs, &cfg);
- }
-
- // read current count
- uint32_t boot_count = 0;
- lfs_file_open(&lfs, &file, "boot_count", LFS_O_RDWR | LFS_O_CREAT);
- lfs_file_read(&lfs, &file, &boot_count, sizeof(boot_count));
-
- // update boot count
- boot_count += 1;
- lfs_file_rewind(&lfs, &file);
- lfs_file_write(&lfs, &file, &boot_count, sizeof(boot_count));
-
- // remember the storage is not updated until the file is closed successfully
- lfs_file_close(&lfs, &file);
-
- // release any resources we were using
- lfs_unmount(&lfs);
-
- // print the boot count
- printf("boot_count: %d\n", boot_count);
-}
-```
-
-## Usage
-
-Detailed documentation (or at least as much detail as is currently available)
-can be found in the comments in [lfs.h](lfs.h).
-
-littlefs takes in a configuration structure that defines how the filesystem
-operates. The configuration struct provides the filesystem with the block
-device operations and dimensions, tweakable parameters that tradeoff memory
-usage for performance, and optional static buffers if the user wants to avoid
-dynamic memory.
-
-The state of the littlefs is stored in the `lfs_t` type which is left up
-to the user to allocate, allowing multiple filesystems to be in use
-simultaneously. With the `lfs_t` and configuration struct, a user can
-format a block device or mount the filesystem.
-
-Once mounted, the littlefs provides a full set of POSIX-like file and
-directory functions, with the deviation that the allocation of filesystem
-structures must be provided by the user.
-
-All POSIX operations, such as remove and rename, are atomic, even in event
-of power-loss. Additionally, file updates are not actually committed to
-the filesystem until sync or close is called on the file.
-
-## Other notes
-
-Littlefs is written in C, and specifically should compile with any compiler
-that conforms to the `C99` standard.
-
-All littlefs calls have the potential to return a negative error code. The
-errors can be either one of those found in the `enum lfs_error` in
-[lfs.h](lfs.h), or an error returned by the user's block device operations.
-
-In the configuration struct, the `prog` and `erase` function provided by the
-user may return a `LFS_ERR_CORRUPT` error if the implementation already can
-detect corrupt blocks. However, the wear leveling does not depend on the return
-code of these functions, instead all data is read back and checked for
-integrity.
-
-If your storage caches writes, make sure that the provided `sync` function
-flushes all the data to memory and ensures that the next read fetches the data
-from memory, otherwise data integrity can not be guaranteed. If the `write`
-function does not perform caching, and therefore each `read` or `write` call
-hits the memory, the `sync` function can simply return 0.
-
-## Design
-
-At a high level, littlefs is a block based filesystem that uses small logs to
-store metadata and larger copy-on-write (COW) structures to store file data.
-
-In littlefs, these ingredients form a sort of two-layered cake, with the small
-logs (called metadata pairs) providing fast updates to metadata anywhere on
-storage, while the COW structures store file data compactly and without any
-wear amplification cost.
-
-Both of these data structures are built out of blocks, which are fed by a
-common block allocator. By limiting the number of erases allowed on a block
-per allocation, the allocator provides dynamic wear leveling over the entire
-filesystem.
-
-```
- root
- .--------.--------.
- | A'| B'| |
- | | |-> |
- | | | |
- '--------'--------'
- .----' '--------------.
- A v B v
- .--------.--------. .--------.--------.
- | C'| D'| | | E'|new| |
- | | |-> | | | E'|-> |
- | | | | | | | |
- '--------'--------' '--------'--------'
- .-' '--. | '------------------.
- v v .-' v
-.--------. .--------. v .--------.
-| C | | D | .--------. write | new E |
-| | | | | E | ==> | |
-| | | | | | | |
-'--------' '--------' | | '--------'
- '--------' .-' |
- .-' '-. .-------------|------'
- v v v v
- .--------. .--------. .--------.
- | F | | G | | new F |
- | | | | | |
- | | | | | |
- '--------' '--------' '--------'
-```
-
-More details on how littlefs works can be found in [DESIGN.md](DESIGN.md) and
-[SPEC.md](SPEC.md).
-
-- [DESIGN.md](DESIGN.md) - A fully detailed dive into how littlefs works.
- I would suggest reading it as the tradeoffs at work are quite interesting.
-
-- [SPEC.md](SPEC.md) - The on-disk specification of littlefs with all the
- nitty-gritty details. May be useful for tooling development.
-
-## Testing
-
-The littlefs comes with a test suite designed to run on a PC using the
-[emulated block device](bd/lfs_testbd.h) found in the `bd` directory.
-The tests assume a Linux environment and can be started with make:
-
-``` bash
-make test
-```
-
-## License
-
-The littlefs is provided under the [BSD-3-Clause] license. See
-[LICENSE.md](LICENSE.md) for more information. Contributions to this project
-are accepted under the same license.
-
-Individual files contain the following tag instead of the full license text.
-
- SPDX-License-Identifier: BSD-3-Clause
-
-This enables machine processing of license information based on the SPDX
-License Identifiers that are here available: http://spdx.org/licenses/
-
-## Related projects
-
-- [littlefs-fuse] - A [FUSE] wrapper for littlefs. The project allows you to
- mount littlefs directly on a Linux machine. Can be useful for debugging
- littlefs if you have an SD card handy.
-
-- [littlefs-js] - A javascript wrapper for littlefs. I'm not sure why you would
- want this, but it is handy for demos. You can see it in action
- [here][littlefs-js-demo].
-
-- [littlefs-python] - A Python wrapper for littlefs. The project allows you
- to create images of the filesystem on your PC. Check if littlefs will fit
- your needs, create images for a later download to the target memory or
- inspect the content of a binary image of the target memory.
-
-- [mklfs] - A command line tool built by the [Lua RTOS] guys for making
- littlefs images from a host PC. Supports Windows, Mac OS, and Linux.
-
-- [Mbed OS] - The easiest way to get started with littlefs is to jump into Mbed
- which already has block device drivers for most forms of embedded storage.
- littlefs is available in Mbed OS as the [LittleFileSystem] class.
-
-- [SPIFFS] - Another excellent embedded filesystem for NOR flash. As a more
- traditional logging filesystem with full static wear-leveling, SPIFFS will
- likely outperform littlefs on small memories such as the internal flash on
- microcontrollers.
-
-- [Dhara] - An interesting NAND flash translation layer designed for small
- MCUs. It offers static wear-leveling and power-resilience with only a fixed
- _O(|address|)_ pointer structure stored on each block and in RAM.
-
-
-[BSD-3-Clause]: https://spdx.org/licenses/BSD-3-Clause.html
-[littlefs-fuse]: https://github.com/geky/littlefs-fuse
-[FUSE]: https://github.com/libfuse/libfuse
-[littlefs-js]: https://github.com/geky/littlefs-js
-[littlefs-js-demo]:http://littlefs.geky.net/demo.html
-[mklfs]: https://github.com/whitecatboard/Lua-RTOS-ESP32/tree/master/components/mklfs/src
-[Lua RTOS]: https://github.com/whitecatboard/Lua-RTOS-ESP32
-[Mbed OS]: https://github.com/armmbed/mbed-os
-[LittleFileSystem]: https://os.mbed.com/docs/mbed-os/v5.12/apis/littlefilesystem.html
-[SPIFFS]: https://github.com/pellepl/spiffs
-[Dhara]: https://github.com/dlbeer/dhara
-[littlefs-python]: https://pypi.org/project/littlefs-python/
diff --git a/fs/littlefs/SPEC.md b/fs/littlefs/SPEC.md
deleted file mode 100644
index 3663ea544..000000000
--- a/fs/littlefs/SPEC.md
+++ /dev/null
@@ -1,787 +0,0 @@
-## littlefs technical specification
-
-This is the technical specification of the little filesystem. This document
-covers the technical details of how the littlefs is stored on disk for
-introspection and tooling. This document assumes you are familiar with the
-design of the littlefs, for more info on how littlefs works check
-out [DESIGN.md](DESIGN.md).
-
-```
- | | | .---._____
- .-----. | |
---|o |---| littlefs |
---| |---| |
- '-----' '----------'
- | | |
-```
-
-## Some quick notes
-
-- littlefs is a block-based filesystem. The disk is divided into an array of
- evenly sized blocks that are used as the logical unit of storage.
-
-- Block pointers are stored in 32 bits, with the special value `0xffffffff`
- representing a null block address.
-
-- In addition to the logical block size (which usually matches the erase
- block size), littlefs also uses a program block size and read block size.
- These determine the alignment of block device operations, but don't need
- to be consistent for portability.
-
-- By default, all values in littlefs are stored in little-endian byte order.
-
-## Directories / Metadata pairs
-
-Metadata pairs form the backbone of littlefs and provide a system for
-distributed atomic updates. Even the superblock is stored in a metadata pair.
-
-As their name suggests, a metadata pair is stored in two blocks, with one block
-providing a backup during erase cycles in case power is lost. These two blocks
-are not necessarily sequential and may be anywhere on disk, so a "pointer" to a
-metadata pair is stored as two block pointers.
-
-On top of this, each metadata block behaves as an appendable log, containing a
-variable number of commits. Commits can be appended to the metadata log in
-order to update the metadata without requiring an erase cycles. Note that
-successive commits may supersede the metadata in previous commits. Only the
-most recent metadata should be considered valid.
-
-The high-level layout of a metadata block is fairly simple:
-
-```
- .---------------------------------------.
-.-| revision count | entries | \
-| |-------------------+ | |
-| | | |
-| | | +-- 1st commit
-| | | |
-| | +-------------------| |
-| | | CRC | /
-| |-------------------+-------------------|
-| | entries | \
-| | | |
-| | | +-- 2nd commit
-| | +-------------------+--------------| |
-| | | CRC | padding | /
-| |----+-------------------+--------------|
-| | entries | \
-| | | |
-| | | +-- 3rd commit
-| | +-------------------+---------| |
-| | | CRC | | /
-| |---------+-------------------+ |
-| | unwritten storage | more commits
-| | | |
-| | | v
-| | |
-| | |
-| '---------------------------------------'
-'---------------------------------------'
-```
-
-Each metadata block contains a 32-bit revision count followed by a number of
-commits. Each commit contains a variable number of metadata entries followed
-by a 32-bit CRC.
-
-Note also that entries aren't necessarily word-aligned. This allows us to
-store metadata more compactly, however we can only write to addresses that are
-aligned to our program block size. This means each commit may have padding for
-alignment.
-
-Metadata block fields:
-
-1. **Revision count (32-bits)** - Incremented every erase cycle. If both blocks
- contain valid commits, only the block with the most recent revision count
- should be used. Sequence comparison must be used to avoid issues with
- integer overflow.
-
-2. **CRC (32-bits)** - Detects corruption from power-loss or other write
- issues. Uses a CRC-32 with a polynomial of `0x04c11db7` initialized
- with `0xffffffff`.
-
-Entries themselves are stored as a 32-bit tag followed by a variable length
-blob of data. But exactly how these tags are stored is a little bit tricky.
-
-Metadata blocks support both forward and backward iteration. In order to do
-this without duplicating the space for each tag, neighboring entries have their
-tags XORed together, starting with `0xffffffff`.
-
-```
- Forward iteration Backward iteration
-
-.-------------------. 0xffffffff .-------------------.
-| revision count | | | revision count |
-|-------------------| v |-------------------|
-| tag ~A |---> xor -> tag A | tag ~A |---> xor -> 0xffffffff
-|-------------------| | |-------------------| ^
-| data A | | | data A | |
-| | | | | |
-| | | | | |
-|-------------------| v |-------------------| |
-| tag AxB |---> xor -> tag B | tag AxB |---> xor -> tag A
-|-------------------| | |-------------------| ^
-| data B | | | data B | |
-| | | | | |
-| | | | | |
-|-------------------| v |-------------------| |
-| tag BxC |---> xor -> tag C | tag BxC |---> xor -> tag B
-|-------------------| |-------------------| ^
-| data C | | data C | |
-| | | | tag C
-| | | |
-| | | |
-'-------------------' '-------------------'
-```
-
-One last thing to note before we get into the details around tag encoding. Each
-tag contains a valid bit used to indicate if the tag and containing commit is
-valid. This valid bit is the first bit found in the tag and the commit and can
-be used to tell if we've attempted to write to the remaining space in the
-block.
-
-Here's a more complete example of metadata block containing 4 entries:
-
-```
- .---------------------------------------.
-.-| revision count | tag ~A | \
-| |-------------------+-------------------| |
-| | data A | |
-| | | |
-| |-------------------+-------------------| |
-| | tag AxB | data B | <--. |
-| |-------------------+ | | |
-| | | | +-- 1st commit
-| | +-------------------+---------| | |
-| | | tag BxC | | <-.| |
-| |---------+-------------------+ | || |
-| | data C | || |
-| | | || |
-| |-------------------+-------------------| || |
-| | tag CxCRC | CRC | || /
-| |-------------------+-------------------| ||
-| | tag CRCxA' | data A' | || \
-| |-------------------+ | || |
-| | | || |
-| | +-------------------+----| || +-- 2nd commit
-| | | tag CRCxA' | | || |
-| |--------------+-------------------+----| || |
-| | CRC | padding | || /
-| |--------------+----+-------------------| ||
-| | tag CRCxA'' | data A'' | <---. \
-| |-------------------+ | ||| |
-| | | ||| |
-| | +-------------------+---------| ||| |
-| | | tag A''xD | | < ||| |
-| |---------+-------------------+ | |||| +-- 3rd commit
-| | data D | |||| |
-| | +---------| |||| |
-| | | tag Dx| |||| |
-| |---------+-------------------+---------| |||| |
-| |CRC | CRC | | |||| /
-| |---------+-------------------+ | ||||
-| | unwritten storage | |||| more commits
-| | | |||| |
-| | | |||| v
-| | | ||||
-| | | ||||
-| '---------------------------------------' ||||
-'---------------------------------------' |||'- most recent A
- ||'-- most recent B
- |'--- most recent C
- '---- most recent D
-```
-
-## Metadata tags
-
-So in littlefs, 32-bit tags describe every type of metadata. And this means
-_every_ type of metadata, including file entries, directory fields, and
-global state. Even the CRCs used to mark the end of commits get their own tag.
-
-Because of this, the tag format contains some densely packed information. Note
-that there are multiple levels of types which break down into more info:
-
-```
-[---- 32 ----]
-[1|-- 11 --|-- 10 --|-- 10 --]
- ^. ^ . ^ ^- length
- |. | . '------------ id
- |. '-----.------------------ type (type3)
- '.-----------.------------------ valid bit
- [-3-|-- 8 --]
- ^ ^- chunk
- '------- type (type1)
-```
-
-
-Before we go further, there's one important thing to note. These tags are
-**not** stored in little-endian. Tags stored in commits are actually stored
-in big-endian (and is the only thing in littlefs stored in big-endian). This
-little bit of craziness comes from the fact that the valid bit must be the
-first bit in a commit, and when converted to little-endian, the valid bit finds
-itself in byte 4. We could restructure the tag to store the valid bit lower,
-but, because none of the fields are byte-aligned, this would be more
-complicated than just storing the tag in big-endian.
-
-Another thing to note is that both the tags `0x00000000` and `0xffffffff` are
-invalid and can be used for null values.
-
-Metadata tag fields:
-
-1. **Valid bit (1-bit)** - Indicates if the tag is valid.
-
-2. **Type3 (11-bits)** - Type of the tag. This field is broken down further
- into a 3-bit abstract type and an 8-bit chunk field. Note that the value
- `0x000` is invalid and not assigned a type.
-
- 1. **Type1 (3-bits)** - Abstract type of the tag. Groups the tags into
- 8 categories that facilitate bitmasked lookups.
-
- 2. **Chunk (8-bits)** - Chunk field used for various purposes by the different
- abstract types. type1+chunk+id form a unique identifier for each tag in the
- metadata block.
-
-3. **Id (10-bits)** - File id associated with the tag. Each file in a metadata
- block gets a unique id which is used to associate tags with that file. The
- special value `0x3ff` is used for any tags that are not associated with a
- file, such as directory and global metadata.
-
-4. **Length (10-bits)** - Length of the data in bytes. The special value
- `0x3ff` indicates that this tag has been deleted.
-
-## Metadata types
-
-What follows is an exhaustive list of metadata in littlefs.
-
----
-#### `0x401` LFS_TYPE_CREATE
-
-Creates a new file with this id. Note that files in a metadata block
-don't necessarily need a create tag. All a create does is move over any
-files using this id. In this sense a create is similar to insertion into
-an imaginary array of files.
-
-The create and delete tags allow littlefs to keep files in a directory
-ordered alphabetically by filename.
-
----
-#### `0x4ff` LFS_TYPE_DELETE
-
-Deletes the file with this id. An inverse to create, this tag moves over
-any files neighboring this id similar to a deletion from an imaginary
-array of files.
-
----
-#### `0x0xx` LFS_TYPE_NAME
-
-Associates the id with a file name and file type.
-
-The data contains the file name stored as an ASCII string (may be expanded to
-UTF8 in the future).
-
-The chunk field in this tag indicates an 8-bit file type which can be one of
-the following.
-
-Currently, the name tag must precede any other tags associated with the id and
-can not be reassigned without deleting the file.
-
-Layout of the name tag:
-
-```
- tag data
-[-- 32 --][--- variable length ---]
-[1| 3| 8 | 10 | 10 ][--- (size * 8) ---]
- ^ ^ ^ ^ ^- size ^- file name
- | | | '------ id
- | | '----------- file type
- | '-------------- type1 (0x0)
- '----------------- valid bit
-```
-
-Name fields:
-
-1. **file type (8-bits)** - Type of the file.
-
-2. **file name** - File name stored as an ASCII string.
-
----
-#### `0x001` LFS_TYPE_REG
-
-Initializes the id + name as a regular file.
-
-How each file is stored depends on its struct tag, which is described below.
-
----
-#### `0x002` LFS_TYPE_DIR
-
-Initializes the id + name as a directory.
-
-Directories in littlefs are stored on disk as a linked-list of metadata pairs,
-each pair containing any number of files in alphabetical order. A pointer to
-the directory is stored in the struct tag, which is described below.
-
----
-#### `0x0ff` LFS_TYPE_SUPERBLOCK
-
-Initializes the id as a superblock entry.
-
-The superblock entry is a special entry used to store format-time configuration
-and identify the filesystem.
-
-The name is a bit of a misnomer. While the superblock entry serves the same
-purpose as a superblock found in other filesystems, in littlefs the superblock
-does not get a dedicated block. Instead, the superblock entry is duplicated
-across a linked-list of metadata pairs rooted on the blocks 0 and 1. The last
-metadata pair doubles as the root directory of the filesystem.
-
-```
- .--------. .--------. .--------. .--------. .--------.
-.| super |->| super |->| super |->| super |->| file B |
-|| block | || block | || block | || block | || file C |
-|| | || | || | || file A | || file D |
-|'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '--------' '--------' '--------' '--------'
-
-\----------------+----------------/ \----------+----------/
- superblock pairs root directory
-```
-
-The filesystem starts with only the root directory. The superblock metadata
-pairs grow every time the root pair is compacted in order to prolong the
-life of the device exponentially.
-
-The contents of the superblock entry are stored in a name tag with the
-superblock type and an inline-struct tag. The name tag contains the magic
-string "littlefs", while the inline-struct tag contains version and
-configuration information.
-
-Layout of the superblock name tag and inline-struct tag:
-
-```
- tag data
-[-- 32 --][-- 32 --|-- 32 --]
-[1|- 11 -| 10 | 10 ][--- 64 ---]
- ^ ^ ^ ^- size (8) ^- magic string ("littlefs")
- | | '------ id (0)
- | '------------ type (0x0ff)
- '----------------- valid bit
-
- tag data
-[-- 32 --][-- 32 --|-- 32 --|-- 32 --]
-[1|- 11 -| 10 | 10 ][-- 32 --|-- 32 --|-- 32 --]
- ^ ^ ^ ^ ^- version ^- block size ^- block count
- | | | | [-- 32 --|-- 32 --|-- 32 --]
- | | | | [-- 32 --|-- 32 --|-- 32 --]
- | | | | ^- name max ^- file max ^- attr max
- | | | '- size (24)
- | | '------ id (0)
- | '------------ type (0x201)
- '----------------- valid bit
-```
-
-Superblock fields:
-
-1. **Magic string (8-bytes)** - Magic string indicating the presence of
- littlefs on the device. Must be the string "littlefs".
-
-2. **Version (32-bits)** - The version of littlefs at format time. The version
- is encoded in a 32-bit value with the upper 16-bits containing the major
- version, and the lower 16-bits containing the minor version.
-
- This specification describes version 2.0 (`0x00020000`).
-
-3. **Block size (32-bits)** - Size of the logical block size used by the
- filesystem in bytes.
-
-4. **Block count (32-bits)** - Number of blocks in the filesystem.
-
-5. **Name max (32-bits)** - Maximum size of file names in bytes.
-
-6. **File max (32-bits)** - Maximum size of files in bytes.
-
-7. **Attr max (32-bits)** - Maximum size of file attributes in bytes.
-
-The superblock must always be the first entry (id 0) in a metadata pair as well
-as be the first entry written to the block. This means that the superblock
-entry can be read from a device using offsets alone.
-
----
-#### `0x2xx` LFS_TYPE_STRUCT
-
-Associates the id with an on-disk data structure.
-
-The exact layout of the data depends on the data structure type stored in the
-chunk field and can be one of the following.
-
-Any type of struct supersedes all other structs associated with the id. For
-example, appending a ctz-struct replaces an inline-struct on the same file.
-
----
-#### `0x200` LFS_TYPE_DIRSTRUCT
-
-Gives the id a directory data structure.
-
-Directories in littlefs are stored on disk as a linked-list of metadata pairs,
-each pair containing any number of files in alphabetical order.
-
-```
- |
- v
- .--------. .--------. .--------. .--------. .--------. .--------.
-.| file A |->| file D |->| file G |->| file I |->| file J |->| file M |
-|| file B | || file E | || file H | || | || file K | || file N |
-|| file C | || file F | || | || | || file L | || |
-|'--------' |'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '--------' '--------' '--------' '--------' '--------'
-```
-
-The dir-struct tag contains only the pointer to the first metadata-pair in the
-directory. The directory size is not known without traversing the directory.
-
-The pointer to the next metadata-pair in the directory is stored in a tail tag,
-which is described below.
-
-Layout of the dir-struct tag:
-
-```
- tag data
-[-- 32 --][-- 32 --|-- 32 --]
-[1|- 11 -| 10 | 10 ][--- 64 ---]
- ^ ^ ^ ^- size (8) ^- metadata pair
- | | '------ id
- | '------------ type (0x200)
- '----------------- valid bit
-```
-
-Dir-struct fields:
-
-1. **Metadata pair (8-bytes)** - Pointer to the first metadata-pair
- in the directory.
-
----
-#### `0x201` LFS_TYPE_INLINESTRUCT
-
-Gives the id an inline data structure.
-
-Inline structs store small files that can fit in the metadata pair. In this
-case, the file data is stored directly in the tag's data area.
-
-Layout of the inline-struct tag:
-
-```
- tag data
-[-- 32 --][--- variable length ---]
-[1|- 11 -| 10 | 10 ][--- (size * 8) ---]
- ^ ^ ^ ^- size ^- inline data
- | | '------ id
- | '------------ type (0x201)
- '----------------- valid bit
-```
-
-Inline-struct fields:
-
-1. **Inline data** - File data stored directly in the metadata-pair.
-
----
-#### `0x202` LFS_TYPE_CTZSTRUCT
-
-Gives the id a CTZ skip-list data structure.
-
-CTZ skip-lists store files that can not fit in the metadata pair. These files
-are stored in a skip-list in reverse, with a pointer to the head of the
-skip-list. Note that the head of the skip-list and the file size is enough
-information to read the file.
-
-How exactly CTZ skip-lists work is a bit complicated. A full explanation can be
-found in the [DESIGN.md](DESIGN.md#ctz-skip-lists).
-
-A quick summary: For every _n_‍th block where _n_ is divisible by
-2‍_ˣ_, that block contains a pointer to block _n_-2‍_ˣ_.
-These pointers are stored in increasing order of _x_ in each block of the file
-before the actual data.
-
-```
- |
- v
-.--------. .--------. .--------. .--------. .--------. .--------.
-| A |<-| D |<-| G |<-| J |<-| M |<-| P |
-| B |<-| E |--| H |<-| K |--| N | | Q |
-| C |<-| F |--| I |--| L |--| O | | |
-'--------' '--------' '--------' '--------' '--------' '--------'
- block 0 block 1 block 2 block 3 block 4 block 5
- 1 skip 2 skips 1 skip 3 skips 1 skip
-```
-
-Note that the maximum number of pointers in a block is bounded by the maximum
-file size divided by the block size. With 32 bits for file size, this results
-in a minimum block size of 104 bytes.
-
-Layout of the CTZ-struct tag:
-
-```
- tag data
-[-- 32 --][-- 32 --|-- 32 --]
-[1|- 11 -| 10 | 10 ][-- 32 --|-- 32 --]
- ^ ^ ^ ^ ^ ^- file size
- | | | | '-------------------- file head
- | | | '- size (8)
- | | '------ id
- | '------------ type (0x202)
- '----------------- valid bit
-```
-
-CTZ-struct fields:
-
-1. **File head (32-bits)** - Pointer to the block that is the head of the
- file's CTZ skip-list.
-
-2. **File size (32-bits)** - Size of the file in bytes.
-
----
-#### `0x3xx` LFS_TYPE_USERATTR
-
-Attaches a user attribute to an id.
-
-littlefs has a concept of "user attributes". These are small user-provided
-attributes that can be used to store things like timestamps, hashes,
-permissions, etc.
-
-Each user attribute is uniquely identified by an 8-bit type which is stored in
-the chunk field, and the user attribute itself can be found in the tag's data.
-
-There are currently no standard user attributes and a portable littlefs
-implementation should work with any user attributes missing.
-
-Layout of the user-attr tag:
-
-```
- tag data
-[-- 32 --][--- variable length ---]
-[1| 3| 8 | 10 | 10 ][--- (size * 8) ---]
- ^ ^ ^ ^ ^- size ^- attr data
- | | | '------ id
- | | '----------- attr type
- | '-------------- type1 (0x3)
- '----------------- valid bit
-```
-
-User-attr fields:
-
-1. **Attr type (8-bits)** - Type of the user attributes.
-
-2. **Attr data** - The data associated with the user attribute.
-
----
-#### `0x6xx` LFS_TYPE_TAIL
-
-Provides the tail pointer for the metadata pair itself.
-
-The metadata pair's tail pointer is used in littlefs for a linked-list
-containing all metadata pairs. The chunk field contains the type of the tail,
-which indicates if the following metadata pair is a part of the directory
-(hard-tail) or only used to traverse the filesystem (soft-tail).
-
-```
- .--------.
- .| dir A |-.
- ||softtail| |
-.--------| |-'
-| |'--------'
-| '---|--|-'
-| .-' '-------------.
-| v v
-| .--------. .--------. .--------.
-'->| dir B |->| dir B |->| dir C |
- ||hardtail| ||softtail| || |
- || | || | || |
- |'--------' |'--------' |'--------'
- '--------' '--------' '--------'
-```
-
-Currently any type supersedes any other preceding tails in the metadata pair,
-but this may change if additional metadata pair state is added.
-
-A note about the metadata pair linked-list: Normally, this linked-list contains
-every metadata pair in the filesystem. However, there are some operations that
-can cause this linked-list to become out of sync if a power-loss were to occur.
-When this happens, littlefs sets the "sync" flag in the global state. How
-exactly this flag is stored is described below.
-
-When the sync flag is set:
-
-1. The linked-list may contain an orphaned directory that has been removed in
- the filesystem.
-2. The linked-list may contain a metadata pair with a bad block that has been
- replaced in the filesystem.
-
-If the sync flag is set, the threaded linked-list must be checked for these
-errors before it can be used reliably. Note that the threaded linked-list can
-be ignored if littlefs is mounted read-only.
-
-Layout of the tail tag:
-
-```
- tag data
-[-- 32 --][-- 32 --|-- 32 --]
-[1| 3| 8 | 10 | 10 ][--- 64 ---]
- ^ ^ ^ ^ ^- size (8) ^- metadata pair
- | | | '------ id
- | | '---------- tail type
- | '------------- type1 (0x6)
- '---------------- valid bit
-```
-
-Tail fields:
-
-1. **Tail type (8-bits)** - Type of the tail pointer.
-
-2. **Metadata pair (8-bytes)** - Pointer to the next metadata-pair.
-
----
-#### `0x600` LFS_TYPE_SOFTTAIL
-
-Provides a tail pointer that points to the next metadata pair in the
-filesystem.
-
-In this case, the next metadata pair is not a part of our current directory
-and should only be followed when traversing the entire filesystem.
-
----
-#### `0x601` LFS_TYPE_HARDTAIL
-
-Provides a tail pointer that points to the next metadata pair in the
-directory.
-
-In this case, the next metadata pair belongs to the current directory. Note
-that because directories in littlefs are sorted alphabetically, the next
-metadata pair should only contain filenames greater than any filename in the
-current pair.
-
----
-#### `0x7xx` LFS_TYPE_GSTATE
-
-Provides delta bits for global state entries.
-
-littlefs has a concept of "global state". This is a small set of state that
-can be updated by a commit to _any_ metadata pair in the filesystem.
-
-The way this works is that the global state is stored as a set of deltas
-distributed across the filesystem such that the global state can be found by
-the xor-sum of these deltas.
-
-```
- .--------. .--------. .--------. .--------. .--------.
-.| |->| gdelta |->| |->| gdelta |->| gdelta |
-|| | || 0x23 | || | || 0xff | || 0xce |
-|| | || | || | || | || |
-|'--------' |'--------' |'--------' |'--------' |'--------'
-'--------' '----|---' '--------' '----|---' '----|---'
- v v v
- 0x00 --> xor ------------------> xor ------> xor --> gstate = 0x12
-```
-
-Note that storing globals this way is very expensive in terms of storage usage,
-so any global state should be kept very small.
-
-The size and format of each piece of global state depends on the type, which
-is stored in the chunk field. Currently, the only global state is move state,
-which is outlined below.
-
----
-#### `0x7ff` LFS_TYPE_MOVESTATE
-
-Provides delta bits for the global move state.
-
-The move state in littlefs is used to store info about operations that could
-cause to filesystem to go out of sync if the power is lost. The operations
-where this could occur is moves of files between metadata pairs and any
-operation that changes metadata pairs on the threaded linked-list.
-
-In the case of moves, the move state contains a tag + metadata pair describing
-the source of the ongoing move. If this tag is non-zero, that means that power
-was lost during a move, and the file exists in two different locations. If this
-happens, the source of the move should be considered deleted, and the move
-should be completed (the source should be deleted) before any other write
-operations to the filesystem.
-
-In the case of operations to the threaded linked-list, a single "sync" bit is
-used to indicate that a modification is ongoing. If this sync flag is set, the
-threaded linked-list will need to be checked for errors before it can be used
-reliably. The exact cases to check for are described above in the tail tag.
-
-Layout of the move state:
-
-```
- tag data
-[-- 32 --][-- 32 --|-- 32 --|-- 32 --]
-[1|- 11 -| 10 | 10 ][1|- 11 -| 10 | 10 |--- 64 ---]
- ^ ^ ^ ^ ^ ^ ^ ^- padding (0) ^- metadata pair
- | | | | | | '------ move id
- | | | | | '------------ move type
- | | | | '----------------- sync bit
- | | | |
- | | | '- size (12)
- | | '------ id (0x3ff)
- | '------------ type (0x7ff)
- '----------------- valid bit
-```
-
-Move state fields:
-
-1. **Sync bit (1-bit)** - Indicates if the metadata pair threaded linked-list
- is in-sync. If set, the threaded linked-list should be checked for errors.
-
-2. **Move type (11-bits)** - Type of move being performed. Must be either
- `0x000`, indicating no move, or `0x4ff` indicating the source file should
- be deleted.
-
-3. **Move id (10-bits)** - The file id being moved.
-
-4. **Metadata pair (8-bytes)** - Pointer to the metadata-pair containing
- the move.
-
----
-#### `0x5xx` LFS_TYPE_CRC
-
-Last but not least, the CRC tag marks the end of a commit and provides a
-checksum for any commits to the metadata block.
-
-The first 32-bits of the data contain a CRC-32 with a polynomial of
-`0x04c11db7` initialized with `0xffffffff`. This CRC provides a checksum for
-all metadata since the previous CRC tag, including the CRC tag itself. For
-the first commit, this includes the revision count for the metadata block.
-
-However, the size of the data is not limited to 32-bits. The data field may
-larger to pad the commit to the next program-aligned boundary.
-
-In addition, the CRC tag's chunk field contains a set of flags which can
-change the behaviour of commits. Currently the only flag in use is the lowest
-bit, which determines the expected state of the valid bit for any following
-tags. This is used to guarantee that unwritten storage in a metadata block
-will be detected as invalid.
-
-Layout of the CRC tag:
-
-```
- tag data
-[-- 32 --][-- 32 --|--- variable length ---]
-[1| 3| 8 | 10 | 10 ][-- 32 --|--- (size * 8 - 32) ---]
- ^ ^ ^ ^ ^ ^- crc ^- padding
- | | | | '- size
- | | | '------ id (0x3ff)
- | | '----------- valid state
- | '-------------- type1 (0x5)
- '----------------- valid bit
-```
-
-CRC fields:
-
-1. **Valid state (1-bit)** - Indicates the expected value of the valid bit for
- any tags in the next commit.
-
-2. **CRC (32-bits)** - CRC-32 with a polynomial of `0x04c11db7` initialized
- with `0xffffffff`.
-
-3. **Padding** - Padding to the next program-aligned boundary. No guarantees
- are made about the contents.
-
----
diff --git a/fs/littlefs/pkg.yml b/fs/littlefs/pkg.yml
index 8c3471b00..0dde6930b 100644
--- a/fs/littlefs/pkg.yml
+++ b/fs/littlefs/pkg.yml
@@ -26,6 +26,14 @@ pkg.keywords:
- filesystem
- ffs
- littlefs
+pkg.type: sdk
+
+repository.littlefs:
+ type: github
+ vers: v2.5.0-commit
+ branch: master
+ user: littlefs-project
+ repo: littlefs
pkg.deps:
- "@apache-mynewt-core/fs/fs"
@@ -33,6 +41,13 @@ pkg.deps:
- "@apache-mynewt-core/kernel/os"
- "@apache-mynewt-core/sys/flash_map"
+pkg.source_dirs:
+ - "@littlefs/."
+ - "src"
+
+pkg.include_dirs:
+ - "@littlefs/."
+
pkg.cflags.LITTLEFS_MIGRATE_V1:
- -DLFS_MIGRATE
diff --git a/fs/littlefs/src/lfs.c b/fs/littlefs/src/lfs.c
deleted file mode 100644
index 117595e04..000000000
--- a/fs/littlefs/src/lfs.c
+++ /dev/null
@@ -1,5819 +0,0 @@
-/*
- * The little filesystem
- *
- * Copyright (c) 2022, The littlefs authors.
- * Copyright (c) 2017, Arm Limited. All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#include "lfs.h"
-#include "lfs_util.h"
-
-
-// some constants used throughout the code
-#define LFS_BLOCK_NULL ((lfs_block_t)-1)
-#define LFS_BLOCK_INLINE ((lfs_block_t)-2)
-
-enum {
- LFS_OK_RELOCATED = 1,
- LFS_OK_DROPPED = 2,
- LFS_OK_ORPHANED = 3,
-};
-
-enum {
- LFS_CMP_EQ = 0,
- LFS_CMP_LT = 1,
- LFS_CMP_GT = 2,
-};
-
-
-/// Caching block device operations ///
-
-static inline void lfs_cache_drop(lfs_t *lfs, lfs_cache_t *rcache) {
- // do not zero, cheaper if cache is readonly or only going to be
- // written with identical data (during relocates)
- (void)lfs;
- rcache->block = LFS_BLOCK_NULL;
-}
-
-static inline void lfs_cache_zero(lfs_t *lfs, lfs_cache_t *pcache) {
- // zero to avoid information leak
- memset(pcache->buffer, 0xff, lfs->cfg->cache_size);
- pcache->block = LFS_BLOCK_NULL;
-}
-
-static int lfs_bd_read(lfs_t *lfs,
- const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
- lfs_block_t block, lfs_off_t off,
- void *buffer, lfs_size_t size) {
- uint8_t *data = buffer;
- if (block >= lfs->cfg->block_count ||
- off+size > lfs->cfg->block_size) {
- return LFS_ERR_CORRUPT;
- }
-
- while (size > 0) {
- lfs_size_t diff = size;
-
- if (pcache && block == pcache->block &&
- off < pcache->off + pcache->size) {
- if (off >= pcache->off) {
- // is already in pcache?
- diff = lfs_min(diff, pcache->size - (off-pcache->off));
- memcpy(data, &pcache->buffer[off-pcache->off], diff);
-
- data += diff;
- off += diff;
- size -= diff;
- continue;
- }
-
- // pcache takes priority
- diff = lfs_min(diff, pcache->off-off);
- }
-
- if (block == rcache->block &&
- off < rcache->off + rcache->size) {
- if (off >= rcache->off) {
- // is already in rcache?
- diff = lfs_min(diff, rcache->size - (off-rcache->off));
- memcpy(data, &rcache->buffer[off-rcache->off], diff);
-
- data += diff;
- off += diff;
- size -= diff;
- continue;
- }
-
- // rcache takes priority
- diff = lfs_min(diff, rcache->off-off);
- }
-
- if (size >= hint && off % lfs->cfg->read_size == 0 &&
- size >= lfs->cfg->read_size) {
- // bypass cache?
- diff = lfs_aligndown(diff, lfs->cfg->read_size);
- int err = lfs->cfg->read(lfs->cfg, block, off, data, diff);
- if (err) {
- return err;
- }
-
- data += diff;
- off += diff;
- size -= diff;
- continue;
- }
-
- // load to cache, first condition can no longer fail
- LFS_ASSERT(block < lfs->cfg->block_count);
- rcache->block = block;
- rcache->off = lfs_aligndown(off, lfs->cfg->read_size);
- rcache->size = lfs_min(
- lfs_min(
- lfs_alignup(off+hint, lfs->cfg->read_size),
- lfs->cfg->block_size)
- - rcache->off,
- lfs->cfg->cache_size);
- int err = lfs->cfg->read(lfs->cfg, rcache->block,
- rcache->off, rcache->buffer, rcache->size);
- LFS_ASSERT(err <= 0);
- if (err) {
- return err;
- }
- }
-
- return 0;
-}
-
-static int lfs_bd_cmp(lfs_t *lfs,
- const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
- lfs_block_t block, lfs_off_t off,
- const void *buffer, lfs_size_t size) {
- const uint8_t *data = buffer;
- lfs_size_t diff = 0;
-
- for (lfs_off_t i = 0; i < size; i += diff) {
- uint8_t dat[8];
-
- diff = lfs_min(size-i, sizeof(dat));
- int res = lfs_bd_read(lfs,
- pcache, rcache, hint-i,
- block, off+i, &dat, diff);
- if (res) {
- return res;
- }
-
- res = memcmp(dat, data + i, diff);
- if (res) {
- return res < 0 ? LFS_CMP_LT : LFS_CMP_GT;
- }
- }
-
- return LFS_CMP_EQ;
-}
-
-#ifndef LFS_READONLY
-static int lfs_bd_flush(lfs_t *lfs,
- lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) {
- if (pcache->block != LFS_BLOCK_NULL && pcache->block != LFS_BLOCK_INLINE) {
- LFS_ASSERT(pcache->block < lfs->cfg->block_count);
- lfs_size_t diff = lfs_alignup(pcache->size, lfs->cfg->prog_size);
- int err = lfs->cfg->prog(lfs->cfg, pcache->block,
- pcache->off, pcache->buffer, diff);
- LFS_ASSERT(err <= 0);
- if (err) {
- return err;
- }
-
- if (validate) {
- // check data on disk
- lfs_cache_drop(lfs, rcache);
- int res = lfs_bd_cmp(lfs,
- NULL, rcache, diff,
- pcache->block, pcache->off, pcache->buffer, diff);
- if (res < 0) {
- return res;
- }
-
- if (res != LFS_CMP_EQ) {
- return LFS_ERR_CORRUPT;
- }
- }
-
- lfs_cache_zero(lfs, pcache);
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_bd_sync(lfs_t *lfs,
- lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) {
- lfs_cache_drop(lfs, rcache);
-
- int err = lfs_bd_flush(lfs, pcache, rcache, validate);
- if (err) {
- return err;
- }
-
- err = lfs->cfg->sync(lfs->cfg);
- LFS_ASSERT(err <= 0);
- return err;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_bd_prog(lfs_t *lfs,
- lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate,
- lfs_block_t block, lfs_off_t off,
- const void *buffer, lfs_size_t size) {
- const uint8_t *data = buffer;
- LFS_ASSERT(block == LFS_BLOCK_INLINE || block < lfs->cfg->block_count);
- LFS_ASSERT(off + size <= lfs->cfg->block_size);
-
- while (size > 0) {
- if (block == pcache->block &&
- off >= pcache->off &&
- off < pcache->off + lfs->cfg->cache_size) {
- // already fits in pcache?
- lfs_size_t diff = lfs_min(size,
- lfs->cfg->cache_size - (off-pcache->off));
- memcpy(&pcache->buffer[off-pcache->off], data, diff);
-
- data += diff;
- off += diff;
- size -= diff;
-
- pcache->size = lfs_max(pcache->size, off - pcache->off);
- if (pcache->size == lfs->cfg->cache_size) {
- // eagerly flush out pcache if we fill up
- int err = lfs_bd_flush(lfs, pcache, rcache, validate);
- if (err) {
- return err;
- }
- }
-
- continue;
- }
-
- // pcache must have been flushed, either by programming and
- // entire block or manually flushing the pcache
- LFS_ASSERT(pcache->block == LFS_BLOCK_NULL);
-
- // prepare pcache, first condition can no longer fail
- pcache->block = block;
- pcache->off = lfs_aligndown(off, lfs->cfg->prog_size);
- pcache->size = 0;
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_bd_erase(lfs_t *lfs, lfs_block_t block) {
- LFS_ASSERT(block < lfs->cfg->block_count);
- int err = lfs->cfg->erase(lfs->cfg, block);
- LFS_ASSERT(err <= 0);
- return err;
-}
-#endif
-
-
-/// Small type-level utilities ///
-// operations on block pairs
-static inline void lfs_pair_swap(lfs_block_t pair[2]) {
- lfs_block_t t = pair[0];
- pair[0] = pair[1];
- pair[1] = t;
-}
-
-static inline bool lfs_pair_isnull(const lfs_block_t pair[2]) {
- return pair[0] == LFS_BLOCK_NULL || pair[1] == LFS_BLOCK_NULL;
-}
-
-static inline int lfs_pair_cmp(
- const lfs_block_t paira[2],
- const lfs_block_t pairb[2]) {
- return !(paira[0] == pairb[0] || paira[1] == pairb[1] ||
- paira[0] == pairb[1] || paira[1] == pairb[0]);
-}
-
-#ifndef LFS_READONLY
-static inline bool lfs_pair_sync(
- const lfs_block_t paira[2],
- const lfs_block_t pairb[2]) {
- return (paira[0] == pairb[0] && paira[1] == pairb[1]) ||
- (paira[0] == pairb[1] && paira[1] == pairb[0]);
-}
-#endif
-
-static inline void lfs_pair_fromle32(lfs_block_t pair[2]) {
- pair[0] = lfs_fromle32(pair[0]);
- pair[1] = lfs_fromle32(pair[1]);
-}
-
-#ifndef LFS_READONLY
-static inline void lfs_pair_tole32(lfs_block_t pair[2]) {
- pair[0] = lfs_tole32(pair[0]);
- pair[1] = lfs_tole32(pair[1]);
-}
-#endif
-
-// operations on 32-bit entry tags
-typedef uint32_t lfs_tag_t;
-typedef int32_t lfs_stag_t;
-
-#define LFS_MKTAG(type, id, size) \
- (((lfs_tag_t)(type) << 20) | ((lfs_tag_t)(id) << 10) | (lfs_tag_t)(size))
-
-#define LFS_MKTAG_IF(cond, type, id, size) \
- ((cond) ? LFS_MKTAG(type, id, size) : LFS_MKTAG(LFS_FROM_NOOP, 0, 0))
-
-#define LFS_MKTAG_IF_ELSE(cond, type1, id1, size1, type2, id2, size2) \
- ((cond) ? LFS_MKTAG(type1, id1, size1) : LFS_MKTAG(type2, id2, size2))
-
-static inline bool lfs_tag_isvalid(lfs_tag_t tag) {
- return !(tag & 0x80000000);
-}
-
-static inline bool lfs_tag_isdelete(lfs_tag_t tag) {
- return ((int32_t)(tag << 22) >> 22) == -1;
-}
-
-static inline uint16_t lfs_tag_type1(lfs_tag_t tag) {
- return (tag & 0x70000000) >> 20;
-}
-
-static inline uint16_t lfs_tag_type3(lfs_tag_t tag) {
- return (tag & 0x7ff00000) >> 20;
-}
-
-static inline uint8_t lfs_tag_chunk(lfs_tag_t tag) {
- return (tag & 0x0ff00000) >> 20;
-}
-
-static inline int8_t lfs_tag_splice(lfs_tag_t tag) {
- return (int8_t)lfs_tag_chunk(tag);
-}
-
-static inline uint16_t lfs_tag_id(lfs_tag_t tag) {
- return (tag & 0x000ffc00) >> 10;
-}
-
-static inline lfs_size_t lfs_tag_size(lfs_tag_t tag) {
- return tag & 0x000003ff;
-}
-
-static inline lfs_size_t lfs_tag_dsize(lfs_tag_t tag) {
- return sizeof(tag) + lfs_tag_size(tag + lfs_tag_isdelete(tag));
-}
-
-// operations on attributes in attribute lists
-struct lfs_mattr {
- lfs_tag_t tag;
- const void *buffer;
-};
-
-struct lfs_diskoff {
- lfs_block_t block;
- lfs_off_t off;
-};
-
-#define LFS_MKATTRS(...) \
- (struct lfs_mattr[]){__VA_ARGS__}, \
- sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr)
-
-// operations on global state
-static inline void lfs_gstate_xor(lfs_gstate_t *a, const lfs_gstate_t *b) {
- for (int i = 0; i < 3; i++) {
- ((uint32_t*)a)[i] ^= ((const uint32_t*)b)[i];
- }
-}
-
-static inline bool lfs_gstate_iszero(const lfs_gstate_t *a) {
- for (int i = 0; i < 3; i++) {
- if (((uint32_t*)a)[i] != 0) {
- return false;
- }
- }
- return true;
-}
-
-#ifndef LFS_READONLY
-static inline bool lfs_gstate_hasorphans(const lfs_gstate_t *a) {
- return lfs_tag_size(a->tag);
-}
-
-static inline uint8_t lfs_gstate_getorphans(const lfs_gstate_t *a) {
- return lfs_tag_size(a->tag);
-}
-
-static inline bool lfs_gstate_hasmove(const lfs_gstate_t *a) {
- return lfs_tag_type1(a->tag);
-}
-#endif
-
-static inline bool lfs_gstate_hasmovehere(const lfs_gstate_t *a,
- const lfs_block_t *pair) {
- return lfs_tag_type1(a->tag) && lfs_pair_cmp(a->pair, pair) == 0;
-}
-
-static inline void lfs_gstate_fromle32(lfs_gstate_t *a) {
- a->tag = lfs_fromle32(a->tag);
- a->pair[0] = lfs_fromle32(a->pair[0]);
- a->pair[1] = lfs_fromle32(a->pair[1]);
-}
-
-#ifndef LFS_READONLY
-static inline void lfs_gstate_tole32(lfs_gstate_t *a) {
- a->tag = lfs_tole32(a->tag);
- a->pair[0] = lfs_tole32(a->pair[0]);
- a->pair[1] = lfs_tole32(a->pair[1]);
-}
-#endif
-
-// other endianness operations
-static void lfs_ctz_fromle32(struct lfs_ctz *ctz) {
- ctz->head = lfs_fromle32(ctz->head);
- ctz->size = lfs_fromle32(ctz->size);
-}
-
-#ifndef LFS_READONLY
-static void lfs_ctz_tole32(struct lfs_ctz *ctz) {
- ctz->head = lfs_tole32(ctz->head);
- ctz->size = lfs_tole32(ctz->size);
-}
-#endif
-
-static inline void lfs_superblock_fromle32(lfs_superblock_t *superblock) {
- superblock->version = lfs_fromle32(superblock->version);
- superblock->block_size = lfs_fromle32(superblock->block_size);
- superblock->block_count = lfs_fromle32(superblock->block_count);
- superblock->name_max = lfs_fromle32(superblock->name_max);
- superblock->file_max = lfs_fromle32(superblock->file_max);
- superblock->attr_max = lfs_fromle32(superblock->attr_max);
-}
-
-#ifndef LFS_READONLY
-static inline void lfs_superblock_tole32(lfs_superblock_t *superblock) {
- superblock->version = lfs_tole32(superblock->version);
- superblock->block_size = lfs_tole32(superblock->block_size);
- superblock->block_count = lfs_tole32(superblock->block_count);
- superblock->name_max = lfs_tole32(superblock->name_max);
- superblock->file_max = lfs_tole32(superblock->file_max);
- superblock->attr_max = lfs_tole32(superblock->attr_max);
-}
-#endif
-
-#ifndef LFS_NO_ASSERT
-static bool lfs_mlist_isopen(struct lfs_mlist *head,
- struct lfs_mlist *node) {
- for (struct lfs_mlist **p = &head; *p; p = &(*p)->next) {
- if (*p == (struct lfs_mlist*)node) {
- return true;
- }
- }
-
- return false;
-}
-#endif
-
-static void lfs_mlist_remove(lfs_t *lfs, struct lfs_mlist *mlist) {
- for (struct lfs_mlist **p = &lfs->mlist; *p; p = &(*p)->next) {
- if (*p == mlist) {
- *p = (*p)->next;
- break;
- }
- }
-}
-
-static void lfs_mlist_append(lfs_t *lfs, struct lfs_mlist *mlist) {
- mlist->next = lfs->mlist;
- lfs->mlist = mlist;
-}
-
-
-/// Internal operations predeclared here ///
-#ifndef LFS_READONLY
-static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
- const struct lfs_mattr *attrs, int attrcount);
-static int lfs_dir_compact(lfs_t *lfs,
- lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
- lfs_mdir_t *source, uint16_t begin, uint16_t end);
-static lfs_ssize_t lfs_file_flushedwrite(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size);
-static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size);
-static int lfs_file_rawsync(lfs_t *lfs, lfs_file_t *file);
-static int lfs_file_outline(lfs_t *lfs, lfs_file_t *file);
-static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file);
-
-static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss);
-static int lfs_fs_preporphans(lfs_t *lfs, int8_t orphans);
-static void lfs_fs_prepmove(lfs_t *lfs,
- uint16_t id, const lfs_block_t pair[2]);
-static int lfs_fs_pred(lfs_t *lfs, const lfs_block_t dir[2],
- lfs_mdir_t *pdir);
-static lfs_stag_t lfs_fs_parent(lfs_t *lfs, const lfs_block_t dir[2],
- lfs_mdir_t *parent);
-static int lfs_fs_forceconsistency(lfs_t *lfs);
-#endif
-
-#ifdef LFS_MIGRATE
-static int lfs1_traverse(lfs_t *lfs,
- int (*cb)(void*, lfs_block_t), void *data);
-#endif
-
-static int lfs_dir_rawrewind(lfs_t *lfs, lfs_dir_t *dir);
-
-static lfs_ssize_t lfs_file_flushedread(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size);
-static lfs_ssize_t lfs_file_rawread(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size);
-static int lfs_file_rawclose(lfs_t *lfs, lfs_file_t *file);
-static lfs_soff_t lfs_file_rawsize(lfs_t *lfs, lfs_file_t *file);
-
-static lfs_ssize_t lfs_fs_rawsize(lfs_t *lfs);
-static int lfs_fs_rawtraverse(lfs_t *lfs,
- int (*cb)(void *data, lfs_block_t block), void *data,
- bool includeorphans);
-
-static int lfs_deinit(lfs_t *lfs);
-static int lfs_rawunmount(lfs_t *lfs);
-
-
-/// Block allocator ///
-#ifndef LFS_READONLY
-static int lfs_alloc_lookahead(void *p, lfs_block_t block) {
- lfs_t *lfs = (lfs_t*)p;
- lfs_block_t off = ((block - lfs->free.off)
- + lfs->cfg->block_count) % lfs->cfg->block_count;
-
- if (off < lfs->free.size) {
- lfs->free.buffer[off / 32] |= 1U << (off % 32);
- }
-
- return 0;
-}
-#endif
-
-// indicate allocated blocks have been committed into the filesystem, this
-// is to prevent blocks from being garbage collected in the middle of a
-// commit operation
-static void lfs_alloc_ack(lfs_t *lfs) {
- lfs->free.ack = lfs->cfg->block_count;
-}
-
-// drop the lookahead buffer, this is done during mounting and failed
-// traversals in order to avoid invalid lookahead state
-static void lfs_alloc_drop(lfs_t *lfs) {
- lfs->free.size = 0;
- lfs->free.i = 0;
- lfs_alloc_ack(lfs);
-}
-
-#ifndef LFS_READONLY
-static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) {
- while (true) {
- while (lfs->free.i != lfs->free.size) {
- lfs_block_t off = lfs->free.i;
- lfs->free.i += 1;
- lfs->free.ack -= 1;
-
- if (!(lfs->free.buffer[off / 32] & (1U << (off % 32)))) {
- // found a free block
- *block = (lfs->free.off + off) % lfs->cfg->block_count;
-
- // eagerly find next off so an alloc ack can
- // discredit old lookahead blocks
- while (lfs->free.i != lfs->free.size &&
- (lfs->free.buffer[lfs->free.i / 32]
- & (1U << (lfs->free.i % 32)))) {
- lfs->free.i += 1;
- lfs->free.ack -= 1;
- }
-
- return 0;
- }
- }
-
- // check if we have looked at all blocks since last ack
- if (lfs->free.ack == 0) {
- LFS_ERROR("No more free space %"PRIu32,
- lfs->free.i + lfs->free.off);
- return LFS_ERR_NOSPC;
- }
-
- lfs->free.off = (lfs->free.off + lfs->free.size)
- % lfs->cfg->block_count;
- lfs->free.size = lfs_min(8*lfs->cfg->lookahead_size, lfs->free.ack);
- lfs->free.i = 0;
-
- // find mask of free blocks from tree
- memset(lfs->free.buffer, 0, lfs->cfg->lookahead_size);
- int err = lfs_fs_rawtraverse(lfs, lfs_alloc_lookahead, lfs, true);
- if (err) {
- lfs_alloc_drop(lfs);
- return err;
- }
- }
-}
-#endif
-
-/// Metadata pair and directory operations ///
-static lfs_stag_t lfs_dir_getslice(lfs_t *lfs, const lfs_mdir_t *dir,
- lfs_tag_t gmask, lfs_tag_t gtag,
- lfs_off_t goff, void *gbuffer, lfs_size_t gsize) {
- lfs_off_t off = dir->off;
- lfs_tag_t ntag = dir->etag;
- lfs_stag_t gdiff = 0;
-
- if (lfs_gstate_hasmovehere(&lfs->gdisk, dir->pair) &&
- lfs_tag_id(gmask) != 0 &&
- lfs_tag_id(lfs->gdisk.tag) <= lfs_tag_id(gtag)) {
- // synthetic moves
- gdiff -= LFS_MKTAG(0, 1, 0);
- }
-
- // iterate over dir block backwards (for faster lookups)
- while (off >= sizeof(lfs_tag_t) + lfs_tag_dsize(ntag)) {
- off -= lfs_tag_dsize(ntag);
- lfs_tag_t tag = ntag;
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, sizeof(ntag),
- dir->pair[0], off, &ntag, sizeof(ntag));
- if (err) {
- return err;
- }
-
- ntag = (lfs_frombe32(ntag) ^ tag) & 0x7fffffff;
-
- if (lfs_tag_id(gmask) != 0 &&
- lfs_tag_type1(tag) == LFS_TYPE_SPLICE &&
- lfs_tag_id(tag) <= lfs_tag_id(gtag - gdiff)) {
- if (tag == (LFS_MKTAG(LFS_TYPE_CREATE, 0, 0) |
- (LFS_MKTAG(0, 0x3ff, 0) & (gtag - gdiff)))) {
- // found where we were created
- return LFS_ERR_NOENT;
- }
-
- // move around splices
- gdiff += LFS_MKTAG(0, lfs_tag_splice(tag), 0);
- }
-
- if ((gmask & tag) == (gmask & (gtag - gdiff))) {
- if (lfs_tag_isdelete(tag)) {
- return LFS_ERR_NOENT;
- }
-
- lfs_size_t diff = lfs_min(lfs_tag_size(tag), gsize);
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, diff,
- dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
- if (err) {
- return err;
- }
-
- memset((uint8_t*)gbuffer + diff, 0, gsize - diff);
-
- return tag + gdiff;
- }
- }
-
- return LFS_ERR_NOENT;
-}
-
-static lfs_stag_t lfs_dir_get(lfs_t *lfs, const lfs_mdir_t *dir,
- lfs_tag_t gmask, lfs_tag_t gtag, void *buffer) {
- return lfs_dir_getslice(lfs, dir,
- gmask, gtag,
- 0, buffer, lfs_tag_size(gtag));
-}
-
-static int lfs_dir_getread(lfs_t *lfs, const lfs_mdir_t *dir,
- const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
- lfs_tag_t gmask, lfs_tag_t gtag,
- lfs_off_t off, void *buffer, lfs_size_t size) {
- uint8_t *data = buffer;
- if (off+size > lfs->cfg->block_size) {
- return LFS_ERR_CORRUPT;
- }
-
- while (size > 0) {
- lfs_size_t diff = size;
-
- if (pcache && pcache->block == LFS_BLOCK_INLINE &&
- off < pcache->off + pcache->size) {
- if (off >= pcache->off) {
- // is already in pcache?
- diff = lfs_min(diff, pcache->size - (off-pcache->off));
- memcpy(data, &pcache->buffer[off-pcache->off], diff);
-
- data += diff;
- off += diff;
- size -= diff;
- continue;
- }
-
- // pcache takes priority
- diff = lfs_min(diff, pcache->off-off);
- }
-
- if (rcache->block == LFS_BLOCK_INLINE &&
- off < rcache->off + rcache->size) {
- if (off >= rcache->off) {
- // is already in rcache?
- diff = lfs_min(diff, rcache->size - (off-rcache->off));
- memcpy(data, &rcache->buffer[off-rcache->off], diff);
-
- data += diff;
- off += diff;
- size -= diff;
- continue;
- }
-
- // rcache takes priority
- diff = lfs_min(diff, rcache->off-off);
- }
-
- // load to cache, first condition can no longer fail
- rcache->block = LFS_BLOCK_INLINE;
- rcache->off = lfs_aligndown(off, lfs->cfg->read_size);
- rcache->size = lfs_min(lfs_alignup(off+hint, lfs->cfg->read_size),
- lfs->cfg->cache_size);
- int err = lfs_dir_getslice(lfs, dir, gmask, gtag,
- rcache->off, rcache->buffer, rcache->size);
- if (err < 0) {
- return err;
- }
- }
-
- return 0;
-}
-
-#ifndef LFS_READONLY
-static int lfs_dir_traverse_filter(void *p,
- lfs_tag_t tag, const void *buffer) {
- lfs_tag_t *filtertag = p;
- (void)buffer;
-
- // which mask depends on unique bit in tag structure
- uint32_t mask = (tag & LFS_MKTAG(0x100, 0, 0))
- ? LFS_MKTAG(0x7ff, 0x3ff, 0)
- : LFS_MKTAG(0x700, 0x3ff, 0);
-
- // check for redundancy
- if ((mask & tag) == (mask & *filtertag) ||
- lfs_tag_isdelete(*filtertag) ||
- (LFS_MKTAG(0x7ff, 0x3ff, 0) & tag) == (
- LFS_MKTAG(LFS_TYPE_DELETE, 0, 0) |
- (LFS_MKTAG(0, 0x3ff, 0) & *filtertag))) {
- *filtertag = LFS_MKTAG(LFS_FROM_NOOP, 0, 0);
- return true;
- }
-
- // check if we need to adjust for created/deleted tags
- if (lfs_tag_type1(tag) == LFS_TYPE_SPLICE &&
- lfs_tag_id(tag) <= lfs_tag_id(*filtertag)) {
- *filtertag += LFS_MKTAG(0, lfs_tag_splice(tag), 0);
- }
-
- return false;
-}
-#endif
-
-#ifndef LFS_READONLY
-// maximum recursive depth of lfs_dir_traverse, the deepest call:
-//
-// traverse with commit
-// '-> traverse with move
-// '-> traverse with filter
-//
-#define LFS_DIR_TRAVERSE_DEPTH 3
-
-struct lfs_dir_traverse {
- const lfs_mdir_t *dir;
- lfs_off_t off;
- lfs_tag_t ptag;
- const struct lfs_mattr *attrs;
- int attrcount;
-
- lfs_tag_t tmask;
- lfs_tag_t ttag;
- uint16_t begin;
- uint16_t end;
- int16_t diff;
-
- int (*cb)(void *data, lfs_tag_t tag, const void *buffer);
- void *data;
-
- lfs_tag_t tag;
- const void *buffer;
- struct lfs_diskoff disk;
-};
-
-static int lfs_dir_traverse(lfs_t *lfs,
- const lfs_mdir_t *dir, lfs_off_t off, lfs_tag_t ptag,
- const struct lfs_mattr *attrs, int attrcount,
- lfs_tag_t tmask, lfs_tag_t ttag,
- uint16_t begin, uint16_t end, int16_t diff,
- int (*cb)(void *data, lfs_tag_t tag, const void *buffer), void *data) {
- // This function in inherently recursive, but bounded. To allow tool-based
- // analysis without unnecessary code-cost we use an explicit stack
- struct lfs_dir_traverse stack[LFS_DIR_TRAVERSE_DEPTH-1];
- unsigned sp = 0;
- int res;
-
- // iterate over directory and attrs
- lfs_tag_t tag;
- const void *buffer;
- struct lfs_diskoff disk;
- while (true) {
- {
- if (off+lfs_tag_dsize(ptag) < dir->off) {
- off += lfs_tag_dsize(ptag);
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, sizeof(tag),
- dir->pair[0], off, &tag, sizeof(tag));
- if (err) {
- return err;
- }
-
- tag = (lfs_frombe32(tag) ^ ptag) | 0x80000000;
- disk.block = dir->pair[0];
- disk.off = off+sizeof(lfs_tag_t);
- buffer = &disk;
- ptag = tag;
- } else if (attrcount > 0) {
- tag = attrs[0].tag;
- buffer = attrs[0].buffer;
- attrs += 1;
- attrcount -= 1;
- } else {
- // finished traversal, pop from stack?
- res = 0;
- break;
- }
-
- // do we need to filter?
- lfs_tag_t mask = LFS_MKTAG(0x7ff, 0, 0);
- if ((mask & tmask & tag) != (mask & tmask & ttag)) {
- continue;
- }
-
- if (lfs_tag_id(tmask) != 0) {
- LFS_ASSERT(sp < LFS_DIR_TRAVERSE_DEPTH);
- // recurse, scan for duplicates, and update tag based on
- // creates/deletes
- stack[sp] = (struct lfs_dir_traverse){
- .dir = dir,
- .off = off,
- .ptag = ptag,
- .attrs = attrs,
- .attrcount = attrcount,
- .tmask = tmask,
- .ttag = ttag,
- .begin = begin,
- .end = end,
- .diff = diff,
- .cb = cb,
- .data = data,
- .tag = tag,
- .buffer = buffer,
- .disk = disk,
- };
- sp += 1;
-
- dir = dir;
- off = off;
- ptag = ptag;
- attrs = attrs;
- attrcount = attrcount;
- tmask = 0;
- ttag = 0;
- begin = 0;
- end = 0;
- diff = 0;
- cb = lfs_dir_traverse_filter;
- data = &stack[sp-1].tag;
- continue;
- }
- }
-
-popped:
- // in filter range?
- if (lfs_tag_id(tmask) != 0 &&
- !(lfs_tag_id(tag) >= begin && lfs_tag_id(tag) < end)) {
- continue;
- }
-
- // handle special cases for mcu-side operations
- if (lfs_tag_type3(tag) == LFS_FROM_NOOP) {
- // do nothing
- } else if (lfs_tag_type3(tag) == LFS_FROM_MOVE) {
- // Without this condition, lfs_dir_traverse can exhibit an
- // extremely expensive O(n^3) of nested loops when renaming.
- // This happens because lfs_dir_traverse tries to filter tags by
- // the tags in the source directory, triggering a second
- // lfs_dir_traverse with its own filter operation.
- //
- // traverse with commit
- // '-> traverse with filter
- // '-> traverse with move
- // '-> traverse with filter
- //
- // However we don't actually care about filtering the second set of
- // tags, since duplicate tags have no effect when filtering.
- //
- // This check skips this unnecessary recursive filtering explicitly,
- // reducing this runtime from O(n^3) to O(n^2).
- if (cb == lfs_dir_traverse_filter) {
- continue;
- }
-
- // recurse into move
- stack[sp] = (struct lfs_dir_traverse){
- .dir = dir,
- .off = off,
- .ptag = ptag,
- .attrs = attrs,
- .attrcount = attrcount,
- .tmask = tmask,
- .ttag = ttag,
- .begin = begin,
- .end = end,
- .diff = diff,
- .cb = cb,
- .data = data,
- .tag = LFS_MKTAG(LFS_FROM_NOOP, 0, 0),
- };
- sp += 1;
-
- uint16_t fromid = lfs_tag_size(tag);
- uint16_t toid = lfs_tag_id(tag);
- dir = buffer;
- off = 0;
- ptag = 0xffffffff;
- attrs = NULL;
- attrcount = 0;
- tmask = LFS_MKTAG(0x600, 0x3ff, 0);
- ttag = LFS_MKTAG(LFS_TYPE_STRUCT, 0, 0);
- begin = fromid;
- end = fromid+1;
- diff = toid-fromid+diff;
- } else if (lfs_tag_type3(tag) == LFS_FROM_USERATTRS) {
- for (unsigned i = 0; i < lfs_tag_size(tag); i++) {
- const struct lfs_attr *a = buffer;
- res = cb(data, LFS_MKTAG(LFS_TYPE_USERATTR + a[i].type,
- lfs_tag_id(tag) + diff, a[i].size), a[i].buffer);
- if (res < 0) {
- return res;
- }
-
- if (res) {
- break;
- }
- }
- } else {
- res = cb(data, tag + LFS_MKTAG(0, diff, 0), buffer);
- if (res < 0) {
- return res;
- }
-
- if (res) {
- break;
- }
- }
- }
-
- if (sp > 0) {
- // pop from the stack and return, fortunately all pops share
- // a destination
- dir = stack[sp-1].dir;
- off = stack[sp-1].off;
- ptag = stack[sp-1].ptag;
- attrs = stack[sp-1].attrs;
- attrcount = stack[sp-1].attrcount;
- tmask = stack[sp-1].tmask;
- ttag = stack[sp-1].ttag;
- begin = stack[sp-1].begin;
- end = stack[sp-1].end;
- diff = stack[sp-1].diff;
- cb = stack[sp-1].cb;
- data = stack[sp-1].data;
- tag = stack[sp-1].tag;
- buffer = stack[sp-1].buffer;
- disk = stack[sp-1].disk;
- sp -= 1;
- goto popped;
- } else {
- return res;
- }
-}
-#endif
-
-static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
- lfs_mdir_t *dir, const lfs_block_t pair[2],
- lfs_tag_t fmask, lfs_tag_t ftag, uint16_t *id,
- int (*cb)(void *data, lfs_tag_t tag, const void *buffer), void *data) {
- // we can find tag very efficiently during a fetch, since we're already
- // scanning the entire directory
- lfs_stag_t besttag = -1;
-
- // if either block address is invalid we return LFS_ERR_CORRUPT here,
- // otherwise later writes to the pair could fail
- if (pair[0] >= lfs->cfg->block_count || pair[1] >= lfs->cfg->block_count) {
- return LFS_ERR_CORRUPT;
- }
-
- // find the block with the most recent revision
- uint32_t revs[2] = {0, 0};
- int r = 0;
- for (int i = 0; i < 2; i++) {
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, sizeof(revs[i]),
- pair[i], 0, &revs[i], sizeof(revs[i]));
- revs[i] = lfs_fromle32(revs[i]);
- if (err && err != LFS_ERR_CORRUPT) {
- return err;
- }
-
- if (err != LFS_ERR_CORRUPT &&
- lfs_scmp(revs[i], revs[(i+1)%2]) > 0) {
- r = i;
- }
- }
-
- dir->pair[0] = pair[(r+0)%2];
- dir->pair[1] = pair[(r+1)%2];
- dir->rev = revs[(r+0)%2];
- dir->off = 0; // nonzero = found some commits
-
- // now scan tags to fetch the actual dir and find possible match
- for (int i = 0; i < 2; i++) {
- lfs_off_t off = 0;
- lfs_tag_t ptag = 0xffffffff;
-
- uint16_t tempcount = 0;
- lfs_block_t temptail[2] = {LFS_BLOCK_NULL, LFS_BLOCK_NULL};
- bool tempsplit = false;
- lfs_stag_t tempbesttag = besttag;
-
- dir->rev = lfs_tole32(dir->rev);
- uint32_t crc = lfs_crc(0xffffffff, &dir->rev, sizeof(dir->rev));
- dir->rev = lfs_fromle32(dir->rev);
-
- while (true) {
- // extract next tag
- lfs_tag_t tag;
- off += lfs_tag_dsize(ptag);
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, lfs->cfg->block_size,
- dir->pair[0], off, &tag, sizeof(tag));
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- // can't continue?
- dir->erased = false;
- break;
- }
- return err;
- }
-
- crc = lfs_crc(crc, &tag, sizeof(tag));
- tag = lfs_frombe32(tag) ^ ptag;
-
- // next commit not yet programmed or we're not in valid range
- if (!lfs_tag_isvalid(tag)) {
- dir->erased = (lfs_tag_type1(ptag) == LFS_TYPE_CRC &&
- dir->off % lfs->cfg->prog_size == 0);
- break;
- } else if (off + lfs_tag_dsize(tag) > lfs->cfg->block_size) {
- dir->erased = false;
- break;
- }
-
- ptag = tag;
-
- if (lfs_tag_type1(tag) == LFS_TYPE_CRC) {
- // check the crc attr
- uint32_t dcrc;
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, lfs->cfg->block_size,
- dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- dir->erased = false;
- break;
- }
- return err;
- }
- dcrc = lfs_fromle32(dcrc);
-
- if (crc != dcrc) {
- dir->erased = false;
- break;
- }
-
- // reset the next bit if we need to
- ptag ^= (lfs_tag_t)(lfs_tag_chunk(tag) & 1U) << 31;
-
- // toss our crc into the filesystem seed for
- // pseudorandom numbers, note we use another crc here
- // as a collection function because it is sufficiently
- // random and convenient
- lfs->seed = lfs_crc(lfs->seed, &crc, sizeof(crc));
-
- // update with what's found so far
- besttag = tempbesttag;
- dir->off = off + lfs_tag_dsize(tag);
- dir->etag = ptag;
- dir->count = tempcount;
- dir->tail[0] = temptail[0];
- dir->tail[1] = temptail[1];
- dir->split = tempsplit;
-
- // reset crc
- crc = 0xffffffff;
- continue;
- }
-
- // crc the entry first, hopefully leaving it in the cache
- for (lfs_off_t j = sizeof(tag); j < lfs_tag_dsize(tag); j++) {
- uint8_t dat;
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, lfs->cfg->block_size,
- dir->pair[0], off+j, &dat, 1);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- dir->erased = false;
- break;
- }
- return err;
- }
-
- crc = lfs_crc(crc, &dat, 1);
- }
-
- // directory modification tags?
- if (lfs_tag_type1(tag) == LFS_TYPE_NAME) {
- // increase count of files if necessary
- if (lfs_tag_id(tag) >= tempcount) {
- tempcount = lfs_tag_id(tag) + 1;
- }
- } else if (lfs_tag_type1(tag) == LFS_TYPE_SPLICE) {
- tempcount += lfs_tag_splice(tag);
-
- if (tag == (LFS_MKTAG(LFS_TYPE_DELETE, 0, 0) |
- (LFS_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
- tempbesttag |= 0x80000000;
- } else if (tempbesttag != -1 &&
- lfs_tag_id(tag) <= lfs_tag_id(tempbesttag)) {
- tempbesttag += LFS_MKTAG(0, lfs_tag_splice(tag), 0);
- }
- } else if (lfs_tag_type1(tag) == LFS_TYPE_TAIL) {
- tempsplit = (lfs_tag_chunk(tag) & 1);
-
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, lfs->cfg->block_size,
- dir->pair[0], off+sizeof(tag), &temptail, 8);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- dir->erased = false;
- break;
- }
- }
- lfs_pair_fromle32(temptail);
- }
-
- // found a match for our fetcher?
- if ((fmask & tag) == (fmask & ftag)) {
- int res = cb(data, tag, &(struct lfs_diskoff){
- dir->pair[0], off+sizeof(tag)});
- if (res < 0) {
- if (res == LFS_ERR_CORRUPT) {
- dir->erased = false;
- break;
- }
- return res;
- }
-
- if (res == LFS_CMP_EQ) {
- // found a match
- tempbesttag = tag;
- } else if ((LFS_MKTAG(0x7ff, 0x3ff, 0) & tag) ==
- (LFS_MKTAG(0x7ff, 0x3ff, 0) & tempbesttag)) {
- // found an identical tag, but contents didn't match
- // this must mean that our besttag has been overwritten
- tempbesttag = -1;
- } else if (res == LFS_CMP_GT &&
- lfs_tag_id(tag) <= lfs_tag_id(tempbesttag)) {
- // found a greater match, keep track to keep things sorted
- tempbesttag = tag | 0x80000000;
- }
- }
- }
-
- // consider what we have good enough
- if (dir->off > 0) {
- // synthetic move
- if (lfs_gstate_hasmovehere(&lfs->gdisk, dir->pair)) {
- if (lfs_tag_id(lfs->gdisk.tag) == lfs_tag_id(besttag)) {
- besttag |= 0x80000000;
- } else if (besttag != -1 &&
- lfs_tag_id(lfs->gdisk.tag) < lfs_tag_id(besttag)) {
- besttag -= LFS_MKTAG(0, 1, 0);
- }
- }
-
- // found tag? or found best id?
- if (id) {
- *id = lfs_min(lfs_tag_id(besttag), dir->count);
- }
-
- if (lfs_tag_isvalid(besttag)) {
- return besttag;
- } else if (lfs_tag_id(besttag) < dir->count) {
- return LFS_ERR_NOENT;
- } else {
- return 0;
- }
- }
-
- // failed, try the other block?
- lfs_pair_swap(dir->pair);
- dir->rev = revs[(r+1)%2];
- }
-
- LFS_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
- dir->pair[0], dir->pair[1]);
- return LFS_ERR_CORRUPT;
-}
-
-static int lfs_dir_fetch(lfs_t *lfs,
- lfs_mdir_t *dir, const lfs_block_t pair[2]) {
- // note, mask=-1, tag=-1 can never match a tag since this
- // pattern has the invalid bit set
- return (int)lfs_dir_fetchmatch(lfs, dir, pair,
- (lfs_tag_t)-1, (lfs_tag_t)-1, NULL, NULL, NULL);
-}
-
-static int lfs_dir_getgstate(lfs_t *lfs, const lfs_mdir_t *dir,
- lfs_gstate_t *gstate) {
- lfs_gstate_t temp;
- lfs_stag_t res = lfs_dir_get(lfs, dir, LFS_MKTAG(0x7ff, 0, 0),
- LFS_MKTAG(LFS_TYPE_MOVESTATE, 0, sizeof(temp)), &temp);
- if (res < 0 && res != LFS_ERR_NOENT) {
- return res;
- }
-
- if (res != LFS_ERR_NOENT) {
- // xor together to find resulting gstate
- lfs_gstate_fromle32(&temp);
- lfs_gstate_xor(gstate, &temp);
- }
-
- return 0;
-}
-
-static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir,
- uint16_t id, struct lfs_info *info) {
- if (id == 0x3ff) {
- // special case for root
- strcpy(info->name, "/");
- info->type = LFS_TYPE_DIR;
- return 0;
- }
-
- lfs_stag_t tag = lfs_dir_get(lfs, dir, LFS_MKTAG(0x780, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_NAME, id, lfs->name_max+1), info->name);
- if (tag < 0) {
- return (int)tag;
- }
-
- info->type = lfs_tag_type3(tag);
-
- struct lfs_ctz ctz;
- tag = lfs_dir_get(lfs, dir, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
- if (tag < 0) {
- return (int)tag;
- }
- lfs_ctz_fromle32(&ctz);
-
- if (lfs_tag_type3(tag) == LFS_TYPE_CTZSTRUCT) {
- info->size = ctz.size;
- } else if (lfs_tag_type3(tag) == LFS_TYPE_INLINESTRUCT) {
- info->size = lfs_tag_size(tag);
- }
-
- return 0;
-}
-
-struct lfs_dir_find_match {
- lfs_t *lfs;
- const void *name;
- lfs_size_t size;
-};
-
-static int lfs_dir_find_match(void *data,
- lfs_tag_t tag, const void *buffer) {
- struct lfs_dir_find_match *name = data;
- lfs_t *lfs = name->lfs;
- const struct lfs_diskoff *disk = buffer;
-
- // compare with disk
- lfs_size_t diff = lfs_min(name->size, lfs_tag_size(tag));
- int res = lfs_bd_cmp(lfs,
- NULL, &lfs->rcache, diff,
- disk->block, disk->off, name->name, diff);
- if (res != LFS_CMP_EQ) {
- return res;
- }
-
- // only equal if our size is still the same
- if (name->size != lfs_tag_size(tag)) {
- return (name->size < lfs_tag_size(tag)) ? LFS_CMP_LT : LFS_CMP_GT;
- }
-
- // found a match!
- return LFS_CMP_EQ;
-}
-
-static lfs_stag_t lfs_dir_find(lfs_t *lfs, lfs_mdir_t *dir,
- const char **path, uint16_t *id) {
- // we reduce path to a single name if we can find it
- const char *name = *path;
- if (id) {
- *id = 0x3ff;
- }
-
- // default to root dir
- lfs_stag_t tag = LFS_MKTAG(LFS_TYPE_DIR, 0x3ff, 0);
- dir->tail[0] = lfs->root[0];
- dir->tail[1] = lfs->root[1];
-
- while (true) {
-nextname:
- // skip slashes
- name += strspn(name, "/");
- lfs_size_t namelen = strcspn(name, "/");
-
- // skip '.' and root '..'
- if ((namelen == 1 && memcmp(name, ".", 1) == 0) ||
- (namelen == 2 && memcmp(name, "..", 2) == 0)) {
- name += namelen;
- goto nextname;
- }
-
- // skip if matched by '..' in name
- const char *suffix = name + namelen;
- lfs_size_t sufflen;
- int depth = 1;
- while (true) {
- suffix += strspn(suffix, "/");
- sufflen = strcspn(suffix, "/");
- if (sufflen == 0) {
- break;
- }
-
- if (sufflen == 2 && memcmp(suffix, "..", 2) == 0) {
- depth -= 1;
- if (depth == 0) {
- name = suffix + sufflen;
- goto nextname;
- }
- } else {
- depth += 1;
- }
-
- suffix += sufflen;
- }
-
- // found path
- if (name[0] == '\0') {
- return tag;
- }
-
- // update what we've found so far
- *path = name;
-
- // only continue if we hit a directory
- if (lfs_tag_type3(tag) != LFS_TYPE_DIR) {
- return LFS_ERR_NOTDIR;
- }
-
- // grab the entry data
- if (lfs_tag_id(tag) != 0x3ff) {
- lfs_stag_t res = lfs_dir_get(lfs, dir, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), dir->tail);
- if (res < 0) {
- return res;
- }
- lfs_pair_fromle32(dir->tail);
- }
-
- // find entry matching name
- while (true) {
- tag = lfs_dir_fetchmatch(lfs, dir, dir->tail,
- LFS_MKTAG(0x780, 0, 0),
- LFS_MKTAG(LFS_TYPE_NAME, 0, namelen),
- // are we last name?
- (strchr(name, '/') == NULL) ? id : NULL,
- lfs_dir_find_match, &(struct lfs_dir_find_match){
- lfs, name, namelen});
- if (tag < 0) {
- return tag;
- }
-
- if (tag) {
- break;
- }
-
- if (!dir->split) {
- return LFS_ERR_NOENT;
- }
- }
-
- // to next name
- name += namelen;
- }
-}
-
-// commit logic
-struct lfs_commit {
- lfs_block_t block;
- lfs_off_t off;
- lfs_tag_t ptag;
- uint32_t crc;
-
- lfs_off_t begin;
- lfs_off_t end;
-};
-
-#ifndef LFS_READONLY
-static int lfs_dir_commitprog(lfs_t *lfs, struct lfs_commit *commit,
- const void *buffer, lfs_size_t size) {
- int err = lfs_bd_prog(lfs,
- &lfs->pcache, &lfs->rcache, false,
- commit->block, commit->off ,
- (const uint8_t*)buffer, size);
- if (err) {
- return err;
- }
-
- commit->crc = lfs_crc(commit->crc, buffer, size);
- commit->off += size;
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_commitattr(lfs_t *lfs, struct lfs_commit *commit,
- lfs_tag_t tag, const void *buffer) {
- // check if we fit
- lfs_size_t dsize = lfs_tag_dsize(tag);
- if (commit->off + dsize > commit->end) {
- return LFS_ERR_NOSPC;
- }
-
- // write out tag
- lfs_tag_t ntag = lfs_tobe32((tag & 0x7fffffff) ^ commit->ptag);
- int err = lfs_dir_commitprog(lfs, commit, &ntag, sizeof(ntag));
- if (err) {
- return err;
- }
-
- if (!(tag & 0x80000000)) {
- // from memory
- err = lfs_dir_commitprog(lfs, commit, buffer, dsize-sizeof(tag));
- if (err) {
- return err;
- }
- } else {
- // from disk
- const struct lfs_diskoff *disk = buffer;
- for (lfs_off_t i = 0; i < dsize-sizeof(tag); i++) {
- // rely on caching to make this efficient
- uint8_t dat;
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, dsize-sizeof(tag)-i,
- disk->block, disk->off+i, &dat, 1);
- if (err) {
- return err;
- }
-
- err = lfs_dir_commitprog(lfs, commit, &dat, 1);
- if (err) {
- return err;
- }
- }
- }
-
- commit->ptag = tag & 0x7fffffff;
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
- // align to program units
- const lfs_off_t end = lfs_alignup(commit->off + 2*sizeof(uint32_t),
- lfs->cfg->prog_size);
-
- lfs_off_t off1 = 0;
- uint32_t crc1 = 0;
-
- // create crc tags to fill up remainder of commit, note that
- // padding is not crced, which lets fetches skip padding but
- // makes committing a bit more complicated
- while (commit->off < end) {
- lfs_off_t off = commit->off + sizeof(lfs_tag_t);
- lfs_off_t noff = lfs_min(end - off, 0x3fe) + off;
- if (noff < end) {
- noff = lfs_min(noff, end - 2*sizeof(uint32_t));
- }
-
- // read erased state from next program unit
- lfs_tag_t tag = 0xffffffff;
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, sizeof(tag),
- commit->block, noff, &tag, sizeof(tag));
- if (err && err != LFS_ERR_CORRUPT) {
- return err;
- }
-
- // build crc tag
- bool reset = ~lfs_frombe32(tag) >> 31;
- tag = LFS_MKTAG(LFS_TYPE_CRC + reset, 0x3ff, noff - off);
-
- // write out crc
- uint32_t footer[2];
- footer[0] = lfs_tobe32(tag ^ commit->ptag);
- commit->crc = lfs_crc(commit->crc, &footer[0], sizeof(footer[0]));
- footer[1] = lfs_tole32(commit->crc);
- err = lfs_bd_prog(lfs,
- &lfs->pcache, &lfs->rcache, false,
- commit->block, commit->off, &footer, sizeof(footer));
- if (err) {
- return err;
- }
-
- // keep track of non-padding checksum to verify
- if (off1 == 0) {
- off1 = commit->off + sizeof(uint32_t);
- crc1 = commit->crc;
- }
-
- commit->off += sizeof(tag)+lfs_tag_size(tag);
- commit->ptag = tag ^ ((lfs_tag_t)reset << 31);
- commit->crc = 0xffffffff; // reset crc for next "commit"
- }
-
- // flush buffers
- int err = lfs_bd_sync(lfs, &lfs->pcache, &lfs->rcache, false);
- if (err) {
- return err;
- }
-
- // successful commit, check checksums to make sure
- lfs_off_t off = commit->begin;
- lfs_off_t noff = off1;
- while (off < end) {
- uint32_t crc = 0xffffffff;
- for (lfs_off_t i = off; i < noff+sizeof(uint32_t); i++) {
- // check against written crc, may catch blocks that
- // become readonly and match our commit size exactly
- if (i == off1 && crc != crc1) {
- return LFS_ERR_CORRUPT;
- }
-
- // leave it up to caching to make this efficient
- uint8_t dat;
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, noff+sizeof(uint32_t)-i,
- commit->block, i, &dat, 1);
- if (err) {
- return err;
- }
-
- crc = lfs_crc(crc, &dat, 1);
- }
-
- // detected write error?
- if (crc != 0) {
- return LFS_ERR_CORRUPT;
- }
-
- // skip padding
- off = lfs_min(end - noff, 0x3fe) + noff;
- if (off < end) {
- off = lfs_min(off, end - 2*sizeof(uint32_t));
- }
- noff = off + sizeof(uint32_t);
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir) {
- // allocate pair of dir blocks (backwards, so we write block 1 first)
- for (int i = 0; i < 2; i++) {
- int err = lfs_alloc(lfs, &dir->pair[(i+1)%2]);
- if (err) {
- return err;
- }
- }
-
- // zero for reproducibility in case initial block is unreadable
- dir->rev = 0;
-
- // rather than clobbering one of the blocks we just pretend
- // the revision may be valid
- int err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, sizeof(dir->rev),
- dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
- dir->rev = lfs_fromle32(dir->rev);
- if (err && err != LFS_ERR_CORRUPT) {
- return err;
- }
-
- // to make sure we don't immediately evict, align the new revision count
- // to our block_cycles modulus, see lfs_dir_compact for why our modulus
- // is tweaked this way
- if (lfs->cfg->block_cycles > 0) {
- dir->rev = lfs_alignup(dir->rev, ((lfs->cfg->block_cycles+1)|1));
- }
-
- // set defaults
- dir->off = sizeof(dir->rev);
- dir->etag = 0xffffffff;
- dir->count = 0;
- dir->tail[0] = LFS_BLOCK_NULL;
- dir->tail[1] = LFS_BLOCK_NULL;
- dir->erased = false;
- dir->split = false;
-
- // don't write out yet, let caller take care of that
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_drop(lfs_t *lfs, lfs_mdir_t *dir, lfs_mdir_t *tail) {
- // steal state
- int err = lfs_dir_getgstate(lfs, tail, &lfs->gdelta);
- if (err) {
- return err;
- }
-
- // steal tail
- lfs_pair_tole32(tail->tail);
- err = lfs_dir_commit(lfs, dir, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_TAIL + tail->split, 0x3ff, 8), tail->tail}));
- lfs_pair_fromle32(tail->tail);
- if (err) {
- return err;
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_split(lfs_t *lfs,
- lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
- lfs_mdir_t *source, uint16_t split, uint16_t end) {
- // create tail metadata pair
- lfs_mdir_t tail;
- int err = lfs_dir_alloc(lfs, &tail);
- if (err) {
- return err;
- }
-
- tail.split = dir->split;
- tail.tail[0] = dir->tail[0];
- tail.tail[1] = dir->tail[1];
-
- // note we don't care about LFS_OK_RELOCATED
- int res = lfs_dir_compact(lfs, &tail, attrs, attrcount, source, split, end);
- if (res < 0) {
- return res;
- }
-
- dir->tail[0] = tail.pair[0];
- dir->tail[1] = tail.pair[1];
- dir->split = true;
-
- // update root if needed
- if (lfs_pair_cmp(dir->pair, lfs->root) == 0 && split == 0) {
- lfs->root[0] = tail.pair[0];
- lfs->root[1] = tail.pair[1];
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_commit_size(void *p, lfs_tag_t tag, const void *buffer) {
- lfs_size_t *size = p;
- (void)buffer;
-
- *size += lfs_tag_dsize(tag);
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-struct lfs_dir_commit_commit {
- lfs_t *lfs;
- struct lfs_commit *commit;
-};
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_commit_commit(void *p, lfs_tag_t tag, const void *buffer) {
- struct lfs_dir_commit_commit *commit = p;
- return lfs_dir_commitattr(commit->lfs, commit->commit, tag, buffer);
-}
-#endif
-
-#ifndef LFS_READONLY
-static bool lfs_dir_needsrelocation(lfs_t *lfs, lfs_mdir_t *dir) {
- // If our revision count == n * block_cycles, we should force a relocation,
- // this is how littlefs wear-levels at the metadata-pair level. Note that we
- // actually use (block_cycles+1)|1, this is to avoid two corner cases:
- // 1. block_cycles = 1, which would prevent relocations from terminating
- // 2. block_cycles = 2n, which, due to aliasing, would only ever relocate
- // one metadata block in the pair, effectively making this useless
- return (lfs->cfg->block_cycles > 0
- && ((dir->rev + 1) % ((lfs->cfg->block_cycles+1)|1) == 0));
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_compact(lfs_t *lfs,
- lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
- lfs_mdir_t *source, uint16_t begin, uint16_t end) {
- // save some state in case block is bad
- bool relocated = false;
- bool tired = lfs_dir_needsrelocation(lfs, dir);
-
- // increment revision count
- dir->rev += 1;
-
- // do not proactively relocate blocks during migrations, this
- // can cause a number of failure states such: clobbering the
- // v1 superblock if we relocate root, and invalidating directory
- // pointers if we relocate the head of a directory. On top of
- // this, relocations increase the overall complexity of
- // lfs_migration, which is already a delicate operation.
-#ifdef LFS_MIGRATE
- if (lfs->lfs1) {
- tired = false;
- }
-#endif
-
- if (tired && lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) != 0) {
- // we're writing too much, time to relocate
- goto relocate;
- }
-
- // begin loop to commit compaction to blocks until a compact sticks
- while (true) {
- {
- // setup commit state
- struct lfs_commit commit = {
- .block = dir->pair[1],
- .off = 0,
- .ptag = 0xffffffff,
- .crc = 0xffffffff,
-
- .begin = 0,
- .end = (lfs->cfg->metadata_max ?
- lfs->cfg->metadata_max : lfs->cfg->block_size) - 8,
- };
-
- // erase block to write to
- int err = lfs_bd_erase(lfs, dir->pair[1]);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- // write out header
- dir->rev = lfs_tole32(dir->rev);
- err = lfs_dir_commitprog(lfs, &commit,
- &dir->rev, sizeof(dir->rev));
- dir->rev = lfs_fromle32(dir->rev);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- // traverse the directory, this time writing out all unique tags
- err = lfs_dir_traverse(lfs,
- source, 0, 0xffffffff, attrs, attrcount,
- LFS_MKTAG(0x400, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_NAME, 0, 0),
- begin, end, -begin,
- lfs_dir_commit_commit, &(struct lfs_dir_commit_commit){
- lfs, &commit});
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- // commit tail, which may be new after last size check
- if (!lfs_pair_isnull(dir->tail)) {
- lfs_pair_tole32(dir->tail);
- err = lfs_dir_commitattr(lfs, &commit,
- LFS_MKTAG(LFS_TYPE_TAIL + dir->split, 0x3ff, 8),
- dir->tail);
- lfs_pair_fromle32(dir->tail);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
- }
-
- // bring over gstate?
- lfs_gstate_t delta = {0};
- if (!relocated) {
- lfs_gstate_xor(&delta, &lfs->gdisk);
- lfs_gstate_xor(&delta, &lfs->gstate);
- }
- lfs_gstate_xor(&delta, &lfs->gdelta);
- delta.tag &= ~LFS_MKTAG(0, 0, 0x3ff);
-
- err = lfs_dir_getgstate(lfs, dir, &delta);
- if (err) {
- return err;
- }
-
- if (!lfs_gstate_iszero(&delta)) {
- lfs_gstate_tole32(&delta);
- err = lfs_dir_commitattr(lfs, &commit,
- LFS_MKTAG(LFS_TYPE_MOVESTATE, 0x3ff,
- sizeof(delta)), &delta);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
- }
-
- // complete commit with crc
- err = lfs_dir_commitcrc(lfs, &commit);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- // successful compaction, swap dir pair to indicate most recent
- LFS_ASSERT(commit.off % lfs->cfg->prog_size == 0);
- lfs_pair_swap(dir->pair);
- dir->count = end - begin;
- dir->off = commit.off;
- dir->etag = commit.ptag;
- // update gstate
- lfs->gdelta = (lfs_gstate_t){0};
- if (!relocated) {
- lfs->gdisk = lfs->gstate;
- }
- }
- break;
-
-relocate:
- // commit was corrupted, drop caches and prepare to relocate block
- relocated = true;
- lfs_cache_drop(lfs, &lfs->pcache);
- if (!tired) {
- LFS_DEBUG("Bad block at 0x%"PRIx32, dir->pair[1]);
- }
-
- // can't relocate superblock, filesystem is now frozen
- if (lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) == 0) {
- LFS_WARN("Superblock 0x%"PRIx32" has become unwritable",
- dir->pair[1]);
- return LFS_ERR_NOSPC;
- }
-
- // relocate half of pair
- int err = lfs_alloc(lfs, &dir->pair[1]);
- if (err && (err != LFS_ERR_NOSPC || !tired)) {
- return err;
- }
-
- tired = false;
- continue;
- }
-
- return relocated ? LFS_OK_RELOCATED : 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_splittingcompact(lfs_t *lfs, lfs_mdir_t *dir,
- const struct lfs_mattr *attrs, int attrcount,
- lfs_mdir_t *source, uint16_t begin, uint16_t end) {
- while (true) {
- // find size of first split, we do this by halving the split until
- // the metadata is guaranteed to fit
- //
- // Note that this isn't a true binary search, we never increase the
- // split size. This may result in poorly distributed metadata but isn't
- // worth the extra code size or performance hit to fix.
- lfs_size_t split = begin;
- while (end - split > 1) {
- lfs_size_t size = 0;
- int err = lfs_dir_traverse(lfs,
- source, 0, 0xffffffff, attrs, attrcount,
- LFS_MKTAG(0x400, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_NAME, 0, 0),
- split, end, -split,
- lfs_dir_commit_size, &size);
- if (err) {
- return err;
- }
-
- // space is complicated, we need room for tail, crc, gstate,
- // cleanup delete, and we cap at half a block to give room
- // for metadata updates.
- if (end - split < 0xff
- && size <= lfs_min(lfs->cfg->block_size - 36,
- lfs_alignup(
- (lfs->cfg->metadata_max
- ? lfs->cfg->metadata_max
- : lfs->cfg->block_size)/2,
- lfs->cfg->prog_size))) {
- break;
- }
-
- split = split + ((end - split) / 2);
- }
-
- if (split == begin) {
- // no split needed
- break;
- }
-
- // split into two metadata pairs and continue
- int err = lfs_dir_split(lfs, dir, attrs, attrcount,
- source, split, end);
- if (err && err != LFS_ERR_NOSPC) {
- return err;
- }
-
- if (err) {
- // we can't allocate a new block, try to compact with degraded
- // performance
- LFS_WARN("Unable to split {0x%"PRIx32", 0x%"PRIx32"}",
- dir->pair[0], dir->pair[1]);
- break;
- } else {
- end = split;
- }
- }
-
- if (lfs_dir_needsrelocation(lfs, dir)
- && lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) == 0) {
- // oh no! we're writing too much to the superblock,
- // should we expand?
- lfs_ssize_t size = lfs_fs_rawsize(lfs);
- if (size < 0) {
- return size;
- }
-
- // do we have extra space? littlefs can't reclaim this space
- // by itself, so expand cautiously
- if ((lfs_size_t)size < lfs->cfg->block_count/2) {
- LFS_DEBUG("Expanding superblock at rev %"PRIu32, dir->rev);
- int err = lfs_dir_split(lfs, dir, attrs, attrcount,
- source, begin, end);
- if (err && err != LFS_ERR_NOSPC) {
- return err;
- }
-
- if (err) {
- // welp, we tried, if we ran out of space there's not much
- // we can do, we'll error later if we've become frozen
- LFS_WARN("Unable to expand superblock");
- } else {
- end = begin;
- }
- }
- }
-
- return lfs_dir_compact(lfs, dir, attrs, attrcount, source, begin, end);
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_relocatingcommit(lfs_t *lfs, lfs_mdir_t *dir,
- const lfs_block_t pair[2],
- const struct lfs_mattr *attrs, int attrcount,
- lfs_mdir_t *pdir) {
- int state = 0;
-
- // calculate changes to the directory
- bool hasdelete = false;
- for (int i = 0; i < attrcount; i++) {
- if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_CREATE) {
- dir->count += 1;
- } else if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_DELETE) {
- LFS_ASSERT(dir->count > 0);
- dir->count -= 1;
- hasdelete = true;
- } else if (lfs_tag_type1(attrs[i].tag) == LFS_TYPE_TAIL) {
- dir->tail[0] = ((lfs_block_t*)attrs[i].buffer)[0];
- dir->tail[1] = ((lfs_block_t*)attrs[i].buffer)[1];
- dir->split = (lfs_tag_chunk(attrs[i].tag) & 1);
- lfs_pair_fromle32(dir->tail);
- }
- }
-
- // should we actually drop the directory block?
- if (hasdelete && dir->count == 0) {
- LFS_ASSERT(pdir);
- int err = lfs_fs_pred(lfs, dir->pair, pdir);
- if (err && err != LFS_ERR_NOENT) {
- return err;
- }
-
- if (err != LFS_ERR_NOENT && pdir->split) {
- state = LFS_OK_DROPPED;
- goto fixmlist;
- }
- }
-
- if (dir->erased) {
- // try to commit
- struct lfs_commit commit = {
- .block = dir->pair[0],
- .off = dir->off,
- .ptag = dir->etag,
- .crc = 0xffffffff,
-
- .begin = dir->off,
- .end = (lfs->cfg->metadata_max ?
- lfs->cfg->metadata_max : lfs->cfg->block_size) - 8,
- };
-
- // traverse attrs that need to be written out
- lfs_pair_tole32(dir->tail);
- int err = lfs_dir_traverse(lfs,
- dir, dir->off, dir->etag, attrs, attrcount,
- 0, 0, 0, 0, 0,
- lfs_dir_commit_commit, &(struct lfs_dir_commit_commit){
- lfs, &commit});
- lfs_pair_fromle32(dir->tail);
- if (err) {
- if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
- goto compact;
- }
- return err;
- }
-
- // commit any global diffs if we have any
- lfs_gstate_t delta = {0};
- lfs_gstate_xor(&delta, &lfs->gstate);
- lfs_gstate_xor(&delta, &lfs->gdisk);
- lfs_gstate_xor(&delta, &lfs->gdelta);
- delta.tag &= ~LFS_MKTAG(0, 0, 0x3ff);
- if (!lfs_gstate_iszero(&delta)) {
- err = lfs_dir_getgstate(lfs, dir, &delta);
- if (err) {
- return err;
- }
-
- lfs_gstate_tole32(&delta);
- err = lfs_dir_commitattr(lfs, &commit,
- LFS_MKTAG(LFS_TYPE_MOVESTATE, 0x3ff,
- sizeof(delta)), &delta);
- if (err) {
- if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
- goto compact;
- }
- return err;
- }
- }
-
- // finalize commit with the crc
- err = lfs_dir_commitcrc(lfs, &commit);
- if (err) {
- if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
- goto compact;
- }
- return err;
- }
-
- // successful commit, update dir
- LFS_ASSERT(commit.off % lfs->cfg->prog_size == 0);
- dir->off = commit.off;
- dir->etag = commit.ptag;
- // and update gstate
- lfs->gdisk = lfs->gstate;
- lfs->gdelta = (lfs_gstate_t){0};
-
- goto fixmlist;
- }
-
-compact:
- // fall back to compaction
- lfs_cache_drop(lfs, &lfs->pcache);
-
- state = lfs_dir_splittingcompact(lfs, dir, attrs, attrcount,
- dir, 0, dir->count);
- if (state < 0) {
- return state;
- }
-
- goto fixmlist;
-
-fixmlist:;
- // this complicated bit of logic is for fixing up any active
- // metadata-pairs that we may have affected
- //
- // note we have to make two passes since the mdir passed to
- // lfs_dir_commit could also be in this list, and even then
- // we need to copy the pair so they don't get clobbered if we refetch
- // our mdir.
- lfs_block_t oldpair[2] = {pair[0], pair[1]};
- for (struct lfs_mlist *d = lfs->mlist; d; d = d->next) {
- if (lfs_pair_cmp(d->m.pair, oldpair) == 0) {
- d->m = *dir;
- if (d->m.pair != pair) {
- for (int i = 0; i < attrcount; i++) {
- if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_DELETE &&
- d->id == lfs_tag_id(attrs[i].tag)) {
- d->m.pair[0] = LFS_BLOCK_NULL;
- d->m.pair[1] = LFS_BLOCK_NULL;
- } else if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_DELETE &&
- d->id > lfs_tag_id(attrs[i].tag)) {
- d->id -= 1;
- if (d->type == LFS_TYPE_DIR) {
- ((lfs_dir_t*)d)->pos -= 1;
- }
- } else if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_CREATE &&
- d->id >= lfs_tag_id(attrs[i].tag)) {
- d->id += 1;
- if (d->type == LFS_TYPE_DIR) {
- ((lfs_dir_t*)d)->pos += 1;
- }
- }
- }
- }
-
- while (d->id >= d->m.count && d->m.split) {
- // we split and id is on tail now
- d->id -= d->m.count;
- int err = lfs_dir_fetch(lfs, &d->m, d->m.tail);
- if (err) {
- return err;
- }
- }
- }
- }
-
- return state;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_orphaningcommit(lfs_t *lfs, lfs_mdir_t *dir,
- const struct lfs_mattr *attrs, int attrcount) {
- // check for any inline files that aren't RAM backed and
- // forcefully evict them, needed for filesystem consistency
- for (lfs_file_t *f = (lfs_file_t*)lfs->mlist; f; f = f->next) {
- if (dir != &f->m && lfs_pair_cmp(f->m.pair, dir->pair) == 0 &&
- f->type == LFS_TYPE_REG && (f->flags & LFS_F_INLINE) &&
- f->ctz.size > lfs->cfg->cache_size) {
- int err = lfs_file_outline(lfs, f);
- if (err) {
- return err;
- }
-
- err = lfs_file_flush(lfs, f);
- if (err) {
- return err;
- }
- }
- }
-
- lfs_block_t lpair[2] = {dir->pair[0], dir->pair[1]};
- lfs_mdir_t ldir = *dir;
- lfs_mdir_t pdir;
- int state = lfs_dir_relocatingcommit(lfs, &ldir, dir->pair,
- attrs, attrcount, &pdir);
- if (state < 0) {
- return state;
- }
-
- // update if we're not in mlist, note we may have already been
- // updated if we are in mlist
- if (lfs_pair_cmp(dir->pair, lpair) == 0) {
- *dir = ldir;
- }
-
- // commit was successful, but may require other changes in the
- // filesystem, these would normally be tail recursive, but we have
- // flattened them here avoid unbounded stack usage
-
- // need to drop?
- if (state == LFS_OK_DROPPED) {
- // steal state
- int err = lfs_dir_getgstate(lfs, dir, &lfs->gdelta);
- if (err) {
- return err;
- }
-
- // steal tail, note that this can't create a recursive drop
- lpair[0] = pdir.pair[0];
- lpair[1] = pdir.pair[1];
- lfs_pair_tole32(dir->tail);
- state = lfs_dir_relocatingcommit(lfs, &pdir, lpair, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_TAIL + dir->split, 0x3ff, 8),
- dir->tail}),
- NULL);
- lfs_pair_fromle32(dir->tail);
- if (state < 0) {
- return state;
- }
-
- ldir = pdir;
- }
-
- // need to relocate?
- bool orphans = false;
- while (state == LFS_OK_RELOCATED) {
- LFS_DEBUG("Relocating {0x%"PRIx32", 0x%"PRIx32"} "
- "-> {0x%"PRIx32", 0x%"PRIx32"}",
- lpair[0], lpair[1], ldir.pair[0], ldir.pair[1]);
- state = 0;
-
- // update internal root
- if (lfs_pair_cmp(lpair, lfs->root) == 0) {
- lfs->root[0] = ldir.pair[0];
- lfs->root[1] = ldir.pair[1];
- }
-
- // update internally tracked dirs
- for (struct lfs_mlist *d = lfs->mlist; d; d = d->next) {
- if (lfs_pair_cmp(lpair, d->m.pair) == 0) {
- d->m.pair[0] = ldir.pair[0];
- d->m.pair[1] = ldir.pair[1];
- }
-
- if (d->type == LFS_TYPE_DIR &&
- lfs_pair_cmp(lpair, ((lfs_dir_t*)d)->head) == 0) {
- ((lfs_dir_t*)d)->head[0] = ldir.pair[0];
- ((lfs_dir_t*)d)->head[1] = ldir.pair[1];
- }
- }
-
- // find parent
- lfs_stag_t tag = lfs_fs_parent(lfs, lpair, &pdir);
- if (tag < 0 && tag != LFS_ERR_NOENT) {
- return tag;
- }
-
- bool hasparent = (tag != LFS_ERR_NOENT);
- if (tag != LFS_ERR_NOENT) {
- // note that if we have a parent, we must have a pred, so this will
- // always create an orphan
- int err = lfs_fs_preporphans(lfs, +1);
- if (err) {
- return err;
- }
-
- // fix pending move in this pair? this looks like an optimization but
- // is in fact _required_ since relocating may outdate the move.
- uint16_t moveid = 0x3ff;
- if (lfs_gstate_hasmovehere(&lfs->gstate, pdir.pair)) {
- moveid = lfs_tag_id(lfs->gstate.tag);
- LFS_DEBUG("Fixing move while relocating "
- "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
- pdir.pair[0], pdir.pair[1], moveid);
- lfs_fs_prepmove(lfs, 0x3ff, NULL);
- if (moveid < lfs_tag_id(tag)) {
- tag -= LFS_MKTAG(0, 1, 0);
- }
- }
-
- lfs_block_t ppair[2] = {pdir.pair[0], pdir.pair[1]};
- lfs_pair_tole32(ldir.pair);
- state = lfs_dir_relocatingcommit(lfs, &pdir, ppair, LFS_MKATTRS(
- {LFS_MKTAG_IF(moveid != 0x3ff,
- LFS_TYPE_DELETE, moveid, 0), NULL},
- {tag, ldir.pair}),
- NULL);
- lfs_pair_fromle32(ldir.pair);
- if (state < 0) {
- return state;
- }
-
- if (state == LFS_OK_RELOCATED) {
- lpair[0] = ppair[0];
- lpair[1] = ppair[1];
- ldir = pdir;
- orphans = true;
- continue;
- }
- }
-
- // find pred
- int err = lfs_fs_pred(lfs, lpair, &pdir);
- if (err && err != LFS_ERR_NOENT) {
- return err;
- }
- LFS_ASSERT(!(hasparent && err == LFS_ERR_NOENT));
-
- // if we can't find dir, it must be new
- if (err != LFS_ERR_NOENT) {
- if (lfs_gstate_hasorphans(&lfs->gstate)) {
- // next step, clean up orphans
- err = lfs_fs_preporphans(lfs, -hasparent);
- if (err) {
- return err;
- }
- }
-
- // fix pending move in this pair? this looks like an optimization
- // but is in fact _required_ since relocating may outdate the move.
- uint16_t moveid = 0x3ff;
- if (lfs_gstate_hasmovehere(&lfs->gstate, pdir.pair)) {
- moveid = lfs_tag_id(lfs->gstate.tag);
- LFS_DEBUG("Fixing move while relocating "
- "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
- pdir.pair[0], pdir.pair[1], moveid);
- lfs_fs_prepmove(lfs, 0x3ff, NULL);
- }
-
- // replace bad pair, either we clean up desync, or no desync occured
- lpair[0] = pdir.pair[0];
- lpair[1] = pdir.pair[1];
- lfs_pair_tole32(ldir.pair);
- state = lfs_dir_relocatingcommit(lfs, &pdir, lpair, LFS_MKATTRS(
- {LFS_MKTAG_IF(moveid != 0x3ff,
- LFS_TYPE_DELETE, moveid, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_TAIL + pdir.split, 0x3ff, 8),
- ldir.pair}),
- NULL);
- lfs_pair_fromle32(ldir.pair);
- if (state < 0) {
- return state;
- }
-
- ldir = pdir;
- }
- }
-
- return orphans ? LFS_OK_ORPHANED : 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
- const struct lfs_mattr *attrs, int attrcount) {
- int orphans = lfs_dir_orphaningcommit(lfs, dir, attrs, attrcount);
- if (orphans < 0) {
- return orphans;
- }
-
- if (orphans) {
- // make sure we've removed all orphans, this is a noop if there
- // are none, but if we had nested blocks failures we may have
- // created some
- int err = lfs_fs_deorphan(lfs, false);
- if (err) {
- return err;
- }
- }
-
- return 0;
-}
-#endif
-
-
-/// Top level directory operations ///
-#ifndef LFS_READONLY
-static int lfs_rawmkdir(lfs_t *lfs, const char *path) {
- // deorphan if we haven't yet, needed at most once after poweron
- int err = lfs_fs_forceconsistency(lfs);
- if (err) {
- return err;
- }
-
- struct lfs_mlist cwd;
- cwd.next = lfs->mlist;
- uint16_t id;
- err = lfs_dir_find(lfs, &cwd.m, &path, &id);
- if (!(err == LFS_ERR_NOENT && id != 0x3ff)) {
- return (err < 0) ? err : LFS_ERR_EXIST;
- }
-
- // check that name fits
- lfs_size_t nlen = strlen(path);
- if (nlen > lfs->name_max) {
- return LFS_ERR_NAMETOOLONG;
- }
-
- // build up new directory
- lfs_alloc_ack(lfs);
- lfs_mdir_t dir;
- err = lfs_dir_alloc(lfs, &dir);
- if (err) {
- return err;
- }
-
- // find end of list
- lfs_mdir_t pred = cwd.m;
- while (pred.split) {
- err = lfs_dir_fetch(lfs, &pred, pred.tail);
- if (err) {
- return err;
- }
- }
-
- // setup dir
- lfs_pair_tole32(pred.tail);
- err = lfs_dir_commit(lfs, &dir, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail}));
- lfs_pair_fromle32(pred.tail);
- if (err) {
- return err;
- }
-
- // current block not end of list?
- if (cwd.m.split) {
- // update tails, this creates a desync
- err = lfs_fs_preporphans(lfs, +1);
- if (err) {
- return err;
- }
-
- // it's possible our predecessor has to be relocated, and if
- // our parent is our predecessor's predecessor, this could have
- // caused our parent to go out of date, fortunately we can hook
- // ourselves into littlefs to catch this
- cwd.type = 0;
- cwd.id = 0;
- lfs->mlist = &cwd;
-
- lfs_pair_tole32(dir.pair);
- err = lfs_dir_commit(lfs, &pred, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
- lfs_pair_fromle32(dir.pair);
- if (err) {
- lfs->mlist = cwd.next;
- return err;
- }
-
- lfs->mlist = cwd.next;
- err = lfs_fs_preporphans(lfs, -1);
- if (err) {
- return err;
- }
- }
-
- // now insert into our parent block
- lfs_pair_tole32(dir.pair);
- err = lfs_dir_commit(lfs, &cwd.m, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_CREATE, id, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_DIR, id, nlen), path},
- {LFS_MKTAG(LFS_TYPE_DIRSTRUCT, id, 8), dir.pair},
- {LFS_MKTAG_IF(!cwd.m.split,
- LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
- lfs_pair_fromle32(dir.pair);
- if (err) {
- return err;
- }
-
- return 0;
-}
-#endif
-
-static int lfs_dir_rawopen(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
- lfs_stag_t tag = lfs_dir_find(lfs, &dir->m, &path, NULL);
- if (tag < 0) {
- return tag;
- }
-
- if (lfs_tag_type3(tag) != LFS_TYPE_DIR) {
- return LFS_ERR_NOTDIR;
- }
-
- lfs_block_t pair[2];
- if (lfs_tag_id(tag) == 0x3ff) {
- // handle root dir separately
- pair[0] = lfs->root[0];
- pair[1] = lfs->root[1];
- } else {
- // get dir pair from parent
- lfs_stag_t res = lfs_dir_get(lfs, &dir->m, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), pair);
- if (res < 0) {
- return res;
- }
- lfs_pair_fromle32(pair);
- }
-
- // fetch first pair
- int err = lfs_dir_fetch(lfs, &dir->m, pair);
- if (err) {
- return err;
- }
-
- // setup entry
- dir->head[0] = dir->m.pair[0];
- dir->head[1] = dir->m.pair[1];
- dir->id = 0;
- dir->pos = 0;
-
- // add to list of mdirs
- dir->type = LFS_TYPE_DIR;
- lfs_mlist_append(lfs, (struct lfs_mlist *)dir);
-
- return 0;
-}
-
-static int lfs_dir_rawclose(lfs_t *lfs, lfs_dir_t *dir) {
- // remove from list of mdirs
- lfs_mlist_remove(lfs, (struct lfs_mlist *)dir);
-
- return 0;
-}
-
-static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
- memset(info, 0, sizeof(*info));
-
- // special offset for '.' and '..'
- if (dir->pos == 0) {
- info->type = LFS_TYPE_DIR;
- strcpy(info->name, ".");
- dir->pos += 1;
- return true;
- } else if (dir->pos == 1) {
- info->type = LFS_TYPE_DIR;
- strcpy(info->name, "..");
- dir->pos += 1;
- return true;
- }
-
- while (true) {
- if (dir->id == dir->m.count) {
- if (!dir->m.split) {
- return false;
- }
-
- int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
- if (err) {
- return err;
- }
-
- dir->id = 0;
- }
-
- int err = lfs_dir_getinfo(lfs, &dir->m, dir->id, info);
- if (err && err != LFS_ERR_NOENT) {
- return err;
- }
-
- dir->id += 1;
- if (err != LFS_ERR_NOENT) {
- break;
- }
- }
-
- dir->pos += 1;
- return true;
-}
-
-static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
- // simply walk from head dir
- int err = lfs_dir_rawrewind(lfs, dir);
- if (err) {
- return err;
- }
-
- // first two for ./..
- dir->pos = lfs_min(2, off);
- off -= dir->pos;
-
- // skip superblock entry
- dir->id = (off > 0 && lfs_pair_cmp(dir->head, lfs->root) == 0);
-
- while (off > 0) {
- int diff = lfs_min(dir->m.count - dir->id, off);
- dir->id += diff;
- dir->pos += diff;
- off -= diff;
-
- if (dir->id == dir->m.count) {
- if (!dir->m.split) {
- return LFS_ERR_INVAL;
- }
-
- err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
- if (err) {
- return err;
- }
-
- dir->id = 0;
- }
- }
-
- return 0;
-}
-
-static lfs_soff_t lfs_dir_rawtell(lfs_t *lfs, lfs_dir_t *dir) {
- (void)lfs;
- return dir->pos;
-}
-
-static int lfs_dir_rawrewind(lfs_t *lfs, lfs_dir_t *dir) {
- // reload the head dir
- int err = lfs_dir_fetch(lfs, &dir->m, dir->head);
- if (err) {
- return err;
- }
-
- dir->id = 0;
- dir->pos = 0;
- return 0;
-}
-
-
-/// File index list operations ///
-static int lfs_ctz_index(lfs_t *lfs, lfs_off_t *off) {
- lfs_off_t size = *off;
- lfs_off_t b = lfs->cfg->block_size - 2*4;
- lfs_off_t i = size / b;
- if (i == 0) {
- return 0;
- }
-
- i = (size - 4*(lfs_popc(i-1)+2)) / b;
- *off = size - b*i - 4*lfs_popc(i);
- return i;
-}
-
-static int lfs_ctz_find(lfs_t *lfs,
- const lfs_cache_t *pcache, lfs_cache_t *rcache,
- lfs_block_t head, lfs_size_t size,
- lfs_size_t pos, lfs_block_t *block, lfs_off_t *off) {
- if (size == 0) {
- *block = LFS_BLOCK_NULL;
- *off = 0;
- return 0;
- }
-
- lfs_off_t current = lfs_ctz_index(lfs, &(lfs_off_t){size-1});
- lfs_off_t target = lfs_ctz_index(lfs, &pos);
-
- while (current > target) {
- lfs_size_t skip = lfs_min(
- lfs_npw2(current-target+1) - 1,
- lfs_ctz(current));
-
- int err = lfs_bd_read(lfs,
- pcache, rcache, sizeof(head),
- head, 4*skip, &head, sizeof(head));
- head = lfs_fromle32(head);
- if (err) {
- return err;
- }
-
- current -= 1 << skip;
- }
-
- *block = head;
- *off = pos;
- return 0;
-}
-
-#ifndef LFS_READONLY
-static int lfs_ctz_extend(lfs_t *lfs,
- lfs_cache_t *pcache, lfs_cache_t *rcache,
- lfs_block_t head, lfs_size_t size,
- lfs_block_t *block, lfs_off_t *off) {
- while (true) {
- // go ahead and grab a block
- lfs_block_t nblock;
- int err = lfs_alloc(lfs, &nblock);
- if (err) {
- return err;
- }
-
- {
- err = lfs_bd_erase(lfs, nblock);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- if (size == 0) {
- *block = nblock;
- *off = 0;
- return 0;
- }
-
- lfs_size_t noff = size - 1;
- lfs_off_t index = lfs_ctz_index(lfs, &noff);
- noff = noff + 1;
-
- // just copy out the last block if it is incomplete
- if (noff != lfs->cfg->block_size) {
- for (lfs_off_t i = 0; i < noff; i++) {
- uint8_t data;
- err = lfs_bd_read(lfs,
- NULL, rcache, noff-i,
- head, i, &data, 1);
- if (err) {
- return err;
- }
-
- err = lfs_bd_prog(lfs,
- pcache, rcache, true,
- nblock, i, &data, 1);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
- }
-
- *block = nblock;
- *off = noff;
- return 0;
- }
-
- // append block
- index += 1;
- lfs_size_t skips = lfs_ctz(index) + 1;
- lfs_block_t nhead = head;
- for (lfs_off_t i = 0; i < skips; i++) {
- nhead = lfs_tole32(nhead);
- err = lfs_bd_prog(lfs, pcache, rcache, true,
- nblock, 4*i, &nhead, 4);
- nhead = lfs_fromle32(nhead);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- if (i != skips-1) {
- err = lfs_bd_read(lfs,
- NULL, rcache, sizeof(nhead),
- nhead, 4*i, &nhead, sizeof(nhead));
- nhead = lfs_fromle32(nhead);
- if (err) {
- return err;
- }
- }
- }
-
- *block = nblock;
- *off = 4*skips;
- return 0;
- }
-
-relocate:
- LFS_DEBUG("Bad block at 0x%"PRIx32, nblock);
-
- // just clear cache and try a new block
- lfs_cache_drop(lfs, pcache);
- }
-}
-#endif
-
-static int lfs_ctz_traverse(lfs_t *lfs,
- const lfs_cache_t *pcache, lfs_cache_t *rcache,
- lfs_block_t head, lfs_size_t size,
- int (*cb)(void*, lfs_block_t), void *data) {
- if (size == 0) {
- return 0;
- }
-
- lfs_off_t index = lfs_ctz_index(lfs, &(lfs_off_t){size-1});
-
- while (true) {
- int err = cb(data, head);
- if (err) {
- return err;
- }
-
- if (index == 0) {
- return 0;
- }
-
- lfs_block_t heads[2];
- int count = 2 - (index & 1);
- err = lfs_bd_read(lfs,
- pcache, rcache, count*sizeof(head),
- head, 0, &heads, count*sizeof(head));
- heads[0] = lfs_fromle32(heads[0]);
- heads[1] = lfs_fromle32(heads[1]);
- if (err) {
- return err;
- }
-
- for (int i = 0; i < count-1; i++) {
- err = cb(data, heads[i]);
- if (err) {
- return err;
- }
- }
-
- head = heads[count-1];
- index -= count;
- }
-}
-
-
-/// Top level file operations ///
-static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
- const char *path, int flags,
- const struct lfs_file_config *cfg) {
-#ifndef LFS_READONLY
- // deorphan if we haven't yet, needed at most once after poweron
- if ((flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
- int err = lfs_fs_forceconsistency(lfs);
- if (err) {
- return err;
- }
- }
-#else
- LFS_ASSERT((flags & LFS_O_RDONLY) == LFS_O_RDONLY);
-#endif
-
- // setup simple file details
- int err;
- file->cfg = cfg;
- file->flags = flags;
- file->pos = 0;
- file->off = 0;
- file->cache.buffer = NULL;
-
- // allocate entry for file if it doesn't exist
- lfs_stag_t tag = lfs_dir_find(lfs, &file->m, &path, &file->id);
- if (tag < 0 && !(tag == LFS_ERR_NOENT && file->id != 0x3ff)) {
- err = tag;
- goto cleanup;
- }
-
- // get id, add to list of mdirs to catch update changes
- file->type = LFS_TYPE_REG;
- lfs_mlist_append(lfs, (struct lfs_mlist *)file);
-
-#ifdef LFS_READONLY
- if (tag == LFS_ERR_NOENT) {
- err = LFS_ERR_NOENT;
- goto cleanup;
-#else
- if (tag == LFS_ERR_NOENT) {
- if (!(flags & LFS_O_CREAT)) {
- err = LFS_ERR_NOENT;
- goto cleanup;
- }
-
- // check that name fits
- lfs_size_t nlen = strlen(path);
- if (nlen > lfs->name_max) {
- err = LFS_ERR_NAMETOOLONG;
- goto cleanup;
- }
-
- // get next slot and create entry to remember name
- err = lfs_dir_commit(lfs, &file->m, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_CREATE, file->id, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_REG, file->id, nlen), path},
- {LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0), NULL}));
-
- // it may happen that the file name doesn't fit in the metadata blocks, e.g., a 256 byte file name will
- // not fit in a 128 byte block.
- err = (err == LFS_ERR_NOSPC) ? LFS_ERR_NAMETOOLONG : err;
- if (err) {
- goto cleanup;
- }
-
- tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, 0);
- } else if (flags & LFS_O_EXCL) {
- err = LFS_ERR_EXIST;
- goto cleanup;
-#endif
- } else if (lfs_tag_type3(tag) != LFS_TYPE_REG) {
- err = LFS_ERR_ISDIR;
- goto cleanup;
-#ifndef LFS_READONLY
- } else if (flags & LFS_O_TRUNC) {
- // truncate if requested
- tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0);
- file->flags |= LFS_F_DIRTY;
-#endif
- } else {
- // try to load what's on disk, if it's inlined we'll fix it later
- tag = lfs_dir_get(lfs, &file->m, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, file->id, 8), &file->ctz);
- if (tag < 0) {
- err = tag;
- goto cleanup;
- }
- lfs_ctz_fromle32(&file->ctz);
- }
-
- // fetch attrs
- for (unsigned i = 0; i < file->cfg->attr_count; i++) {
- // if opened for read / read-write operations
- if ((file->flags & LFS_O_RDONLY) == LFS_O_RDONLY) {
- lfs_stag_t res = lfs_dir_get(lfs, &file->m,
- LFS_MKTAG(0x7ff, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_USERATTR + file->cfg->attrs[i].type,
- file->id, file->cfg->attrs[i].size),
- file->cfg->attrs[i].buffer);
- if (res < 0 && res != LFS_ERR_NOENT) {
- err = res;
- goto cleanup;
- }
- }
-
-#ifndef LFS_READONLY
- // if opened for write / read-write operations
- if ((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
- if (file->cfg->attrs[i].size > lfs->attr_max) {
- err = LFS_ERR_NOSPC;
- goto cleanup;
- }
-
- file->flags |= LFS_F_DIRTY;
- }
-#endif
- }
-
- // allocate buffer if needed
- if (file->cfg->buffer) {
- file->cache.buffer = file->cfg->buffer;
- } else {
- file->cache.buffer = lfs_malloc(lfs->cfg->cache_size);
- if (!file->cache.buffer) {
- err = LFS_ERR_NOMEM;
- goto cleanup;
- }
- }
-
- // zero to avoid information leak
- lfs_cache_zero(lfs, &file->cache);
-
- if (lfs_tag_type3(tag) == LFS_TYPE_INLINESTRUCT) {
- // load inline files
- file->ctz.head = LFS_BLOCK_INLINE;
- file->ctz.size = lfs_tag_size(tag);
- file->flags |= LFS_F_INLINE;
- file->cache.block = file->ctz.head;
- file->cache.off = 0;
- file->cache.size = lfs->cfg->cache_size;
-
- // don't always read (may be new/trunc file)
- if (file->ctz.size > 0) {
- lfs_stag_t res = lfs_dir_get(lfs, &file->m,
- LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, file->id,
- lfs_min(file->cache.size, 0x3fe)),
- file->cache.buffer);
- if (res < 0) {
- err = res;
- goto cleanup;
- }
- }
- }
-
- return 0;
-
-cleanup:
- // clean up lingering resources
-#ifndef LFS_READONLY
- file->flags |= LFS_F_ERRED;
-#endif
- lfs_file_rawclose(lfs, file);
- return err;
-}
-
-static int lfs_file_rawopen(lfs_t *lfs, lfs_file_t *file,
- const char *path, int flags) {
- static const struct lfs_file_config defaults = {0};
- int err = lfs_file_rawopencfg(lfs, file, path, flags, &defaults);
- return err;
-}
-
-static int lfs_file_rawclose(lfs_t *lfs, lfs_file_t *file) {
-#ifndef LFS_READONLY
- int err = lfs_file_rawsync(lfs, file);
-#else
- int err = 0;
-#endif
-
- // remove from list of mdirs
- lfs_mlist_remove(lfs, (struct lfs_mlist*)file);
-
- // clean up memory
- if (!file->cfg->buffer) {
- lfs_free(file->cache.buffer);
- }
-
- return err;
-}
-
-
-#ifndef LFS_READONLY
-static int lfs_file_relocate(lfs_t *lfs, lfs_file_t *file) {
- while (true) {
- // just relocate what exists into new block
- lfs_block_t nblock;
- int err = lfs_alloc(lfs, &nblock);
- if (err) {
- return err;
- }
-
- err = lfs_bd_erase(lfs, nblock);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- // either read from dirty cache or disk
- for (lfs_off_t i = 0; i < file->off; i++) {
- uint8_t data;
- if (file->flags & LFS_F_INLINE) {
- err = lfs_dir_getread(lfs, &file->m,
- // note we evict inline files before they can be dirty
- NULL, &file->cache, file->off-i,
- LFS_MKTAG(0xfff, 0x1ff, 0),
- LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0),
- i, &data, 1);
- if (err) {
- return err;
- }
- } else {
- err = lfs_bd_read(lfs,
- &file->cache, &lfs->rcache, file->off-i,
- file->block, i, &data, 1);
- if (err) {
- return err;
- }
- }
-
- err = lfs_bd_prog(lfs,
- &lfs->pcache, &lfs->rcache, true,
- nblock, i, &data, 1);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
- }
-
- // copy over new state of file
- memcpy(file->cache.buffer, lfs->pcache.buffer, lfs->cfg->cache_size);
- file->cache.block = lfs->pcache.block;
- file->cache.off = lfs->pcache.off;
- file->cache.size = lfs->pcache.size;
- lfs_cache_zero(lfs, &lfs->pcache);
-
- file->block = nblock;
- file->flags |= LFS_F_WRITING;
- return 0;
-
-relocate:
- LFS_DEBUG("Bad block at 0x%"PRIx32, nblock);
-
- // just clear cache and try a new block
- lfs_cache_drop(lfs, &lfs->pcache);
- }
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_file_outline(lfs_t *lfs, lfs_file_t *file) {
- file->off = file->pos;
- lfs_alloc_ack(lfs);
- int err = lfs_file_relocate(lfs, file);
- if (err) {
- return err;
- }
-
- file->flags &= ~LFS_F_INLINE;
- return 0;
-}
-#endif
-
-static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file) {
- if (file->flags & LFS_F_READING) {
- if (!(file->flags & LFS_F_INLINE)) {
- lfs_cache_drop(lfs, &file->cache);
- }
- file->flags &= ~LFS_F_READING;
- }
-
-#ifndef LFS_READONLY
- if (file->flags & LFS_F_WRITING) {
- lfs_off_t pos = file->pos;
-
- if (!(file->flags & LFS_F_INLINE)) {
- // copy over anything after current branch
- lfs_file_t orig = {
- .ctz.head = file->ctz.head,
- .ctz.size = file->ctz.size,
- .flags = LFS_O_RDONLY,
- .pos = file->pos,
- .cache = lfs->rcache,
- };
- lfs_cache_drop(lfs, &lfs->rcache);
-
- while (file->pos < file->ctz.size) {
- // copy over a byte at a time, leave it up to caching
- // to make this efficient
- uint8_t data;
- lfs_ssize_t res = lfs_file_flushedread(lfs, &orig, &data, 1);
- if (res < 0) {
- return res;
- }
-
- res = lfs_file_flushedwrite(lfs, file, &data, 1);
- if (res < 0) {
- return res;
- }
-
- // keep our reference to the rcache in sync
- if (lfs->rcache.block != LFS_BLOCK_NULL) {
- lfs_cache_drop(lfs, &orig.cache);
- lfs_cache_drop(lfs, &lfs->rcache);
- }
- }
-
- // write out what we have
- while (true) {
- int err = lfs_bd_flush(lfs, &file->cache, &lfs->rcache, true);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- return err;
- }
-
- break;
-
-relocate:
- LFS_DEBUG("Bad block at 0x%"PRIx32, file->block);
- err = lfs_file_relocate(lfs, file);
- if (err) {
- return err;
- }
- }
- } else {
- file->pos = lfs_max(file->pos, file->ctz.size);
- }
-
- // actual file updates
- file->ctz.head = file->block;
- file->ctz.size = file->pos;
- file->flags &= ~LFS_F_WRITING;
- file->flags |= LFS_F_DIRTY;
-
- file->pos = pos;
- }
-#endif
-
- return 0;
-}
-
-#ifndef LFS_READONLY
-static int lfs_file_rawsync(lfs_t *lfs, lfs_file_t *file) {
- if (file->flags & LFS_F_ERRED) {
- // it's not safe to do anything if our file errored
- return 0;
- }
-
- int err = lfs_file_flush(lfs, file);
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
-
-
- if ((file->flags & LFS_F_DIRTY) &&
- !lfs_pair_isnull(file->m.pair)) {
- // update dir entry
- uint16_t type;
- const void *buffer;
- lfs_size_t size;
- struct lfs_ctz ctz;
- if (file->flags & LFS_F_INLINE) {
- // inline the whole file
- type = LFS_TYPE_INLINESTRUCT;
- buffer = file->cache.buffer;
- size = file->ctz.size;
- } else {
- // update the ctz reference
- type = LFS_TYPE_CTZSTRUCT;
- // copy ctz so alloc will work during a relocate
- ctz = file->ctz;
- lfs_ctz_tole32(&ctz);
- buffer = &ctz;
- size = sizeof(ctz);
- }
-
- // commit file data and attributes
- err = lfs_dir_commit(lfs, &file->m, LFS_MKATTRS(
- {LFS_MKTAG(type, file->id, size), buffer},
- {LFS_MKTAG(LFS_FROM_USERATTRS, file->id,
- file->cfg->attr_count), file->cfg->attrs}));
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
-
- file->flags &= ~LFS_F_DIRTY;
- }
-
- return 0;
-}
-#endif
-
-static lfs_ssize_t lfs_file_flushedread(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size) {
- uint8_t *data = buffer;
- lfs_size_t nsize = size;
-
- if (file->pos >= file->ctz.size) {
- // eof if past end
- return 0;
- }
-
- size = lfs_min(size, file->ctz.size - file->pos);
- nsize = size;
-
- while (nsize > 0) {
- // check if we need a new block
- if (!(file->flags & LFS_F_READING) ||
- file->off == lfs->cfg->block_size) {
- if (!(file->flags & LFS_F_INLINE)) {
- int err = lfs_ctz_find(lfs, NULL, &file->cache,
- file->ctz.head, file->ctz.size,
- file->pos, &file->block, &file->off);
- if (err) {
- return err;
- }
- } else {
- file->block = LFS_BLOCK_INLINE;
- file->off = file->pos;
- }
-
- file->flags |= LFS_F_READING;
- }
-
- // read as much as we can in current block
- lfs_size_t diff = lfs_min(nsize, lfs->cfg->block_size - file->off);
- if (file->flags & LFS_F_INLINE) {
- int err = lfs_dir_getread(lfs, &file->m,
- NULL, &file->cache, lfs->cfg->block_size,
- LFS_MKTAG(0xfff, 0x1ff, 0),
- LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0),
- file->off, data, diff);
- if (err) {
- return err;
- }
- } else {
- int err = lfs_bd_read(lfs,
- NULL, &file->cache, lfs->cfg->block_size,
- file->block, file->off, data, diff);
- if (err) {
- return err;
- }
- }
-
- file->pos += diff;
- file->off += diff;
- data += diff;
- nsize -= diff;
- }
-
- return size;
-}
-
-static lfs_ssize_t lfs_file_rawread(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size) {
- LFS_ASSERT((file->flags & LFS_O_RDONLY) == LFS_O_RDONLY);
-
-#ifndef LFS_READONLY
- if (file->flags & LFS_F_WRITING) {
- // flush out any writes
- int err = lfs_file_flush(lfs, file);
- if (err) {
- return err;
- }
- }
-#endif
-
- return lfs_file_flushedread(lfs, file, buffer, size);
-}
-
-
-#ifndef LFS_READONLY
-static lfs_ssize_t lfs_file_flushedwrite(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size) {
- const uint8_t *data = buffer;
- lfs_size_t nsize = size;
-
- if ((file->flags & LFS_F_INLINE) &&
- lfs_max(file->pos+nsize, file->ctz.size) >
- lfs_min(0x3fe, lfs_min(
- lfs->cfg->cache_size,
- (lfs->cfg->metadata_max ?
- lfs->cfg->metadata_max : lfs->cfg->block_size) / 8))) {
- // inline file doesn't fit anymore
- int err = lfs_file_outline(lfs, file);
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
- }
-
- while (nsize > 0) {
- // check if we need a new block
- if (!(file->flags & LFS_F_WRITING) ||
- file->off == lfs->cfg->block_size) {
- if (!(file->flags & LFS_F_INLINE)) {
- if (!(file->flags & LFS_F_WRITING) && file->pos > 0) {
- // find out which block we're extending from
- int err = lfs_ctz_find(lfs, NULL, &file->cache,
- file->ctz.head, file->ctz.size,
- file->pos-1, &file->block, &file->off);
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
-
- // mark cache as dirty since we may have read data into it
- lfs_cache_zero(lfs, &file->cache);
- }
-
- // extend file with new blocks
- lfs_alloc_ack(lfs);
- int err = lfs_ctz_extend(lfs, &file->cache, &lfs->rcache,
- file->block, file->pos,
- &file->block, &file->off);
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
- } else {
- file->block = LFS_BLOCK_INLINE;
- file->off = file->pos;
- }
-
- file->flags |= LFS_F_WRITING;
- }
-
- // program as much as we can in current block
- lfs_size_t diff = lfs_min(nsize, lfs->cfg->block_size - file->off);
- while (true) {
- int err = lfs_bd_prog(lfs, &file->cache, &lfs->rcache, true,
- file->block, file->off, data, diff);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- goto relocate;
- }
- file->flags |= LFS_F_ERRED;
- return err;
- }
-
- break;
-relocate:
- err = lfs_file_relocate(lfs, file);
- if (err) {
- file->flags |= LFS_F_ERRED;
- return err;
- }
- }
-
- file->pos += diff;
- file->off += diff;
- data += diff;
- nsize -= diff;
-
- lfs_alloc_ack(lfs);
- }
-
- return size;
-}
-
-static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size) {
- LFS_ASSERT((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY);
-
- if (file->flags & LFS_F_READING) {
- // drop any reads
- int err = lfs_file_flush(lfs, file);
- if (err) {
- return err;
- }
- }
-
- if ((file->flags & LFS_O_APPEND) && file->pos < file->ctz.size) {
- file->pos = file->ctz.size;
- }
-
- if (file->pos + size > lfs->file_max) {
- // Larger than file limit?
- return LFS_ERR_FBIG;
- }
-
- if (!(file->flags & LFS_F_WRITING) && file->pos > file->ctz.size) {
- // fill with zeros
- lfs_off_t pos = file->pos;
- file->pos = file->ctz.size;
-
- while (file->pos < pos) {
- lfs_ssize_t res = lfs_file_flushedwrite(lfs, file, &(uint8_t){0}, 1);
- if (res < 0) {
- return res;
- }
- }
- }
-
- lfs_ssize_t nsize = lfs_file_flushedwrite(lfs, file, buffer, size);
- if (nsize < 0) {
- return nsize;
- }
-
- file->flags &= ~LFS_F_ERRED;
- return nsize;
-}
-#endif
-
-static lfs_soff_t lfs_file_rawseek(lfs_t *lfs, lfs_file_t *file,
- lfs_soff_t off, int whence) {
- // find new pos
- lfs_off_t npos = file->pos;
- if (whence == LFS_SEEK_SET) {
- npos = off;
- } else if (whence == LFS_SEEK_CUR) {
- if ((lfs_soff_t)file->pos + off < 0) {
- return LFS_ERR_INVAL;
- } else {
- npos = file->pos + off;
- }
- } else if (whence == LFS_SEEK_END) {
- lfs_soff_t res = lfs_file_rawsize(lfs, file) + off;
- if (res < 0) {
- return LFS_ERR_INVAL;
- } else {
- npos = res;
- }
- }
-
- if (npos > lfs->file_max) {
- // file position out of range
- return LFS_ERR_INVAL;
- }
-
- if (file->pos == npos) {
- // noop - position has not changed
- return npos;
- }
-
- // if we're only reading and our new offset is still in the file's cache
- // we can avoid flushing and needing to reread the data
- if (
-#ifndef LFS_READONLY
- !(file->flags & LFS_F_WRITING)
-#else
- true
-#endif
- ) {
- int oindex = lfs_ctz_index(lfs, &(lfs_off_t){file->pos});
- lfs_off_t noff = npos;
- int nindex = lfs_ctz_index(lfs, &noff);
- if (oindex == nindex
- && noff >= file->cache.off
- && noff < file->cache.off + file->cache.size) {
- file->pos = npos;
- file->off = noff;
- return npos;
- }
- }
-
- // write out everything beforehand, may be noop if rdonly
- int err = lfs_file_flush(lfs, file);
- if (err) {
- return err;
- }
-
- // update pos
- file->pos = npos;
- return npos;
-}
-
-#ifndef LFS_READONLY
-static int lfs_file_rawtruncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
- LFS_ASSERT((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY);
-
- if (size > LFS_FILE_MAX) {
- return LFS_ERR_INVAL;
- }
-
- lfs_off_t pos = file->pos;
- lfs_off_t oldsize = lfs_file_rawsize(lfs, file);
- if (size < oldsize) {
- // need to flush since directly changing metadata
- int err = lfs_file_flush(lfs, file);
- if (err) {
- return err;
- }
-
- // lookup new head in ctz skip list
- err = lfs_ctz_find(lfs, NULL, &file->cache,
- file->ctz.head, file->ctz.size,
- size, &file->block, &file->off);
- if (err) {
- return err;
- }
-
- // need to set pos/block/off consistently so seeking back to
- // the old position does not get confused
- file->pos = size;
- file->ctz.head = file->block;
- file->ctz.size = size;
- file->flags |= LFS_F_DIRTY | LFS_F_READING;
- } else if (size > oldsize) {
- // flush+seek if not already at end
- lfs_soff_t res = lfs_file_rawseek(lfs, file, 0, LFS_SEEK_END);
- if (res < 0) {
- return (int)res;
- }
-
- // fill with zeros
- while (file->pos < size) {
- res = lfs_file_rawwrite(lfs, file, &(uint8_t){0}, 1);
- if (res < 0) {
- return (int)res;
- }
- }
- }
-
- // restore pos
- lfs_soff_t res = lfs_file_rawseek(lfs, file, pos, LFS_SEEK_SET);
- if (res < 0) {
- return (int)res;
- }
-
- return 0;
-}
-#endif
-
-static lfs_soff_t lfs_file_rawtell(lfs_t *lfs, lfs_file_t *file) {
- (void)lfs;
- return file->pos;
-}
-
-static int lfs_file_rawrewind(lfs_t *lfs, lfs_file_t *file) {
- lfs_soff_t res = lfs_file_rawseek(lfs, file, 0, LFS_SEEK_SET);
- if (res < 0) {
- return (int)res;
- }
-
- return 0;
-}
-
-static lfs_soff_t lfs_file_rawsize(lfs_t *lfs, lfs_file_t *file) {
- (void)lfs;
-
-#ifndef LFS_READONLY
- if (file->flags & LFS_F_WRITING) {
- return lfs_max(file->pos, file->ctz.size);
- }
-#endif
-
- return file->ctz.size;
-}
-
-
-/// General fs operations ///
-static int lfs_rawstat(lfs_t *lfs, const char *path, struct lfs_info *info) {
- lfs_mdir_t cwd;
- lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL);
- if (tag < 0) {
- return (int)tag;
- }
-
- return lfs_dir_getinfo(lfs, &cwd, lfs_tag_id(tag), info);
-}
-
-#ifndef LFS_READONLY
-static int lfs_rawremove(lfs_t *lfs, const char *path) {
- // deorphan if we haven't yet, needed at most once after poweron
- int err = lfs_fs_forceconsistency(lfs);
- if (err) {
- return err;
- }
-
- lfs_mdir_t cwd;
- lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL);
- if (tag < 0 || lfs_tag_id(tag) == 0x3ff) {
- return (tag < 0) ? (int)tag : LFS_ERR_INVAL;
- }
-
- struct lfs_mlist dir;
- dir.next = lfs->mlist;
- if (lfs_tag_type3(tag) == LFS_TYPE_DIR) {
- // must be empty before removal
- lfs_block_t pair[2];
- lfs_stag_t res = lfs_dir_get(lfs, &cwd, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), pair);
- if (res < 0) {
- return (int)res;
- }
- lfs_pair_fromle32(pair);
-
- err = lfs_dir_fetch(lfs, &dir.m, pair);
- if (err) {
- return err;
- }
-
- if (dir.m.count > 0 || dir.m.split) {
- return LFS_ERR_NOTEMPTY;
- }
-
- // mark fs as orphaned
- err = lfs_fs_preporphans(lfs, +1);
- if (err) {
- return err;
- }
-
- // I know it's crazy but yes, dir can be changed by our parent's
- // commit (if predecessor is child)
- dir.type = 0;
- dir.id = 0;
- lfs->mlist = &dir;
- }
-
- // delete the entry
- err = lfs_dir_commit(lfs, &cwd, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_DELETE, lfs_tag_id(tag), 0), NULL}));
- if (err) {
- lfs->mlist = dir.next;
- return err;
- }
-
- lfs->mlist = dir.next;
- if (lfs_tag_type3(tag) == LFS_TYPE_DIR) {
- // fix orphan
- err = lfs_fs_preporphans(lfs, -1);
- if (err) {
- return err;
- }
-
- err = lfs_fs_pred(lfs, dir.m.pair, &cwd);
- if (err) {
- return err;
- }
-
- err = lfs_dir_drop(lfs, &cwd, &dir.m);
- if (err) {
- return err;
- }
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_rawrename(lfs_t *lfs, const char *oldpath, const char *newpath) {
- // deorphan if we haven't yet, needed at most once after poweron
- int err = lfs_fs_forceconsistency(lfs);
- if (err) {
- return err;
- }
-
- // find old entry
- lfs_mdir_t oldcwd;
- lfs_stag_t oldtag = lfs_dir_find(lfs, &oldcwd, &oldpath, NULL);
- if (oldtag < 0 || lfs_tag_id(oldtag) == 0x3ff) {
- return (oldtag < 0) ? (int)oldtag : LFS_ERR_INVAL;
- }
-
- // find new entry
- lfs_mdir_t newcwd;
- uint16_t newid;
- lfs_stag_t prevtag = lfs_dir_find(lfs, &newcwd, &newpath, &newid);
- if ((prevtag < 0 || lfs_tag_id(prevtag) == 0x3ff) &&
- !(prevtag == LFS_ERR_NOENT && newid != 0x3ff)) {
- return (prevtag < 0) ? (int)prevtag : LFS_ERR_INVAL;
- }
-
- // if we're in the same pair there's a few special cases...
- bool samepair = (lfs_pair_cmp(oldcwd.pair, newcwd.pair) == 0);
- uint16_t newoldid = lfs_tag_id(oldtag);
-
- struct lfs_mlist prevdir;
- prevdir.next = lfs->mlist;
- if (prevtag == LFS_ERR_NOENT) {
- // check that name fits
- lfs_size_t nlen = strlen(newpath);
- if (nlen > lfs->name_max) {
- return LFS_ERR_NAMETOOLONG;
- }
-
- // there is a small chance we are being renamed in the same
- // directory/ to an id less than our old id, the global update
- // to handle this is a bit messy
- if (samepair && newid <= newoldid) {
- newoldid += 1;
- }
- } else if (lfs_tag_type3(prevtag) != lfs_tag_type3(oldtag)) {
- return LFS_ERR_ISDIR;
- } else if (samepair && newid == newoldid) {
- // we're renaming to ourselves??
- return 0;
- } else if (lfs_tag_type3(prevtag) == LFS_TYPE_DIR) {
- // must be empty before removal
- lfs_block_t prevpair[2];
- lfs_stag_t res = lfs_dir_get(lfs, &newcwd, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, newid, 8), prevpair);
- if (res < 0) {
- return (int)res;
- }
- lfs_pair_fromle32(prevpair);
-
- // must be empty before removal
- err = lfs_dir_fetch(lfs, &prevdir.m, prevpair);
- if (err) {
- return err;
- }
-
- if (prevdir.m.count > 0 || prevdir.m.split) {
- return LFS_ERR_NOTEMPTY;
- }
-
- // mark fs as orphaned
- err = lfs_fs_preporphans(lfs, +1);
- if (err) {
- return err;
- }
-
- // I know it's crazy but yes, dir can be changed by our parent's
- // commit (if predecessor is child)
- prevdir.type = 0;
- prevdir.id = 0;
- lfs->mlist = &prevdir;
- }
-
- if (!samepair) {
- lfs_fs_prepmove(lfs, newoldid, oldcwd.pair);
- }
-
- // move over all attributes
- err = lfs_dir_commit(lfs, &newcwd, LFS_MKATTRS(
- {LFS_MKTAG_IF(prevtag != LFS_ERR_NOENT,
- LFS_TYPE_DELETE, newid, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_CREATE, newid, 0), NULL},
- {LFS_MKTAG(lfs_tag_type3(oldtag), newid, strlen(newpath)), newpath},
- {LFS_MKTAG(LFS_FROM_MOVE, newid, lfs_tag_id(oldtag)), &oldcwd},
- {LFS_MKTAG_IF(samepair,
- LFS_TYPE_DELETE, newoldid, 0), NULL}));
- if (err) {
- lfs->mlist = prevdir.next;
- return err;
- }
-
- // let commit clean up after move (if we're different! otherwise move
- // logic already fixed it for us)
- if (!samepair && lfs_gstate_hasmove(&lfs->gstate)) {
- // prep gstate and delete move id
- lfs_fs_prepmove(lfs, 0x3ff, NULL);
- err = lfs_dir_commit(lfs, &oldcwd, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_DELETE, lfs_tag_id(oldtag), 0), NULL}));
- if (err) {
- lfs->mlist = prevdir.next;
- return err;
- }
- }
-
- lfs->mlist = prevdir.next;
- if (prevtag != LFS_ERR_NOENT
- && lfs_tag_type3(prevtag) == LFS_TYPE_DIR) {
- // fix orphan
- err = lfs_fs_preporphans(lfs, -1);
- if (err) {
- return err;
- }
-
- err = lfs_fs_pred(lfs, prevdir.m.pair, &newcwd);
- if (err) {
- return err;
- }
-
- err = lfs_dir_drop(lfs, &newcwd, &prevdir.m);
- if (err) {
- return err;
- }
- }
-
- return 0;
-}
-#endif
-
-static lfs_ssize_t lfs_rawgetattr(lfs_t *lfs, const char *path,
- uint8_t type, void *buffer, lfs_size_t size) {
- lfs_mdir_t cwd;
- lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL);
- if (tag < 0) {
- return tag;
- }
-
- uint16_t id = lfs_tag_id(tag);
- if (id == 0x3ff) {
- // special case for root
- id = 0;
- int err = lfs_dir_fetch(lfs, &cwd, lfs->root);
- if (err) {
- return err;
- }
- }
-
- tag = lfs_dir_get(lfs, &cwd, LFS_MKTAG(0x7ff, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_USERATTR + type,
- id, lfs_min(size, lfs->attr_max)),
- buffer);
- if (tag < 0) {
- if (tag == LFS_ERR_NOENT) {
- return LFS_ERR_NOATTR;
- }
-
- return tag;
- }
-
- return lfs_tag_size(tag);
-}
-
-#ifndef LFS_READONLY
-static int lfs_commitattr(lfs_t *lfs, const char *path,
- uint8_t type, const void *buffer, lfs_size_t size) {
- lfs_mdir_t cwd;
- lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL);
- if (tag < 0) {
- return tag;
- }
-
- uint16_t id = lfs_tag_id(tag);
- if (id == 0x3ff) {
- // special case for root
- id = 0;
- int err = lfs_dir_fetch(lfs, &cwd, lfs->root);
- if (err) {
- return err;
- }
- }
-
- return lfs_dir_commit(lfs, &cwd, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_USERATTR + type, id, size), buffer}));
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_rawsetattr(lfs_t *lfs, const char *path,
- uint8_t type, const void *buffer, lfs_size_t size) {
- if (size > lfs->attr_max) {
- return LFS_ERR_NOSPC;
- }
-
- return lfs_commitattr(lfs, path, type, buffer, size);
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_rawremoveattr(lfs_t *lfs, const char *path, uint8_t type) {
- return lfs_commitattr(lfs, path, type, NULL, 0x3ff);
-}
-#endif
-
-
-/// Filesystem operations ///
-static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
- lfs->cfg = cfg;
- int err = 0;
-
- // validate that the lfs-cfg sizes were initiated properly before
- // performing any arithmetic logics with them
- LFS_ASSERT(lfs->cfg->read_size != 0);
- LFS_ASSERT(lfs->cfg->prog_size != 0);
- LFS_ASSERT(lfs->cfg->cache_size != 0);
-
- // check that block size is a multiple of cache size is a multiple
- // of prog and read sizes
- LFS_ASSERT(lfs->cfg->cache_size % lfs->cfg->read_size == 0);
- LFS_ASSERT(lfs->cfg->cache_size % lfs->cfg->prog_size == 0);
- LFS_ASSERT(lfs->cfg->block_size % lfs->cfg->cache_size == 0);
-
- // check that the block size is large enough to fit ctz pointers
- LFS_ASSERT(4*lfs_npw2(0xffffffff / (lfs->cfg->block_size-2*4))
- <= lfs->cfg->block_size);
-
- // block_cycles = 0 is no longer supported.
- //
- // block_cycles is the number of erase cycles before littlefs evicts
- // metadata logs as a part of wear leveling. Suggested values are in the
- // range of 100-1000, or set block_cycles to -1 to disable block-level
- // wear-leveling.
- LFS_ASSERT(lfs->cfg->block_cycles != 0);
-
-
- // setup read cache
- if (lfs->cfg->read_buffer) {
- lfs->rcache.buffer = lfs->cfg->read_buffer;
- } else {
- lfs->rcache.buffer = lfs_malloc(lfs->cfg->cache_size);
- if (!lfs->rcache.buffer) {
- err = LFS_ERR_NOMEM;
- goto cleanup;
- }
- }
-
- // setup program cache
- if (lfs->cfg->prog_buffer) {
- lfs->pcache.buffer = lfs->cfg->prog_buffer;
- } else {
- lfs->pcache.buffer = lfs_malloc(lfs->cfg->cache_size);
- if (!lfs->pcache.buffer) {
- err = LFS_ERR_NOMEM;
- goto cleanup;
- }
- }
-
- // zero to avoid information leaks
- lfs_cache_zero(lfs, &lfs->rcache);
- lfs_cache_zero(lfs, &lfs->pcache);
-
- // setup lookahead, must be multiple of 64-bits, 32-bit aligned
- LFS_ASSERT(lfs->cfg->lookahead_size > 0);
- LFS_ASSERT(lfs->cfg->lookahead_size % 8 == 0 &&
- (uintptr_t)lfs->cfg->lookahead_buffer % 4 == 0);
- if (lfs->cfg->lookahead_buffer) {
- lfs->free.buffer = lfs->cfg->lookahead_buffer;
- } else {
- lfs->free.buffer = lfs_malloc(lfs->cfg->lookahead_size);
- if (!lfs->free.buffer) {
- err = LFS_ERR_NOMEM;
- goto cleanup;
- }
- }
-
- // check that the size limits are sane
- LFS_ASSERT(lfs->cfg->name_max <= LFS_NAME_MAX);
- lfs->name_max = lfs->cfg->name_max;
- if (!lfs->name_max) {
- lfs->name_max = LFS_NAME_MAX;
- }
-
- LFS_ASSERT(lfs->cfg->file_max <= LFS_FILE_MAX);
- lfs->file_max = lfs->cfg->file_max;
- if (!lfs->file_max) {
- lfs->file_max = LFS_FILE_MAX;
- }
-
- LFS_ASSERT(lfs->cfg->attr_max <= LFS_ATTR_MAX);
- lfs->attr_max = lfs->cfg->attr_max;
- if (!lfs->attr_max) {
- lfs->attr_max = LFS_ATTR_MAX;
- }
-
- LFS_ASSERT(lfs->cfg->metadata_max <= lfs->cfg->block_size);
-
- // setup default state
- lfs->root[0] = LFS_BLOCK_NULL;
- lfs->root[1] = LFS_BLOCK_NULL;
- lfs->mlist = NULL;
- lfs->seed = 0;
- lfs->gdisk = (lfs_gstate_t){0};
- lfs->gstate = (lfs_gstate_t){0};
- lfs->gdelta = (lfs_gstate_t){0};
-#ifdef LFS_MIGRATE
- lfs->lfs1 = NULL;
-#endif
-
- return 0;
-
-cleanup:
- lfs_deinit(lfs);
- return err;
-}
-
-static int lfs_deinit(lfs_t *lfs) {
- // free allocated memory
- if (!lfs->cfg->read_buffer) {
- lfs_free(lfs->rcache.buffer);
- }
-
- if (!lfs->cfg->prog_buffer) {
- lfs_free(lfs->pcache.buffer);
- }
-
- if (!lfs->cfg->lookahead_buffer) {
- lfs_free(lfs->free.buffer);
- }
-
- return 0;
-}
-
-#ifndef LFS_READONLY
-static int lfs_rawformat(lfs_t *lfs, const struct lfs_config *cfg) {
- int err = 0;
- {
- err = lfs_init(lfs, cfg);
- if (err) {
- return err;
- }
-
- // create free lookahead
- memset(lfs->free.buffer, 0, lfs->cfg->lookahead_size);
- lfs->free.off = 0;
- lfs->free.size = lfs_min(8*lfs->cfg->lookahead_size,
- lfs->cfg->block_count);
- lfs->free.i = 0;
- lfs_alloc_ack(lfs);
-
- // create root dir
- lfs_mdir_t root;
- err = lfs_dir_alloc(lfs, &root);
- if (err) {
- goto cleanup;
- }
-
- // write one superblock
- lfs_superblock_t superblock = {
- .version = LFS_DISK_VERSION,
- .block_size = lfs->cfg->block_size,
- .block_count = lfs->cfg->block_count,
- .name_max = lfs->name_max,
- .file_max = lfs->file_max,
- .attr_max = lfs->attr_max,
- };
-
- lfs_superblock_tole32(&superblock);
- err = lfs_dir_commit(lfs, &root, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_CREATE, 0, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
- {LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
- &superblock}));
- if (err) {
- goto cleanup;
- }
-
- // force compaction to prevent accidentally mounting any
- // older version of littlefs that may live on disk
- root.erased = false;
- err = lfs_dir_commit(lfs, &root, NULL, 0);
- if (err) {
- goto cleanup;
- }
-
- // sanity check that fetch works
- err = lfs_dir_fetch(lfs, &root, (const lfs_block_t[2]){0, 1});
- if (err) {
- goto cleanup;
- }
- }
-
-cleanup:
- lfs_deinit(lfs);
- return err;
-
-}
-#endif
-
-static int lfs_rawmount(lfs_t *lfs, const struct lfs_config *cfg) {
- int err = lfs_init(lfs, cfg);
- if (err) {
- return err;
- }
-
- // scan directory blocks for superblock and any global updates
- lfs_mdir_t dir = {.tail = {0, 1}};
- lfs_block_t cycle = 0;
- while (!lfs_pair_isnull(dir.tail)) {
- if (cycle >= lfs->cfg->block_count/2) {
- // loop detected
- err = LFS_ERR_CORRUPT;
- goto cleanup;
- }
- cycle += 1;
-
- // fetch next block in tail list
- lfs_stag_t tag = lfs_dir_fetchmatch(lfs, &dir, dir.tail,
- LFS_MKTAG(0x7ff, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_SUPERBLOCK, 0, 8),
- NULL,
- lfs_dir_find_match, &(struct lfs_dir_find_match){
- lfs, "littlefs", 8});
- if (tag < 0) {
- err = tag;
- goto cleanup;
- }
-
- // has superblock?
- if (tag && !lfs_tag_isdelete(tag)) {
- // update root
- lfs->root[0] = dir.pair[0];
- lfs->root[1] = dir.pair[1];
-
- // grab superblock
- lfs_superblock_t superblock;
- tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x7ff, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
- &superblock);
- if (tag < 0) {
- err = tag;
- goto cleanup;
- }
- lfs_superblock_fromle32(&superblock);
-
- // check version
- uint16_t major_version = (0xffff & (superblock.version >> 16));
- uint16_t minor_version = (0xffff & (superblock.version >> 0));
- if ((major_version != LFS_DISK_VERSION_MAJOR ||
- minor_version > LFS_DISK_VERSION_MINOR)) {
- LFS_ERROR("Invalid version v%"PRIu16".%"PRIu16,
- major_version, minor_version);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- // check superblock configuration
- if (superblock.name_max) {
- if (superblock.name_max > lfs->name_max) {
- LFS_ERROR("Unsupported name_max (%"PRIu32" > %"PRIu32")",
- superblock.name_max, lfs->name_max);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- lfs->name_max = superblock.name_max;
- }
-
- if (superblock.file_max) {
- if (superblock.file_max > lfs->file_max) {
- LFS_ERROR("Unsupported file_max (%"PRIu32" > %"PRIu32")",
- superblock.file_max, lfs->file_max);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- lfs->file_max = superblock.file_max;
- }
-
- if (superblock.attr_max) {
- if (superblock.attr_max > lfs->attr_max) {
- LFS_ERROR("Unsupported attr_max (%"PRIu32" > %"PRIu32")",
- superblock.attr_max, lfs->attr_max);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- lfs->attr_max = superblock.attr_max;
- }
-
- if (superblock.block_count != lfs->cfg->block_count) {
- LFS_ERROR("Invalid block count (%"PRIu32" != %"PRIu32")",
- superblock.block_count, lfs->cfg->block_count);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- if (superblock.block_size != lfs->cfg->block_size) {
- LFS_ERROR("Invalid block size (%"PRIu32" != %"PRIu32")",
- superblock.block_count, lfs->cfg->block_count);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
- }
-
- // has gstate?
- err = lfs_dir_getgstate(lfs, &dir, &lfs->gstate);
- if (err) {
- goto cleanup;
- }
- }
-
- // found superblock?
- if (lfs_pair_isnull(lfs->root)) {
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- // update littlefs with gstate
- if (!lfs_gstate_iszero(&lfs->gstate)) {
- LFS_DEBUG("Found pending gstate 0x%08"PRIx32"%08"PRIx32"%08"PRIx32,
- lfs->gstate.tag,
- lfs->gstate.pair[0],
- lfs->gstate.pair[1]);
- }
- lfs->gstate.tag += !lfs_tag_isvalid(lfs->gstate.tag);
- lfs->gdisk = lfs->gstate;
-
- // setup free lookahead, to distribute allocations uniformly across
- // boots, we start the allocator at a random location
- lfs->free.off = lfs->seed % lfs->cfg->block_count;
- lfs_alloc_drop(lfs);
-
- return 0;
-
-cleanup:
- lfs_rawunmount(lfs);
- return err;
-}
-
-static int lfs_rawunmount(lfs_t *lfs) {
- return lfs_deinit(lfs);
-}
-
-
-/// Filesystem filesystem operations ///
-int lfs_fs_rawtraverse(lfs_t *lfs,
- int (*cb)(void *data, lfs_block_t block), void *data,
- bool includeorphans) {
- // iterate over metadata pairs
- lfs_mdir_t dir = {.tail = {0, 1}};
-
-#ifdef LFS_MIGRATE
- // also consider v1 blocks during migration
- if (lfs->lfs1) {
- int err = lfs1_traverse(lfs, cb, data);
- if (err) {
- return err;
- }
-
- dir.tail[0] = lfs->root[0];
- dir.tail[1] = lfs->root[1];
- }
-#endif
-
- lfs_block_t cycle = 0;
- while (!lfs_pair_isnull(dir.tail)) {
- if (cycle >= lfs->cfg->block_count/2) {
- // loop detected
- return LFS_ERR_CORRUPT;
- }
- cycle += 1;
-
- for (int i = 0; i < 2; i++) {
- int err = cb(data, dir.tail[i]);
- if (err) {
- return err;
- }
- }
-
- // iterate through ids in directory
- int err = lfs_dir_fetch(lfs, &dir, dir.tail);
- if (err) {
- return err;
- }
-
- for (uint16_t id = 0; id < dir.count; id++) {
- struct lfs_ctz ctz;
- lfs_stag_t tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x700, 0x3ff, 0),
- LFS_MKTAG(LFS_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
- if (tag < 0) {
- if (tag == LFS_ERR_NOENT) {
- continue;
- }
- return tag;
- }
- lfs_ctz_fromle32(&ctz);
-
- if (lfs_tag_type3(tag) == LFS_TYPE_CTZSTRUCT) {
- err = lfs_ctz_traverse(lfs, NULL, &lfs->rcache,
- ctz.head, ctz.size, cb, data);
- if (err) {
- return err;
- }
- } else if (includeorphans &&
- lfs_tag_type3(tag) == LFS_TYPE_DIRSTRUCT) {
- for (int i = 0; i < 2; i++) {
- err = cb(data, (&ctz.head)[i]);
- if (err) {
- return err;
- }
- }
- }
- }
- }
-
-#ifndef LFS_READONLY
- // iterate over any open files
- for (lfs_file_t *f = (lfs_file_t*)lfs->mlist; f; f = f->next) {
- if (f->type != LFS_TYPE_REG) {
- continue;
- }
-
- if ((f->flags & LFS_F_DIRTY) && !(f->flags & LFS_F_INLINE)) {
- int err = lfs_ctz_traverse(lfs, &f->cache, &lfs->rcache,
- f->ctz.head, f->ctz.size, cb, data);
- if (err) {
- return err;
- }
- }
-
- if ((f->flags & LFS_F_WRITING) && !(f->flags & LFS_F_INLINE)) {
- int err = lfs_ctz_traverse(lfs, &f->cache, &lfs->rcache,
- f->block, f->pos, cb, data);
- if (err) {
- return err;
- }
- }
- }
-#endif
-
- return 0;
-}
-
-#ifndef LFS_READONLY
-static int lfs_fs_pred(lfs_t *lfs,
- const lfs_block_t pair[2], lfs_mdir_t *pdir) {
- // iterate over all directory directory entries
- pdir->tail[0] = 0;
- pdir->tail[1] = 1;
- lfs_block_t cycle = 0;
- while (!lfs_pair_isnull(pdir->tail)) {
- if (cycle >= lfs->cfg->block_count/2) {
- // loop detected
- return LFS_ERR_CORRUPT;
- }
- cycle += 1;
-
- if (lfs_pair_cmp(pdir->tail, pair) == 0) {
- return 0;
- }
-
- int err = lfs_dir_fetch(lfs, pdir, pdir->tail);
- if (err) {
- return err;
- }
- }
-
- return LFS_ERR_NOENT;
-}
-#endif
-
-#ifndef LFS_READONLY
-struct lfs_fs_parent_match {
- lfs_t *lfs;
- const lfs_block_t pair[2];
-};
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_fs_parent_match(void *data,
- lfs_tag_t tag, const void *buffer) {
- struct lfs_fs_parent_match *find = data;
- lfs_t *lfs = find->lfs;
- const struct lfs_diskoff *disk = buffer;
- (void)tag;
-
- lfs_block_t child[2];
- int err = lfs_bd_read(lfs,
- &lfs->pcache, &lfs->rcache, lfs->cfg->block_size,
- disk->block, disk->off, &child, sizeof(child));
- if (err) {
- return err;
- }
-
- lfs_pair_fromle32(child);
- return (lfs_pair_cmp(child, find->pair) == 0) ? LFS_CMP_EQ : LFS_CMP_LT;
-}
-#endif
-
-#ifndef LFS_READONLY
-static lfs_stag_t lfs_fs_parent(lfs_t *lfs, const lfs_block_t pair[2],
- lfs_mdir_t *parent) {
- // use fetchmatch with callback to find pairs
- parent->tail[0] = 0;
- parent->tail[1] = 1;
- lfs_block_t cycle = 0;
- while (!lfs_pair_isnull(parent->tail)) {
- if (cycle >= lfs->cfg->block_count/2) {
- // loop detected
- return LFS_ERR_CORRUPT;
- }
- cycle += 1;
-
- lfs_stag_t tag = lfs_dir_fetchmatch(lfs, parent, parent->tail,
- LFS_MKTAG(0x7ff, 0, 0x3ff),
- LFS_MKTAG(LFS_TYPE_DIRSTRUCT, 0, 8),
- NULL,
- lfs_fs_parent_match, &(struct lfs_fs_parent_match){
- lfs, {pair[0], pair[1]}});
- if (tag && tag != LFS_ERR_NOENT) {
- return tag;
- }
- }
-
- return LFS_ERR_NOENT;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_fs_preporphans(lfs_t *lfs, int8_t orphans) {
- LFS_ASSERT(lfs_tag_size(lfs->gstate.tag) > 0 || orphans >= 0);
- lfs->gstate.tag += orphans;
- lfs->gstate.tag = ((lfs->gstate.tag & ~LFS_MKTAG(0x800, 0, 0)) |
- ((uint32_t)lfs_gstate_hasorphans(&lfs->gstate) << 31));
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static void lfs_fs_prepmove(lfs_t *lfs,
- uint16_t id, const lfs_block_t pair[2]) {
- lfs->gstate.tag = ((lfs->gstate.tag & ~LFS_MKTAG(0x7ff, 0x3ff, 0)) |
- ((id != 0x3ff) ? LFS_MKTAG(LFS_TYPE_DELETE, id, 0) : 0));
- lfs->gstate.pair[0] = (id != 0x3ff) ? pair[0] : 0;
- lfs->gstate.pair[1] = (id != 0x3ff) ? pair[1] : 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_fs_demove(lfs_t *lfs) {
- if (!lfs_gstate_hasmove(&lfs->gdisk)) {
- return 0;
- }
-
- // Fix bad moves
- LFS_DEBUG("Fixing move {0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16,
- lfs->gdisk.pair[0],
- lfs->gdisk.pair[1],
- lfs_tag_id(lfs->gdisk.tag));
-
- // fetch and delete the moved entry
- lfs_mdir_t movedir;
- int err = lfs_dir_fetch(lfs, &movedir, lfs->gdisk.pair);
- if (err) {
- return err;
- }
-
- // prep gstate and delete move id
- uint16_t moveid = lfs_tag_id(lfs->gdisk.tag);
- lfs_fs_prepmove(lfs, 0x3ff, NULL);
- err = lfs_dir_commit(lfs, &movedir, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_DELETE, moveid, 0), NULL}));
- if (err) {
- return err;
- }
-
- return 0;
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss) {
- if (!lfs_gstate_hasorphans(&lfs->gstate)) {
- return 0;
- }
-
- int8_t found = 0;
-restart:
- {
- // Fix any orphans
- lfs_mdir_t pdir = {.split = true, .tail = {0, 1}};
- lfs_mdir_t dir;
-
- // iterate over all directory directory entries
- while (!lfs_pair_isnull(pdir.tail)) {
- int err = lfs_dir_fetch(lfs, &dir, pdir.tail);
- if (err) {
- return err;
- }
-
- // check head blocks for orphans
- if (!pdir.split) {
- // check if we have a parent
- lfs_mdir_t parent;
- lfs_stag_t tag = lfs_fs_parent(lfs, pdir.tail, &parent);
- if (tag < 0 && tag != LFS_ERR_NOENT) {
- return tag;
- }
-
- // note we only check for full orphans if we may have had a
- // power-loss, otherwise orphans are created intentionally
- // during operations such as lfs_mkdir
- if (tag == LFS_ERR_NOENT && powerloss) {
- // we are an orphan
- LFS_DEBUG("Fixing orphan {0x%"PRIx32", 0x%"PRIx32"}",
- pdir.tail[0], pdir.tail[1]);
-
- // steal state
- err = lfs_dir_getgstate(lfs, &dir, &lfs->gdelta);
- if (err) {
- return err;
- }
-
- // steal tail
- lfs_pair_tole32(dir.tail);
- int state = lfs_dir_orphaningcommit(lfs, &pdir, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_TAIL + dir.split, 0x3ff, 8),
- dir.tail}));
- lfs_pair_fromle32(dir.tail);
- if (state < 0) {
- return state;
- }
-
- found += 1;
-
- // did our commit create more orphans?
- if (state == LFS_OK_ORPHANED) {
- goto restart;
- }
-
- // refetch tail
- continue;
- }
-
- if (tag != LFS_ERR_NOENT) {
- lfs_block_t pair[2];
- lfs_stag_t state = lfs_dir_get(lfs, &parent,
- LFS_MKTAG(0x7ff, 0x3ff, 0), tag, pair);
- if (state < 0) {
- return state;
- }
- lfs_pair_fromle32(pair);
-
- if (!lfs_pair_sync(pair, pdir.tail)) {
- // we have desynced
- LFS_DEBUG("Fixing half-orphan "
- "{0x%"PRIx32", 0x%"PRIx32"} "
- "-> {0x%"PRIx32", 0x%"PRIx32"}",
- pdir.tail[0], pdir.tail[1], pair[0], pair[1]);
-
- // fix pending move in this pair? this looks like an
- // optimization but is in fact _required_ since
- // relocating may outdate the move.
- uint16_t moveid = 0x3ff;
- if (lfs_gstate_hasmovehere(&lfs->gstate, pdir.pair)) {
- moveid = lfs_tag_id(lfs->gstate.tag);
- LFS_DEBUG("Fixing move while fixing orphans "
- "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
- pdir.pair[0], pdir.pair[1], moveid);
- lfs_fs_prepmove(lfs, 0x3ff, NULL);
- }
-
- lfs_pair_tole32(pair);
- state = lfs_dir_orphaningcommit(lfs, &pdir, LFS_MKATTRS(
- {LFS_MKTAG_IF(moveid != 0x3ff,
- LFS_TYPE_DELETE, moveid, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8),
- pair}));
- lfs_pair_fromle32(pair);
- if (state < 0) {
- return state;
- }
-
- found += 1;
-
- // did our commit create more orphans?
- if (state == LFS_OK_ORPHANED) {
- goto restart;
- }
-
- // refetch tail
- continue;
- }
- }
- }
-
- pdir = dir;
- }
- }
-
- // mark orphans as fixed
- return lfs_fs_preporphans(lfs, -lfs_min(
- lfs_gstate_getorphans(&lfs->gstate),
- found));
-}
-#endif
-
-#ifndef LFS_READONLY
-static int lfs_fs_forceconsistency(lfs_t *lfs) {
- int err = lfs_fs_demove(lfs);
- if (err) {
- return err;
- }
-
- err = lfs_fs_deorphan(lfs, true);
- if (err) {
- return err;
- }
-
- return 0;
-}
-#endif
-
-static int lfs_fs_size_count(void *p, lfs_block_t block) {
- (void)block;
- lfs_size_t *size = p;
- *size += 1;
- return 0;
-}
-
-static lfs_ssize_t lfs_fs_rawsize(lfs_t *lfs) {
- lfs_size_t size = 0;
- int err = lfs_fs_rawtraverse(lfs, lfs_fs_size_count, &size, false);
- if (err) {
- return err;
- }
-
- return size;
-}
-
-#ifdef LFS_MIGRATE
-////// Migration from littelfs v1 below this //////
-
-/// Version info ///
-
-// Software library version
-// Major (top-nibble), incremented on backwards incompatible changes
-// Minor (bottom-nibble), incremented on feature additions
-#define LFS1_VERSION 0x00010007
-#define LFS1_VERSION_MAJOR (0xffff & (LFS1_VERSION >> 16))
-#define LFS1_VERSION_MINOR (0xffff & (LFS1_VERSION >> 0))
-
-// Version of On-disk data structures
-// Major (top-nibble), incremented on backwards incompatible changes
-// Minor (bottom-nibble), incremented on feature additions
-#define LFS1_DISK_VERSION 0x00010001
-#define LFS1_DISK_VERSION_MAJOR (0xffff & (LFS1_DISK_VERSION >> 16))
-#define LFS1_DISK_VERSION_MINOR (0xffff & (LFS1_DISK_VERSION >> 0))
-
-
-/// v1 Definitions ///
-
-// File types
-enum lfs1_type {
- LFS1_TYPE_REG = 0x11,
- LFS1_TYPE_DIR = 0x22,
- LFS1_TYPE_SUPERBLOCK = 0x2e,
-};
-
-typedef struct lfs1 {
- lfs_block_t root[2];
-} lfs1_t;
-
-typedef struct lfs1_entry {
- lfs_off_t off;
-
- struct lfs1_disk_entry {
- uint8_t type;
- uint8_t elen;
- uint8_t alen;
- uint8_t nlen;
- union {
- struct {
- lfs_block_t head;
- lfs_size_t size;
- } file;
- lfs_block_t dir[2];
- } u;
- } d;
-} lfs1_entry_t;
-
-typedef struct lfs1_dir {
- struct lfs1_dir *next;
- lfs_block_t pair[2];
- lfs_off_t off;
-
- lfs_block_t head[2];
- lfs_off_t pos;
-
- struct lfs1_disk_dir {
- uint32_t rev;
- lfs_size_t size;
- lfs_block_t tail[2];
- } d;
-} lfs1_dir_t;
-
-typedef struct lfs1_superblock {
- lfs_off_t off;
-
- struct lfs1_disk_superblock {
- uint8_t type;
- uint8_t elen;
- uint8_t alen;
- uint8_t nlen;
- lfs_block_t root[2];
- uint32_t block_size;
- uint32_t block_count;
- uint32_t version;
- char magic[8];
- } d;
-} lfs1_superblock_t;
-
-
-/// Low-level wrappers v1->v2 ///
-static void lfs1_crc(uint32_t *crc, const void *buffer, size_t size) {
- *crc = lfs_crc(*crc, buffer, size);
-}
-
-static int lfs1_bd_read(lfs_t *lfs, lfs_block_t block,
- lfs_off_t off, void *buffer, lfs_size_t size) {
- // if we ever do more than writes to alternating pairs,
- // this may need to consider pcache
- return lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, size,
- block, off, buffer, size);
-}
-
-static int lfs1_bd_crc(lfs_t *lfs, lfs_block_t block,
- lfs_off_t off, lfs_size_t size, uint32_t *crc) {
- for (lfs_off_t i = 0; i < size; i++) {
- uint8_t c;
- int err = lfs1_bd_read(lfs, block, off+i, &c, 1);
- if (err) {
- return err;
- }
-
- lfs1_crc(crc, &c, 1);
- }
-
- return 0;
-}
-
-
-/// Endian swapping functions ///
-static void lfs1_dir_fromle32(struct lfs1_disk_dir *d) {
- d->rev = lfs_fromle32(d->rev);
- d->size = lfs_fromle32(d->size);
- d->tail[0] = lfs_fromle32(d->tail[0]);
- d->tail[1] = lfs_fromle32(d->tail[1]);
-}
-
-static void lfs1_dir_tole32(struct lfs1_disk_dir *d) {
- d->rev = lfs_tole32(d->rev);
- d->size = lfs_tole32(d->size);
- d->tail[0] = lfs_tole32(d->tail[0]);
- d->tail[1] = lfs_tole32(d->tail[1]);
-}
-
-static void lfs1_entry_fromle32(struct lfs1_disk_entry *d) {
- d->u.dir[0] = lfs_fromle32(d->u.dir[0]);
- d->u.dir[1] = lfs_fromle32(d->u.dir[1]);
-}
-
-static void lfs1_entry_tole32(struct lfs1_disk_entry *d) {
- d->u.dir[0] = lfs_tole32(d->u.dir[0]);
- d->u.dir[1] = lfs_tole32(d->u.dir[1]);
-}
-
-static void lfs1_superblock_fromle32(struct lfs1_disk_superblock *d) {
- d->root[0] = lfs_fromle32(d->root[0]);
- d->root[1] = lfs_fromle32(d->root[1]);
- d->block_size = lfs_fromle32(d->block_size);
- d->block_count = lfs_fromle32(d->block_count);
- d->version = lfs_fromle32(d->version);
-}
-
-
-///// Metadata pair and directory operations ///
-static inline lfs_size_t lfs1_entry_size(const lfs1_entry_t *entry) {
- return 4 + entry->d.elen + entry->d.alen + entry->d.nlen;
-}
-
-static int lfs1_dir_fetch(lfs_t *lfs,
- lfs1_dir_t *dir, const lfs_block_t pair[2]) {
- // copy out pair, otherwise may be aliasing dir
- const lfs_block_t tpair[2] = {pair[0], pair[1]};
- bool valid = false;
-
- // check both blocks for the most recent revision
- for (int i = 0; i < 2; i++) {
- struct lfs1_disk_dir test;
- int err = lfs1_bd_read(lfs, tpair[i], 0, &test, sizeof(test));
- lfs1_dir_fromle32(&test);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- continue;
- }
- return err;
- }
-
- if (valid && lfs_scmp(test.rev, dir->d.rev) < 0) {
- continue;
- }
-
- if ((0x7fffffff & test.size) < sizeof(test)+4 ||
- (0x7fffffff & test.size) > lfs->cfg->block_size) {
- continue;
- }
-
- uint32_t crc = 0xffffffff;
- lfs1_dir_tole32(&test);
- lfs1_crc(&crc, &test, sizeof(test));
- lfs1_dir_fromle32(&test);
- err = lfs1_bd_crc(lfs, tpair[i], sizeof(test),
- (0x7fffffff & test.size) - sizeof(test), &crc);
- if (err) {
- if (err == LFS_ERR_CORRUPT) {
- continue;
- }
- return err;
- }
-
- if (crc != 0) {
- continue;
- }
-
- valid = true;
-
- // setup dir in case it's valid
- dir->pair[0] = tpair[(i+0) % 2];
- dir->pair[1] = tpair[(i+1) % 2];
- dir->off = sizeof(dir->d);
- dir->d = test;
- }
-
- if (!valid) {
- LFS_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
- tpair[0], tpair[1]);
- return LFS_ERR_CORRUPT;
- }
-
- return 0;
-}
-
-static int lfs1_dir_next(lfs_t *lfs, lfs1_dir_t *dir, lfs1_entry_t *entry) {
- while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
- if (!(0x80000000 & dir->d.size)) {
- entry->off = dir->off;
- return LFS_ERR_NOENT;
- }
-
- int err = lfs1_dir_fetch(lfs, dir, dir->d.tail);
- if (err) {
- return err;
- }
-
- dir->off = sizeof(dir->d);
- dir->pos += sizeof(dir->d) + 4;
- }
-
- int err = lfs1_bd_read(lfs, dir->pair[0], dir->off,
- &entry->d, sizeof(entry->d));
- lfs1_entry_fromle32(&entry->d);
- if (err) {
- return err;
- }
-
- entry->off = dir->off;
- dir->off += lfs1_entry_size(entry);
- dir->pos += lfs1_entry_size(entry);
- return 0;
-}
-
-/// littlefs v1 specific operations ///
-int lfs1_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
- if (lfs_pair_isnull(lfs->lfs1->root)) {
- return 0;
- }
-
- // iterate over metadata pairs
- lfs1_dir_t dir;
- lfs1_entry_t entry;
- lfs_block_t cwd[2] = {0, 1};
-
- while (true) {
- for (int i = 0; i < 2; i++) {
- int err = cb(data, cwd[i]);
- if (err) {
- return err;
- }
- }
-
- int err = lfs1_dir_fetch(lfs, &dir, cwd);
- if (err) {
- return err;
- }
-
- // iterate over contents
- while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
- err = lfs1_bd_read(lfs, dir.pair[0], dir.off,
- &entry.d, sizeof(entry.d));
- lfs1_entry_fromle32(&entry.d);
- if (err) {
- return err;
- }
-
- dir.off += lfs1_entry_size(&entry);
- if ((0x70 & entry.d.type) == (0x70 & LFS1_TYPE_REG)) {
- err = lfs_ctz_traverse(lfs, NULL, &lfs->rcache,
- entry.d.u.file.head, entry.d.u.file.size, cb, data);
- if (err) {
- return err;
- }
- }
- }
-
- // we also need to check if we contain a threaded v2 directory
- lfs_mdir_t dir2 = {.split=true, .tail={cwd[0], cwd[1]}};
- while (dir2.split) {
- err = lfs_dir_fetch(lfs, &dir2, dir2.tail);
- if (err) {
- break;
- }
-
- for (int i = 0; i < 2; i++) {
- err = cb(data, dir2.pair[i]);
- if (err) {
- return err;
- }
- }
- }
-
- cwd[0] = dir.d.tail[0];
- cwd[1] = dir.d.tail[1];
-
- if (lfs_pair_isnull(cwd)) {
- break;
- }
- }
-
- return 0;
-}
-
-static int lfs1_moved(lfs_t *lfs, const void *e) {
- if (lfs_pair_isnull(lfs->lfs1->root)) {
- return 0;
- }
-
- // skip superblock
- lfs1_dir_t cwd;
- int err = lfs1_dir_fetch(lfs, &cwd, (const lfs_block_t[2]){0, 1});
- if (err) {
- return err;
- }
-
- // iterate over all directory directory entries
- lfs1_entry_t entry;
- while (!lfs_pair_isnull(cwd.d.tail)) {
- err = lfs1_dir_fetch(lfs, &cwd, cwd.d.tail);
- if (err) {
- return err;
- }
-
- while (true) {
- err = lfs1_dir_next(lfs, &cwd, &entry);
- if (err && err != LFS_ERR_NOENT) {
- return err;
- }
-
- if (err == LFS_ERR_NOENT) {
- break;
- }
-
- if (!(0x80 & entry.d.type) &&
- memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
- return true;
- }
- }
- }
-
- return false;
-}
-
-/// Filesystem operations ///
-static int lfs1_mount(lfs_t *lfs, struct lfs1 *lfs1,
- const struct lfs_config *cfg) {
- int err = 0;
- {
- err = lfs_init(lfs, cfg);
- if (err) {
- return err;
- }
-
- lfs->lfs1 = lfs1;
- lfs->lfs1->root[0] = LFS_BLOCK_NULL;
- lfs->lfs1->root[1] = LFS_BLOCK_NULL;
-
- // setup free lookahead
- lfs->free.off = 0;
- lfs->free.size = 0;
- lfs->free.i = 0;
- lfs_alloc_ack(lfs);
-
- // load superblock
- lfs1_dir_t dir;
- lfs1_superblock_t superblock;
- err = lfs1_dir_fetch(lfs, &dir, (const lfs_block_t[2]){0, 1});
- if (err && err != LFS_ERR_CORRUPT) {
- goto cleanup;
- }
-
- if (!err) {
- err = lfs1_bd_read(lfs, dir.pair[0], sizeof(dir.d),
- &superblock.d, sizeof(superblock.d));
- lfs1_superblock_fromle32(&superblock.d);
- if (err) {
- goto cleanup;
- }
-
- lfs->lfs1->root[0] = superblock.d.root[0];
- lfs->lfs1->root[1] = superblock.d.root[1];
- }
-
- if (err || memcmp(superblock.d.magic, "littlefs", 8) != 0) {
- LFS_ERROR("Invalid superblock at {0x%"PRIx32", 0x%"PRIx32"}",
- 0, 1);
- err = LFS_ERR_CORRUPT;
- goto cleanup;
- }
-
- uint16_t major_version = (0xffff & (superblock.d.version >> 16));
- uint16_t minor_version = (0xffff & (superblock.d.version >> 0));
- if ((major_version != LFS1_DISK_VERSION_MAJOR ||
- minor_version > LFS1_DISK_VERSION_MINOR)) {
- LFS_ERROR("Invalid version v%d.%d", major_version, minor_version);
- err = LFS_ERR_INVAL;
- goto cleanup;
- }
-
- return 0;
- }
-
-cleanup:
- lfs_deinit(lfs);
- return err;
-}
-
-static int lfs1_unmount(lfs_t *lfs) {
- return lfs_deinit(lfs);
-}
-
-/// v1 migration ///
-static int lfs_rawmigrate(lfs_t *lfs, const struct lfs_config *cfg) {
- struct lfs1 lfs1;
- int err = lfs1_mount(lfs, &lfs1, cfg);
- if (err) {
- return err;
- }
-
- {
- // iterate through each directory, copying over entries
- // into new directory
- lfs1_dir_t dir1;
- lfs_mdir_t dir2;
- dir1.d.tail[0] = lfs->lfs1->root[0];
- dir1.d.tail[1] = lfs->lfs1->root[1];
- while (!lfs_pair_isnull(dir1.d.tail)) {
- // iterate old dir
- err = lfs1_dir_fetch(lfs, &dir1, dir1.d.tail);
- if (err) {
- goto cleanup;
- }
-
- // create new dir and bind as temporary pretend root
- err = lfs_dir_alloc(lfs, &dir2);
- if (err) {
- goto cleanup;
- }
-
- dir2.rev = dir1.d.rev;
- dir1.head[0] = dir1.pair[0];
- dir1.head[1] = dir1.pair[1];
- lfs->root[0] = dir2.pair[0];
- lfs->root[1] = dir2.pair[1];
-
- err = lfs_dir_commit(lfs, &dir2, NULL, 0);
- if (err) {
- goto cleanup;
- }
-
- while (true) {
- lfs1_entry_t entry1;
- err = lfs1_dir_next(lfs, &dir1, &entry1);
- if (err && err != LFS_ERR_NOENT) {
- goto cleanup;
- }
-
- if (err == LFS_ERR_NOENT) {
- break;
- }
-
- // check that entry has not been moved
- if (entry1.d.type & 0x80) {
- int moved = lfs1_moved(lfs, &entry1.d.u);
- if (moved < 0) {
- err = moved;
- goto cleanup;
- }
-
- if (moved) {
- continue;
- }
-
- entry1.d.type &= ~0x80;
- }
-
- // also fetch name
- char name[LFS_NAME_MAX+1];
- memset(name, 0, sizeof(name));
- err = lfs1_bd_read(lfs, dir1.pair[0],
- entry1.off + 4+entry1.d.elen+entry1.d.alen,
- name, entry1.d.nlen);
- if (err) {
- goto cleanup;
- }
-
- bool isdir = (entry1.d.type == LFS1_TYPE_DIR);
-
- // create entry in new dir
- err = lfs_dir_fetch(lfs, &dir2, lfs->root);
- if (err) {
- goto cleanup;
- }
-
- uint16_t id;
- err = lfs_dir_find(lfs, &dir2, &(const char*){name}, &id);
- if (!(err == LFS_ERR_NOENT && id != 0x3ff)) {
- err = (err < 0) ? err : LFS_ERR_EXIST;
- goto cleanup;
- }
-
- lfs1_entry_tole32(&entry1.d);
- err = lfs_dir_commit(lfs, &dir2, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_CREATE, id, 0), NULL},
- {LFS_MKTAG_IF_ELSE(isdir,
- LFS_TYPE_DIR, id, entry1.d.nlen,
- LFS_TYPE_REG, id, entry1.d.nlen),
- name},
- {LFS_MKTAG_IF_ELSE(isdir,
- LFS_TYPE_DIRSTRUCT, id, sizeof(entry1.d.u),
- LFS_TYPE_CTZSTRUCT, id, sizeof(entry1.d.u)),
- &entry1.d.u}));
- lfs1_entry_fromle32(&entry1.d);
- if (err) {
- goto cleanup;
- }
- }
-
- if (!lfs_pair_isnull(dir1.d.tail)) {
- // find last block and update tail to thread into fs
- err = lfs_dir_fetch(lfs, &dir2, lfs->root);
- if (err) {
- goto cleanup;
- }
-
- while (dir2.split) {
- err = lfs_dir_fetch(lfs, &dir2, dir2.tail);
- if (err) {
- goto cleanup;
- }
- }
-
- lfs_pair_tole32(dir2.pair);
- err = lfs_dir_commit(lfs, &dir2, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir1.d.tail}));
- lfs_pair_fromle32(dir2.pair);
- if (err) {
- goto cleanup;
- }
- }
-
- // Copy over first block to thread into fs. Unfortunately
- // if this fails there is not much we can do.
- LFS_DEBUG("Migrating {0x%"PRIx32", 0x%"PRIx32"} "
- "-> {0x%"PRIx32", 0x%"PRIx32"}",
- lfs->root[0], lfs->root[1], dir1.head[0], dir1.head[1]);
-
- err = lfs_bd_erase(lfs, dir1.head[1]);
- if (err) {
- goto cleanup;
- }
-
- err = lfs_dir_fetch(lfs, &dir2, lfs->root);
- if (err) {
- goto cleanup;
- }
-
- for (lfs_off_t i = 0; i < dir2.off; i++) {
- uint8_t dat;
- err = lfs_bd_read(lfs,
- NULL, &lfs->rcache, dir2.off,
- dir2.pair[0], i, &dat, 1);
- if (err) {
- goto cleanup;
- }
-
- err = lfs_bd_prog(lfs,
- &lfs->pcache, &lfs->rcache, true,
- dir1.head[1], i, &dat, 1);
- if (err) {
- goto cleanup;
- }
- }
-
- err = lfs_bd_flush(lfs, &lfs->pcache, &lfs->rcache, true);
- if (err) {
- goto cleanup;
- }
- }
-
- // Create new superblock. This marks a successful migration!
- err = lfs1_dir_fetch(lfs, &dir1, (const lfs_block_t[2]){0, 1});
- if (err) {
- goto cleanup;
- }
-
- dir2.pair[0] = dir1.pair[0];
- dir2.pair[1] = dir1.pair[1];
- dir2.rev = dir1.d.rev;
- dir2.off = sizeof(dir2.rev);
- dir2.etag = 0xffffffff;
- dir2.count = 0;
- dir2.tail[0] = lfs->lfs1->root[0];
- dir2.tail[1] = lfs->lfs1->root[1];
- dir2.erased = false;
- dir2.split = true;
-
- lfs_superblock_t superblock = {
- .version = LFS_DISK_VERSION,
- .block_size = lfs->cfg->block_size,
- .block_count = lfs->cfg->block_count,
- .name_max = lfs->name_max,
- .file_max = lfs->file_max,
- .attr_max = lfs->attr_max,
- };
-
- lfs_superblock_tole32(&superblock);
- err = lfs_dir_commit(lfs, &dir2, LFS_MKATTRS(
- {LFS_MKTAG(LFS_TYPE_CREATE, 0, 0), NULL},
- {LFS_MKTAG(LFS_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
- {LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
- &superblock}));
- if (err) {
- goto cleanup;
- }
-
- // sanity check that fetch works
- err = lfs_dir_fetch(lfs, &dir2, (const lfs_block_t[2]){0, 1});
- if (err) {
- goto cleanup;
- }
-
- // force compaction to prevent accidentally mounting v1
- dir2.erased = false;
- err = lfs_dir_commit(lfs, &dir2, NULL, 0);
- if (err) {
- goto cleanup;
- }
- }
-
-cleanup:
- lfs1_unmount(lfs);
- return err;
-}
-
-#endif
-
-
-/// Public API wrappers ///
-
-// Here we can add tracing/thread safety easily
-
-// Thread-safe wrappers if enabled
-#ifdef LFS_THREADSAFE
-#define LFS_LOCK(cfg) cfg->lock(cfg)
-#define LFS_UNLOCK(cfg) cfg->unlock(cfg)
-#else
-#define LFS_LOCK(cfg) ((void)cfg, 0)
-#define LFS_UNLOCK(cfg) ((void)cfg)
-#endif
-
-// Public API
-#ifndef LFS_READONLY
-int lfs_format(lfs_t *lfs, const struct lfs_config *cfg) {
- int err = LFS_LOCK(cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_format(%p, %p {.context=%p, "
- ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
- ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
- ".block_size=%"PRIu32", .block_count=%"PRIu32", "
- ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
- ".lookahead_size=%"PRIu32", .read_buffer=%p, "
- ".prog_buffer=%p, .lookahead_buffer=%p, "
- ".name_max=%"PRIu32", .file_max=%"PRIu32", "
- ".attr_max=%"PRIu32"})",
- (void*)lfs, (void*)cfg, cfg->context,
- (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
- (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
- cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
- cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
- cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
- cfg->name_max, cfg->file_max, cfg->attr_max);
-
- err = lfs_rawformat(lfs, cfg);
-
- LFS_TRACE("lfs_format -> %d", err);
- LFS_UNLOCK(cfg);
- return err;
-}
-#endif
-
-int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
- int err = LFS_LOCK(cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_mount(%p, %p {.context=%p, "
- ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
- ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
- ".block_size=%"PRIu32", .block_count=%"PRIu32", "
- ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
- ".lookahead_size=%"PRIu32", .read_buffer=%p, "
- ".prog_buffer=%p, .lookahead_buffer=%p, "
- ".name_max=%"PRIu32", .file_max=%"PRIu32", "
- ".attr_max=%"PRIu32"})",
- (void*)lfs, (void*)cfg, cfg->context,
- (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
- (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
- cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
- cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
- cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
- cfg->name_max, cfg->file_max, cfg->attr_max);
-
- err = lfs_rawmount(lfs, cfg);
-
- LFS_TRACE("lfs_mount -> %d", err);
- LFS_UNLOCK(cfg);
- return err;
-}
-
-int lfs_unmount(lfs_t *lfs) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_unmount(%p)", (void*)lfs);
-
- err = lfs_rawunmount(lfs);
-
- LFS_TRACE("lfs_unmount -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-#ifndef LFS_READONLY
-int lfs_remove(lfs_t *lfs, const char *path) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_remove(%p, \"%s\")", (void*)lfs, path);
-
- err = lfs_rawremove(lfs, path);
-
- LFS_TRACE("lfs_remove -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-#ifndef LFS_READONLY
-int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_rename(%p, \"%s\", \"%s\")", (void*)lfs, oldpath, newpath);
-
- err = lfs_rawrename(lfs, oldpath, newpath);
-
- LFS_TRACE("lfs_rename -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_stat(%p, \"%s\", %p)", (void*)lfs, path, (void*)info);
-
- err = lfs_rawstat(lfs, path, info);
-
- LFS_TRACE("lfs_stat -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
- uint8_t type, void *buffer, lfs_size_t size) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_getattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
- (void*)lfs, path, type, buffer, size);
-
- lfs_ssize_t res = lfs_rawgetattr(lfs, path, type, buffer, size);
-
- LFS_TRACE("lfs_getattr -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-#ifndef LFS_READONLY
-int lfs_setattr(lfs_t *lfs, const char *path,
- uint8_t type, const void *buffer, lfs_size_t size) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_setattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
- (void*)lfs, path, type, buffer, size);
-
- err = lfs_rawsetattr(lfs, path, type, buffer, size);
-
- LFS_TRACE("lfs_setattr -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-#ifndef LFS_READONLY
-int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_removeattr(%p, \"%s\", %"PRIu8")", (void*)lfs, path, type);
-
- err = lfs_rawremoveattr(lfs, path, type);
-
- LFS_TRACE("lfs_removeattr -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-#ifndef LFS_NO_MALLOC
-int lfs_file_open(lfs_t *lfs, lfs_file_t *file, const char *path, int flags) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_open(%p, %p, \"%s\", %x)",
- (void*)lfs, (void*)file, path, flags);
- LFS_ASSERT(!lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- err = lfs_file_rawopen(lfs, file, path, flags);
-
- LFS_TRACE("lfs_file_open -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
- const char *path, int flags,
- const struct lfs_file_config *cfg) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_opencfg(%p, %p, \"%s\", %x, %p {"
- ".buffer=%p, .attrs=%p, .attr_count=%"PRIu32"})",
- (void*)lfs, (void*)file, path, flags,
- (void*)cfg, cfg->buffer, (void*)cfg->attrs, cfg->attr_count);
- LFS_ASSERT(!lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- err = lfs_file_rawopencfg(lfs, file, path, flags, cfg);
-
- LFS_TRACE("lfs_file_opencfg -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-int lfs_file_close(lfs_t *lfs, lfs_file_t *file) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_close(%p, %p)", (void*)lfs, (void*)file);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- err = lfs_file_rawclose(lfs, file);
-
- LFS_TRACE("lfs_file_close -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-#ifndef LFS_READONLY
-int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_sync(%p, %p)", (void*)lfs, (void*)file);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- err = lfs_file_rawsync(lfs, file);
-
- LFS_TRACE("lfs_file_sync -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_read(%p, %p, %p, %"PRIu32")",
- (void*)lfs, (void*)file, buffer, size);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- lfs_ssize_t res = lfs_file_rawread(lfs, file, buffer, size);
-
- LFS_TRACE("lfs_file_read -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-#ifndef LFS_READONLY
-lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_write(%p, %p, %p, %"PRIu32")",
- (void*)lfs, (void*)file, buffer, size);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- lfs_ssize_t res = lfs_file_rawwrite(lfs, file, buffer, size);
-
- LFS_TRACE("lfs_file_write -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-#endif
-
-lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
- lfs_soff_t off, int whence) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_seek(%p, %p, %"PRId32", %d)",
- (void*)lfs, (void*)file, off, whence);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- lfs_soff_t res = lfs_file_rawseek(lfs, file, off, whence);
-
- LFS_TRACE("lfs_file_seek -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-#ifndef LFS_READONLY
-int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_truncate(%p, %p, %"PRIu32")",
- (void*)lfs, (void*)file, size);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- err = lfs_file_rawtruncate(lfs, file, size);
-
- LFS_TRACE("lfs_file_truncate -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_tell(%p, %p)", (void*)lfs, (void*)file);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- lfs_soff_t res = lfs_file_rawtell(lfs, file);
-
- LFS_TRACE("lfs_file_tell -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_rewind(%p, %p)", (void*)lfs, (void*)file);
-
- err = lfs_file_rawrewind(lfs, file);
-
- LFS_TRACE("lfs_file_rewind -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_file_size(%p, %p)", (void*)lfs, (void*)file);
- LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
-
- lfs_soff_t res = lfs_file_rawsize(lfs, file);
-
- LFS_TRACE("lfs_file_size -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-#ifndef LFS_READONLY
-int lfs_mkdir(lfs_t *lfs, const char *path) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_mkdir(%p, \"%s\")", (void*)lfs, path);
-
- err = lfs_rawmkdir(lfs, path);
-
- LFS_TRACE("lfs_mkdir -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-#endif
-
-int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_open(%p, %p, \"%s\")", (void*)lfs, (void*)dir, path);
- LFS_ASSERT(!lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)dir));
-
- err = lfs_dir_rawopen(lfs, dir, path);
-
- LFS_TRACE("lfs_dir_open -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_close(%p, %p)", (void*)lfs, (void*)dir);
-
- err = lfs_dir_rawclose(lfs, dir);
-
- LFS_TRACE("lfs_dir_close -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_read(%p, %p, %p)",
- (void*)lfs, (void*)dir, (void*)info);
-
- err = lfs_dir_rawread(lfs, dir, info);
-
- LFS_TRACE("lfs_dir_read -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_seek(%p, %p, %"PRIu32")",
- (void*)lfs, (void*)dir, off);
-
- err = lfs_dir_rawseek(lfs, dir, off);
-
- LFS_TRACE("lfs_dir_seek -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_tell(%p, %p)", (void*)lfs, (void*)dir);
-
- lfs_soff_t res = lfs_dir_rawtell(lfs, dir);
-
- LFS_TRACE("lfs_dir_tell -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_dir_rewind(%p, %p)", (void*)lfs, (void*)dir);
-
- err = lfs_dir_rawrewind(lfs, dir);
-
- LFS_TRACE("lfs_dir_rewind -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-lfs_ssize_t lfs_fs_size(lfs_t *lfs) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_fs_size(%p)", (void*)lfs);
-
- lfs_ssize_t res = lfs_fs_rawsize(lfs);
-
- LFS_TRACE("lfs_fs_size -> %"PRId32, res);
- LFS_UNLOCK(lfs->cfg);
- return res;
-}
-
-int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void *, lfs_block_t), void *data) {
- int err = LFS_LOCK(lfs->cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_fs_traverse(%p, %p, %p)",
- (void*)lfs, (void*)(uintptr_t)cb, data);
-
- err = lfs_fs_rawtraverse(lfs, cb, data, true);
-
- LFS_TRACE("lfs_fs_traverse -> %d", err);
- LFS_UNLOCK(lfs->cfg);
- return err;
-}
-
-#ifdef LFS_MIGRATE
-int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) {
- int err = LFS_LOCK(cfg);
- if (err) {
- return err;
- }
- LFS_TRACE("lfs_migrate(%p, %p {.context=%p, "
- ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
- ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
- ".block_size=%"PRIu32", .block_count=%"PRIu32", "
- ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
- ".lookahead_size=%"PRIu32", .read_buffer=%p, "
- ".prog_buffer=%p, .lookahead_buffer=%p, "
- ".name_max=%"PRIu32", .file_max=%"PRIu32", "
- ".attr_max=%"PRIu32"})",
- (void*)lfs, (void*)cfg, cfg->context,
- (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
- (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
- cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
- cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
- cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
- cfg->name_max, cfg->file_max, cfg->attr_max);
-
- err = lfs_rawmigrate(lfs, cfg);
-
- LFS_TRACE("lfs_migrate -> %d", err);
- LFS_UNLOCK(cfg);
- return err;
-}
-#endif
-
diff --git a/fs/littlefs/src/lfs.h b/fs/littlefs/src/lfs.h
deleted file mode 100644
index 3fc1e982f..000000000
--- a/fs/littlefs/src/lfs.h
+++ /dev/null
@@ -1,701 +0,0 @@
-/*
- * The little filesystem
- *
- * Copyright (c) 2022, The littlefs authors.
- * Copyright (c) 2017, Arm Limited. All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#ifndef LFS_H
-#define LFS_H
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "lfs_util.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-/// Version info ///
-
-// Software library version
-// Major (top-nibble), incremented on backwards incompatible changes
-// Minor (bottom-nibble), incremented on feature additions
-#define LFS_VERSION 0x00020005
-#define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
-#define LFS_VERSION_MINOR (0xffff & (LFS_VERSION >> 0))
-
-// Version of On-disk data structures
-// Major (top-nibble), incremented on backwards incompatible changes
-// Minor (bottom-nibble), incremented on feature additions
-#define LFS_DISK_VERSION 0x00020000
-#define LFS_DISK_VERSION_MAJOR (0xffff & (LFS_DISK_VERSION >> 16))
-#define LFS_DISK_VERSION_MINOR (0xffff & (LFS_DISK_VERSION >> 0))
-
-
-/// Definitions ///
-
-// Type definitions
-typedef uint32_t lfs_size_t;
-typedef uint32_t lfs_off_t;
-
-typedef int32_t lfs_ssize_t;
-typedef int32_t lfs_soff_t;
-
-typedef uint32_t lfs_block_t;
-
-// Maximum name size in bytes, may be redefined to reduce the size of the
-// info struct. Limited to <= 1022. Stored in superblock and must be
-// respected by other littlefs drivers.
-#ifndef LFS_NAME_MAX
-#define LFS_NAME_MAX 255
-#endif
-
-// Maximum size of a file in bytes, may be redefined to limit to support other
-// drivers. Limited on disk to <= 4294967296. However, above 2147483647 the
-// functions lfs_file_seek, lfs_file_size, and lfs_file_tell will return
-// incorrect values due to using signed integers. Stored in superblock and
-// must be respected by other littlefs drivers.
-#ifndef LFS_FILE_MAX
-#define LFS_FILE_MAX 2147483647
-#endif
-
-// Maximum size of custom attributes in bytes, may be redefined, but there is
-// no real benefit to using a smaller LFS_ATTR_MAX. Limited to <= 1022.
-#ifndef LFS_ATTR_MAX
-#define LFS_ATTR_MAX 1022
-#endif
-
-// Possible error codes, these are negative to allow
-// valid positive return values
-enum lfs_error {
- LFS_ERR_OK = 0, // No error
- LFS_ERR_IO = -5, // Error during device operation
- LFS_ERR_CORRUPT = -84, // Corrupted
- LFS_ERR_NOENT = -2, // No directory entry
- LFS_ERR_EXIST = -17, // Entry already exists
- LFS_ERR_NOTDIR = -20, // Entry is not a dir
- LFS_ERR_ISDIR = -21, // Entry is a dir
- LFS_ERR_NOTEMPTY = -39, // Dir is not empty
- LFS_ERR_BADF = -9, // Bad file number
- LFS_ERR_FBIG = -27, // File too large
- LFS_ERR_INVAL = -22, // Invalid parameter
- LFS_ERR_NOSPC = -28, // No space left on device
- LFS_ERR_NOMEM = -12, // No more memory available
- LFS_ERR_NOATTR = -61, // No data/attr available
- LFS_ERR_NAMETOOLONG = -36, // File name too long
-};
-
-// File types
-enum lfs_type {
- // file types
- LFS_TYPE_REG = 0x001,
- LFS_TYPE_DIR = 0x002,
-
- // internally used types
- LFS_TYPE_SPLICE = 0x400,
- LFS_TYPE_NAME = 0x000,
- LFS_TYPE_STRUCT = 0x200,
- LFS_TYPE_USERATTR = 0x300,
- LFS_TYPE_FROM = 0x100,
- LFS_TYPE_TAIL = 0x600,
- LFS_TYPE_GLOBALS = 0x700,
- LFS_TYPE_CRC = 0x500,
-
- // internally used type specializations
- LFS_TYPE_CREATE = 0x401,
- LFS_TYPE_DELETE = 0x4ff,
- LFS_TYPE_SUPERBLOCK = 0x0ff,
- LFS_TYPE_DIRSTRUCT = 0x200,
- LFS_TYPE_CTZSTRUCT = 0x202,
- LFS_TYPE_INLINESTRUCT = 0x201,
- LFS_TYPE_SOFTTAIL = 0x600,
- LFS_TYPE_HARDTAIL = 0x601,
- LFS_TYPE_MOVESTATE = 0x7ff,
-
- // internal chip sources
- LFS_FROM_NOOP = 0x000,
- LFS_FROM_MOVE = 0x101,
- LFS_FROM_USERATTRS = 0x102,
-};
-
-// File open flags
-enum lfs_open_flags {
- // open flags
- LFS_O_RDONLY = 1, // Open a file as read only
-#ifndef LFS_READONLY
- LFS_O_WRONLY = 2, // Open a file as write only
- LFS_O_RDWR = 3, // Open a file as read and write
- LFS_O_CREAT = 0x0100, // Create a file if it does not exist
- LFS_O_EXCL = 0x0200, // Fail if a file already exists
- LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size
- LFS_O_APPEND = 0x0800, // Move to end of file on every write
-#endif
-
- // internally used flags
-#ifndef LFS_READONLY
- LFS_F_DIRTY = 0x010000, // File does not match storage
- LFS_F_WRITING = 0x020000, // File has been written since last flush
-#endif
- LFS_F_READING = 0x040000, // File has been read since last flush
-#ifndef LFS_READONLY
- LFS_F_ERRED = 0x080000, // An error occurred during write
-#endif
- LFS_F_INLINE = 0x100000, // Currently inlined in directory entry
-};
-
-// File seek flags
-enum lfs_whence_flags {
- LFS_SEEK_SET = 0, // Seek relative to an absolute position
- LFS_SEEK_CUR = 1, // Seek relative to the current file position
- LFS_SEEK_END = 2, // Seek relative to the end of the file
-};
-
-
-// Configuration provided during initialization of the littlefs
-struct lfs_config {
- // Opaque user provided context that can be used to pass
- // information to the block device operations
- void *context;
-
- // Read a region in a block. Negative error codes are propagated
- // to the user.
- int (*read)(const struct lfs_config *c, lfs_block_t block,
- lfs_off_t off, void *buffer, lfs_size_t size);
-
- // Program a region in a block. The block must have previously
- // been erased. Negative error codes are propagated to the user.
- // May return LFS_ERR_CORRUPT if the block should be considered bad.
- int (*prog)(const struct lfs_config *c, lfs_block_t block,
- lfs_off_t off, const void *buffer, lfs_size_t size);
-
- // Erase a block. A block must be erased before being programmed.
- // The state of an erased block is undefined. Negative error codes
- // are propagated to the user.
- // May return LFS_ERR_CORRUPT if the block should be considered bad.
- int (*erase)(const struct lfs_config *c, lfs_block_t block);
-
- // Sync the state of the underlying block device. Negative error codes
- // are propagated to the user.
- int (*sync)(const struct lfs_config *c);
-
-#ifdef LFS_THREADSAFE
- // Lock the underlying block device. Negative error codes
- // are propagated to the user.
- int (*lock)(const struct lfs_config *c);
-
- // Unlock the underlying block device. Negative error codes
- // are propagated to the user.
- int (*unlock)(const struct lfs_config *c);
-#endif
-
- // Minimum size of a block read in bytes. All read operations will be a
- // multiple of this value.
- lfs_size_t read_size;
-
- // Minimum size of a block program in bytes. All program operations will be
- // a multiple of this value.
- lfs_size_t prog_size;
-
- // Size of an erasable block in bytes. This does not impact ram consumption
- // and may be larger than the physical erase size. However, non-inlined
- // files take up at minimum one block. Must be a multiple of the read and
- // program sizes.
- lfs_size_t block_size;
-
- // Number of erasable blocks on the device.
- lfs_size_t block_count;
-
- // Number of erase cycles before littlefs evicts metadata logs and moves
- // the metadata to another block. Suggested values are in the
- // range 100-1000, with large values having better performance at the cost
- // of less consistent wear distribution.
- //
- // Set to -1 to disable block-level wear-leveling.
- int32_t block_cycles;
-
- // Size of block caches in bytes. Each cache buffers a portion of a block in
- // RAM. The littlefs needs a read cache, a program cache, and one additional
- // cache per file. Larger caches can improve performance by storing more
- // data and reducing the number of disk accesses. Must be a multiple of the
- // read and program sizes, and a factor of the block size.
- lfs_size_t cache_size;
-
- // Size of the lookahead buffer in bytes. A larger lookahead buffer
- // increases the number of blocks found during an allocation pass. The
- // lookahead buffer is stored as a compact bitmap, so each byte of RAM
- // can track 8 blocks. Must be a multiple of 8.
- lfs_size_t lookahead_size;
-
- // Optional statically allocated read buffer. Must be cache_size.
- // By default lfs_malloc is used to allocate this buffer.
- void *read_buffer;
-
- // Optional statically allocated program buffer. Must be cache_size.
- // By default lfs_malloc is used to allocate this buffer.
- void *prog_buffer;
-
- // Optional statically allocated lookahead buffer. Must be lookahead_size
- // and aligned to a 32-bit boundary. By default lfs_malloc is used to
- // allocate this buffer.
- void *lookahead_buffer;
-
- // Optional upper limit on length of file names in bytes. No downside for
- // larger names except the size of the info struct which is controlled by
- // the LFS_NAME_MAX define. Defaults to LFS_NAME_MAX when zero. Stored in
- // superblock and must be respected by other littlefs drivers.
- lfs_size_t name_max;
-
- // Optional upper limit on files in bytes. No downside for larger files
- // but must be <= LFS_FILE_MAX. Defaults to LFS_FILE_MAX when zero. Stored
- // in superblock and must be respected by other littlefs drivers.
- lfs_size_t file_max;
-
- // Optional upper limit on custom attributes in bytes. No downside for
- // larger attributes size but must be <= LFS_ATTR_MAX. Defaults to
- // LFS_ATTR_MAX when zero.
- lfs_size_t attr_max;
-
- // Optional upper limit on total space given to metadata pairs in bytes. On
- // devices with large blocks (e.g. 128kB) setting this to a low size (2-8kB)
- // can help bound the metadata compaction time. Must be <= block_size.
- // Defaults to block_size when zero.
- lfs_size_t metadata_max;
-};
-
-// File info structure
-struct lfs_info {
- // Type of the file, either LFS_TYPE_REG or LFS_TYPE_DIR
- uint8_t type;
-
- // Size of the file, only valid for REG files. Limited to 32-bits.
- lfs_size_t size;
-
- // Name of the file stored as a null-terminated string. Limited to
- // LFS_NAME_MAX+1, which can be changed by redefining LFS_NAME_MAX to
- // reduce RAM. LFS_NAME_MAX is stored in superblock and must be
- // respected by other littlefs drivers.
- char name[LFS_NAME_MAX+1];
-};
-
-// Custom attribute structure, used to describe custom attributes
-// committed atomically during file writes.
-struct lfs_attr {
- // 8-bit type of attribute, provided by user and used to
- // identify the attribute
- uint8_t type;
-
- // Pointer to buffer containing the attribute
- void *buffer;
-
- // Size of attribute in bytes, limited to LFS_ATTR_MAX
- lfs_size_t size;
-};
-
-// Optional configuration provided during lfs_file_opencfg
-struct lfs_file_config {
- // Optional statically allocated file buffer. Must be cache_size.
- // By default lfs_malloc is used to allocate this buffer.
- void *buffer;
-
- // Optional list of custom attributes related to the file. If the file
- // is opened with read access, these attributes will be read from disk
- // during the open call. If the file is opened with write access, the
- // attributes will be written to disk every file sync or close. This
- // write occurs atomically with update to the file's contents.
- //
- // Custom attributes are uniquely identified by an 8-bit type and limited
- // to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
- // than the buffer, it will be padded with zeros. If the stored attribute
- // is larger, then it will be silently truncated. If the attribute is not
- // found, it will be created implicitly.
- struct lfs_attr *attrs;
-
- // Number of custom attributes in the list
- lfs_size_t attr_count;
-};
-
-
-/// internal littlefs data structures ///
-typedef struct lfs_cache {
- lfs_block_t block;
- lfs_off_t off;
- lfs_size_t size;
- uint8_t *buffer;
-} lfs_cache_t;
-
-typedef struct lfs_mdir {
- lfs_block_t pair[2];
- uint32_t rev;
- lfs_off_t off;
- uint32_t etag;
- uint16_t count;
- bool erased;
- bool split;
- lfs_block_t tail[2];
-} lfs_mdir_t;
-
-// littlefs directory type
-typedef struct lfs_dir {
- struct lfs_dir *next;
- uint16_t id;
- uint8_t type;
- lfs_mdir_t m;
-
- lfs_off_t pos;
- lfs_block_t head[2];
-} lfs_dir_t;
-
-// littlefs file type
-typedef struct lfs_file {
- struct lfs_file *next;
- uint16_t id;
- uint8_t type;
- lfs_mdir_t m;
-
- struct lfs_ctz {
- lfs_block_t head;
- lfs_size_t size;
- } ctz;
-
- uint32_t flags;
- lfs_off_t pos;
- lfs_block_t block;
- lfs_off_t off;
- lfs_cache_t cache;
-
- const struct lfs_file_config *cfg;
-} lfs_file_t;
-
-typedef struct lfs_superblock {
- uint32_t version;
- lfs_size_t block_size;
- lfs_size_t block_count;
- lfs_size_t name_max;
- lfs_size_t file_max;
- lfs_size_t attr_max;
-} lfs_superblock_t;
-
-typedef struct lfs_gstate {
- uint32_t tag;
- lfs_block_t pair[2];
-} lfs_gstate_t;
-
-// The littlefs filesystem type
-typedef struct lfs {
- lfs_cache_t rcache;
- lfs_cache_t pcache;
-
- lfs_block_t root[2];
- struct lfs_mlist {
- struct lfs_mlist *next;
- uint16_t id;
- uint8_t type;
- lfs_mdir_t m;
- } *mlist;
- uint32_t seed;
-
- lfs_gstate_t gstate;
- lfs_gstate_t gdisk;
- lfs_gstate_t gdelta;
-
- struct lfs_free {
- lfs_block_t off;
- lfs_block_t size;
- lfs_block_t i;
- lfs_block_t ack;
- uint32_t *buffer;
- } free;
-
- const struct lfs_config *cfg;
- lfs_size_t name_max;
- lfs_size_t file_max;
- lfs_size_t attr_max;
-
-#ifdef LFS_MIGRATE
- struct lfs1 *lfs1;
-#endif
-} lfs_t;
-
-
-/// Filesystem functions ///
-
-#ifndef LFS_READONLY
-// Format a block device with the littlefs
-//
-// Requires a littlefs object and config struct. This clobbers the littlefs
-// object, and does not leave the filesystem mounted. The config struct must
-// be zeroed for defaults and backwards compatibility.
-//
-// Returns a negative error code on failure.
-int lfs_format(lfs_t *lfs, const struct lfs_config *config);
-#endif
-
-// Mounts a littlefs
-//
-// Requires a littlefs object and config struct. Multiple filesystems
-// may be mounted simultaneously with multiple littlefs objects. Both
-// lfs and config must be allocated while mounted. The config struct must
-// be zeroed for defaults and backwards compatibility.
-//
-// Returns a negative error code on failure.
-int lfs_mount(lfs_t *lfs, const struct lfs_config *config);
-
-// Unmounts a littlefs
-//
-// Does nothing besides releasing any allocated resources.
-// Returns a negative error code on failure.
-int lfs_unmount(lfs_t *lfs);
-
-/// General operations ///
-
-#ifndef LFS_READONLY
-// Removes a file or directory
-//
-// If removing a directory, the directory must be empty.
-// Returns a negative error code on failure.
-int lfs_remove(lfs_t *lfs, const char *path);
-#endif
-
-#ifndef LFS_READONLY
-// Rename or move a file or directory
-//
-// If the destination exists, it must match the source in type.
-// If the destination is a directory, the directory must be empty.
-//
-// Returns a negative error code on failure.
-int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath);
-#endif
-
-// Find info about a file or directory
-//
-// Fills out the info structure, based on the specified file or directory.
-// Returns a negative error code on failure.
-int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
-
-// Get a custom attribute
-//
-// Custom attributes are uniquely identified by an 8-bit type and limited
-// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller than
-// the buffer, it will be padded with zeros. If the stored attribute is larger,
-// then it will be silently truncated. If no attribute is found, the error
-// LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
-//
-// Returns the size of the attribute, or a negative error code on failure.
-// Note, the returned size is the size of the attribute on disk, irrespective
-// of the size of the buffer. This can be used to dynamically allocate a buffer
-// or check for existence.
-lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
- uint8_t type, void *buffer, lfs_size_t size);
-
-#ifndef LFS_READONLY
-// Set custom attributes
-//
-// Custom attributes are uniquely identified by an 8-bit type and limited
-// to LFS_ATTR_MAX bytes. If an attribute is not found, it will be
-// implicitly created.
-//
-// Returns a negative error code on failure.
-int lfs_setattr(lfs_t *lfs, const char *path,
- uint8_t type, const void *buffer, lfs_size_t size);
-#endif
-
-#ifndef LFS_READONLY
-// Removes a custom attribute
-//
-// If an attribute is not found, nothing happens.
-//
-// Returns a negative error code on failure.
-int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type);
-#endif
-
-
-/// File operations ///
-
-#ifndef LFS_NO_MALLOC
-// Open a file
-//
-// The mode that the file is opened in is determined by the flags, which
-// are values from the enum lfs_open_flags that are bitwise-ored together.
-//
-// Returns a negative error code on failure.
-int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
- const char *path, int flags);
-
-// if LFS_NO_MALLOC is defined, lfs_file_open() will fail with LFS_ERR_NOMEM
-// thus use lfs_file_opencfg() with config.buffer set.
-#endif
-
-// Open a file with extra configuration
-//
-// The mode that the file is opened in is determined by the flags, which
-// are values from the enum lfs_open_flags that are bitwise-ored together.
-//
-// The config struct provides additional config options per file as described
-// above. The config struct must be allocated while the file is open, and the
-// config struct must be zeroed for defaults and backwards compatibility.
-//
-// Returns a negative error code on failure.
-int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
- const char *path, int flags,
- const struct lfs_file_config *config);
-
-// Close a file
-//
-// Any pending writes are written out to storage as though
-// sync had been called and releases any allocated resources.
-//
-// Returns a negative error code on failure.
-int lfs_file_close(lfs_t *lfs, lfs_file_t *file);
-
-// Synchronize a file on storage
-//
-// Any pending writes are written out to storage.
-// Returns a negative error code on failure.
-int lfs_file_sync(lfs_t *lfs, lfs_file_t *file);
-
-// Read data from file
-//
-// Takes a buffer and size indicating where to store the read data.
-// Returns the number of bytes read, or a negative error code on failure.
-lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
- void *buffer, lfs_size_t size);
-
-#ifndef LFS_READONLY
-// Write data to file
-//
-// Takes a buffer and size indicating the data to write. The file will not
-// actually be updated on the storage until either sync or close is called.
-//
-// Returns the number of bytes written, or a negative error code on failure.
-lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
- const void *buffer, lfs_size_t size);
-#endif
-
-// Change the position of the file
-//
-// The change in position is determined by the offset and whence flag.
-// Returns the new position of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
- lfs_soff_t off, int whence);
-
-#ifndef LFS_READONLY
-// Truncates the size of the file to the specified size
-//
-// Returns a negative error code on failure.
-int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size);
-#endif
-
-// Return the position of the file
-//
-// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_CUR)
-// Returns the position of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file);
-
-// Change the position of the file to the beginning of the file
-//
-// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_SET)
-// Returns a negative error code on failure.
-int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file);
-
-// Return the size of the file
-//
-// Similar to lfs_file_seek(lfs, file, 0, LFS_SEEK_END)
-// Returns the size of the file, or a negative error code on failure.
-lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file);
-
-
-/// Directory operations ///
-
-#ifndef LFS_READONLY
-// Create a directory
-//
-// Returns a negative error code on failure.
-int lfs_mkdir(lfs_t *lfs, const char *path);
-#endif
-
-// Open a directory
-//
-// Once open a directory can be used with read to iterate over files.
-// Returns a negative error code on failure.
-int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path);
-
-// Close a directory
-//
-// Releases any allocated resources.
-// Returns a negative error code on failure.
-int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
-
-// Read an entry in the directory
-//
-// Fills out the info structure, based on the specified file or directory.
-// Returns a positive value on success, 0 at the end of directory,
-// or a negative error code on failure.
-int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
-
-// Change the position of the directory
-//
-// The new off must be a value previous returned from tell and specifies
-// an absolute offset in the directory seek.
-//
-// Returns a negative error code on failure.
-int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off);
-
-// Return the position of the directory
-//
-// The returned offset is only meant to be consumed by seek and may not make
-// sense, but does indicate the current position in the directory iteration.
-//
-// Returns the position of the directory, or a negative error code on failure.
-lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir);
-
-// Change the position of the directory to the beginning of the directory
-//
-// Returns a negative error code on failure.
-int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
-
-
-/// Filesystem-level filesystem operations
-
-// Finds the current size of the filesystem
-//
-// Note: Result is best effort. If files share COW structures, the returned
-// size may be larger than the filesystem actually is.
-//
-// Returns the number of allocated blocks, or a negative error code on failure.
-lfs_ssize_t lfs_fs_size(lfs_t *lfs);
-
-// Traverse through all blocks in use by the filesystem
-//
-// The provided callback will be called with each block address that is
-// currently in use by the filesystem. This can be used to determine which
-// blocks are in use or how much of the storage is available.
-//
-// Returns a negative error code on failure.
-int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
-
-#ifndef LFS_READONLY
-#ifdef LFS_MIGRATE
-// Attempts to migrate a previous version of littlefs
-//
-// Behaves similarly to the lfs_format function. Attempts to mount
-// the previous version of littlefs and update the filesystem so it can be
-// mounted with the current version of littlefs.
-//
-// Requires a littlefs object and config struct. This clobbers the littlefs
-// object, and does not leave the filesystem mounted. The config struct must
-// be zeroed for defaults and backwards compatibility.
-//
-// Returns a negative error code on failure.
-int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg);
-#endif
-#endif
-
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif
diff --git a/fs/littlefs/src/lfs_util.c b/fs/littlefs/src/lfs_util.c
deleted file mode 100644
index 9cdd1c60e..000000000
--- a/fs/littlefs/src/lfs_util.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * lfs util functions
- *
- * Copyright (c) 2022, The littlefs authors.
- * Copyright (c) 2017, Arm Limited. All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#include "lfs_util.h"
-
-// Only compile if user does not provide custom config
-#ifndef LFS_CONFIG
-
-
-// Software CRC implementation with small lookup table
-uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
- static const uint32_t rtable[16] = {
- 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
- 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
- 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
- 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
- };
-
- const uint8_t *data = buffer;
-
- for (size_t i = 0; i < size; i++) {
- crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
- crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
- }
-
- return crc;
-}
-
-
-#endif
diff --git a/fs/littlefs/src/lfs_util.h b/fs/littlefs/src/lfs_util.h
deleted file mode 100644
index 0cbc2a319..000000000
--- a/fs/littlefs/src/lfs_util.h
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * lfs utility functions
- *
- * Copyright (c) 2022, The littlefs authors.
- * Copyright (c) 2017, Arm Limited. All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#ifndef LFS_UTIL_H
-#define LFS_UTIL_H
-
-// Users can override lfs_util.h with their own configuration by defining
-// LFS_CONFIG as a header file to include (-DLFS_CONFIG=lfs_config.h).
-//
-// If LFS_CONFIG is used, none of the default utils will be emitted and must be
-// provided by the config file. To start, I would suggest copying lfs_util.h
-// and modifying as needed.
-#ifdef LFS_CONFIG
-#define LFS_STRINGIZE(x) LFS_STRINGIZE2(x)
-#define LFS_STRINGIZE2(x) #x
-#include LFS_STRINGIZE(LFS_CONFIG)
-#else
-
-// System includes
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <inttypes.h>
-
-#ifndef LFS_NO_MALLOC
-#include <stdlib.h>
-#endif
-#ifndef LFS_NO_ASSERT
-#include <assert.h>
-#endif
-#if !defined(LFS_NO_DEBUG) || \
- !defined(LFS_NO_WARN) || \
- !defined(LFS_NO_ERROR) || \
- defined(LFS_YES_TRACE)
-#include <stdio.h>
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-// Macros, may be replaced by system specific wrappers. Arguments to these
-// macros must not have side-effects as the macros can be removed for a smaller
-// code footprint
-
-// Logging functions
-#ifndef LFS_TRACE
-#ifdef LFS_YES_TRACE
-#define LFS_TRACE_(fmt, ...) \
- printf("%s:%d:trace: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
-#define LFS_TRACE(...) LFS_TRACE_(__VA_ARGS__, "")
-#else
-#define LFS_TRACE(...)
-#endif
-#endif
-
-#ifndef LFS_DEBUG
-#ifndef LFS_NO_DEBUG
-#define LFS_DEBUG_(fmt, ...) \
- printf("%s:%d:debug: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
-#define LFS_DEBUG(...) LFS_DEBUG_(__VA_ARGS__, "")
-#else
-#define LFS_DEBUG(...)
-#endif
-#endif
-
-#ifndef LFS_WARN
-#ifndef LFS_NO_WARN
-#define LFS_WARN_(fmt, ...) \
- printf("%s:%d:warn: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
-#define LFS_WARN(...) LFS_WARN_(__VA_ARGS__, "")
-#else
-#define LFS_WARN(...)
-#endif
-#endif
-
-#ifndef LFS_ERROR
-#ifndef LFS_NO_ERROR
-#define LFS_ERROR_(fmt, ...) \
- printf("%s:%d:error: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
-#define LFS_ERROR(...) LFS_ERROR_(__VA_ARGS__, "")
-#else
-#define LFS_ERROR(...)
-#endif
-#endif
-
-// Runtime assertions
-#ifndef LFS_ASSERT
-#ifndef LFS_NO_ASSERT
-#define LFS_ASSERT(test) assert(test)
-#else
-#define LFS_ASSERT(test)
-#endif
-#endif
-
-
-// Builtin functions, these may be replaced by more efficient
-// toolchain-specific implementations. LFS_NO_INTRINSICS falls back to a more
-// expensive basic C implementation for debugging purposes
... 140 lines suppressed ...
[mynewt-core] 02/02: apps/fs_test: Fix includes
Posted by je...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jerzy pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-core.git
commit a20166facfabe583d0a49ec2a146ac4028d59126
Author: Jerzy Kasenberg <je...@codecoup.pl>
AuthorDate: Wed Jun 14 23:50:43 2023 +0200
apps/fs_test: Fix includes
file was trying to include "littlefs/lfs.h" file but
newt never added include search path that would match this.
Now with littlefs converted to sdk package it is included
but path changed so littlefs directory does not apply anymore.
---
apps/fs_test/src/littlefs.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/apps/fs_test/src/littlefs.c b/apps/fs_test/src/littlefs.c
index 74604d1f5..647b5021b 100644
--- a/apps/fs_test/src/littlefs.c
+++ b/apps/fs_test/src/littlefs.c
@@ -25,7 +25,7 @@
#error "No LITTLEFS_FLASH_AREA defined"
#endif
-#include "littlefs/lfs.h"
+#include "lfs.h"
int littlefs_reformat(void);
int littlefs_init(void);