Lines Matching defs:dir
546 static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
549 lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
563 static int lfs_fs_pred(lfs_t *lfs, const lfs_block_t dir[2],
565 static lfs_stag_t lfs_fs_parent(lfs_t *lfs, const lfs_block_t dir[2],
577 static int lfs_dir_rawrewind(lfs_t *lfs, lfs_dir_t *dir);
686 static lfs_stag_t lfs_dir_getslice(lfs_t *lfs, const lfs_mdir_t *dir,
689 lfs_off_t off = dir->off;
690 lfs_tag_t ntag = dir->etag;
693 if (lfs_gstate_hasmovehere(&lfs->gdisk, dir->pair) &&
700 // iterate over dir block backwards (for faster lookups)
706 dir->pair[0], off, &ntag, sizeof(ntag));
734 dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
748 static lfs_stag_t lfs_dir_get(lfs_t *lfs, const lfs_mdir_t *dir,
750 return lfs_dir_getslice(lfs, dir,
755 static int lfs_dir_getread(lfs_t *lfs, const lfs_mdir_t *dir,
806 int err = lfs_dir_getslice(lfs, dir, gmask, gtag,
857 const lfs_mdir_t *dir;
878 const lfs_mdir_t *dir, lfs_off_t off, lfs_tag_t ptag,
895 if (off+lfs_tag_dsize(ptag) < dir->off) {
899 dir->pair[0], off, &tag, sizeof(tag));
905 disk.block = dir->pair[0];
931 .dir = dir,
993 .dir = dir,
1011 dir = buffer;
1049 dir = stack[sp-1].dir;
1073 lfs_mdir_t *dir, const lfs_block_t pair[2],
1105 dir->pair[0] = pair[(r+0)%2];
1106 dir->pair[1] = pair[(r+1)%2];
1107 dir->rev = revs[(r+0)%2];
1108 dir->off = 0; // nonzero = found some commits
1110 // now scan tags to fetch the actual dir and find possible match
1125 dir->rev = lfs_tole32(dir->rev);
1126 uint32_t crc = lfs_crc(0xffffffff, &dir->rev, sizeof(dir->rev));
1127 dir->rev = lfs_fromle32(dir->rev);
1135 dir->pair[0], off, &tag, sizeof(tag));
1164 dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
1188 dir->off = off + lfs_tag_dsize(tag);
1189 dir->etag = ptag;
1190 dir->count = tempcount;
1191 dir->tail[0] = temptail[0];
1192 dir->tail[1] = temptail[1];
1193 dir->split = tempsplit;
1203 dir->pair[0], off+sizeof(tag),
1233 dir->pair[0], off+sizeof(tag), &temptail, 8);
1244 dir->pair[0], off+sizeof(tag),
1259 dir->pair[0], off+sizeof(tag)});
1284 if (dir->off == 0) {
1286 lfs_pair_swap(dir->pair);
1287 dir->rev = revs[(r+1)%2];
1292 dir->erased = false;
1293 if (maybeerased && dir->off % lfs->cfg->prog_size == 0) {
1301 dir->erased = true;
1312 dir->pair[0], dir->off, fcrc.size, &fcrc_);
1318 dir->erased = (fcrc_ == fcrc.crc);
1323 if (lfs_gstate_hasmovehere(&lfs->gdisk, dir->pair)) {
1334 *id = lfs_min(lfs_tag_id(besttag), dir->count);
1339 } else if (lfs_tag_id(besttag) < dir->count) {
1346 LFS_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
1347 dir->pair[0], dir->pair[1]);
1352 lfs_mdir_t *dir, const lfs_block_t pair[2]) {
1355 return (int)lfs_dir_fetchmatch(lfs, dir, pair,
1359 static int lfs_dir_getgstate(lfs_t *lfs, const lfs_mdir_t *dir,
1362 lfs_stag_t res = lfs_dir_get(lfs, dir, LFS_MKTAG(0x7ff, 0, 0),
1377 static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir,
1386 lfs_stag_t tag = lfs_dir_get(lfs, dir, LFS_MKTAG(0x780, 0x3ff, 0),
1395 tag = lfs_dir_get(lfs, dir, LFS_MKTAG(0x700, 0x3ff, 0),
1441 static lfs_stag_t lfs_dir_find(lfs_t *lfs, lfs_mdir_t *dir,
1449 // default to root dir
1451 dir->tail[0] = lfs->root[0];
1452 dir->tail[1] = lfs->root[1];
1506 lfs_stag_t res = lfs_dir_get(lfs, dir, LFS_MKTAG(0x700, 0x3ff, 0),
1507 LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), dir->tail);
1511 lfs_pair_fromle32(dir->tail);
1516 tag = lfs_dir_fetchmatch(lfs, dir, dir->tail,
1531 if (!dir->split) {
1764 static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir) {
1765 // allocate pair of dir blocks (backwards, so we write block 1 first)
1767 int err = lfs_alloc(lfs, &dir->pair[(i+1)%2]);
1774 dir->rev = 0;
1779 NULL, &lfs->rcache, sizeof(dir->rev),
1780 dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
1781 dir->rev = lfs_fromle32(dir->rev);
1790 dir->rev = lfs_alignup(dir->rev, ((lfs->cfg->block_cycles+1)|1));
1794 dir->off = sizeof(dir->rev);
1795 dir->etag = 0xffffffff;
1796 dir->count = 0;
1797 dir->tail[0] = LFS_BLOCK_NULL;
1798 dir->tail[1] = LFS_BLOCK_NULL;
1799 dir->erased = false;
1800 dir->split = false;
1808 static int lfs_dir_drop(lfs_t *lfs, lfs_mdir_t *dir, lfs_mdir_t *tail) {
1817 err = lfs_dir_commit(lfs, dir, LFS_MKATTRS(
1830 lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
1839 tail.split = dir->split;
1840 tail.tail[0] = dir->tail[0];
1841 tail.tail[1] = dir->tail[1];
1849 dir->tail[0] = tail.pair[0];
1850 dir->tail[1] = tail.pair[1];
1851 dir->split = true;
1854 if (lfs_pair_cmp(dir->pair, lfs->root) == 0 && split == 0) {
1888 static bool lfs_dir_needsrelocation(lfs_t *lfs, lfs_mdir_t *dir) {
1896 && ((dir->rev + 1) % ((lfs->cfg->block_cycles+1)|1) == 0));
1902 lfs_mdir_t *dir, const struct lfs_mattr *attrs, int attrcount,
1906 bool tired = lfs_dir_needsrelocation(lfs, dir);
1909 dir->rev += 1;
1923 if (tired && lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) != 0) {
1933 .block = dir->pair[1],
1944 int err = lfs_bd_erase(lfs, dir->pair[1]);
1953 dir->rev = lfs_tole32(dir->rev);
1955 &dir->rev, sizeof(dir->rev));
1956 dir->rev = lfs_fromle32(dir->rev);
1980 if (!lfs_pair_isnull(dir->tail)) {
1981 lfs_pair_tole32(dir->tail);
1983 LFS_MKTAG(LFS_TYPE_TAIL + dir->split, 0x3ff, 8),
1984 dir->tail);
1985 lfs_pair_fromle32(dir->tail);
2003 err = lfs_dir_getgstate(lfs, dir, &delta);
2030 // successful compaction, swap dir pair to indicate most recent
2032 lfs_pair_swap(dir->pair);
2033 dir->count = end - begin;
2034 dir->off = commit.off;
2035 dir->etag = commit.ptag;
2049 LFS_DEBUG("Bad block at 0x%"PRIx32, dir->pair[1]);
2053 if (lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) == 0) {
2055 dir->pair[1]);
2060 int err = lfs_alloc(lfs, &dir->pair[1]);
2074 static int lfs_dir_splittingcompact(lfs_t *lfs, lfs_mdir_t *dir,
2128 int err = lfs_dir_split(lfs, dir, attrs, attrcount,
2138 dir->pair[0], dir->pair[1]);
2145 if (lfs_dir_needsrelocation(lfs, dir)
2146 && lfs_pair_cmp(dir->pair, (const lfs_block_t[2]){0, 1}) == 0) {
2157 LFS_DEBUG("Expanding superblock at rev %"PRIu32, dir->rev);
2158 int err = lfs_dir_split(lfs, dir, attrs, attrcount,
2174 return lfs_dir_compact(lfs, dir, attrs, attrcount, source, begin, end);
2179 static int lfs_dir_relocatingcommit(lfs_t *lfs, lfs_mdir_t *dir,
2189 dir->count += 1;
2191 LFS_ASSERT(dir->count > 0);
2192 dir->count -= 1;
2195 dir->tail[0] = ((lfs_block_t*)attrs[i].buffer)[0];
2196 dir->tail[1] = ((lfs_block_t*)attrs[i].buffer)[1];
2197 dir->split = (lfs_tag_chunk(attrs[i].tag) & 1);
2198 lfs_pair_fromle32(dir->tail);
2203 if (hasdelete && dir->count == 0) {
2205 int err = lfs_fs_pred(lfs, dir->pair, pdir);
2216 if (dir->erased) {
2219 .block = dir->pair[0],
2220 .off = dir->off,
2221 .ptag = dir->etag,
2224 .begin = dir->off,
2230 lfs_pair_tole32(dir->tail);
2232 dir, dir->off, dir->etag, attrs, attrcount,
2236 lfs_pair_fromle32(dir->tail);
2251 err = lfs_dir_getgstate(lfs, dir, &delta);
2277 // successful commit, update dir
2279 dir->off = commit.off;
2280 dir->etag = commit.ptag;
2292 state = lfs_dir_splittingcompact(lfs, dir, attrs, attrcount,
2293 dir, 0, dir->count);
2311 d->m = *dir;
2350 static int lfs_dir_orphaningcommit(lfs_t *lfs, lfs_mdir_t *dir,
2355 if (dir != &f->m && lfs_pair_cmp(f->m.pair, dir->pair) == 0 &&
2370 lfs_block_t lpair[2] = {dir->pair[0], dir->pair[1]};
2371 lfs_mdir_t ldir = *dir;
2373 int state = lfs_dir_relocatingcommit(lfs, &ldir, dir->pair,
2381 if (lfs_pair_cmp(dir->pair, lpair) == 0) {
2382 *dir = ldir;
2392 int err = lfs_dir_getgstate(lfs, dir, &lfs->gdelta);
2400 lfs_pair_tole32(dir->tail);
2402 {LFS_MKTAG(LFS_TYPE_TAIL + dir->split, 0x3ff, 8),
2403 dir->tail}),
2405 lfs_pair_fromle32(dir->tail);
2498 // if we can't find dir, it must be new
2543 static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
2545 int orphans = lfs_dir_orphaningcommit(lfs, dir, attrs, attrcount);
2590 lfs_mdir_t dir;
2591 err = lfs_dir_alloc(lfs, &dir);
2605 // setup dir
2607 err = lfs_dir_commit(lfs, &dir, LFS_MKATTRS(
2630 lfs_pair_tole32(dir.pair);
2632 {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
2633 lfs_pair_fromle32(dir.pair);
2647 lfs_pair_tole32(dir.pair);
2651 {LFS_MKTAG(LFS_TYPE_DIRSTRUCT, id, 8), dir.pair},
2653 LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
2654 lfs_pair_fromle32(dir.pair);
2663 static int lfs_dir_rawopen(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
2664 lfs_stag_t tag = lfs_dir_find(lfs, &dir->m, &path, NULL);
2675 // handle root dir separately
2679 // get dir pair from parent
2680 lfs_stag_t res = lfs_dir_get(lfs, &dir->m, LFS_MKTAG(0x700, 0x3ff, 0),
2689 int err = lfs_dir_fetch(lfs, &dir->m, pair);
2695 dir->head[0] = dir->m.pair[0];
2696 dir->head[1] = dir->m.pair[1];
2697 dir->id = 0;
2698 dir->pos = 0;
2701 dir->type = LFS_TYPE_DIR;
2702 lfs_mlist_append(lfs, (struct lfs_mlist *)dir);
2707 static int lfs_dir_rawclose(lfs_t *lfs, lfs_dir_t *dir) {
2709 lfs_mlist_remove(lfs, (struct lfs_mlist *)dir);
2714 static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
2718 if (dir->pos == 0) {
2721 dir->pos += 1;
2723 } else if (dir->pos == 1) {
2726 dir->pos += 1;
2731 if (dir->id == dir->m.count) {
2732 if (!dir->m.split) {
2736 int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
2741 dir->id = 0;
2744 int err = lfs_dir_getinfo(lfs, &dir->m, dir->id, info);
2749 dir->id += 1;
2755 dir->pos += 1;
2759 static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
2760 // simply walk from head dir
2761 int err = lfs_dir_rawrewind(lfs, dir);
2767 dir->pos = lfs_min(2, off);
2768 off -= dir->pos;
2771 dir->id = (off > 0 && lfs_pair_cmp(dir->head, lfs->root) == 0);
2774 if (dir->id == dir->m.count) {
2775 if (!dir->m.split) {
2779 err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
2784 dir->id = 0;
2787 int diff = lfs_min(dir->m.count - dir->id, off);
2788 dir->id += diff;
2789 dir->pos += diff;
2796 static lfs_soff_t lfs_dir_rawtell(lfs_t *lfs, lfs_dir_t *dir) {
2798 return dir->pos;
2801 static int lfs_dir_rawrewind(lfs_t *lfs, lfs_dir_t *dir) {
2802 // reload the head dir
2803 int err = lfs_dir_fetch(lfs, &dir->m, dir->head);
2808 dir->id = 0;
2809 dir->pos = 0;
3382 // update dir entry
3832 struct lfs_mlist dir;
3833 dir.next = lfs->mlist;
3844 err = lfs_dir_fetch(lfs, &dir.m, pair);
3849 if (dir.m.count > 0 || dir.m.split) {
3859 // I know it's crazy but yes, dir can be changed by our parent's
3861 dir.type = 0;
3862 dir.id = 0;
3863 lfs->mlist = &dir;
3870 lfs->mlist = dir.next;
3874 lfs->mlist = dir.next;
3882 err = lfs_fs_pred(lfs, dir.m.pair, &cwd);
3887 err = lfs_dir_drop(lfs, &cwd, &dir.m);
3971 // I know it's crazy but yes, dir can be changed by our parent's
4275 // create root dir
4331 lfs_mdir_t dir = {.tail = {0, 1}};
4335 while (!lfs_pair_isnull(dir.tail)) {
4337 if (lfs_pair_issync(dir.tail, tortoise)) {
4343 tortoise[0] = dir.tail[0];
4344 tortoise[1] = dir.tail[1];
4351 lfs_stag_t tag = lfs_dir_fetchmatch(lfs, &dir, dir.tail,
4365 lfs->root[0] = dir.pair[0];
4366 lfs->root[1] = dir.pair[1];
4370 tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x7ff, 0x3ff, 0),
4463 err = lfs_dir_getgstate(lfs, &dir, &lfs->gstate);
4506 lfs_mdir_t dir;
4507 int err = lfs_dir_fetch(lfs, &dir, lfs->root);
4513 lfs_stag_t tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x7ff, 0x3ff, 0),
4541 lfs_mdir_t dir = {.tail = {0, 1}};
4551 dir.tail[0] = lfs->root[0];
4552 dir.tail[1] = lfs->root[1];
4559 while (!lfs_pair_isnull(dir.tail)) {
4561 if (lfs_pair_issync(dir.tail, tortoise)) {
4566 tortoise[0] = dir.tail[0];
4567 tortoise[1] = dir.tail[1];
4574 int err = cb(data, dir.tail[i]);
4581 int err = lfs_dir_fetch(lfs, &dir, dir.tail);
4586 for (uint16_t id = 0; id < dir.count; id++) {
4588 lfs_stag_t tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x700, 0x3ff, 0),
4867 lfs_mdir_t dir;
4872 int err = lfs_dir_fetch(lfs, &dir, pdir.tail);
4944 err = lfs_dir_getgstate(lfs, &dir, &lfs->gdelta);
4950 lfs_pair_tole32(dir.tail);
4952 {LFS_MKTAG(LFS_TYPE_TAIL + dir.split, 0x3ff, 8),
4953 dir.tail}));
4954 lfs_pair_fromle32(dir.tail);
4969 pdir = dir;
5133 lfs_block_t dir[2];
5215 d->u.dir[0] = lfs_fromle32(d->u.dir[0]);
5216 d->u.dir[1] = lfs_fromle32(d->u.dir[1]);
5220 d->u.dir[0] = lfs_tole32(d->u.dir[0]);
5221 d->u.dir[1] = lfs_tole32(d->u.dir[1]);
5239 lfs1_dir_t *dir, const lfs_block_t pair[2]) {
5240 // copy out pair, otherwise may be aliasing dir
5256 if (valid && lfs_scmp(test.rev, dir->d.rev) < 0) {
5284 // setup dir in case it's valid
5285 dir->pair[0] = tpair[(i+0) % 2];
5286 dir->pair[1] = tpair[(i+1) % 2];
5287 dir->off = sizeof(dir->d);
5288 dir->d = test;
5292 LFS_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
5300 static int lfs1_dir_next(lfs_t *lfs, lfs1_dir_t *dir, lfs1_entry_t *entry) {
5301 while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
5302 if (!(0x80000000 & dir->d.size)) {
5303 entry->off = dir->off;
5307 int err = lfs1_dir_fetch(lfs, dir, dir->d.tail);
5312 dir->off = sizeof(dir->d);
5313 dir->pos += sizeof(dir->d) + 4;
5316 int err = lfs1_bd_read(lfs, dir->pair[0], dir->off,
5323 entry->off = dir->off;
5324 dir->off += lfs1_entry_size(entry);
5325 dir->pos += lfs1_entry_size(entry);
5336 lfs1_dir_t dir;
5348 int err = lfs1_dir_fetch(lfs, &dir, cwd);
5354 while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
5355 err = lfs1_bd_read(lfs, dir.pair[0], dir.off,
5362 dir.off += lfs1_entry_size(&entry);
5388 cwd[0] = dir.d.tail[0];
5389 cwd[1] = dir.d.tail[1];
5460 lfs1_dir_t dir;
5462 err = lfs1_dir_fetch(lfs, &dir, (const lfs_block_t[2]){0, 1});
5468 err = lfs1_bd_read(lfs, dir.pair[0], sizeof(dir.d),
5527 // iterate old dir
5533 // create new dir and bind as temporary pretend root
5588 // create entry in new dir
6123 int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
6128 LFS_TRACE("lfs_dir_open(%p, %p, \"%s\")", (void*)lfs, (void*)dir, path);
6129 LFS_ASSERT(!lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)dir));
6131 err = lfs_dir_rawopen(lfs, dir, path);
6138 int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir) {
6143 LFS_TRACE("lfs_dir_close(%p, %p)", (void*)lfs, (void*)dir);
6145 err = lfs_dir_rawclose(lfs, dir);
6152 int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
6158 (void*)lfs, (void*)dir, (void*)info);
6160 err = lfs_dir_rawread(lfs, dir, info);
6167 int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
6173 (void*)lfs, (void*)dir, off);
6175 err = lfs_dir_rawseek(lfs, dir, off);
6182 lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir) {
6187 LFS_TRACE("lfs_dir_tell(%p, %p)", (void*)lfs, (void*)dir);
6189 lfs_soff_t res = lfs_dir_rawtell(lfs, dir);
6196 int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) {
6201 LFS_TRACE("lfs_dir_rewind(%p, %p)", (void*)lfs, (void*)dir);
6203 err = lfs_dir_rawrewind(lfs, dir);