adafruit-mirror/littlefs-pure-js
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
littlefs-pure-js/littlefs.js
Melissa LeBlanc-Williams fa15abc13e Add some utility functions that are now only used here
2022-04-08 08:17:38 -07:00

3447 lines
100 KiB
JavaScript
Raw Permalink Blame History

/*********************************************************************/
// LittleFS JavaScript Port based on LittleFS 2.4.2
// Written by Melissa LeBlanc-Williams for Adafruit Industries
/*********************************************************************/
// Error constants
const LFS_ERR_OK = 0 // No error
const LFS_ERR_IO = -5 // Error during device operation
const LFS_ERR_CORRUPT = -84 // Corrupted
const LFS_ERR_NOENT = -2 // No directory entry
const LFS_ERR_EXIST = -17 // Entry already exists
const LFS_ERR_NOTDIR = -20 // Entry is not a dir
const LFS_ERR_ISDIR = -21 // Entry is a dir
const LFS_ERR_NOTEMPTY = -39 // Dir is not empty
const LFS_ERR_BADF = -9 // Bad file number
const LFS_ERR_FBIG = -27 // File too large
const LFS_ERR_INVAL = -22 // Invalid parameter
const LFS_ERR_NOSPC = -28 // No space left on device
const LFS_ERR_NOMEM = -12 // No more memory available
const LFS_ERR_NOATTR = -61 // No data/attr available
const LFS_ERR_NAMETOOLONG = -36 // File name too long
const LFS_DISK_VERSION = 0x00020000
const LFS_DISK_VERSION_MAJOR = (0xffff & (LFS_DISK_VERSION >>> 16))
const LFS_DISK_VERSION_MINOR = (0xffff & (LFS_DISK_VERSION >>> 0))
const LFS_NAME_MAX = 32
const LFS_FILE_MAX = 2147483647
const LFS_ATTR_MAX = 1022
const LFS_BLOCK_NULL = -1
const LFS_BLOCK_INLINE = -2
const LFS_TYPE_REG = 0x001
const LFS_TYPE_DIR = 0x002
// internally used types
const LFS_TYPE_SPLICE = 0x400
const LFS_TYPE_NAME = 0x000
const LFS_TYPE_STRUCT = 0x200
const LFS_TYPE_USERATTR = 0x300
const LFS_TYPE_FROM = 0x100
const LFS_TYPE_TAIL = 0x600
const LFS_TYPE_GLOBALS = 0x700
const LFS_TYPE_CRC = 0x500
// internally used type specializations
const LFS_TYPE_CREATE = 0x401
const LFS_TYPE_DELETE = 0x4ff
const LFS_TYPE_SUPERBLOCK = 0x0ff
const LFS_TYPE_DIRSTRUCT = 0x200
const LFS_TYPE_CTZSTRUCT = 0x202
const LFS_TYPE_INLINESTRUCT = 0x201
const LFS_TYPE_SOFTTAIL = 0x600
const LFS_TYPE_HARDTAIL = 0x601
const LFS_TYPE_MOVESTATE = 0x7ff
// internal chip sources
const LFS_FROM_NOOP = 0x000
const LFS_FROM_MOVE = 0x101
const LFS_FROM_USERATTRS = 0x102
// Comparison Constants
const LFS_CMP_EQ = 0
const LFS_CMP_LT = 1
const LFS_CMP_GT = 2
const LFS_F_DIRTY = 0x010000 // File does not match storage
const LFS_F_WRITING = 0x020000 // File has been written since last flush
const LFS_F_READING = 0x040000 // File has been read since last flush
const LFS_F_ERRED = 0x080000 // An error occurred during write
const LFS_F_INLINE = 0x100000 // Currently inlined in directory entry
// File open flags
const LFS_O_RDONLY = 1 // Open a file as read only
const LFS_O_WRONLY = 2 // Open a file as write only
const LFS_O_RDWR = 3 // Open a file as read and write
const LFS_O_CREAT = 0x0100 // Create a file if it does not exist
const LFS_O_EXCL = 0x0200 // Fail if a file already exists
const LFS_O_TRUNC = 0x0400 // Truncate the existing file to zero size
const LFS_O_APPEND = 0x0800 // Move to end of file on every write
function toHex(value, size=2) {
return "0x" + value.toString(16).toUpperCase().padStart(size, "0");
}
function toByteArray(str) {
let byteArray = [];
for (let i = 0; i < str.length; i++) {
let charcode = str.charCodeAt(i);
if (charcode <= 0xFF) {
byteArray.push(charcode);
}
}
return byteArray;
}
class LittleFS {
constructor(config) {
this.rcache = new Cache();
this.pcache = new Cache();
this.root = new Uint8Array(2);
this.mList = new MList();
this.seed = 0;
this.gstate = new GState({tag: 0});
this.gdisk = new GState({tag: 0});
this.gdelta = new GState({tag: 0});
this.free = {
off: LFS_BLOCK_NULL,
size: LFS_BLOCK_NULL,
i: LFS_BLOCK_NULL,
ack: LFS_BLOCK_NULL,
buffer: null
};
this.nameMax = 0;
this.fileMax = 0;
this.attrMax = 0;
this.init(config);
}
init(config) {
let err = 0;
if (config) {
this.cfg = config;
}
// validate that the lfs-cfg sizes were initiated properly before
// performing any arithmetic logics with them
console.assert(this.cfg.readSize != 0);
console.assert(this.cfg.progSize != 0);
console.assert(this.cfg.cacheSize != 0);
// check that block size is a multiple of cache size is a multiple
// of prog and read sizes
console.assert(this.cfg.cacheSize % this.cfg.readSize == 0);
console.assert(this.cfg.cacheSize % this.cfg.progSize == 0);
console.assert(this.cfg.blockSize % this.cfg.cacheSize == 0);
// check that the block size is large enough to fit ctz pointers
console.assert(4*this.npw2(0xffffffff / (this.cfg.blockSize-2*4))
<= this.cfg.blockSize);
// 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.
console.assert(this.cfg.blockCycles != 0);
// setup read cache
if (this.cfg.readBuffer) {
this.rcache.buffer = this.cfg.readBuffer;
} else {
this.rcache.buffer = new Uint8Array(this.cfg.cacheSize);
}
// setup program cache
if (this.cfg.progBuffer) {
this.pcache.buffer = this.cfg.progBuffer;
} else {
this.pcache.buffer = new Uint8Array(this.cfg.cacheSize);
}
// zero to avoid information leaks
this.cacheZero(this.rcache);
this.cacheZero(this.pcache);
// setup lookahead, must be multiple of 64-bits, 32-bit aligned
console.assert(this.cfg.lookaheadSize > 0);
console.assert(this.cfg.lookaheadSize % 8 == 0 &&
this.cfg.lookaheadBuffer % 4 == 0);
if (this.cfg.lookaheadBuffer) {
this.free.buffer = this.cfg.lookaheadBuffer
} else {
this.free.buffer = new Uint8Array(this.cfg.lookaheadSize);
}
if (!this.nameMax) {
this.nameMax = this.cfg.nameMax;
}
if (!this.fileMax) {
this.fileMax = this.cfg.fileMax;
}
if (!this.attrMax) {
this.attrMax = this.cfg.attrMax;
}
this.root[0] = LFS_BLOCK_NULL;
this.root[1] = LFS_BLOCK_NULL;
this.mList = new MList();
this.seed = 0;
this.gdisk.tag = 0;
this.gstate.tag = 0;
this.gdelta.tag = 0;
}
deinit() {
if (!this.cfg.readBuffer) {
this.rcache.buffer = null;
}
if (!this.cfg.progBuffer) {
this.pcache.buffer = null;
}
if (!this.cfg.lookaheadBuffer) {
this.free.buffer = null;
}
}
format() {
let err;
main_block: if(true) {
this.init()
this.free.off = 0;
this.free.size = Math.min(this.cfg.lookaheadSize, this.cfg.blockSize)
this.free.i = 0;
this.allocAck();
let root = new MDir();
err = this.dirAlloc(root);
if (err) {
return;
}
let superblock = new SuperBlock({
version: LFS_DISK_VERSION,
blockSize: this.cfg.blockSize,
blockCount: this.cfg.blockCount,
nameMax: this.nameMax,
fileMax: this.fileMax,
attrMax: this.attrMax
});
this.tagId(0x6000);
this.superblockTole32(superblock);
this.dirCommit(root, this.mkAttrs(
[this.mkTag(LFS_TYPE_CREATE, 0, 0), null],
[this.mkTag(LFS_TYPE_SUPERBLOCK, 0, 8), "littlefs"],
[this.mkTag(LFS_TYPE_INLINESTRUCT, 0, struct.calcsize("IIIIII")), superblock]
));
err = this.dirCommit(root, null);
if (err) {
break main_block;
}
err = this.dirFetch(root, [0, 1]);
if (err) {
break main_block;
}
}
this.deinit()
return err;
}
allocAck() {
this.free.ack = this.cfg.blockCount;
}
dirAlloc(dir) {
let err;
for (let i = 0; i < 2; i++) {
let blockObj = new ByRef();
err = this.alloc(blockObj);
dir.pair[(i+1) % 2] = blockObj.get();
if (err) return err;
}
dir.rev = 0;
let bufferByRef = new ByRef(dir.rev)
err = this.bdRead(null, this.rcache, struct.calcsize("I"), dir.pair[0], 0, bufferByRef, struct.calcsize("I"));
dir.rev = bufferByRef.get();
dir.rev = this.fromle32(dir.rev);
if (err && err != LFS_ERR_CORRUPT) {
return err;
}
if (this.cfg.blockCycles > 0) {
dir.rev = this.alignup(dir.rev, ((this.cfg.blockCycles+1)|1));
}
// set defaults
dir.off = struct.calcsize("I");
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 LFS_ERR_OK;
}
// Find the smallest power of 2 greater than or equal to a
npw2(a) {
let r = 0;
let s;
a -= 1;
s = (a > 0xffff) << 4; a >>>= s; r |= s;
s = (a > 0xff ) << 3; a >>>= s; r |= s;
s = (a > 0xf ) << 2; a >>>= s; r |= s;
s = (a > 0x3 ) << 1; a >>>= s; r |= s;
return (r | (a >>> 1)) + 1;
}
aligndown(value, alignment) {
return (value - (value % alignment)) >>> 0;
}
alignup(value, alignment) {
return this.aligndown((value + alignment - 1) >>> 0, alignment);
}
alloc(blockObj) {
while (true) {
while (this.free.i != this.free.size) {
let off = this.free.i;
this.free.i += 1;
this.free.ack -= 1;
if (!(this.free.buffer[parseInt(this.free.i / 32)] & (1 << (off % 32)))) {
// found a free block
blockObj.set((this.free.off + off) % this.cfg.blockCount);
// eagerly find next off so an alloc ack can
// discredit old lookahead blocks
while (this.free.i != this.free.size &&
(this.free.buffer[parseInt(this.free.i / 32)]
& (1 << (this.free.i % 32)))) {
this.free.i += 1;
this.free.ack -= 1;
}
return 0;
}
}
// check if we have looked at all blocks since last ack
if (this.free.ack == 0) {
console.warn("No more free space " + this.free.i + this.free.off);
return LFS_ERR_NOSPC;
}
this.free.off = (this.free.off + this.free.size)
% this.cfg.blockCount;
this.free.size = Math.min(8 * this.cfg.lookaheadSize, this.free.ack);
this.free.i = 0;
// find mask of free blocks from tree
let err = this.fsTraverse(this.allocLookahead.bind(this), null, true);
if (err) {
this.allocDrop();
return err;
}
}
}
pairIsnull(pair) {
return pair[0] == LFS_BLOCK_NULL || pair[1] == LFS_BLOCK_NULL;
}
fsTraverse(callback, data, includeOrphans) {
let err;
// iterate over metadata pairs
let dir = new MDir();
dir.tail = [0, 1];
let cycle = 0;
while (!this.pairIsnull(dir.tail)) {
if (cycle >= this.cfg.blockCount/2) {
// loop detected
return LFS_ERR_CORRUPT;
}
cycle += 1;
for (let i = 0; i < 2; i++) {
err = callback(dir.tail[i]);
if (err) {
return err;
}
}
// iterate through ids in directory
err = this.dirFetch(dir, dir.tail);
if (err) {
return err;
}
for (let id = 0; id < dir.count; id++) {
let ctz = new Ctz();
let bufferObj = new ByRef(new Uint8Array(struct.calcsize("II")));
let tag = this.dirGet(dir, this.mkTag(0x700, 0x3ff, 0),
this.mkTag(LFS_TYPE_STRUCT, id, struct.calcsize("II")), bufferObj);
ctz.setFromBuffer(bufferObj.get())
if (tag < 0) {
if (tag == LFS_ERR_NOENT) {
continue;
}
return tag;
}
this.ctzFromle32(ctz);
if (this.tagType3(tag) == LFS_TYPE_CTZSTRUCT) {
err = this.ctzTraverse(this.rcache,
ctz.head, ctz.size, callback, data);
if (err) {
return err;
}
} else if (includeOrphans &&
this.tagType3(tag) == LFS_TYPE_DIRSTRUCT) {
for (let i = 0; i < 2; i++) {
err = callback(data, (ctz.head)[i]);
if (err) {
return err;
}
}
}
}
}
// iterate over any open files
for (let f = this.mList; f; f = f.next) {
if (f.type != LFS_TYPE_REG) {
continue;
}
if ((f.flags & LFS_F_DIRTY) && !(f.flags & LFS_F_INLINE)) {
let err = this.ctzTraverse(f.cache, this.rcache,
f.ctz.head, f.ctz.size, callback, data);
if (err) {
return err;
}
}
if ((f.flags & LFS_F_WRITING) && !(f.flags & LFS_F_INLINE)) {
let err = this.ctzTraverse(f.cache, this.rcache,
f.block, f.pos, callback, data);
if (err) {
return err;
}
}
}
return 0;
}
dirFetch(dir, pair) {
// note, mask=-1, tag=-1 can never match a tag since this
// pattern has the invalid bit set
return this.dirFetchmatch(dir, pair, -1, -1, new ByRef(null), null, null);
}
dirFetchmatch(dir, pair, fmask, ftag, idByRef, callback, data) {
// we can find tag very efficiently during a fetch, since we're already
// scanning the entire directory
let 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] >= this.cfg.blockCount || pair[1] >= this.cfg.blockCount) {
return LFS_ERR_CORRUPT;
}
// find the block with the most recent revision
let revs = [0, 0];
let r = 0;
let bufferByRef = new ByRef();
for (let i = 0; i < 2; i++) {
let err = this.bdRead(null, this.rcache, struct.calcsize("I"),
pair[i], 0, bufferByRef, struct.calcsize("I"));
revs[i] = bufferByRef.get();
revs[i] = this.fromle32(revs[i]);
if (err && err != LFS_ERR_CORRUPT) {
return err;
}
if (err != LFS_ERR_CORRUPT &&
this.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 (let i = 0; i < 2; i++) {
let off = 0;
let ptag = 0xffffffff;
let tempcount = 0;
let temptail = [LFS_BLOCK_NULL, LFS_BLOCK_NULL];
let tempsplit = false;
let tempbesttag = besttag;
dir.rev = this.tole32(dir.rev);
let crc = this.crc(0xffffffff, dir.rev, struct.calcsize("I"));
dir.rev = this.fromle32(dir.rev);
while (true) {
// extract next tag
let tag;
bufferByRef = new ByRef();
off += this.tagDsize(ptag);
let err = this.bdRead(null, this.rcache, this.cfg.blockSize,
dir.pair[0], off, bufferByRef, struct.calcsize("I"));
tag = bufferByRef.get();
if (err) {
if (err == LFS_ERR_CORRUPT) {
// can't continue?
dir.erased = false;
break;
}
return err;
}
crc = this.crc(crc, tag, struct.calcsize("I"));
tag = (this.fromBe32(tag) ^ ptag) >>> 0;
// next commit not yet programmed or we're not in valid range
if (!this.tagIsvalid(tag)) {
dir.erased = (this.tagType1(ptag) == LFS_TYPE_CRC &&
dir.off % this.cfg.progSize == 0);
break;
} else if (off + this.tagDsize(tag) > this.cfg.blockSize) {
dir.erased = false;
break;
}
ptag = tag;
if (this.tagType1(tag) == LFS_TYPE_CRC) {
// check the crc attr
let dcrc;
bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, this.cfg.blockSize,
dir.pair[0], off + struct.calcsize("I"), bufferByRef, struct.calcsize("I"));
if (err) {
if (err == LFS_ERR_CORRUPT) {
dir.erased = false;
break;
}
return err;
}
dcrc = bufferByRef.get();
dcrc = this.fromle32(dcrc);
if (crc != dcrc) {
dir.erased = false;
break;
}
// reset the next bit if we need to
ptag ^= (this.tagChunk(tag) & 1) << 31;
ptag = ptag >>> 0;
// 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
this.seed = this.crc(this.seed, crc, struct.calcsize("I"));
// update with what's found so far
besttag = tempbesttag;
dir.off = off + this.tagDsize(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 (let j = struct.calcsize("I"); j < this.tagDsize(tag); j++) {
let dat;
bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, this.cfg.blockSize,
dir.pair[0], off+j, bufferByRef, 1);
if (err) {
if (err == LFS_ERR_CORRUPT) {
dir.erased = false;
break;
}
return err;
}
dat = bufferByRef.get();
crc = this.crc(crc, dat, 1);
}
// directory modification tags?
if (this.tagType1(tag) == LFS_TYPE_NAME) {
// increase count of files if necessary
if (this.tagId(tag) >= tempcount) {
tempcount = this.tagId(tag) + 1;
}
} else if (this.tagType1(tag) == LFS_TYPE_SPLICE) {
tempcount += this.tagSplice(tag);
if (tag == (this.mkTag(LFS_TYPE_DELETE, 0, 0) |
(this.mkTag(0, 0x3ff, 0) & tempbesttag))) {
tempbesttag |= 0x80000000;
} else if (tempbesttag != -1 &&
this.tagId(tag) <= this.tagId(tempbesttag)) {
tempbesttag += this.mkTag(0, this.tagSplice(tag), 0);
}
} else if (this.tagType1(tag) == LFS_TYPE_TAIL) {
tempsplit = (this.tagChunk(tag) & 1);
bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, this.cfg.blockSize,
dir.pair[0], off + struct.calcsize("I"), bufferByRef, 8);
if (err) {
if (err == LFS_ERR_CORRUPT) {
dir.erased = false;
break;
}
}
temptail = bufferByRef.get();
this.pairFromle32(temptail);
}
// found a match for our fetcher?
if ((fmask & tag) == (fmask & ftag)) {
let res = callback(data, tag, new Diskoff({block: dir.pair[0], off: off+struct.calcsize("I")}));
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 ((this.mkTag(0x7ff, 0x3ff, 0) & tag) ==
(this.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 &&
this.tagId(tag) <= this.tagId(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 (this.gstateHasmovehere(this.gdisk, dir.pair)) {
if (this.tagId(this.gdisk.tag) == this.tagId(besttag)) {
besttag |= 0x80000000;
} else if (besttag != -1 &&
this.tagId(this.gdisk.tag) < this.tagId(besttag)) {
besttag -= this.mkTag(0, 1, 0);
}
}
// found tag? or found best id?
if (idByRef.get()) {
idByRef.set(Math.min(this.tagId(besttag), dir.count));
}
if (this.tagIsvalid(besttag)) {
return besttag;
} else if (this.tagId(besttag) < dir.count) {
return LFS_ERR_NOENT;
} else {
return 0;
}
}
// failed, try the other block?
this.pairSwap(dir.pair);
dir.rev = revs[(r+1)%2];
}
console.warn("Corrupted dir pair at {" +dir.pair[0]+ ", " + dir.pair[1] + "}");
return LFS_ERR_CORRUPT;
}
dirFindMatch(name, tag, disk) {
// compare with disk
let diff = Math.min(name.size, this.tagSize(tag));
let res = this.bdCmp(null, this.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 != this.tagSize(tag)) {
return (name.size < this.tagSize(tag)) ? LFS_CMP_LT : LFS_CMP_GT;
}
// found a match!
return LFS_CMP_EQ;
}
allocLookahead(block) {
let off = ((block - this.free.off) + this.cfg.blockCount) % this.cfg.blockCount
if (off < this.free.size) {
let offset = parseInt(off / 32);
this.free.buffer.set(this.free.buffer.slice(offset, offset + 1) | 1 << (off % 32), offset);
}
}
tagType1(tag) {
return (tag & 0x70000000) >>> 20;
}
tagType3(tag) {
return (tag & 0x7ff00000) >>> 20;
}
tagId(tag) {
return (tag & 0x000ffc00) >>> 10;
}
tagDsize(tag) {
return struct.calcsize("I") + this.tagSize(tag + this.tagIsdelete(tag));
}
tagSize(tag) {
return tag & 0x000003ff;
}
tagIsdelete(tag) {
return ((tag << 22) >> 22) == -1;
}
tagIsvalid(tag) {
return !(tag & 0x80000000);
}
tagChunk(tag) {
return ((tag & 0x0ff00000) >> 20) & 0xff;
}
tagSplice(tag) {
return (this.tagChunk(tag) << 24) >> 24;
}
crc(crc, buffer, size) {
let data;
const rtable = [
0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
];
if (buffer == null) {
data = [];
} else if (typeof buffer === 'string') {
data = toByteArray(buffer);
} else if (typeof buffer === 'object') {
data = new Uint8Array(size);
const dataSize = parseInt(size / Object.entries(buffer).length);
Object.values(buffer).forEach((value, index) => {
data.set(LittleFS.UintToBuffer(value, dataSize), index * dataSize);
});
data = Array.from(data);
} else {
data = Array.from(LittleFS.UintToBuffer(buffer, size));
}
for (let i = 0; i < size; i++) {
crc = ((crc >>> 4) ^ rtable[(crc ^ (data[i] >>> 0)) & 0xf]) >>> 0;
crc = ((crc >>> 4) ^ rtable[(crc ^ (data[i] >>> 4)) & 0xf]) >>> 0;
}
return crc;
}
allocDrop() {
this.free.size = 0;
this.free.i = 0;
this.allocAck();
}
pairSwap(pair) {
let t = pair[0];
pair[0] = pair[1];
pair[1] = t;
}
gstateHasorphans(a) {
return !!this.tagSize(a.tag);
}
gstateGetorphans(a) {
return this.tagSize(a.tag);
}
gstateHasmove(a) {
return this.tagType1(a.tag);
}
gstateHasmovehere(a, pair) {
return this.tagType1(a.tag) && this.pairCmp(a.pair, pair) == 0;
}
pairCmp(pairA, pairB) {
return !(pairA[0] == pairB[0] || pairA[1] == pairB[1] ||
pairA[0] == pairB[1] || pairA[1] == pairB[0]);
}
static bufferToUint(buffer, size) {
const view = new DataView(buffer.buffer)
let ret = [];
let offset = 0;
// If size > 4, we will return an array of Uints
while(size > 0) {
if (size >= 4) {
ret.push(view.getUint32(offset, true));
size -= 4;
offset += 4;
} else if (size >= 2) {
ret.push(view.getUint16(offset, true));
size -= 2;
offset += 2;
} else if (size >= 1) {
ret.push(view.getUint8(offset, true));
size -= 1;
offset += 1;
}
}
if (ret.length == 1) {
return ret[0];
}
return ret;
}
static UintToBuffer(data, size) {
let buffer = new Uint8Array(size);
const view = new DataView(buffer.buffer);
let offset = 0;
while(size > 0) {
if (size >= 4) {
view.setUint32(offset, data, true);
size -= 4;
offset += 4;
} else if (size >= 2) {
view.setUint16(offset, data, true);
size -= 2;
offset += 2;
} else if (size >= 1) {
view.setUint8(offset, data, true);
size -= 1;
offset += 1;
}
}
return buffer;
}
// Block Device Read
bdRead(pcache, rcache, hint, block, off, bufferByRef, size, returnRaw=false) {
let data = new Uint8Array(size);
let dataPtr = 0;
if (block >= this.cfg.blockCount ||
off+size > this.cfg.blockSize) {
return LFS_ERR_CORRUPT;
}
let bufferSize = size;
while (size > 0) {
let diff = size;
if (pcache && block == pcache.block &&
off < pcache.off + pcache.size) {
if (off >= pcache.off) {
// is already in pcache?
diff = Math.min(diff, pcache.size - (off-pcache.off));
//memcpy(data, pcache.buffer[off-pcache.off], diff);
data.set(pcache.buffer.slice(off-pcache.off, off-pcache.off + diff), dataPtr);
dataPtr += diff;
off += diff;
size -= diff;
continue;
}
// pcache takes priority
diff = Math.min(diff, pcache.off-off);
}
if (block == rcache.block &&
off < rcache.off + rcache.size) {
if (off >= rcache.off) {
// is already in rcache?
diff = Math.min(diff, rcache.size - (off-rcache.off));
//memcpy(data, rcache.buffer[off-rcache.off], diff);
data.set(rcache.buffer.slice(off-rcache.off, off-rcache.off + diff), dataPtr);
dataPtr += diff;
off += diff;
size -= diff;
continue;
}
// rcache takes priority
diff = Math.min(diff, rcache.off-off);
}
if (size >= hint && off % this.cfg.readSize == 0 &&
size >= this.cfg.readSize) {
// bypass cache?
diff = this.aligndown(diff, this.cfg.readSize);
let err = this.cfg.read(block, off, data, diff);
if (err) {
return err;
}
dataPtr += diff;
off += diff;
size -= diff;
continue;
}
// load to cache, first condition can no longer fail
console.assert(block < this.cfg.blockCount);
rcache.block = block;
rcache.off = this.aligndown(off, this.cfg.readSize);
rcache.size = Math.min(
Math.min(
this.alignup(off+hint, this.cfg.readSize),
this.cfg.blockSize)
- rcache.off,
this.cfg.cacheSize);
let err = this.cfg.read(rcache.block, rcache.off, rcache.buffer, rcache.size);
console.assert(err <= 0);
if (err) {
return err;
}
}
bufferByRef.set(data);
if (!returnRaw) {
bufferByRef.set(LittleFS.bufferToUint(bufferByRef.get(), bufferSize));
}
return 0;
}
bdFlush(pcache, rcache, validate) {
if (pcache.block != LFS_BLOCK_NULL && pcache.block != LFS_BLOCK_INLINE) {
console.assert(pcache.block < this.cfg.blockCount);
let diff = this.alignup(pcache.size, this.cfg.progSize);
let err = this.cfg.prog(pcache.block, pcache.off, pcache.buffer, diff);
console.assert(err <= 0);
if (err) {
return err;
}
if (validate) {
// check data on disk
this.cacheDrop(rcache);
let res = this.bdCmp(null, rcache, diff,
pcache.block, pcache.off, pcache.buffer, diff);
if (res < 0) {
return res;
}
if (res != LFS_CMP_EQ) {
return LFS_ERR_CORRUPT;
}
}
this.cacheZero(pcache);
}
return 0;
}
bdCmp(pcache, rcache, hint, block, off, buffer, size) {
let data;
if (typeof buffer === 'string') {
data = toByteArray(buffer);
} else {
data = buffer;
}
let diff = 0;
for (let i = 0; i < size; i += diff) {
let bufferByRef = new ByRef();
diff = Math.min(size-i, struct.calcsize("BBBBBBBB"));
let res = this.bdRead(pcache, rcache, hint-i,
block, off+i, bufferByRef, diff, true);
let dat = bufferByRef.get();
if (res) {
return res;
}
res = this.memcmp(dat, data.slice(i), diff);
if (res) {
return res < 0 ? LFS_CMP_LT : LFS_CMP_GT;
}
}
return LFS_CMP_EQ;
}
memcmp(array1, array2, size) {
size = Math.min(array1.length, array2.length, size);
for (let i = 0; i < size; i++) {
if (array1[i] === array2[i]) {
continue;
} else if (array1[i] < array2[i]) {
return -1;
} else {
return 1;
}
}
return 0;
}
bdErase(block) {
console.assert(block < this.cfg.blockCount);
let err = this.cfg.erase(block);
console.assert(err <= 0);
return err;
}
bdProg(pcache, rcache, validate, block, off, buffer, size) {
let data;
let dataPtr = 0;
if (buffer == null) {
data = new Uint8Array(size);
} else if (Array.isArray(buffer)) {
data = new Uint8Array(size);
const dataSize = parseInt(size / buffer.length);
for(let [index, item] of buffer.entries()) {
data.set(LittleFS.UintToBuffer(item, dataSize), index * dataSize);
}
} else if (typeof buffer === 'object') {
data = new Uint8Array(size);
const dataSize = parseInt(size / Object.entries(buffer).length);
Object.values(buffer).forEach((value, index) => {
data.set(LittleFS.UintToBuffer(value, dataSize), index * dataSize);
});
} else if (typeof buffer === 'string') {
data = new Uint8Array(size);
data.set(toByteArray(buffer));
} else {
data = LittleFS.UintToBuffer(buffer, size);
}
console.assert(block == LFS_BLOCK_INLINE || block < this.cfg.blockCount);
console.assert(off + size <= this.cfg.blockSize);
while (size > 0) {
if (block == pcache.block &&
off >= pcache.off &&
off < pcache.off + this.cfg.cacheSize) {
// already fits in pcache?
let diff = Math.min(size, this.cfg.cacheSize - (off-pcache.off));
//memcpy(&pcache->buffer[off-pcache->off], data, diff);
pcache.buffer.set(data.slice(dataPtr, dataPtr + diff), off-pcache.off);
dataPtr += diff;
off += diff;
size -= diff;
pcache.size = Math.max(pcache.size, off - pcache.off);
if (pcache.size == this.cfg.cacheSize) {
// eagerly flush out pcache if we fill up
let err = this.bdFlush(pcache, rcache, validate);
if (err) {
return err;
}
}
continue;
}
// pcache must have been flushed, either by programming an
// entire block or manually flushing the pcache
console.assert(pcache.block == LFS_BLOCK_NULL);
// prepare pcache, first condition can no longer fail
pcache.block = block;
pcache.off = this.aligndown(off, this.cfg.progSize);
pcache.size = 0;
}
return 0;
}
bdSync(pcache, rcache, validate) {
this.cacheDrop(rcache);
let err = this.bdFlush(pcache, rcache, validate);
if (err) {
return err;
}
err = this.cfg.sync();
console.assert(err <= 0);
return err;
}
mount() {
// scan directory blocks for superblock and any global updates
let dir = new MDir()
dir.tail = [0, 1];
let cycle = 0;
let err;
while (!this.pairIsnull(dir.tail)) {
if (cycle >= this.cfg.blockCount/2) {
// loop detected
err = LFS_ERR_CORRUPT;
}
cycle += 1;
// fetch next block in tail list
let tag = this.dirFetchmatch(dir, dir.tail,
this.mkTag(0x7ff, 0x3ff, 0),
this.mkTag(LFS_TYPE_SUPERBLOCK, 0, 8),
new ByRef(null),
this.dirFindMatch.bind(this),
new DirFindMatch({name: "littlefs", size: 8}));
if (tag < 0) {
err = tag;
}
// has superblock?
if (tag && !this.tagIsdelete(tag)) {
// update root
this.root[0] = dir.pair[0];
this.root[1] = dir.pair[1];
// grab superblock
let superBlockByRef = new ByRef(new Uint8Array(struct.calcsize("IIIIII")));
tag = this.dirGet(dir, this.mkTag(0x7ff, 0x3ff, 0),
this.mkTag(LFS_TYPE_INLINESTRUCT, 0, superBlockByRef.get().byteLength),
superBlockByRef);
if (tag < 0) {
err = tag;
}
let superblock = new SuperBlock();
superblock.setFromBuffer(superBlockByRef.get());
this.superblockFromle32(superblock);
// check version
let major_version = (0xffff & (superblock.version >> 16));
let minor_version = (0xffff & (superblock.version >> 0));
if ((major_version != LFS_DISK_VERSION_MAJOR ||
minor_version > LFS_DISK_VERSION_MINOR)) {
console.warn("Invalid version v" + major_version + "." + minor_version);
err = LFS_ERR_INVAL;
}
// check superblock configuration
if (superblock.nameMax) {
if (superblock.nameMax > this.nameMax) {
console.error("Unsupported nameMax (" + superblock.nameMax + " > " + this.nameMax + ")");
err = LFS_ERR_INVAL;
}
this.nameMax = superblock.nameMax;
}
if (superblock.fileMax) {
if (superblock.fileMax > this.fileMax) {
console.error("Unsupported fileMax (" + superblock.fileMax + " > " + this.fileMax + ")");
err = LFS_ERR_INVAL;
}
this.fileMax = superblock.fileMax;
}
if (superblock.attrMax) {
if (superblock.attrMax > this.attrMax) {
console.error("Unsupported attrMax (" + superblock.attrMax + " > " + this.attrMax + ")");
err = LFS_ERR_INVAL;
}
this.attrMax = superblock.attrMax;
}
}
// has gstate?
err = this.dirGetgstate(dir, this.gstate);
}
// found superblock?
if (this.pairIsnull(this.root)) {
err = LFS_ERR_INVAL;
}
// update littlefs with gstate
if (!this.gstateIszero(this.gstate)) {
console.warn("Found pending gstate " + toHex(this.gstate.tag, 8) + " " + toHex(this.gstate.pair[0], 8) + " " + toHex(this.gstate.pair[1], 8));
}
this.gstate.tag += !this.tagIsvalid(this.gstate.tag);
this.gdisk = this.gstate;
// setup free lookahead, to distribute allocations uniformly across
// boots, we start the allocator at a random location
this.free.off = this.seed % this.cfg.blockCount;
this.allocDrop();
return 0;
}
unmount() {
return this.deinit();
}
deinit() {
// Nothing to do here cause this is JavaScript
return 0;
}
dirCommit(dir, attrs) {
// check for any inline files that aren't RAM backed and
// forcefully evict them, needed for filesystem consistency
if (attrs === null) {
attrs = [];
}
for (let f = this.mList; f; f = f.next) {
if (dir != f.m && this.pairCmp(f.m.pair, dir.pair) == 0 &&
f.type == LFS_TYPE_REG && (f.flags & LFS_F_INLINE) &&
f.ctz.size > this.cfg.cacheSize) {
let err = this.fileOutline(f);
if (err) {
return err;
}
err = this.fileFlush(f);
if (err) {
return err;
}
}
}
// calculate changes to the directory
let olddir = dir;
let hasdelete = false;
for (let i = 0; i < attrs.length; i++) {
if (this.tagType3(attrs[i].tag) == LFS_TYPE_CREATE) {
dir.count += 1;
} else if (this.tagType3(attrs[i].tag) == LFS_TYPE_DELETE) {
console.assert(dir.count > 0);
dir.count -= 1;
hasdelete = true;
} else if (this.tagType1(attrs[i].tag) == LFS_TYPE_TAIL) {
dir.tail[0] = attrs[i].buffer[0];
dir.tail[1] = attrs[i].buffer[1];
dir.split = (this.tagChunk(attrs[i].tag) & 1);
this.pairFromle32(dir.tail);
}
}
// should we actually drop the directory block?
if (hasdelete && dir.count == 0) {
let pdir;
let err = this.fsPred(lfs, dir.pair, pdir);
if (err && err != LFS_ERR_NOENT) {
this.copyObjProps(dir, olddir);
return err;
}
if (err != LFS_ERR_NOENT && pdir.split) {
err = this.dirDrop(pdir, dir);
if (err) {
this.copyObjProps(dir, olddir);
return err;
}
}
}
let doCompact = false;
attempt_commit: if (dir.erased || dir.count >= 0xff) {
// try to commit
let commit = new Commit({
block: dir.pair[0],
off: dir.off,
ptag: dir.etag,
crc: 0xffffffff,
begin: dir.off,
end: (this.cfg.metadataMax ?
this.cfg.metadataMax : this.cfg.blockSize) - 8,
});
// traverse attrs that need to be written out
this.pairTole32(dir.tail);
let err = this.dirTraverse(dir, dir.off, dir.etag, attrs, attrs.length,
0, 0, 0, 0, 0, this.dirCommitCommit.bind(this), commit);
this.pairFromle32(dir.tail);
if (err) {
if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
doCompact = true;
break attempt_commit;
}
this.copyObjProps(dir, olddir);
return err;
}
// commit any global diffs if we have any
let delta = new GState({tag: 0});
this.gstateXor(delta, this.gstate);
this.gstateXor(delta, this.gdisk);
this.gstateXor(delta, this.gdelta);
delta.tag &= ~this.mkTag(0, 0, 0x3ff);
if (!this.gstateIszero(delta)) {
let err = this.dirGetgstate(dir, delta);
if (err) {
this.copyObjProps(dir, olddir);
return err;
}
this.gstateTole32(delta);
err = this.dirCommitattr(
commit,
this.mkTag(LFS_TYPE_MOVESTATE, 0x3ff, struct.calcsize("I")),
delta
);
if (err) {
if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
doCompact = true;
break attempt_commit;
}
this.copyObjProps(dir, olddir);
return err;
}
}
// finalize commit with the crc
err = this.dirCommitcrc(commit);
if (err) {
if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) {
doCompact = true;
break attempt_commit;
}
this.copyObjProps(dir, olddir);
return err;
}
// successful commit, update dir
console.assert(commit.off % this.cfg.progSize == 0);
dir.off = commit.off;
dir.etag = commit.ptag;
// and update gstate
this.gdisk = this.gstate;
this.gdelta = new GState({tag: 0});
} else {
doCompact = true;
break attempt_commit;
}
if (doCompact) {
// fall back to compaction
this.cacheDrop(this.pcache);
let err = this.dirCompact(dir, attrs, attrs.length, dir, 0, dir.count);
if (err) {
this.copyObjProps(dir, olddir);
}
}
// 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.
for (let d = this.mList; d; d = d.next) {
if (d.m != dir && this.pairCmp(d.m.pair, olddir.pair) == 0) {
d.m = dir;
for (let i = 0; i < attrs.length; i++) {
if (this.tagType3(attrs[i].tag) == LFS_TYPE_DELETE &&
d.id == this.tagId(attrs[i].tag)) {
d.m.pair[0] = LFS_BLOCK_NULL;
d.m.pair[1] = LFS_BLOCK_NULL;
} else if (this.tagType3(attrs[i].tag) == LFS_TYPE_DELETE &&
d.id > this.tagId(attrs[i].tag)) {
d.id -= 1;
if (d.type == LFS_TYPE_DIR) {
d.pos -= 1;
}
} else if (this.tagType3(attrs[i].tag) == LFS_TYPE_CREATE &&
d.id >= this.tagId(attrs[i].tag)) {
d.id += 1;
if (d.type == LFS_TYPE_DIR) {
d.pos += 1;
}
}
}
}
}
for (let d = this.mList; d; d = d.next) {
if (this.pairCmp(d.m.pair, olddir.pair) == 0) {
while (d.id >= d.m.count && d.m.split) {
// we split and id is on tail now
d.id -= d.m.count;
let err = this.dirFetch(d.m, d.m.tail);
if (err) {
return err;
}
}
}
}
return 0;
}
dirCompact(dir, attrs, attrcount, source, begin, end) {
// save some state in case block is bad
const oldpair = [dir.pair[0], dir.pair[1]];
let relocated = false;
let tired = false;
let doRelocate = false;
// should we split?
while (end - begin > 1) {
// find size
let size = 0;
let sizeObj = {size: size}
let err = this.dirTraverse(source, 0, 0xffffffff, attrs, attrcount,
this.mkTag(0x400, 0x3ff, 0),
this.mkTag(LFS_TYPE_NAME, 0, 0),
begin, end, -begin,
this.dirCommitSize.bind(this), sizeObj);
size = sizeObj.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 - begin < 0xff &&
size <= Math.min(this.cfg.blockSize - 36,
this.alignup((this.cfg.metadataMax ?
this.cfg.metadataMax : this.cfg.blockSize)/2,
this.cfg.progSize))) {
break;
}
// can't fit, need to split, we should really be finding the
// largest size that fits with a small binary search, but right now
// it's not worth the code size
let split = (end - begin) / 2;
err = this.dirSplit(dir, attrs, attrcount, source, begin+split, end);
if (err) {
// if we fail to split, we may be able to overcompact, unless
// we're too big for even the full block, in which case our
// only option is to error
if (err == LFS_ERR_NOSPC && size <= this.cfg.blockSize - 36) {
break;
}
return err;
}
end = begin + split;
}
// increment revision count
dir.rev += 1;
// 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
if (this.cfg.blockCycles > 0 && (dir.rev % ((this.cfg.blockCycles+1)|1) == 0)) {
if (this.pairCmp(dir.pair, [0, 1]) == 0) {
// oh no! we're writing too much to the superblock,
// should we expand?
let res = this.fsRawsize();
if (res < 0) {
return res;
}
// do we have extra space? littlefs can't reclaim this space
// by itself, so expand cautiously
if (res < this.cfg.blockCount/2) {
console.warn("Expanding superblock at rev " + dir.rev);
let err = this.dirSplit(dir, attrs, attrcount, source, begin, end);
if (err && err != LFS_ERR_NOSPC) {
return 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
if (!err) {
end = begin;
}
}
} else {
// we're writing too much, time to relocate
tired = true;
doRelocate = true;
}
}
// begin loop to commit compaction to blocks until a compact sticks
main_while_loop: while (true) {
compaction_block: if (!doRelocate) {
// setup commit state
let commit = new Commit ({
block: dir.pair[1],
off: 0,
ptag: 0xffffffff,
crc: 0xffffffff,
begin: 0,
end: (this.cfg.metadataMax ?
this.cfg.metadataMax : this.cfg.blockSize) - 8,
});
// erase block to write to
let err = this.bdErase(dir.pair[1]);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
// write out header
dir.rev = this.tole32(dir.rev);
err = this.dirCommitprog(commit, dir.rev, struct.calcsize("I"));
dir.rev = this.fromle32(dir.rev);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
// traverse the directory, this time writing out all unique tags
err = this.dirTraverse(source, 0, 0xffffffff, attrs, attrcount,
this.mkTag(0x400, 0x3ff, 0),
this.mkTag(LFS_TYPE_NAME, 0, 0),
begin, end, -begin,
this.dirCommitCommit.bind(this), commit);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
// commit tail, which may be new after last size check
if (!this.pairIsnull(dir.tail)) {
this.pairTole32(dir.tail);
err = this.dirCommitattr(commit,
this.mkTag(LFS_TYPE_TAIL + dir.split, 0x3ff, 8),
dir.tail);
this.pairFromle32(dir.tail);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
}
// bring over gstate?
let delta = new GState({tag: 0});
if (!relocated) {
this.gstateXor(delta, this.gdisk);
this.gstateXor(delta, this.gstate);
}
this.gstateXor(delta, this.gdelta);
delta.tag &= ~this.mkTag(0, 0, 0x3ff);
err = this.dirGetgstate(dir, delta);
if (err) {
return err;
}
if (!this.gstateIszero(delta)) {
this.gstateTole32(delta);
err = this.dirCommitattr(commit,
this.mkTag(LFS_TYPE_MOVESTATE, 0x3ff,
struct.calcsize("III")), delta);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
}
// complete commit with crc
err = this.dirCommitcrc(commit);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break compaction_block;
}
return err;
}
// successful compaction, swap dir pair to indicate most recent
console.assert(commit.off % this.cfg.progSize == 0);
this.pairSwap(dir.pair);
dir.count = end - begin;
dir.off = commit.off;
dir.etag = commit.ptag;
// update gstate
this.gdelta = new GState({tag: 0});
if (!relocated) {
this.gdisk = this.gstate;
}
break main_while_loop;
} // end compaction_block
// relocate:
// commit was corrupted, drop caches and prepare to relocate block
relocated = true;
this.cacheDrop(this.pcache);
if (!tired) {
// Block is detected as unusable in normal Flash
console.warn("Bad block at " + toHex(dir.pair[1], 8));
}
// can't relocate superblock, filesystem is now frozen
if (this.pairCmp(dir.pair, [0, 1]) == 0) {
console.warn("Superblock " + toHex(dir.pair[1], 8) + " has become unwritable");
return LFS_ERR_NOSPC;
}
// relocate half of pair
let blockObj = new ByRef();
let err = this.alloc(blockObj);
dir.pair[1] = blockObj.get();
if (err && (err != LFS_ERR_NOSPC || !tired)) {
return err;
}
tired = false;
continue;
} // end main_while_loop
if (relocated) {
// update references if we relocated
console.warn("Relocating {" + toHex(oldpair[0], 8) + ", " + toHex(oldpair[1], 8) + "} " +
"-> {" + toHex(dir.pair[0], 8) + ", " + toHex(dir.pair[1], 8) + "}");
let err = this.fsRelocate(oldpair, dir.pair);
if (err) {
return err;
}
}
return 0;
}
dirTraverse(dir, off, ptag, attrs, attrcount, tmask, ttag, begin, end, diff, callback, data) {
// iterate over directory and attrs
let attrPtr = 0;
while (true) {
let tag;
let buffer;
let disk = new Diskoff();
if (off+this.tagDsize(ptag) < dir.off) {
off += this.tagDsize(ptag);
let bufferByRef = new ByRef();
let err = this.bdRead(null, this.rcache, struct.calcsize("I"),
dir.pair[0], off, bufferByRef, struct.calcsize("I"));
tag = bufferByRef.get();
if (err) {
return err;
}
tag = ((this.fromBe32(tag) ^ ptag) >>> 0) | 0x80000000;
disk.block = dir.pair[0];
disk.off = off + struct.calcsize("I");
buffer = disk;
ptag = tag;
} else if (attrcount > 0) {
tag = attrs[attrPtr].tag;
buffer = attrs[attrPtr].buffer;
attrPtr += 1;
attrcount -= 1;
} else {
return 0;
}
let mask = this.mkTag(0x7ff, 0, 0);
if ((mask & tmask & tag) != (mask & tmask & ttag)) {
continue;
}
// do we need to filter? inlining the filtering logic here allows
// for some minor optimizations
if (this.tagId(tmask) != 0) {
// scan for duplicates and update tag based on creates/deletes
let filter = this.dirTraverse(dir, off, ptag, attrs, attrcount,
0, 0, 0, 0, 0, this.dirTraverseFilter.bind(this), tag);
if (filter < 0) {
return filter;
}
if (filter) {
continue;
}
// in filter range?
if (!(this.tagId(tag) >= begin && this.tagId(tag) < end)) {
continue;
}
}
// handle special cases for mcu-side operations
if (this.tagType3(tag) == LFS_FROM_NOOP) {
// do nothing
} else if (this.tagType3(tag) == LFS_FROM_MOVE) {
let fromid = this.tagSize(tag);
let toid = this.tagId(tag);
let err = this.dirTraverse(buffer, 0, 0xffffffff, null, 0,
this.mkTag(0x600, 0x3ff, 0),
this.mkTag(LFS_TYPE_STRUCT, 0, 0),
fromid, fromid+1, toid-fromid+diff,
callback, data);
if (err) {
return err;
}
} else if (this.tagType3(tag) == LFS_FROM_USERATTRS) {
let a = buffer;
for (let i = 0; i < this.tagSize(tag); i++) {
let err = callback(data, this.mkTag(LFS_TYPE_USERATTR + a[i].type,
this.tagId(tag) + diff, a[i].size), a[i].buffer);
if (err) {
return err;
}
}
} else {
let err = callback(data, tag + this.mkTag(0, diff, 0), buffer);
if (err) {
return err;
}
}
}
}
dirTraverseFilter(p, tag, buffer) {
let filtertag = p;
// which mask depends on unique bit in tag structure
let mask = (tag & this.mkTag(0x100, 0, 0))
? this.mkTag(0x7ff, 0x3ff, 0)
: this.mkTag(0x700, 0x3ff, 0);
// check for redundancy
if ((mask & tag) == (mask & filtertag) ||
this.tagIsdelete(filtertag) ||
(this.mkTag(0x7ff, 0x3ff, 0) & tag) == (
this.mkTag(LFS_TYPE_DELETE, 0, 0) |
(this.mkTag(0, 0x3ff, 0) & filtertag))) {
return true;
}
// check if we need to adjust for created/deleted tags
if (this.tagType1(tag) == LFS_TYPE_SPLICE &&
this.tagId(tag) <= this.tagId(filtertag)) {
filtertag += this.mkTag(0, this.tagSplice(tag), 0); // Likely ref error
}
return false;
}
dirSplit() {
console.warn("dirSplit not implemented");
}
dirFind(dir, pathByRef, idByRef) {
// we reduce path to a single name if we can find it
if (idByRef.get()) {
idByRef.set(0x3ff);
}
let name = 0;
let path = pathByRef.get();
// default to root dir
let tag = this.mkTag(LFS_TYPE_DIR, 0x3ff, 0);
dir.tail[0] = this.root[0];
dir.tail[1] = this.root[1];
while (true) {
// skip slashes
name += path.indexOf("/") + 1;
let namelen = path.slice(name).indexOf("/");
if (namelen == -1) {
namelen = path.slice(name).length;
}
// skip '.' and root '..'
if ((namelen == 1 && path.substr(name, 1) == ".") ||
(namelen == 2 && path.substr(name, 2) == "..")) {
name += namelen;
continue;
}
// skip if matched by '..' in name
let suffix = path.substr(name + namelen)
let sufflen;
let depth = 1;
while (true) {
suffix += path.indexOf("/") + 1;
sufflen = path.slice(suffix).indexOf("/");
if (sufflen <= 0) {
break;
}
if (sufflen == 2 && path.substr(suffix, 2) == "..") {
depth -= 1;
if (depth == 0) {
name = suffix + sufflen;
continue;
}
} else {
depth += 1;
}
suffix += sufflen;
}
// found path
if (name == path.length) {
return tag;
}
// update what we've found so far
path = path.slice(name);
pathByRef.set(path);
name = 0;
// only continue if we hit a directory
if (this.tagType3(tag) != LFS_TYPE_DIR) {
return LFS_ERR_NOTDIR;
}
// grab the entry data
if (this.tagId(tag) != 0x3ff) {
let res = this.dirGet(dir, this.mkTag(0x700, 0x3ff, 0),
this.mkTag(LFS_TYPE_STRUCT, this.tagId(tag), 8), dir.tail);
if (res < 0) {
return res;
}
this.pairFromle32(dir.tail);
}
// find entry matching name
while (true) {
tag = this.dirFetchmatch(dir, dir.tail,
this.mkTag(0x780, 0, 0),
this.mkTag(LFS_TYPE_NAME, 0, namelen),
// are we last name?
path.slice(name).indexOf('/') < 0 ? idByRef : new ByRef(null),
this.dirFindMatch.bind(this),
new DirFindMatch({name: path.slice(name), size: namelen})
);
if (tag < 0) {
return tag;
}
if (tag) {
break;
}
if (!dir.split) {
return LFS_ERR_NOENT;
}
}
// to next name
name += namelen;
}
}
dirCommitCommit(p, tag, buffer) {
return this.dirCommitattr(p, tag, buffer);
}
dirCommitcrc(commit) {
// align to program units
const end = this.alignup(commit.off + 2 * struct.calcsize("I"), this.cfg.progSize);
let off1 = 0;
let crc1 = 0;
// create crc tags to fill up remainder of commit, note that
// padding is not crc'd, which lets fetches skip padding but
// makes committing a bit more complicated
while (commit.off < end) {
let off = commit.off + struct.calcsize("I");
let noff = Math.min(end - off, 0x3fe) + off;
if (noff < end) {
noff = Math.min(noff, end - struct.calcsize("II"));
}
// read erased state from next program unit
let tag = 0xffffffff;
let bufferByRef = new ByRef();
let err = this.bdRead(null, this.rcache, struct.calcsize("I"),
commit.block, noff, bufferByRef, struct.calcsize("I"));
if (err && err != LFS_ERR_CORRUPT) {
return err;
}
tag = bufferByRef.get();
// build crc tag
let reset = !!(~this.fromBe32(tag) >>> 31) ? 1 : 0;
tag = this.mkTag(LFS_TYPE_CRC + reset, 0x3ff, noff - off);
// write out crc
let footer = new Array(2);
footer[0] = this.toBe32((tag ^ commit.ptag) >>> 0);
commit.crc = this.crc(commit.crc, footer[0], struct.calcsize("I"));
footer[1] = this.tole32(commit.crc);
err = this.bdProg(this.pcache, this.rcache, false, commit.block, commit.off, footer, struct.calcsize("II"));
if (err) {
return err;
}
// keep track of non-padding checksum to verify
if (off1 == 0) {
off1 = commit.off + struct.calcsize("I");
crc1 = commit.crc;
}
commit.off += struct.calcsize("I") + this.tagSize(tag);
commit.ptag = (tag ^ (reset << 31)) >>> 0;
commit.crc = 0xffffffff; // reset crc for next "commit"
}
// write buffers to flash and flush
let err = this.bdSync(this.pcache, this.rcache, false);
if (err) {
return err;
}
// successful commit, check checksums to make sure
let off = commit.begin;
let noff = off1;
while (off < end) {
let crc = 0xffffffff;
for (let i = off; i < noff + struct.calcsize("I"); 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
let bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, noff + struct.calcsize("I") - i,
commit.block, i, bufferByRef, 1);
if (err) {
return err;
}
let dat = bufferByRef.get();
crc = this.crc(crc, dat, 1);
}
// detected write error?
if (crc != 0) {
return LFS_ERR_CORRUPT;
}
// skip padding
off = Math.min(end - noff, 0x3fe) + noff;
if (off < end) {
off = Math.min(off, end - 2 * struct.calcsize("I"));
}
noff = off + struct.calcsize("I");
}
return 0;
}
fsRawsize() {
console.warn("fsRawsize not implemented");
}
dirCommitSize() {
console.warn("dirCommitSize not implemented");
}
dirCommitattr(commit, tag, buffer) {
// check if we fit
let dsize = this.tagDsize(tag);
if (commit.off + dsize > commit.end) {
return LFS_ERR_NOSPC;
}
// write out tag
let ntag = this.toBe32(((tag & 0x7fffffff) ^ commit.ptag) >>> 0);
let err = this.dirCommitprog(commit, ntag, struct.calcsize("I")); // ntag by ref
if (err) {
return err;
}
if (!(tag & 0x80000000)) {
// from memory
err = this.dirCommitprog(commit, buffer, dsize - struct.calcsize("I"));
if (err) {
return err;
}
} else {
// from disk
let disk = buffer;
for (let i = 0; i < dsize-struct.calcsize("I"); i++) {
// rely on caching to make this efficient
let bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, dsize-struct.calcsize("I")-i,
disk.block, disk.off+i, bufferByRef, 1);
let dat = bufferByRef.get();
if (err) {
return err;
}
err = this.dirCommitprog(commit, dat, 1);
if (err) {
return err;
}
}
}
commit.ptag = tag & 0x7fffffff;
return 0;
}
dirDrop() {
console.warn("dirDrop not implemented");
}
dirGetread() {
console.warn("dirGetread not implemented");
}
dirGet(dir, gmask, gtag, buffer) {
return this.dirGetslice(dir, gmask, gtag, 0, buffer, this.tagSize(gtag));
}
dirGetslice(dir, gmask, gtag, goff, gbuffer, gsize) {
let off = dir.off;
let ntag = dir.etag;
let gdiff = 0;
if (this.gstateHasmovehere(this.gdisk, dir.pair) &&
this.tagId(gmask) != 0 &&
this.tagId(this.gdisk.tag) <= this.tagId(gtag)) {
// synthetic moves
gdiff -= this.mkTag(0, 1, 0);
}
// iterate over dir block backwards (for faster lookups)
while (off >= struct.calcsize("I") + this.tagDsize(ntag)) {
off -= this.tagDsize(ntag);
let tag = ntag;
let bufferByRef = new ByRef();
let err = this.bdRead(null, this.rcache, struct.calcsize("I"),
dir.pair[0], off, bufferByRef, struct.calcsize("I"));
if (err) {
return err;
}
ntag = bufferByRef.get();
ntag = (this.fromBe32(ntag) ^ tag) & 0x7fffffff;
if (this.tagId(gmask) != 0 &&
this.tagType1(tag) == LFS_TYPE_SPLICE &&
this.tagId(tag) <= this.tagId(gtag - gdiff)) {
if (tag == (this.mkTag(LFS_TYPE_CREATE, 0, 0) |
(this.mkTag(0, 0x3ff, 0) & (gtag - gdiff)))) {
// found where we were created
return LFS_ERR_NOENT;
}
// move around splices
gdiff += this.mkTag(0, this.tagSplice(tag), 0);
}
if ((gmask & tag) == (gmask & (gtag - gdiff))) {
if (this.tagIsdelete(tag)) {
return LFS_ERR_NOENT;
}
let diff = Math.min(this.tagSize(tag), gsize);
let bufferByRef = new ByRef();
err = this.bdRead(null, this.rcache, diff,
dir.pair[0], off + struct.calcsize("I") + goff, bufferByRef, diff, true);
if (err) {
return err;
}
gbuffer.data.set(bufferByRef.get());
//memset((uint8_t*)gbuffer + diff, 0, gsize - diff);
gbuffer.data.set(new Uint8Array(gsize-diff).fill(0), diff)
return tag + gdiff;
}
}
return LFS_ERR_NOENT;
}
dirGetgstate(dir, gstate) {
let temp = new GState();
let res = this.dirGet(dir, this.mkTag(0x7ff, 0, 0),
this.mkTag(LFS_TYPE_MOVESTATE, 0, struct.calcsize("III")), temp);
if (res < 0 && res != LFS_ERR_NOENT) {
return res;
}
if (res != LFS_ERR_NOENT) {
// xor together to find resulting gstate
this.gstateFromle32(temp);
this.gstateXor(gstate, temp);
}
return 0;
}
cacheDrop(cache) {
cache.block = LFS_BLOCK_NULL;
}
cacheZero(cache) {
cache.buffer.fill(0xFF);
cache.block = LFS_BLOCK_NULL;
}
fsPred() {
console.warn("fsPred not implemented");
}
fsRelocate() {
console.warn("fsRelocate not implemented");
}
gstateXor(gstateA, gstateB) {
gstateA.tag ^= gstateB.tag
gstateA.pair[0] ^= gstateB.pair[0]
gstateA.pair[1] ^= gstateB.pair[1]
}
gstateIszero(gstate) {
return gstate.tag === 0 && gstate.pair[0] === 0 && gstate.pair[1] === 0;
}
gstateTole32(gstate) {
gstate.tag = this.tole32(gstate.tag);
gstate.pair[0] = this.tole32(gstate.pair[0]);
gstate.pair[1] = this.tole32(gstate.pair[1]);
}
gstateFromle32(gstate) {
gstate.tag = this.fromle32(gstate.tag);
gstate.pair[0] = this.fromle32(gstate.pair[0]);
gstate.pair[1] = this.fromle32(gstate.pair[1]);
}
scmp(a, b) {
return parseInt(a - b);
}
tole32(value) {
return this.fromle32(value);
}
fromle32(value) {
const data = Array.from(LittleFS.UintToBuffer(value, 4));
value = (data[0] << 0) |
(data[1] << 8) |
(data[2] << 16) |
(data[3] << 24);
return value >>> 0;
}
toBe32(value) {
return this.fromBe32(value);
}
fromBe32(value) {
const data = Array.from(LittleFS.UintToBuffer(value, 4));
value = (data[0] << 24) |
(data[1] << 16) |
(data[2] << 8) |
(data[3] << 0);
return value >>> 0;
}
ctzFromle32(ctz) {
ctz.head = this.fromle32(ctz.head);
ctz.size = this.fromle32(ctz.size);
}
ctzTole32(ctz) {
ctz.head = this.tole32(ctz.head);
ctz.size = this.tole32(ctz.size);
}
pairFromle32(pair) {
pair[0] = this.fromle32(pair[0]);
pair[1] = this.fromle32(pair[1]);
}
pairTole32(pair) {
pair[0] = this.tole32(pair[0]);
pair[1] = this.tole32(pair[1]);
}
superblockTole32(superblock) {
superblock.version = this.tole32(superblock.version);
superblock.blockSize = this.tole32(superblock.blockSize);
superblock.blockCount = this.tole32(superblock.blockCount);
superblock.nameMax = this.tole32(superblock.nameMax);
superblock.fileMax = this.tole32(superblock.fileMax);
superblock.attrMax = this.tole32(superblock.attrMax);
}
superblockFromle32(superblock) {
superblock.version = this.fromle32(superblock.version);
superblock.blockSize = this.fromle32(superblock.blockSize);
superblock.blockCount = this.fromle32(superblock.blockCount);
superblock.nameMax = this.fromle32(superblock.nameMax);
superblock.fileMax = this.fromle32(superblock.fileMax);
superblock.attrMax = this.fromle32(superblock.attrMax);
}
fileOpen(file, path, flags) {
let defaults = new FileConfig({attrCount: 0});
let err = this.fileOpencfg(file, path, flags, defaults);
return err;
}
fileOpencfg(file, path, flags, cfg) {
let err;
main_block: if (true) {
// deorphan if we haven't yet, needed at most once after poweron
if ((flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
let err = this.fsForceconsistency();
if (err) {
return err;
}
}
// setup simple file details
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
let pathByRef = new ByRef(path);
let idByRef = new ByRef(file.id);
let tag = this.dirFind(file.m, pathByRef, idByRef);
file.id = idByRef.get();
path = pathByRef.get();
if (tag < 0 && !(tag == LFS_ERR_NOENT && file.id != 0x3ff)) {
err = tag;
break main_block;
}
// get id, add to list of mdirs to catch update changes
file.type = LFS_TYPE_REG;
this.mlistAppend(file);
if (tag == LFS_ERR_NOENT) {
if (!(flags & LFS_O_CREAT)) {
err = LFS_ERR_NOENT;
break main_block;
}
// check that name fits
let nlen = path.length;
if (nlen > this.nameMax) {
err = LFS_ERR_NAMETOOLONG;
break main_block;
}
// get next slot and create entry to remember name
err = this.dirCommit(file.m, this.mkAttrs(
[this.mkTag(LFS_TYPE_CREATE, file.id, 0), null],
[this.mkTag(LFS_TYPE_REG, file.id, nlen), path],
[this.mkTag(LFS_TYPE_INLINESTRUCT, file.id, 0), null]
));
if (err) {
err = LFS_ERR_NAMETOOLONG;
break main_block;
}
tag = this.mkTag(LFS_TYPE_INLINESTRUCT, 0, 0);
} else if (flags & LFS_O_EXCL) {
err = LFS_ERR_EXIST;
break main_block;
} else if (this.tagType3(tag) != LFS_TYPE_REG) {
err = LFS_ERR_ISDIR;
break main_block;
} else if (flags & LFS_O_TRUNC) {
// truncate if requested
tag = this.mkTag(LFS_TYPE_INLINESTRUCT, file.id, 0);
file.flags |= LFS_F_DIRTY;
} else {
// try to load what's on disk, if it's inlined we'll fix it later
tag = this.dirGet(file.m, this.mkTag(0x700, 0x3ff, 0),
this.mkTag(LFS_TYPE_STRUCT, file.id, 8), file.ctz);
if (tag < 0) {
err = tag;
break main_block;
}
this.ctzFromle32(file.ctz);
}
// fetch attrs
for (let i = 0; i < file.cfg.attr_count; i++) {
// if opened for read / read-write operations
if ((file.flags & LFS_O_RDONLY) == LFS_O_RDONLY) {
let res = this.dirGet(file.m,
this.mkTag(0x7ff, 0x3ff, 0),
this.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;
break main_block;
}
}
// if opened for write / read-write operations
if ((file.flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
if (file.cfg.attrs[i].size > this.attrMax) {
err = LFS_ERR_NOSPC;
break main_block;
}
file.flags |= LFS_F_DIRTY;
}
}
// allocate buffer if needed
if (file.cfg.buffer) {
file.cache.buffer = file.cfg.buffer;
} else {
file.cache.buffer = new Uint8Array(this.cfg.cacheSize);
if (!file.cache.buffer) {
err = LFS_ERR_NOMEM;
break main_block;
}
}
// zero to avoid information leak
this.cacheZero(file.cache);
if (this.tagType3(tag) == LFS_TYPE_INLINESTRUCT) {
// load inline files
file.ctz.head = LFS_BLOCK_INLINE;
file.ctz.size = this.tagSize(tag);
file.flags |= LFS_F_INLINE;
file.cache.block = file.ctz.head;
file.cache.off = 0;
file.cache.size = this.cfg.cacheSize;
// don't always read (may be new/trunc file)
if (file.ctz.size > 0) {
let res = this.dirGet(file.m,
this.mkTag(0x700, 0x3ff, 0),
this.mkTag(LFS_TYPE_STRUCT, file.id,
Math.min(file.cache.size, 0x3fe)),
file.cache.buffer);
if (res < 0) {
err = res;
break main_block;
}
}
}
return 0;
}
//cleanup:
// clean up lingering resources
file.flags |= LFS_F_ERRED;
this.fileClose(file);
return err;
}
fileWrite(file, buffer, size) {
console.assert((file.flags & LFS_O_WRONLY) == LFS_O_WRONLY);
let data = 0;
let nsize = size;
if (file.flags & LFS_F_READING) {
// drop any reads
let err = this.fileFlush(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 > this.fileMax) {
// Larger than file limit?
return LFS_ERR_FBIG;
}
if (!(file.flags & LFS_F_WRITING) && file.pos > file.ctz.size) {
// fill with zeros
let pos = file.pos;
file.pos = file.ctz.size;
while (file.pos < pos) {
let res = this.fileWrite(file, 0, 1);
if (res < 0) {
return res;
}
}
}
if ((file.flags & LFS_F_INLINE) &&
Math.max(file.pos+nsize, file.ctz.size) >
Math.min(0x3fe, Math.min(
this.cfg.cacheSize,
(this.cfg.metadataMax ?
this.cfg.metadataMax : this.cfg.blockSize) / 8))) {
// inline file doesn't fit anymore
let err = this.fileOutline(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 == this.cfg.blockSize) {
if (!(file.flags & LFS_F_INLINE)) {
if (!(file.flags & LFS_F_WRITING) && file.pos > 0) {
// find out which block we're extending from
let err = this.ctzFind(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
this.cacheZero(file.cache);
}
// extend file with new blocks
this.allocAck();
let err = this.ctzExtend(file.cache, this.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
let diff = Math.min(nsize, this.cfg.blockSize - file.off);
program_loop: while (true) {
program_block: if (true) {
let err = this.bdProg(file.cache, this.rcache, true,
file.block, file.off, buffer.slice(data), diff);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break program_block;
}
file.flags |= LFS_F_ERRED;
return err;
}
break program_loop;
}
//relocate:
let err = this.fileRelocate(file);
if (err) {
file.flags |= LFS_F_ERRED;
return err;
}
}
file.pos += diff;
file.off += diff;
data += diff;
nsize -= diff;
this.allocAck();
}
file.flags &= ~LFS_F_ERRED;
return size;
}
fileClose(file) {
let err = this.fileSync(file);
// remove from list of mdirs
this.mlistRemove(file);
// clean up memory
if (!file.cfg.buffer) {
file.cache.buffer = null;
}
return err;
}
fileSync(file) {
if (file.flags & LFS_F_ERRED) {
// it's not safe to do anything if our file errored
return 0;
}
let err = this.fileFlush(file);
if (err) {
file.flags |= LFS_F_ERRED;
return err;
}
if ((file.flags & LFS_F_DIRTY) && !this.pairIsnull(file.m.pair)) {
// update dir entry
let type;
let buffer;
let size;
let ctz = new 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;
this.ctzTole32(ctz);
buffer = ctz;
size = struct.calcsize("II");
}
// commit file data and attributes
err = this.dirCommit(file.m, this.mkAttrs(
[this.mkTag(type, file.id, size), buffer],
[this.mkTag(LFS_FROM_USERATTRS, file.id, file.cfg.attrCount), file.cfg.attrs]));
if (err) {
file.flags |= LFS_F_ERRED;
return err;
}
file.flags &= ~LFS_F_DIRTY;
}
return 0;
}
setattr(path, type, buffer, size) {
if (size > this.attrMax) {
return LFS_ERR_NOSPC;
}
return this.commitattr(path, type, buffer, size);
}
fileRelocate(file) {
while (true) {
main_block: if (true) {
// just relocate what exists into new block
let blockObj = new ByRef();
let err = this.alloc(blockObj);
let nblock = blockObj.get();
if (err) {
return err;
}
err = this.bdErase(nblock);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break main_block;
}
return err;
}
// either read from dirty cache or disk
for (let i = 0; i < file.off; i++) {
let data;
if (file.flags & LFS_F_INLINE) {
err = this.dirGetread(file.m,
// note we evict inline files before they can be dirty
null, file.cache, file.off-i,
this.mkTag(0xfff, 0x1ff, 0),
this.mkTag(LFS_TYPE_INLINESTRUCT, file.id, 0),
i, data, 1);
if (err) {
return err;
}
} else {
var bufferByRef = new ByRef();
err = this.bdRead(file.cache, this.rcache, file.off-i,
file.block, i, bufferByRef, 1);
data = bufferByRef.get();
if (err) {
return err;
}
}
err = this.bdProg(this.pcache, this.rcache, true,
nblock, i, data, 1);
if (err) {
if (err == LFS_ERR_CORRUPT) {
break main_block;
}
return err;
}
}
// copy over new state of file
//memcpy(file.cache.buffer, this.pcache.buffer, this.cfg.cacheSize);
file.cache.buffer.set(this.pcache.buffer.slice(0, this.cfg.cacheSize));
file.cache.block = this.pcache.block;
file.cache.off = this.pcache.off;
file.cache.size = this.pcache.size;
this.cacheZero(this.pcache);
file.block = nblock;
file.flags |= LFS_F_WRITING;
return 0;
}
//relocate:
console.warn("Bad block at " + toHex(nblock, 8));
// just clear cache and try a new block
this.cacheDrop(this.pcache);
}
}
fileOutline(file) {
file.off = file.pos;
this.allocAck();
let err = this.fileRelocate(file);
if (err) {
return err;
}
file.flags &= ~LFS_F_INLINE;
return 0;
}
fileFlush(file) {
if (file.flags & LFS_F_READING) {
if (!(file.flags & LFS_F_INLINE)) {
this.cacheDrop(file.cache);
}
file.flags &= ~LFS_F_READING;
}
if (file.flags & LFS_F_WRITING) {
let pos = file.pos;
if (!(file.flags & LFS_F_INLINE)) {
// copy over anything after current branch
let orig = new LfsFile({
ctz: file.ctz,
flags: LFS_O_RDONLY,
pos: file.pos,
cache: this.rcache,
});
this.cacheDrop(this.rcache);
while (file.pos < file.ctz.size) {
// copy over a byte at a time, leave it up to caching
// to make this efficient
let data;
let res = this.fileRead(orig, data, 1);
if (res < 0) {
return res;
}
res = this.fileWrite(file, data, 1);
if (res < 0) {
return res;
}
// keep our reference to the rcache in sync
if (this.rcache.block != LFS_BLOCK_NULL) {
this.cacheDrop(orig.cache);
this.cacheDrop(this.rcache);
}
}
// write out what we have
while (true) {
let err = this.bdFlush(file.cache, this.rcache, true);
if (!err) {
break;
}
if (err != LFS_ERR_CORRUPT) {
return err;
}
console.warn("Bad block at " + toHex(file.block, 8));
err = this.fileRelocate(file);
if (err) {
return err;
}
}
} else {
file.pos = Math.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;
}
return 0;
}
mlistRemove(mlist) {
for (let p = this.mlist; p; p = p.next) {
if (p == mlist) {
p = p.next;
break;
}
}
}
mlistAppend(mList) {
mList.next = this.mList;
this.mList = mList;
}
commitattr(path, type, buffer, size) {
let cwd = new MDir();
let pathByRef = new ByRef(path);
let tag = this.dirFind(cwd, pathByRef, new ByRef(null));
path = pathByRef.get();
if (tag < 0) {
return tag;
}
let id = this.tagId(tag);
if (id == 0x3ff) {
// special case for root
id = 0;
let err = this.dirFetch(cwd, this.root);
if (err) {
return err;
}
}
return this.dirCommit(cwd, this.mkAttrs([this.mkTag(LFS_TYPE_USERATTR + type.charCodeAt(0), id, size), buffer]));
}
dirCommitprog(commit, buffer, size) {
let err = this.bdProg(this.pcache, this.rcache, false,
commit.block, commit.off, buffer, size);
if (err) {
return err;
}
commit.crc = this.crc(commit.crc, buffer, size);
commit.off += size;
return 0;
}
fsForceconsistency() {
let err = this.fsDemove();
if (err) {
return err;
}
err = this.fsDeorphan();
if (err) {
return err;
}
return 0;
}
fsDemove() {
if (!this.gstateHasmove(this.gdisk)) {
return 0;
}
// Fix bad moves
console.warn("Fixing move {" +
toHex(this.gdisk.pair[0], 8) + ", " +
toHex(this.gdisk.pair[1], 8) + "} " +
toHex(this.tagId(this.gdisk.tag), 4));
// fetch and delete the moved entry
let movedir = new MDir();
let err = this.dirFetch(movedir, this.gdisk.pair);
if (err) {
return err;
}
// prep gstate and delete move id
let moveid = this.tagId(this.gdisk.tag);
this.fsPrepmove(0x3ff, null);
err = this.dirCommit(movedir, this.mkAttrs(
[this.mkTag(LFS_TYPE_DELETE, moveid, 0), null]));
if (err) {
return err;
}
return 0;
}
fsDeorphan() {
if (!this.gstateHasorphans(this.gstate)) {
return 0;
}
// Fix any orphans
let pdir = new MDir({split: true, tail: [0, 1]});
let dir = new MDir();
// iterate over all directory directory entries
while (!this.pairIsnull(pdir.tail)) {
let err = this.dirFetch(dir, pdir.tail);
if (err) {
return err;
}
// check head blocks for orphans
if (!pdir.split) {
// check if we have a parent
let parent = new MDir();
let tag = this.fsParent(pdir.tail, parent);
if (tag < 0 && tag != LFS_ERR_NOENT) {
return tag;
}
if (tag == LFS_ERR_NOENT) {
// we are an orphan
console.warn("Fixing orphan {" +
toHex(pdir.tail[0], 8) + ", " +
toHex(pdir.tail[1], 8) + "}");
err = this.dirDrop(pdir, dir);
if (err) {
return err;
}
// refetch tail
continue;
}
let pair = new Array(2);
let res = this.dirGet(parent,
this.mkTag(0x7ff, 0x3ff, 0), tag, pair);
if (res < 0) {
return res;
}
this.pairFromle32(pair);
if (!this.pairSync(pair, pdir.tail)) {
// we have desynced
console.warn("Fixing half-orphan {" +
toHex(pdir.tail[0], 8) + ", " +
toHex(pdir.tail[1], 8) + "} -> {" +
toHex(pair[0], 8) + ", " +
toHex(pair[1], 8) + "}");
this.pairTole32(pair);
err = this.dirCommit(pdir, this.mkAttrs(
[this.mkTag(LFS_TYPE_SOFTTAIL, 0x3ff, 8), pair]));
this.pairFromle32(pair);
if (err) {
return err;
}
// refetch tail
continue;
}
}
pdir = dir;
}
// mark orphans as fixed
return this.fsPreporphans(-this.gstateGetorphans(this.gstate));
}
ctzFind() {
console.warn("ctzFind not implemented");
}
ctzExtend() {
console.warn("ctzExtend not implemented");
}
ctzTraverse() {
console.warn("ctzTraverse not implemented");
}
fsPreporphans() {
console.warn("fsPreporphans not implemented");
}
fsPrepmove() {
console.warn("fsPrepmove not implemented");
}
fsParent() {
console.warn("fsParent not implemented");
}
pairSync() {
console.warn("pairSync not implemented");
}
mkdir(path) {
// deorphan if we haven't yet, needed at most once after poweron
let err = this.fsForceconsistency();
if (err) {
return err;
}
let cwd = new MList();
cwd.next = this.mlist;
let idByRef = new ByRef();
let pathByRef = new ByRef(path);
err = this.dirFind(cwd.m, pathByRef, idByRef);
path = pathByRef.get();
let id = idByRef.get();
if (!(err == LFS_ERR_NOENT && id != 0x3ff)) {
return (err < 0) ? err : LFS_ERR_EXIST;
}
// check that name fits
let nlen = path.length;
if (nlen > this.nameMax) {
return LFS_ERR_NAMETOOLONG;
}
// build up new directory
this.allocAck();
dir = new MDir();
err = this.dirAlloc(dir);
if (err) {
return err;
}
// find end of list
let pred = cwd.m;
while (pred.split) {
err = lfs_dir_fetch(pred, pred.tail);
if (err) {
return err;
}
}
// setup dir
this.pairTole32(pred.tail);
err = this.dirCommit(dir, this.mkAttrs(
[this.mkTag(LFS_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail]));
this.pairFromle32(pred.tail);
if (err) {
return err;
}
// current block end of list?
if (cwd.m.split) {
// update tails, this creates a desync
err = this.fsPreporphans(+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;
this.mlist = cwd;
this.pairTole32(dir.pair);
err = this.dirCommit(pred, this.mkAttrs(
[this.mkTag(LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair]));
this.pairFromle32(dir.pair);
if (err) {
this.mlist = cwd.next;
return err;
}
this.mlist = cwd.next;
err = this.fsPreporphans(-1);
if (err) {
return err;
}
}
// now insert into our parent block
this.pairTole32(dir.pair);
err = this.dirCommit(cwd.m, this.mkAttrs(
[this.mkTag(LFS_TYPE_CREATE, id, 0), null],
[this.mkTag(LFS_TYPE_DIR, id, nlen), path],
[this.mkTag(LFS_TYPE_DIRSTRUCT, id, 8), dir.pair],
[this.mkTagIf(!cwd.m.split, LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair]
));
this.pairFromle32(dir.pair);
if (err) {
return err;
}
return 0;
}
mkTag(type, id, size) {
return ((type << 20) | (id << 10) | size) >>> 0;
}
mkTagIf(cond, type, id, size) {
return cond ? this.mkTag(type, id, size) : this.mkTag(LFS_FROM_NOOP, 0, 0);
}
mkTagIfElse(cond, type1, id1, size1, type2, id2, size2) {
return cond ? this.mkTag(type1, id1, size1) : this.mkTag(type2, id2, size2);
}
mkAttrs(...args) {
let attrs = [];
for (let [tag, buffer] of args) {
attrs.push(new MAttr({tag: tag, buffer: buffer}));
}
return attrs;
}
copyObjProps(toObject, fromObject) {
for (var key in fromObject) {
if (fromObject.hasOwnProperty(key)) {
toObject[key] = fromObject[key];
}
}
}
}
class LfsConfig {
constructor({
context = null,
readSize = 64,
progSize = 64,
blockSize = 0,
blockCount = 0,
blockCycles = 16,
cacheSize = 64,
lookaheadSize = 64,
nameMax = LFS_NAME_MAX,
fileMax = LFS_FILE_MAX,
attrMax = LFS_ATTR_MAX,
flash = flash
}={}) {
this.context = context;
this.readSize = readSize;
this.progSize = progSize;
this.blockSize = blockSize;
this.blockCount = blockCount;
this.blockCycles = blockCycles;
this.cacheSize = cacheSize;
this.lookaheadSize = lookaheadSize;
this.nameMax = nameMax;
this.fileMax = fileMax;
this.attrMax = attrMax;
this.metadataMax = this.blockSize;
this.flash = flash
}
// Read a region in a block. Negative error codes are propagated
// to the user.
read(block, off, buffer, size) {
//memcpy(buffer, this.flash[0] + this.blockSize * block + off, size);
buffer.set(this.flash.data.slice(this.blockSize * block + off, this.blockSize * block + off + size));
return 0;
}
// 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.
prog(block, off, buffer, size) {
//memcpy(&s_flashmem[0] + block * this.blockSize + off, buffer, size);
this.flash.data.set(buffer.slice(0, size), this.blockSize * block + off);
return 0;
}
// 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.
erase(block) {
//memset(&s_flashmem[0] + block * this.blockSize, 0, this.blockSize);
this.flash.data.set(new Uint8Array(this.blockSize).fill(0), this.blockSize * block);
return 0;
}
// Sync the state of the underlying block device. Negative error codes
// are propagated to the user.
sync() {
return 0;
}
// Optional statically allocated read buffer. Must be cache_size.
// By default lfs_malloc is used to allocate this buffer.
readBuffer = null;
// Optional statically allocated program buffer. Must be cache_size.
// By default lfs_malloc is used to allocate this buffer.
progBuffer = null;
// 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.
lookaheadBuffer = null;
}
class SuperBlock {
constructor({
version = 0,
blockSize = 0,
blockCount = 0,
nameMax = 0,
fileMax = 0,
attrMax = 0
} = {}) {
this.version = version;
this.blockSize = blockSize;
this.blockCount = blockCount;
this.nameMax = nameMax;
this.fileMax = fileMax;
this.attrMax = attrMax;
}
setFromBuffer(buffer) {
let items = LittleFS.bufferToUint(buffer, struct.calcsize("IIIIII"));
Object.keys(this).forEach((key, index) => {
this[key] = items[index];
});
}
}
class ByRef {
constructor(data = undefined) {
this.data = data;
}
set(value) {
this.data = value;
}
get() {
return this.data;
}
}
class GState {
constructor({
tag = 0,
pair = [0, 0]
} = {}) {
this.tag = tag;
this.pair = pair;
}
}
class MList {
constructor({
id = 0,
type = 0,
m = new MDir()
} = {}) {
this.id = id;
this.type = type;
this.m = m;
this.next = null;
}
}
class MDir {
constructor({
pair = [0, 0],
rev = 0,
off = 0,
etag = 0,
count = 0,
erased = false,
split = false,
tail = [0, 0]
} = {}) {
this.pair = pair;
this.rev = rev;
this.off = off;
this.etag = etag;
this.count = count;
this.erased = erased;
this.split = split;
this.tail = tail;
}
}
class MAttr {
constructor({
tag = null,
buffer = null
} = {}) {
this.tag = tag;
this.buffer = buffer;
}
}
class Attr {
constructor({
type = 0,
buffer = null,
size = 0
} = {}) {
this.type = type;
this.buffer = buffer;
this.size = size;
}
}
class Diskoff {
constructor({
block,
off
} = {}) {
this.block = block;
this.off = off;
}
};
class Ctz {
constructor({head = null, size = 0} = {}) {
this.head = head;
this.size = size;
}
setFromBuffer(buffer) {
let items = LittleFS.bufferToUint(buffer, struct.calcsize("II"));
Object.keys(this).forEach((key, index) => {
this[key] = items[index];
});
}
}
class DirFindMatch {
constructor({name = null, size = 0} = {}) {
this.name = name;
this.size = size;
}
};
class Commit {
constructor({
block = 0,
off = 0,
ptag = 0,
crc = 0,
begin = 0,
end = 0
} = {}) {
this.block = block;
this.off = off;
this.ptag = ptag;
this.crc = crc;
this.begin = begin;
this.end = end;
}
};
class Cache {
constructor({
block = LFS_BLOCK_NULL,
off = 0,
size = 0,
buffer = null,
} = {}) {
this.block = block;
this.off = off;
this.size = size;
this.buffer = buffer;
}
};
class FileConfig {
constructor({
buffer = null,
attrs = [],
attrCount = 0
} = {}) {
this.buffer = buffer;
this.attrs = attrs;
this.attrCount = attrCount;
}
}
class LfsFile {
constructor({
id = 1,
type = 0,
m = new MDir(),
ctz = new Ctz(),
flags = 0,
pos = 0,
block = 0,
off = 0,
cache = new Cache(),
cfg = new FileConfig()
} = {}) {
this.id = id;
this.type = type;
this.m = m;
this.ctz = ctz;
this.flags = flags;
this.pos = pos;
this.block = block;
this.off = off;
this.cache = cache;
this.cfg = cfg;
this.next = null;
}
};
class struct {
static lut = {
"b": {u: DataView.prototype.getInt8, p: DataView.prototype.setInt8, bytes: 1},
"B": {u: DataView.prototype.getUint8, p: DataView.prototype.setUint8, bytes: 1},
"h": {u: DataView.prototype.getInt16, p: DataView.prototype.setInt16, bytes: 2},
"H": {u: DataView.prototype.getUint16, p: DataView.prototype.setUint16, bytes: 2},
"i": {u: DataView.prototype.getInt32, p: DataView.prototype.setInt32, bytes: 4},
"I": {u: DataView.prototype.getUint32, p: DataView.prototype.setUint32, bytes: 4},
"q": {u: DataView.prototype.getInt64, p: DataView.prototype.setInt64, bytes: 8},
"Q": {u: DataView.prototype.getUint64, p: DataView.prototype.setUint64, bytes: 8},
}
static pack(...args) {
let format = args[0];
let pointer = 0;
let data = args.slice(1);
if (format.replace(/[<>]/, '').length != data.length) {
throw("Pack format to Argument count mismatch");
return;
}
let bytes = [];
let littleEndian = true;
for (let i = 0; i < format.length; i++) {
if (format[i] == "<") {
littleEndian = true;
} else if (format[i] == ">") {
littleEndian = false;
} else {
pushBytes(format[i], data[pointer]);
pointer++;
}
}
function pushBytes(formatChar, value) {
if (!(formatChar in struct.lut)) {
throw("Unhandled character '" + formatChar + "' in pack format");
}
let dataSize = struct.lut[formatChar].bytes;
let view = new DataView(new ArrayBuffer(dataSize));
let dataViewFn = struct.lut[formatChar].p.bind(view);
dataViewFn(0, value, littleEndian);
for (let i = 0; i < dataSize; i++) {
bytes.push(view.getUint8(i));
}
}
return bytes;
};
static unpack(format, bytes) {
let pointer = 0;
let data = [];
let littleEndian = true;
for (let c of format) {
if (c == "<") {
littleEndian = true;
} else if (c == ">") {
littleEndian = false;
} else {
pushData(c);
}
}
function pushData(formatChar) {
if (!(formatChar in struct.lut)) {
throw("Unhandled character '" + formatChar + "' in unpack format");
}
let dataSize = struct.lut[formatChar].bytes;
let view = new DataView(new ArrayBuffer(dataSize));
for (let i = 0; i < dataSize; i++) {
view.setUint8(i, bytes[pointer + i] & 0xFF);
}
let dataViewFn = struct.lut[formatChar].u.bind(view);
data.push(dataViewFn(0, littleEndian));
pointer += dataSize;
}
return data;
};
static calcsize(format) {
let size = 0;
for (let i = 0; i < format.length; i++) {
if (format[i] != "<" && format[i] != ">") {
size += struct.lut[format[i]].bytes;
}
}
return size;
}
}
export { LittleFS, LfsConfig, LfsFile, LFS_O_RDONLY, LFS_O_WRONLY, LFS_O_RDWR, LFS_O_CREAT, LFS_O_EXCL, LFS_O_TRUNC, LFS_O_APPEND };
Reference in a new issue View git blame Copy permalink