littlefs/lfs.c

/*
 * The little filesystem
 *
 * Copyright (c) 2017 Christopher Haster
 * Distributed under the MIT license
 */
#include "lfs.h"
#include "lfs_util.h"

#include <string.h>
#include <stdbool.h>


/// Block device operations ///
static int lfs_bd_info(lfs_t *lfs, struct lfs_bd_info *info) {
    return lfs->bd_ops->info(lfs->bd, info);
}

static int lfs_bd_read(lfs_t *lfs, lfs_block_t block,
        lfs_off_t off, lfs_size_t size, void *buffer) {
    return lfs->bd_ops->read(lfs->bd, block, off, size, buffer);
}

static int lfs_bd_prog(lfs_t *lfs, lfs_block_t block,
        lfs_off_t off, lfs_size_t size, const void *buffer) {
    return lfs->bd_ops->prog(lfs->bd, block, off, size, buffer);
}

static int lfs_bd_erase(lfs_t *lfs, lfs_block_t block,
        lfs_off_t off, lfs_size_t size) {
    return lfs->bd_ops->erase(lfs->bd, block, off, size);
}

static int lfs_bd_sync(lfs_t *lfs) {
    return lfs->bd_ops->sync(lfs->bd);
}

static int lfs_bd_cmp(lfs_t *lfs, lfs_block_t block,
        lfs_off_t off, lfs_size_t size, const void *buffer) {
    const uint8_t *data = buffer;

    for (lfs_off_t i = 0; i < size; i++) {
        uint8_t c;
        int err = lfs_bd_read(lfs, block, off+i, 1, &c);
        if (err) {
            return err;
        }

        if (c != *data) {
            return false;
        }

        data += 1;
    }

    return true;
}

static int lfs_bd_crc(lfs_t *lfs, lfs_block_t block,
        lfs_off_t off, lfs_size_t size, uint32_t *crc) {
    while (off < size) {
        uint8_t c;
        int err = lfs_bd_read(lfs, block, off, 1, &c);
        if (err) {
            return err;
        }

        *crc = lfs_crc(&c, 1, *crc);
        off += 1;
    }

    return 0;
}


/// Block allocator ///

static int lfs_alloc_lookahead(void *p, lfs_block_t block) {
    lfs_t *lfs = p;

    lfs_block_t off = block - lfs->free.begin;
    if (off < LFS_CFG_LOOKAHEAD) {
        lfs->lookahead[off / 32] |= 1U << (off % 32);
    }

    return 0;
}

static int lfs_alloc_stride(void *p, lfs_block_t block) {
    lfs_t *lfs = p;

    lfs_block_t noff = block - lfs->free.begin;
    lfs_block_t off = lfs->free.end - lfs->free.begin;
    if (noff < off) {
        lfs->free.end = noff + lfs->free.begin;
    }

    return 0;
}

static int lfs_alloc_scan(lfs_t *lfs) {
    lfs_block_t start = lfs->free.begin;

    while (true) {
        // mask out blocks in lookahead region
        memset(lfs->lookahead, 0, sizeof(lfs->lookahead));
        int err = lfs_traverse(lfs, lfs_alloc_lookahead, lfs);
        if (err) {
            return err;
        }

        // check if we've found a free block
        for (uint32_t off = 0; off < LFS_CFG_LOOKAHEAD; off++) {
            if (lfs->lookahead[off / 32] & (1U << (off % 32))) {
                continue;
            }

            // found free block, now find stride of free blocks
            // since this is relatively cheap (stress on relatively)
            lfs->free.begin += off;
            lfs->free.end = lfs->block_count; // before superblock

            // find maximum stride in tree
            return lfs_traverse(lfs, lfs_alloc_stride, lfs);
        }

        // continue to next lookahead unless we've searched the whole device
        if (start-1 - lfs->free.begin < LFS_CFG_LOOKAHEAD) {
            return 0;
        }

        // continue to next lookahead region
        lfs->free.begin += LFS_CFG_LOOKAHEAD;
    }
}

static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) {
    // If we don't remember any free blocks we will need to start searching
    if (lfs->free.begin == lfs->free.end) {
        int err = lfs_alloc_scan(lfs);
        if (err) {
            return err;
        }

        if (lfs->free.begin == lfs->free.end) {
            // Still can't allocate a block? check for orphans
            int err = lfs_deorphan(lfs);
            if (err) {
                return err;
            }

            err = lfs_alloc_scan(lfs);
            if (err) {
                return err;
            }

            if (lfs->free.begin == lfs->free.end) {
                // Ok, it's true, we're out of space
                return LFS_ERROR_NO_SPACE;
            }
        }
    }

    // Take first available block
    *block = lfs->free.begin;
    lfs->free.begin += 1;
    return 0;
}

static int lfs_alloc_erased(lfs_t *lfs, lfs_block_t *block) {
    int err = lfs_alloc(lfs, block);
    if (err) {
        return err;
    }

    return lfs_bd_erase(lfs, *block, 0, lfs->block_size);
}


/// Index list operations ///

// Next index offset
static lfs_off_t lfs_indexnext(lfs_t *lfs, lfs_off_t ioff) {
    ioff += 1;
    while (ioff % lfs->words == 0) {
        ioff += lfs_min(lfs_ctz(ioff/lfs->words + 1), lfs->words-1) + 1;
    }

    return ioff;
}

static lfs_off_t lfs_indexfrom(lfs_t *lfs, lfs_off_t off) {
    lfs_off_t i = 0;
    while (off > lfs->block_size) {
        i = lfs_indexnext(lfs, i);
        off -= lfs->block_size;
    }

    return i;
}

// Find index in index chain given its index offset
static int lfs_index_find(lfs_t *lfs, lfs_block_t head,
        lfs_size_t icount, lfs_off_t ioff, lfs_block_t *block) {
    lfs_off_t iitarget = ioff / lfs->words;
    lfs_off_t iicurrent = (icount-1) / lfs->words;

    while (iitarget != iicurrent) {
        lfs_size_t skip = lfs_min(
                lfs_min(lfs_ctz(iicurrent+1), lfs->words-1),
                lfs_npw2((iitarget ^ iicurrent)+1)-1);

        int err = lfs_bd_read(lfs, head, 4*skip, 4, &head);
        if (err) {
            return err;
        }

        iicurrent -= 1 << skip;
    }

    return lfs_bd_read(lfs, head, 4*(ioff % lfs->words), 4, block);
}

// Append index to index chain, updates head and icount
static int lfs_index_append(lfs_t *lfs, lfs_block_t *headp,
        lfs_size_t *icountp, lfs_block_t block) {
    lfs_block_t head = *headp;
    lfs_size_t ioff = *icountp - 1;

    ioff += 1;

    while (ioff % lfs->words == 0) {
        lfs_block_t nhead;
        int err = lfs_alloc_erased(lfs, &nhead);
        if (err) {
            return err;
        }

        lfs_off_t skips = lfs_min(
                lfs_ctz(ioff/lfs->words + 1), lfs->words-2) + 1;
        for (lfs_off_t i = 0; i < skips; i++) {
            err = lfs_bd_prog(lfs, nhead, 4*i, 4, &head);
            if (err) {
                return err;
            }

            if (head && i != skips-1) {
                err = lfs_bd_read(lfs, head, 4*i, 4, &head);
                if (err) {
                    return err;
                }
            }
        }

        ioff += skips;
        head = nhead;
    }

    int err = lfs_bd_prog(lfs, head, 4*(ioff % lfs->words), 4, &block);
    if (err) {
        return err;
    }

    *headp = head;
    *icountp = ioff + 1;
    return 0;
}

static int lfs_index_traverse(lfs_t *lfs, lfs_block_t head,
        lfs_size_t icount, int (*cb)(void*, lfs_block_t), void *data) {
    lfs_off_t iicurrent = (icount-1) / lfs->words;

    while (iicurrent > 0) {
        int err = cb(data, head);
        if (err) {
            return err;
        }

        lfs_size_t skip = lfs_min(lfs_ctz(iicurrent+1), lfs->words-1);
        for (lfs_off_t i = skip; i < lfs->words; i++) {
            lfs_block_t block;
            int err = lfs_bd_read(lfs, head, 4*i, 4, &block);
            if (err) {
                return err;
            }

            err = cb(data, block);
            if (err) {
                return err;
            }
        }

        err = lfs_bd_read(lfs, head, 0, 4, &head);
        if (err) {
            return err;
        }

        iicurrent -= 1;
    }

    int err = cb(data, head);
    if (err) {
        return err;
    }

    for (lfs_off_t i = 0; i < lfs->words; i++) {
        lfs_block_t block;
        int err = lfs_bd_read(lfs, head, 4*i, 4, &block);
        if (err) {
            return err;
        }

        err = cb(data, block);
        if (err) {
            return err;
        }
    }

    return 0;
}


/// Metadata pair operations ///

static inline void lfs_pairswap(lfs_block_t pair[2]) {
    lfs_block_t t = pair[0];
    pair[0] = pair[1];
    pair[1] = t;
}

static inline int lfs_paircmp(
        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]));
}

struct lfs_fetch_region {
    lfs_off_t off;
    lfs_size_t size;
    void *data;
};

static int lfs_pair_fetch(lfs_t *lfs, lfs_block_t pair[2],
        int count, const struct lfs_fetch_region *regions) {
    int checked = 0;
    int rev = 0;
    for (int i = 0; i < 2; i++) {
        uint32_t nrev;
        int err = lfs_bd_read(lfs, pair[1], 0, 4, &nrev);
        if (err) {
            return err;
        }

        if (checked > 0 && lfs_scmp(nrev, rev) < 0) {
            continue;
        }

        uint32_t crc = 0xffffffff;
        err = lfs_bd_crc(lfs, pair[1], 0, lfs->block_size, &crc);
        if (err) {
            return err;
        }

        if (crc != 0) {
            lfs_pairswap(pair);
        }

        checked += 1;
        rev = nrev;
        lfs_pairswap(pair);
    }

    if (checked == 0) {
        LFS_ERROR("Corrupted metadata pair at %d %d", pair[0], pair[1]);
        return LFS_ERROR_CORRUPT;
    }

    for (int i = 0; i < count; i++) {
        int err = lfs_bd_read(lfs, pair[0],
                regions[i].off, regions[i].size, regions[i].data);
        if (err) {
            return err;
        }
    }

    return 0;
}

struct lfs_commit_region {
    lfs_off_t off;
    lfs_size_t size;
    const void *data;
};

static int lfs_pair_commit(lfs_t *lfs, lfs_block_t pair[2],
        int count, const struct lfs_commit_region *regions) {
    uint32_t crc = 0xffffffff;
    int err = lfs_bd_erase(lfs, pair[1], 0, lfs->block_size);
    if (err) {
        return err;
    }

    lfs_off_t off = 0;
    while (off < lfs->block_size - 4) {
        if (count > 0 && regions[0].off == off) {
            crc = lfs_crc(regions[0].data, regions[0].size, crc);
            int err = lfs_bd_prog(lfs, pair[1],
                    off, regions[0].size, regions[0].data);
            if (err) {
                return err;
            }

            off += regions[0].size;
            count -= 1;
            regions += 1;
        } else {
            // TODO faster strides?
            // TODO should we start crcing what's already
            // programmed after dir size?
            uint8_t data;
            int err = lfs_bd_read(lfs, pair[0], off, 1, &data);
            if (err) {
                return err;
            }

            crc = lfs_crc((void*)&data, 1, crc);
            err = lfs_bd_prog(lfs, pair[1], off, 1, &data);
            if (err) {
                return err;
            }

            off += 1;
        }
    }

    err = lfs_bd_prog(lfs, pair[1], lfs->block_size-4, 4, &crc);
    if (err) {
        return err;
    }

    err = lfs_bd_sync(lfs);
    if (err) {
        return err;
    }

    lfs_pairswap(pair);
    return 0;
}

// TODO maybe there is a better abstraction for this?
static int lfs_pair_shift(lfs_t *lfs, lfs_block_t pair[2],
        int count, const struct lfs_commit_region *regions,
        lfs_off_t blank_start, lfs_size_t blank_size) {
    uint32_t crc = 0xffffffff;
    int err = lfs_bd_erase(lfs, pair[1], 0, lfs->block_size);
    if (err) {
        return err;
    }

    lfs_off_t woff = 0;
    lfs_off_t roff = 0;
    while (woff < lfs->block_size - 4) {
        if (count > 0 && regions[0].off == woff) {
            crc = lfs_crc(regions[0].data, regions[0].size, crc);
            int err = lfs_bd_prog(lfs, pair[1],
                    woff, regions[0].size, regions[0].data);
            if (err) {
                return err;
            }

            woff += regions[0].size;
            roff += regions[0].size;
            count -= 1;
            regions += 1;
        } else if (roff == blank_start) {
            roff += blank_size;
        } else if (roff < lfs->block_size - 4) {
            // TODO faster strides?
            // TODO should we start crcing what's already
            // programmed after dir size?
            uint8_t data;
            int err = lfs_bd_read(lfs, pair[0], roff, 1, &data);
            if (err) {
                return err;
            }

            crc = lfs_crc((void*)&data, 1, crc);
            err = lfs_bd_prog(lfs, pair[1], woff, 1, &data);
            if (err) {
                return err;
            }

            woff += 1;
            roff += 1;
        } else {
            uint8_t data = 0;
            crc = lfs_crc((void*)&data, 1, crc);
            err = lfs_bd_prog(lfs, pair[1], woff, 1, &data);
            if (err) {
                return err;
            }

            woff += 1;
        }
    }

    err = lfs_bd_prog(lfs, pair[1], lfs->block_size-4, 4, &crc);
    if (err) {
        return err;
    }

    err = lfs_bd_sync(lfs);
    if (err) {
        return err;
    }

    lfs_pairswap(pair);
    return 0;
}


/// Directory operations ///

static int lfs_dir_alloc(lfs_t *lfs, lfs_dir_t *dir, lfs_block_t tail[2]) {
    // Allocate pair of dir blocks
    for (int i = 0; i < 2; i++) {
        int err = lfs_alloc(lfs, &dir->pair[i]);
        if (err) {
            return err;
        }
    }

    // Rather than clobbering one of the blocks we just pretend
    // the revision may be valid
    int err = lfs_bd_read(lfs, dir->pair[0], 0, 4, &dir->d.rev);
    if (err) {
        return err;
    }
    dir->d.rev += 1;

    // Calculate total size
    dir->d.size = sizeof(dir->d);
    dir->off = sizeof(dir->d);

    // Other defaults
    dir->d.tail[0] = tail[0];
    dir->d.tail[1] = tail[1];

    // Write out to memory
    return lfs_pair_commit(lfs, dir->pair,
        1, (struct lfs_commit_region[]){
            {0, sizeof(dir->d), &dir->d}
        });
}

static int lfs_dir_fetch(lfs_t *lfs, lfs_dir_t *dir, lfs_block_t pair[2]) {
    dir->pair[0] = pair[0];
    dir->pair[1] = pair[1];
    dir->off = sizeof(dir->d);

    return lfs_pair_fetch(lfs, dir->pair,
        1, (struct lfs_fetch_region[1]) {
            {0, sizeof(dir->d), &dir->d}
        });
}

static int lfs_dir_next(lfs_t *lfs, lfs_dir_t *dir, lfs_entry_t *entry) {
    while (true) {
        if ((0x7fffffff & dir->d.size) - dir->off < sizeof(entry->d)) {
            if (!(dir->d.size >> 31)) {
                entry->dir[0] = dir->pair[0];
                entry->dir[1] = dir->pair[1];
                entry->off = dir->off;
                return LFS_ERROR_NO_ENTRY;
            }

            int err = lfs_dir_fetch(lfs, dir, dir->d.tail);
            if (err) {
                return err;
            }

            dir->off = sizeof(dir->d);
        }

        int err = lfs_bd_read(lfs, dir->pair[0], dir->off,
                sizeof(entry->d), &entry->d);
        if (err) {
            return err;
        }

        dir->off += entry->d.len;
        if (entry->d.type == LFS_TYPE_REG || entry->d.type == LFS_TYPE_DIR) {
            entry->dir[0] = dir->pair[0];
            entry->dir[1] = dir->pair[1];
            entry->off = dir->off - entry->d.len;
            return 0;
        }
    }
}

static int lfs_dir_find(lfs_t *lfs, lfs_dir_t *dir,
        const char **path, lfs_entry_t *entry) {
    const char *pathname = *path;
    size_t pathlen;

    while (true) {
    nextname:
        // skip slashes
        pathname += strspn(pathname, "/");
        pathlen = strcspn(pathname, "/");

        // skip '.' and root '..'
        if ((pathlen == 1 && memcmp(pathname, ".", 1) == 0) ||
            (pathlen == 2 && memcmp(pathname, "..", 2) == 0)) {
            pathname += pathlen;
            goto nextname;
        }

        // skip if matched by '..' in name
        const char *suffix = pathname + pathlen;
        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) {
                    pathname = suffix + sufflen;
                    goto nextname;
                }
            } else {
                depth += 1;
            }

            suffix += sufflen;
        }

        // find path
        while (true) {
            int err = lfs_dir_next(lfs, dir, entry);
            if (err) {
                return err;
            }

            if (entry->d.len - sizeof(entry->d) != pathlen) {
                continue;
            }

            int ret = lfs_bd_cmp(lfs, entry->dir[0],
                    entry->off + sizeof(entry->d), pathlen, pathname);
            if (ret < 0) {
                return ret;
            }

            // Found match
            if (ret == true) {
                break;
            }
        }

        pathname += pathlen;
        pathname += strspn(pathname, "/");
        if (pathname[0] == '\0') {
            return 0;
        }

        // continue on if we hit a directory
        if (entry->d.type != LFS_TYPE_DIR) {
            return LFS_ERROR_NOT_DIR;
        }

        int err = lfs_dir_fetch(lfs, dir, entry->d.u.dir);
        if (err) {
            return err;
        }

        *path = pathname;
    }

    return 0;
}

static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
        const char **path, lfs_entry_t *entry) {
    int err = lfs_dir_find(lfs, dir, path, entry);
    if (err != LFS_ERROR_NO_ENTRY) {
        return err ? err : LFS_ERROR_EXISTS;
    }

    // Check if we fit
    if ((0x7fffffff & dir->d.size) + sizeof(entry->d) + strlen(*path)
            > lfs->block_size - 4) {
        lfs_dir_t olddir;
        memcpy(&olddir, dir, sizeof(olddir));

        int err = lfs_dir_alloc(lfs, dir, olddir.d.tail);
        if (err) {
            return err;
        }

        entry->dir[0] = dir->pair[0];
        entry->dir[1] = dir->pair[1];
        entry->off = dir->off;

        olddir.d.rev += 1;
        olddir.d.size |= 1 << 31;
        olddir.d.tail[0] = dir->pair[0];
        olddir.d.tail[1] = dir->pair[1];
        return lfs_pair_commit(lfs, olddir.pair,
            1, (struct lfs_commit_region[]){
                {0, sizeof(olddir.d), &olddir.d}
            });
    }

    return 0;
}

int lfs_mkdir(lfs_t *lfs, const char *path) {
    // Allocate entry for directory
    lfs_dir_t cwd;
    int err = lfs_dir_fetch(lfs, &cwd, lfs->cwd);
    if (err) {
        return err;
    }

    lfs_entry_t entry;
    err = lfs_dir_append(lfs, &cwd, &path, &entry);
    if (err) {
        return err;
    }

    // Build up new directory
    lfs_dir_t dir;
    err = lfs_dir_alloc(lfs, &dir, cwd.d.tail);
    if (err) {
        return err;
    }

    entry.d.type = LFS_TYPE_DIR;
    entry.d.len = sizeof(entry.d) + strlen(path);
    entry.d.u.dir[0] = dir.pair[0];
    entry.d.u.dir[1] = dir.pair[1];

    cwd.d.rev += 1;
    cwd.d.size += entry.d.len;
    cwd.d.tail[0] = dir.pair[0];
    cwd.d.tail[1] = dir.pair[1];

    return lfs_pair_commit(lfs, entry.dir,
        3, (struct lfs_commit_region[3]) {
            {0, sizeof(cwd.d), &cwd.d},
            {entry.off, sizeof(entry.d), &entry.d},
            {entry.off+sizeof(entry.d), entry.d.len - sizeof(entry.d), path}
        });
}

int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
    if (path[0] == '/') {
        dir->pair[0] = lfs->root[0];
        dir->pair[1] = lfs->root[1];
    } else {
        dir->pair[0] = lfs->cwd[0];
        dir->pair[1] = lfs->cwd[1];
    }

    int err = lfs_dir_fetch(lfs, dir, dir->pair);
    if (err) {
        return err;
    } else if (strcmp(path, "/") == 0) {
        // special offset for '.' and '..'
        dir->off = sizeof(dir->d) - 2;
        return 0;
    }

    lfs_entry_t entry;
    err = lfs_dir_find(lfs, dir, &path, &entry);
    if (err) {
        return err;
    } else if (entry.d.type != LFS_TYPE_DIR) {
        return LFS_ERROR_NOT_DIR;
    }

    err = lfs_dir_fetch(lfs, dir, entry.d.u.dir);
    if (err) {
        return err;
    }

    // special offset for '.' and '..'
    dir->off = sizeof(dir->d) - 2;
    return 0;
}

int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir) {
    // Do nothing, dir is always synchronized
    return 0;
}

int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
    memset(info, 0, sizeof(*info));

    if (dir->off == sizeof(dir->d) - 2) {
        info->type = LFS_TYPE_DIR;
        strcpy(info->name, ".");
        dir->off += 1;
        return 1;
    } else if (dir->off == sizeof(dir->d) - 1) {
        info->type = LFS_TYPE_DIR;
        strcpy(info->name, "..");
        dir->off += 1;
        return 1;
    }

    lfs_entry_t entry;
    int err = lfs_dir_next(lfs, dir, &entry);
    if (err) {
        return (err == LFS_ERROR_NO_ENTRY) ? 0 : err;
    }

    info->type = entry.d.type & 0xff;
    if (info->type == LFS_TYPE_REG) {
        info->size = entry.d.u.file.size;
    }

    err = lfs_bd_read(lfs, entry.dir[0], entry.off + sizeof(entry.d),
            entry.d.len - sizeof(entry.d), info->name);
    if (err) {
        return err;
    }

    return 1;
}


/// File operations ///

int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
        const char *path, int flags) {
    // Allocate entry for file if it doesn't exist
    // TODO check open files
    lfs_dir_t cwd;
    int err = lfs_dir_fetch(lfs, &cwd, lfs->cwd);
    if (err) {
        return err;
    }

    if (flags & LFS_O_CREAT) {
        err = lfs_dir_append(lfs, &cwd, &path, &file->entry);
        if (err && err != LFS_ERROR_EXISTS) {
            return err;
        }
    } else {
        err = lfs_dir_find(lfs, &cwd, &path, &file->entry);
        if (err) {
            return err;
        }
    }

    if ((flags & LFS_O_CREAT) && err != LFS_ERROR_EXISTS) {
        // Store file
        file->head = 0;
        file->size = 0;
        file->wblock = 0;
        file->windex = 0;
        file->rblock = 0;
        file->rindex = 0;
        file->roff = 0;

        file->entry.d.type = 1;
        file->entry.d.len = sizeof(file->entry.d) + strlen(path);
        file->entry.d.u.file.head = file->head;
        file->entry.d.u.file.size = file->size;

        cwd.d.rev += 1;
        cwd.d.size += file->entry.d.len;

        return lfs_pair_commit(lfs, file->entry.dir,
            3, (struct lfs_commit_region[3]) {
                {0, sizeof(cwd.d), &cwd.d},
                {file->entry.off,
                 sizeof(file->entry.d),
                 &file->entry.d},
                {file->entry.off+sizeof(file->entry.d),
                 file->entry.d.len-sizeof(file->entry.d),
                 path}
            });
    } else if (file->entry.d.type == LFS_TYPE_DIR) {
        return LFS_ERROR_IS_DIR;
    } else {
        file->head = file->entry.d.u.file.head;
        file->size = file->entry.d.u.file.size;
        file->windex = lfs_indexfrom(lfs, file->size);
        file->rblock = 0;
        file->rindex = 0;
        file->roff = 0;

        // TODO do this lazily in write?
        // TODO cow the head i/d block
        if (file->size < lfs->block_size) {
            file->wblock = file->head;
        } else {
            int err = lfs_index_find(lfs, file->head, file->windex,
                    file->windex, &file->wblock);
            if (err) {
                return err;
            }
        }

        return 0;
    }
}

int lfs_file_close(lfs_t *lfs, lfs_file_t *file) {
    // Store file
    lfs_dir_t cwd;
    int err = lfs_dir_fetch(lfs, &cwd, file->entry.dir);
    if (err) {
        return err;
    }

    file->entry.d.u.file.head = file->head;
    file->entry.d.u.file.size = file->size;

    cwd.d.rev += 1;

    return lfs_pair_commit(lfs, file->entry.dir,
        3, (struct lfs_commit_region[3]) {
            {0, sizeof(cwd.d), &cwd.d},
            {file->entry.off, sizeof(file->entry.d), &file->entry.d},
        });
}

lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
        const void *buffer, lfs_size_t size) {
    const uint8_t *data = buffer;
    lfs_size_t nsize = size;

    while (nsize > 0) {
        lfs_off_t woff = file->size % lfs->block_size;

        if (file->size == 0) {
            int err = lfs_alloc_erased(lfs, &file->wblock);
            if (err) {
                return err;
            }

            file->head = file->wblock;
            file->windex = 0;
        } else if (woff == 0) {
            int err = lfs_alloc_erased(lfs, &file->wblock);
            if (err) {
                return err;
            }

            err = lfs_index_append(lfs, &file->head,
                    &file->windex, file->wblock);
            if (err) {
                return err;
            }
        }

        lfs_size_t diff = lfs_min(nsize, lfs->block_size - woff);
        int err = lfs_bd_prog(lfs, file->wblock, woff, diff, data);
        if (err) {
            return err;
        }

        file->size += diff;
        data += diff;
        nsize -= diff;
    }

    return size;
}

lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
        void *buffer, lfs_size_t size) {
    uint8_t *data = buffer;
    lfs_size_t nsize = size;

    while (nsize > 0 && file->roff < file->size) {
        lfs_off_t roff = file->roff % lfs->block_size;

        // TODO cache index blocks
        if (file->size < lfs->block_size) {
            file->rblock = file->head;
        } else if (roff == 0) {
            int err = lfs_index_find(lfs, file->head, file->windex,
                    file->rindex, &file->rblock);
            if (err) {
                return err;
            }

            file->rindex = lfs_indexnext(lfs, file->rindex);
        }

        lfs_size_t diff = lfs_min(
                lfs_min(nsize, file->size-file->roff),
                lfs->block_size - roff);
        int err = lfs_bd_read(lfs, file->rblock, roff, diff, data);
        if (err) {
            return err;
        }

        file->roff += diff;
        data += diff;
        nsize -= diff;
    }

    return size - nsize;
}


/// Generic filesystem operations ///
static int lfs_configure(lfs_t *lfs, const struct lfs_config *config) {
    lfs->bd = config->bd;
    lfs->bd_ops = config->bd_ops;

    struct lfs_bd_info info;
    int err = lfs_bd_info(lfs, &info);
    if (err) {
        return err;
    }

    if (config->read_size) {
        if (config->read_size < info.read_size ||
            config->read_size % info.read_size != 0) {
            LFS_ERROR("Invalid read size %u, device has %u\n",
                config->read_size, info.read_size);
            return LFS_ERROR_INVALID;
        }

        lfs->read_size = config->read_size;
    } else {
        lfs->read_size = info.read_size;
    }

    if (config->prog_size) {
        if (config->prog_size < info.prog_size ||
            config->prog_size % info.prog_size != 0) {
            LFS_ERROR("Invalid prog size %u, device has %u\n",
                config->prog_size, info.prog_size);
            return LFS_ERROR_INVALID;
        }

        lfs->prog_size = config->prog_size;
    } else {
        lfs->prog_size = info.prog_size;
    }

    if (config->block_size) {
        if (config->block_size < info.erase_size ||
            config->block_size % info.erase_size != 0) {
            LFS_ERROR("Invalid block size %u, device has %u\n",
                config->prog_size, info.prog_size);
            return LFS_ERROR_INVALID;
        }

        lfs->block_size = config->block_size;
    } else {
        lfs->block_size = lfs_min(512, info.erase_size);
    }

    if (config->block_count) {
        if (config->block_count > info.total_size/info.erase_size) {
            LFS_ERROR("Invalid block size %u, device has %u\n",
                config->block_size,
                (uint32_t)(info.total_size/info.erase_size));
            return LFS_ERROR_INVALID;
        }

        lfs->block_count = config->block_count;
    } else {
        lfs->block_count = info.total_size / info.erase_size;
    }

    lfs->words = lfs->block_size / sizeof(uint32_t);
    return 0;
}

int lfs_format(lfs_t *lfs, const struct lfs_config *config) {
    int err = lfs_configure(lfs, config);
    if (err) {
        return err;
    }

    // Create free list
    lfs->free.begin = 2;
    lfs->free.end = lfs->block_count-1;

    // Write root directory
    lfs_dir_t root;
    err = lfs_dir_alloc(lfs, &root, (lfs_block_t[2]){0, 0});
    if (err) {
        return err;
    }
    lfs->root[0] = root.pair[0];
    lfs->root[1] = root.pair[1];
    lfs->cwd[0] = root.pair[0];
    lfs->cwd[1] = root.pair[1];

    // Write superblocks
    lfs_superblock_t superblock = {
        .pair = {0, 1},
        .d.rev = 1,
        .d.size = sizeof(superblock),
        .d.root = {lfs->cwd[0], lfs->cwd[1]},
        .d.magic = {"littlefs"},
        .d.block_size  = lfs->block_size,
        .d.block_count = lfs->block_count,
    };

    for (int i = 0; i < 2; i++) {
        int err = lfs_pair_commit(lfs, superblock.pair,
                1, (struct lfs_commit_region[]){
                    {0, sizeof(superblock.d), &superblock.d}
                });
        if (err) {
            LFS_ERROR("Failed to write superblock at %d", superblock.pair[1]);
            return err;
        }

        uint32_t crc = 0xffffffff;
        err = lfs_bd_crc(lfs, superblock.pair[0], 0, lfs->block_size, &crc);
        if (err || crc != 0) {
            LFS_ERROR("Failed to write superblock at %d", superblock.pair[0]);
            return err ? err : LFS_ERROR_CORRUPT;
        }
    }

    return 0;
}

int lfs_mount(lfs_t *lfs, const struct lfs_config *config) {
    int err = lfs_configure(lfs, config);
    if (err) {
        return err;
    }

    lfs_superblock_t superblock = {
        .pair = {0, 1},
    };
    err = lfs_pair_fetch(lfs, superblock.pair,
            1, (struct lfs_fetch_region[]){
                {0, sizeof(superblock.d), &superblock.d}
            });

    if ((err == LFS_ERROR_CORRUPT ||
            memcmp(superblock.d.magic, "littlefs", 8) != 0)) {
        LFS_ERROR("Invalid superblock at %d %d",
                superblock.pair[0], superblock.pair[1]);
        return LFS_ERROR_CORRUPT;
    }

    lfs->root[0] = superblock.d.root[0];
    lfs->root[1] = superblock.d.root[1];
    lfs->cwd[0] = superblock.d.root[0];
    lfs->cwd[1] = superblock.d.root[1];

    return err;
}

int lfs_unmount(lfs_t *lfs) {
    // Do nothing for now
    return 0;
}

int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
    // iterate over metadata pairs
    lfs_dir_t dir;
    lfs_file_t file;
    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 = lfs_dir_fetch(lfs, &dir, cwd);
        if (err) {
            return err;
        }

        // iterate over contents
        while ((0x7fffffff & dir.d.size) >= dir.off + sizeof(file.entry.d)) {
            int err = lfs_bd_read(lfs, dir.pair[0], dir.off,
                    sizeof(file.entry.d), &file.entry.d);
            if (err) {
                return err;
            }

            dir.off += file.entry.d.len;
            if ((0xf & file.entry.d.type) == LFS_TYPE_REG) {
                if (file.entry.d.u.file.size < lfs->block_size) {
                    int err = cb(data, file.entry.d.u.file.head);
                    if (err) {
                        return err;
                    }
                } else {
                    int err = lfs_index_traverse(lfs,
                            file.entry.d.u.file.head,
                            lfs_indexfrom(lfs, file.entry.d.u.file.size),
                            cb, data);
                    if (err) {
                        return err;
                    }
                }
            }
        }

        cwd[0] = dir.d.tail[0];
        cwd[1] = dir.d.tail[1];

        if (!cwd[0]) {
            return 0;
        }
    }
}

static int lfs_parent(lfs_t *lfs, const lfs_block_t dir[2]) {
    // iterate over all directory directory entries
    lfs_dir_t parent = {
        .d.tail[0] = lfs->root[0],
        .d.tail[1] = lfs->root[1],
    };

    while (parent.d.tail[0]) {
        lfs_entry_t entry;
        int err = lfs_dir_fetch(lfs, &parent, parent.d.tail);
        if (err) {
            return err;
        }

        while (true) {
            int err = lfs_dir_next(lfs, &parent, &entry);
            if (err && err != LFS_ERROR_NO_ENTRY) {
                return err;
            }

            if (err == LFS_ERROR_NO_ENTRY) {
                break;
            }

            if ((0xf & entry.d.type) == LFS_TYPE_DIR &&
                    lfs_paircmp(entry.d.u.dir, dir) == 0) {
                return true;
            }
        }
    }

    return false;
}

int lfs_deorphan(lfs_t *lfs) {
    // iterate over all directories
    lfs_dir_t pdir;
    lfs_dir_t cdir;

    // skip root
    int err = lfs_dir_fetch(lfs, &pdir, lfs->root);
    if (err) {
        return err;
    }

    while (pdir.d.tail[0]) {
        int err = lfs_dir_fetch(lfs, &cdir, pdir.d.tail);
        if (err) {
            return err;
        }

        // check if we have a parent
        int parent = lfs_parent(lfs, pdir.d.tail);
        if (parent < 0) {
            return parent;
        }

        if (!parent) {
            // we are an orphan
            LFS_INFO("Found orphan %d %d", pdir.d.tail[0], pdir.d.tail[1]);

            pdir.d.tail[0] = cdir.d.tail[0];
            pdir.d.tail[1] = cdir.d.tail[1];
            pdir.d.rev += 1;

            err = lfs_pair_commit(lfs, pdir.pair,
                1, (struct lfs_commit_region[]) {
                    {0, sizeof(pdir.d), &pdir.d},
                });
            if (err) {
                return err;
            }

            break;
        }

        memcpy(&pdir, &cdir, sizeof(pdir));
    }

    return 0;
}

int lfs_remove(lfs_t *lfs, const char *path) {
    lfs_dir_t cwd;
    int err = lfs_dir_fetch(lfs, &cwd, lfs->cwd);
    if (err) {
        return err;
    }

    lfs_entry_t entry;
    err = lfs_dir_find(lfs, &cwd, &path, &entry);
    if (err) {
        return err;
    }

    lfs_dir_t dir;
    if (entry.d.type == LFS_TYPE_DIR) {
        // must be empty before removal, checking size
        // without masking top bit checks for any case where
        // dir is not empty
        int err = lfs_dir_fetch(lfs, &dir, entry.d.u.dir);
        if (err) {
            return err;
        } else if (dir.d.size != sizeof(dir.d)) {
            return LFS_ERROR_INVALID;
        }
    }

    cwd.d.rev += 1;
    cwd.d.size -= entry.d.len;

    // either shift out the one entry or remove the whole dir block
    if (cwd.d.size == sizeof(cwd.d)) {
        lfs_dir_t pdir;
        int err = lfs_dir_fetch(lfs, &pdir, lfs->cwd);
        if (err) {
            return err;
        }

        while (lfs_paircmp(pdir.d.tail, cwd.pair) != 0) {
            int err = lfs_dir_fetch(lfs, &pdir, pdir.d.tail);
            if (err) {
                return err;
            }
        }

        // TODO easier check for head block? (common case)
        if (!(pdir.d.size & 0x80000000)) {
            int err = lfs_pair_shift(lfs, entry.dir,
                1, (struct lfs_commit_region[]) {
                    {0, sizeof(cwd.d), &cwd.d},
                },
                entry.off, entry.d.len);
            if (err) {
                return err;
            }
        } else {
            pdir.d.tail[0] = cwd.d.tail[0];
            pdir.d.tail[1] = cwd.d.tail[1];
            pdir.d.rev += 1;

            err = lfs_pair_commit(lfs, pdir.pair,
                1, (struct lfs_commit_region[]) {
                    {0, sizeof(pdir.d), &pdir.d},
                });
            if (err) {
                return err;
            }
        }
    } else {
        int err = lfs_pair_shift(lfs, entry.dir,
            1, (struct lfs_commit_region[]) {
                {0, sizeof(cwd.d), &cwd.d},
            },
            entry.off, entry.d.len);
        if (err) {
            return err;
        }
    }

    if (entry.d.type == LFS_TYPE_DIR) {
        // remove ourselves from the dir list
        // this may create an orphan, which must be deorphaned
        lfs_dir_t pdir;
        memcpy(&pdir, &cwd, sizeof(pdir));

        while (pdir.d.tail[0]) {
            if (lfs_paircmp(pdir.d.tail, entry.d.u.dir) == 0) {
                pdir.d.tail[0] = dir.d.tail[0];
                pdir.d.tail[1] = dir.d.tail[1];
                pdir.d.rev += 1;

                int err = lfs_pair_commit(lfs, pdir.pair,
                    1, (struct lfs_commit_region[]) {
                        {0, sizeof(pdir.d), &pdir.d},
                    });
                if (err) {
                    return err;
                }

                break;
            }

            int err = lfs_dir_fetch(lfs, &pdir, pdir.d.tail);
            if (err) {
                return err;
            }
        }
    }

    return 0;
}

int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
    // Find old entry
    lfs_dir_t oldcwd;
    int err = lfs_dir_fetch(lfs, &oldcwd, lfs->cwd);
    if (err) {
        return err;
    }

    lfs_entry_t oldentry;
    err = lfs_dir_find(lfs, &oldcwd, &oldpath, &oldentry);
    if (err) {
        return err;
    }

    // Allocate new entry
    lfs_dir_t newcwd;
    err = lfs_dir_fetch(lfs, &newcwd, lfs->cwd);
    if (err) {
        return err;
    }

    lfs_entry_t preventry;
    err = lfs_dir_append(lfs, &newcwd, &newpath, &preventry);
    if (err && err != LFS_ERROR_EXISTS) {
        return err;
    }
    bool prevexists = (err == LFS_ERROR_EXISTS);

    // must have same type
    if (prevexists && preventry.d.type != oldentry.d.type) {
        return LFS_ERROR_INVALID;
    }

    lfs_dir_t dir;
    if (prevexists && preventry.d.type == LFS_TYPE_DIR) {
        // must be empty before removal, checking size
        // without masking top bit checks for any case where
        // dir is not empty
        int err = lfs_dir_fetch(lfs, &dir, preventry.d.u.dir);
        if (err) {
            return err;
        } else if (dir.d.size != sizeof(dir.d)) {
            return LFS_ERROR_INVALID;
        }
    }

    // Move to new location
    lfs_entry_t newentry = preventry;
    newentry.d = oldentry.d;
    newentry.d.len = sizeof(newentry.d) + strlen(newpath);

    newcwd.d.rev += 1;
    if (!prevexists) {
        newcwd.d.size += newentry.d.len;
    }

    err = lfs_pair_commit(lfs, newentry.dir,
        3, (struct lfs_commit_region[3]) {
            {0, sizeof(newcwd.d), &newcwd.d},
            {newentry.off,
             sizeof(newentry.d),
             &newentry.d},
            {newentry.off+sizeof(newentry.d),
             newentry.d.len - sizeof(newentry.d),
             newpath}
        });
    if (err) {
        return err;
    }

    // fetch again in case newcwd == oldcwd
    // TODO handle this better?
    err = lfs_dir_fetch(lfs, &oldcwd, oldcwd.pair);
    if (err) {
        return err;
    }

    err = lfs_dir_find(lfs, &oldcwd, &oldpath, &oldentry);
    if (err) {
        return err;
    }

    // Remove from old location
    // TODO abstract this out for rename + remove?
    oldcwd.d.rev += 1;
    oldcwd.d.size -= oldentry.d.len;

    // either shift out the one entry or remove the whole dir block
    if (oldcwd.d.size == sizeof(oldcwd.d)) {
        lfs_dir_t pdir;
        int err = lfs_dir_fetch(lfs, &pdir, lfs->cwd);
        if (err) {
            return err;
        }

        while (lfs_paircmp(pdir.d.tail, oldcwd.pair) != 0) {
            int err = lfs_dir_fetch(lfs, &pdir, pdir.d.tail);
            if (err) {
                return err;
            }
        }

        // TODO easier check for head block? (common case)
        if (!(pdir.d.size & 0x80000000)) {
            int err = lfs_pair_shift(lfs, oldentry.dir,
                1, (struct lfs_commit_region[]) {
                    {0, sizeof(oldcwd.d), &oldcwd.d},
                },
                oldentry.off, oldentry.d.len);
            if (err) {
                return err;
            }
        } else {
            pdir.d.tail[0] = oldcwd.d.tail[0];
            pdir.d.tail[1] = oldcwd.d.tail[1];
            pdir.d.rev += 1;

            err = lfs_pair_commit(lfs, pdir.pair,
                1, (struct lfs_commit_region[]) {
                    {0, sizeof(pdir.d), &pdir.d},
                });
            if (err) {
                return err;
            }
        }
    } else {
        int err = lfs_pair_shift(lfs, oldentry.dir,
            1, (struct lfs_commit_region[]) {
                {0, sizeof(oldcwd.d), &oldcwd.d},
            },
            oldentry.off, oldentry.d.len);
        if (err) {
            return err;
        }
    }

    // TODO abstract this out for rename + remove?
    if (prevexists && preventry.d.type == LFS_TYPE_DIR) {
        // remove dest from the dir list
        // this may create an orphan, which must be deorphaned
        lfs_dir_t pdir;
        int err = lfs_dir_fetch(lfs, &pdir, lfs->root);
        if (err) {
            return err;
        }

        while (pdir.d.tail[0]) {
            if (lfs_paircmp(pdir.d.tail, preventry.d.u.dir) == 0) {
                pdir.d.tail[0] = dir.d.tail[0];
                pdir.d.tail[1] = dir.d.tail[1];
                pdir.d.rev += 1;

                int err = lfs_pair_commit(lfs, pdir.pair,
                    1, (struct lfs_commit_region[]) {
                        {0, sizeof(pdir.d), &pdir.d},
                    });
                if (err) {
                    return err;
                }

                break;
            }

            int err = lfs_dir_fetch(lfs, &pdir, pdir.d.tail);
            if (err) {
                return err;
            }
        }
    }

    return 0;
}

int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info) {
    lfs_dir_t cwd;
    int err = lfs_dir_fetch(lfs, &cwd, lfs->cwd);
    if (err) {
        return err;
    }

    lfs_entry_t entry;
    err = lfs_dir_find(lfs, &cwd, &path, &entry);
    if (err) {
        return err;
    }

    // TODO abstract out info assignment
    memset(info, 0, sizeof(*info));
    info->type = entry.d.type & 0xff;
    if (info->type == LFS_TYPE_REG) {
        info->size = entry.d.u.file.size;
    }

    err = lfs_bd_read(lfs, entry.dir[0], entry.off + sizeof(entry.d),
            entry.d.len - sizeof(entry.d), info->name);
    if (err) {
        return err;
    }

    return 0;
}