+/rtos
git clone https://git.julia.blue/+/rtos
ee4080a
master
1/* 2* The little filesystem 3* 4* Copyright (c) 2017, Arm Limited. All rights reserved. 5* SPDX-License-Identifier: BSD-3-Clause 6*/ 7#include "lfs.h" 8#include "lfs_util.h" 9 10#define LFS_BLOCK_NULL ((lfs_block_t)-1) 11#define LFS_BLOCK_INLINE ((lfs_block_t)-2) 12 13/// Caching block device operations /// 14static inline void lfs_cache_drop (lfs_t * lfs ,lfs_cache_t * rcache ) { 15// do not zero, cheaper if cache is readonly or only going to be 16// written with identical data (during relocates) 17 (void )lfs ; 18rcache -> block = LFS_BLOCK_NULL ; 19} 20 21static inline void lfs_cache_zero (lfs_t * lfs ,lfs_cache_t * pcache ) { 22// zero to avoid information leak 23memset (pcache -> buffer ,0xff ,lfs -> cfg -> cache_size ); 24pcache -> block = LFS_BLOCK_NULL ; 25} 26 27static int lfs_bd_read (lfs_t * lfs ,const lfs_cache_t * pcache , 28lfs_cache_t * rcache ,lfs_size_t hint ,lfs_block_t block , 29lfs_off_t off ,void * buffer ,lfs_size_t size ) { 30uint8_t * data = buffer ; 31if (block >=lfs -> cfg -> block_count || off + size > lfs -> cfg -> block_size ) { 32return LFS_ERR_CORRUPT ; 33 } 34 35while (size > 0 ) { 36lfs_size_t diff = size ; 37 38if (pcache && block == pcache -> block && 39off < pcache -> off + pcache -> size ) { 40if (off >=pcache -> off ) { 41// is already in pcache? 42diff = lfs_min (diff ,pcache -> size - (off - pcache -> off )); 43memcpy (data ,& pcache -> buffer [off - pcache -> off ],diff ); 44 45data += diff ; 46off += diff ; 47size -= diff ; 48continue ; 49 } 50 51// pcache takes priority 52diff = lfs_min (diff ,pcache -> off - off ); 53 } 54 55if (block == rcache -> block && off < rcache -> off + rcache -> size ) { 56if (off >=rcache -> off ) { 57// is already in rcache? 58diff = lfs_min (diff ,rcache -> size - (off - rcache -> off )); 59memcpy (data ,& rcache -> buffer [off - rcache -> off ],diff ); 60 61data += diff ; 62off += diff ; 63size -= diff ; 64continue ; 65 } 66 67// rcache takes priority 68diff = lfs_min (diff ,rcache -> off - off ); 69 } 70 71if (size >=hint && off %lfs -> cfg -> read_size == 0 && 72size >=lfs -> cfg -> read_size ) { 73// bypass cache? 74diff = lfs_aligndown (diff ,lfs -> cfg -> read_size ); 75int err = lfs -> cfg -> read (lfs -> cfg ,block ,off ,data ,diff ); 76if (err ) { 77return err ; 78 } 79 80data += diff ; 81off += diff ; 82size -= diff ; 83continue ; 84 } 85 86// load to cache, first condition can no longer fail 87LFS_ASSERT (block < lfs -> cfg -> block_count ); 88rcache -> block = block ; 89rcache -> off = lfs_aligndown (off ,lfs -> cfg -> read_size ); 90rcache -> size = 91lfs_min (lfs_min (lfs_alignup (off + hint ,lfs -> cfg -> read_size ), 92lfs -> cfg -> block_size )- 93rcache -> off , 94lfs -> cfg -> cache_size ); 95int err = lfs -> cfg -> read (lfs -> cfg ,rcache -> block ,rcache -> off , 96rcache -> buffer ,rcache -> size ); 97LFS_ASSERT (err <=0 ); 98if (err ) { 99return err ; 100 } 101 } 102 103return 0 ; 104} 105 106enum { 107LFS_CMP_EQ = 0 , 108LFS_CMP_LT = 1 , 109LFS_CMP_GT = 2 , 110}; 111 112static int lfs_bd_cmp (lfs_t * lfs ,const lfs_cache_t * pcache , 113lfs_cache_t * rcache ,lfs_size_t hint ,lfs_block_t block , 114lfs_off_t off ,const void * buffer ,lfs_size_t size ) { 115const uint8_t * data = buffer ; 116 117for (lfs_off_t i = 0 ;i < size ;i ++ ) { 118uint8_t dat ; 119int err = 120lfs_bd_read (lfs ,pcache ,rcache ,hint - i ,block ,off + i ,& dat ,1 ); 121if (err ) { 122return err ; 123 } 124 125if (dat != data [i ]) { 126return (dat < data [i ]) ?LFS_CMP_LT :LFS_CMP_GT ; 127 } 128 } 129 130return LFS_CMP_EQ ; 131} 132 133static int lfs_bd_flush (lfs_t * lfs ,lfs_cache_t * pcache ,lfs_cache_t * rcache , 134bool validate ) { 135if (pcache -> block != LFS_BLOCK_NULL && pcache -> block != LFS_BLOCK_INLINE ) { 136LFS_ASSERT (pcache -> block < lfs -> cfg -> block_count ); 137lfs_size_t diff = lfs_alignup (pcache -> size ,lfs -> cfg -> prog_size ); 138int err = lfs -> cfg -> prog (lfs -> cfg ,pcache -> block ,pcache -> off , 139pcache -> buffer ,diff ); 140LFS_ASSERT (err <=0 ); 141if (err ) { 142return err ; 143 } 144 145if (validate ) { 146// check data on disk 147lfs_cache_drop (lfs ,rcache ); 148int res = lfs_bd_cmp (lfs ,NULL ,rcache ,diff ,pcache -> block , 149pcache -> off ,pcache -> buffer ,diff ); 150if (res < 0 ) { 151return res ; 152 } 153 154if (res != LFS_CMP_EQ ) { 155return LFS_ERR_CORRUPT ; 156 } 157 } 158 159lfs_cache_zero (lfs ,pcache ); 160 } 161 162return 0 ; 163} 164 165static int lfs_bd_sync (lfs_t * lfs ,lfs_cache_t * pcache ,lfs_cache_t * rcache , 166bool validate ) { 167lfs_cache_drop (lfs ,rcache ); 168 169int err = lfs_bd_flush (lfs ,pcache ,rcache ,validate ); 170if (err ) { 171return err ; 172 } 173 174err = lfs -> cfg -> sync (lfs -> cfg ); 175LFS_ASSERT (err <=0 ); 176return err ; 177} 178 179static int lfs_bd_prog (lfs_t * lfs ,lfs_cache_t * pcache ,lfs_cache_t * rcache , 180bool validate ,lfs_block_t block ,lfs_off_t off , 181const void * buffer ,lfs_size_t size ) { 182const uint8_t * data = buffer ; 183LFS_ASSERT (block == LFS_BLOCK_INLINE || block < lfs -> cfg -> block_count ); 184LFS_ASSERT (off + size <=lfs -> cfg -> block_size ); 185 186while (size > 0 ) { 187if (block == pcache -> block && off >=pcache -> off && 188off < pcache -> off + lfs -> cfg -> cache_size ) { 189// already fits in pcache? 190lfs_size_t diff = 191lfs_min (size ,lfs -> cfg -> cache_size - (off - pcache -> off )); 192memcpy (& pcache -> buffer [off - pcache -> off ],data ,diff ); 193 194data += diff ; 195off += diff ; 196size -= diff ; 197 198pcache -> size = lfs_max (pcache -> size ,off - pcache -> off ); 199if (pcache -> size == lfs -> cfg -> cache_size ) { 200// eagerly flush out pcache if we fill up 201int err = lfs_bd_flush (lfs ,pcache ,rcache ,validate ); 202if (err ) { 203return err ; 204 } 205 } 206 207continue ; 208 } 209 210// pcache must have been flushed, either by programming and 211// entire block or manually flushing the pcache 212LFS_ASSERT (pcache -> block == LFS_BLOCK_NULL ); 213 214// prepare pcache, first condition can no longer fail 215pcache -> block = block ; 216pcache -> off = lfs_aligndown (off ,lfs -> cfg -> prog_size ); 217pcache -> size = 0 ; 218 } 219 220return 0 ; 221} 222 223static int lfs_bd_erase (lfs_t * lfs ,lfs_block_t block ) { 224LFS_ASSERT (block < lfs -> cfg -> block_count ); 225int err = lfs -> cfg -> erase (lfs -> cfg ,block ); 226LFS_ASSERT (err <=0 ); 227return err ; 228} 229 230/// Small type-level utilities /// 231// operations on block pairs 232static inline void lfs_pair_swap (lfs_block_t pair [2 ]) { 233lfs_block_t t = pair [0 ]; 234pair [0 ]= pair [1 ]; 235pair [1 ]= t ; 236} 237 238static inline bool lfs_pair_isnull (const lfs_block_t pair [2 ]) { 239return pair [0 ]== LFS_BLOCK_NULL || pair [1 ]== LFS_BLOCK_NULL ; 240} 241 242static inline int lfs_pair_cmp (const lfs_block_t paira [2 ], 243const lfs_block_t pairb [2 ]) { 244return !(paira [0 ]== pairb [0 ]|| paira [1 ]== pairb [1 ]|| 245paira [0 ]== pairb [1 ]|| paira [1 ]== pairb [0 ]); 246} 247 248static inline bool lfs_pair_sync (const lfs_block_t paira [2 ], 249const lfs_block_t pairb [2 ]) { 250return (paira [0 ]== pairb [0 ]&& paira [1 ]== pairb [1 ])|| 251 (paira [0 ]== pairb [1 ]&& paira [1 ]== pairb [0 ]); 252} 253 254static inline void lfs_pair_fromle32 (lfs_block_t pair [2 ]) { 255pair [0 ]= lfs_fromle32 (pair [0 ]); 256pair [1 ]= lfs_fromle32 (pair [1 ]); 257} 258 259static inline void lfs_pair_tole32 (lfs_block_t pair [2 ]) { 260pair [0 ]= lfs_tole32 (pair [0 ]); 261pair [1 ]= lfs_tole32 (pair [1 ]); 262} 263 264// operations on 32-bit entry tags 265typedef uint32_t lfs_tag_t ; 266typedef int32_t lfs_stag_t ; 267 268#define LFS_MKTAG (type ,id ,size ) \ 269 (((lfs_tag_t)(type) << 20) | ((lfs_tag_t)(id) << 10) | (lfs_tag_t)(size)) 270 271#define LFS_MKTAG_IF (cond ,type ,id ,size ) \ 272 ((cond) ? LFS_MKTAG(type, id, size) : LFS_MKTAG(LFS_FROM_NOOP, 0, 0)) 273 274#define LFS_MKTAG_IF_ELSE (cond ,type1 ,id1 ,size1 ,type2 ,id2 ,size2 ) \ 275 ((cond) ? LFS_MKTAG(type1, id1, size1) : LFS_MKTAG(type2, id2, size2)) 276 277static inline bool lfs_tag_isvalid (lfs_tag_t tag ) { 278return !(tag & 0x80000000 ); 279} 280 281static inline bool lfs_tag_isdelete (lfs_tag_t tag ) { 282return ((int32_t )(tag <<22 ) >>22 )== -1 ; 283} 284 285static inline uint16_t lfs_tag_type1 (lfs_tag_t tag ) { 286return (tag & 0x70000000 ) >>20 ; 287} 288 289static inline uint16_t lfs_tag_type3 (lfs_tag_t tag ) { 290return (tag & 0x7ff00000 ) >>20 ; 291} 292 293static inline uint8_t lfs_tag_chunk (lfs_tag_t tag ) { 294return (tag & 0x0ff00000 ) >>20 ; 295} 296 297static inline int8_t lfs_tag_splice (lfs_tag_t tag ) { 298return (int8_t )lfs_tag_chunk (tag ); 299} 300 301static inline uint16_t lfs_tag_id (lfs_tag_t tag ) { 302return (tag & 0x000ffc00 ) >>10 ; 303} 304 305static inline lfs_size_t lfs_tag_size (lfs_tag_t tag ) { 306return tag & 0x000003ff ; 307} 308 309static inline lfs_size_t lfs_tag_dsize (lfs_tag_t tag ) { 310return sizeof (tag )+ lfs_tag_size (tag + lfs_tag_isdelete (tag )); 311} 312 313// operations on attributes in attribute lists 314struct lfs_mattr { 315lfs_tag_t tag ; 316const void * buffer ; 317}; 318 319struct lfs_diskoff { 320lfs_block_t block ; 321lfs_off_t off ; 322}; 323 324#define LFS_MKATTRS (...) \ 325 (struct lfs_mattr[]){__VA_ARGS__}, \ 326 sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr) 327 328// operations on global state 329static inline void lfs_gstate_xor (lfs_gstate_t * a ,const lfs_gstate_t * b ) { 330for (int i = 0 ;i < 3 ;i ++ ) { 331 ((uint32_t * )a )[i ] ^= ((const uint32_t * )b )[i ]; 332 } 333} 334 335static inline bool lfs_gstate_iszero (const lfs_gstate_t * a ) { 336for (int i = 0 ;i < 3 ;i ++ ) { 337if (((uint32_t * )a )[i ]!= 0 ) { 338return false; 339 } 340 } 341return true; 342} 343 344static inline bool lfs_gstate_hasorphans (const lfs_gstate_t * a ) { 345return lfs_tag_size (a -> tag ); 346} 347 348static inline uint8_t lfs_gstate_getorphans (const lfs_gstate_t * a ) { 349return lfs_tag_size (a -> tag ); 350} 351 352static inline bool lfs_gstate_hasmove (const lfs_gstate_t * a ) { 353return lfs_tag_type1 (a -> tag ); 354} 355 356static inline bool lfs_gstate_hasmovehere (const lfs_gstate_t * a , 357const lfs_block_t * pair ) { 358return lfs_tag_type1 (a -> tag )&& lfs_pair_cmp (a -> pair ,pair )== 0 ; 359} 360 361static inline void lfs_gstate_fromle32 (lfs_gstate_t * a ) { 362a -> tag = lfs_fromle32 (a -> tag ); 363a -> pair [0 ]= lfs_fromle32 (a -> pair [0 ]); 364a -> pair [1 ]= lfs_fromle32 (a -> pair [1 ]); 365} 366 367static inline void lfs_gstate_tole32 (lfs_gstate_t * a ) { 368a -> tag = lfs_tole32 (a -> tag ); 369a -> pair [0 ]= lfs_tole32 (a -> pair [0 ]); 370a -> pair [1 ]= lfs_tole32 (a -> pair [1 ]); 371} 372 373// other endianness operations 374static void lfs_ctz_fromle32 (struct lfs_ctz * ctz ) { 375ctz -> head = lfs_fromle32 (ctz -> head ); 376ctz -> size = lfs_fromle32 (ctz -> size ); 377} 378 379static void lfs_ctz_tole32 (struct lfs_ctz * ctz ) { 380ctz -> head = lfs_tole32 (ctz -> head ); 381ctz -> size = lfs_tole32 (ctz -> size ); 382} 383 384static inline void lfs_superblock_fromle32 (lfs_superblock_t * superblock ) { 385superblock -> version = lfs_fromle32 (superblock -> version ); 386superblock -> block_size = lfs_fromle32 (superblock -> block_size ); 387superblock -> block_count = lfs_fromle32 (superblock -> block_count ); 388superblock -> name_max = lfs_fromle32 (superblock -> name_max ); 389superblock -> file_max = lfs_fromle32 (superblock -> file_max ); 390superblock -> attr_max = lfs_fromle32 (superblock -> attr_max ); 391} 392 393static inline void lfs_superblock_tole32 (lfs_superblock_t * superblock ) { 394superblock -> version = lfs_tole32 (superblock -> version ); 395superblock -> block_size = lfs_tole32 (superblock -> block_size ); 396superblock -> block_count = lfs_tole32 (superblock -> block_count ); 397superblock -> name_max = lfs_tole32 (superblock -> name_max ); 398superblock -> file_max = lfs_tole32 (superblock -> file_max ); 399superblock -> attr_max = lfs_tole32 (superblock -> attr_max ); 400} 401 402/// Internal operations predeclared here /// 403static int lfs_dir_commit (lfs_t * lfs ,lfs_mdir_t * dir , 404const struct lfs_mattr * attrs ,int attrcount ); 405static int lfs_dir_compact (lfs_t * lfs ,lfs_mdir_t * dir , 406const struct lfs_mattr * attrs ,int attrcount , 407lfs_mdir_t * source ,uint16_t begin ,uint16_t end ); 408static int lfs_file_outline (lfs_t * lfs ,lfs_file_t * file ); 409static int lfs_file_flush (lfs_t * lfs ,lfs_file_t * file ); 410static void lfs_fs_preporphans (lfs_t * lfs ,int8_t orphans ); 411static void lfs_fs_prepmove (lfs_t * lfs ,uint16_t id ,const lfs_block_t pair [2 ]); 412static int lfs_fs_pred (lfs_t * lfs ,const lfs_block_t dir [2 ],lfs_mdir_t * pdir ); 413static lfs_stag_t lfs_fs_parent (lfs_t * lfs ,const lfs_block_t dir [2 ], 414lfs_mdir_t * parent ); 415static int lfs_fs_relocate (lfs_t * lfs ,const lfs_block_t oldpair [2 ], 416lfs_block_t newpair [2 ]); 417int lfs_fs_traverseraw (lfs_t * lfs ,int (* cb )(void * data ,lfs_block_t block ), 418void * data ,bool includeorphans ); 419static int lfs_fs_forceconsistency (lfs_t * lfs ); 420static int lfs_deinit (lfs_t * lfs ); 421#ifdef LFS_MIGRATE 422static int lfs1_traverse (lfs_t * lfs ,int (* cb )(void * ,lfs_block_t ),void * data ); 423#endif 424 425/// Block allocator /// 426static int lfs_alloc_lookahead (void * p ,lfs_block_t block ) { 427lfs_t * lfs = (lfs_t * )p ; 428lfs_block_t off = ((block - lfs -> free .off )+ lfs -> cfg -> block_count ) % 429lfs -> cfg -> block_count ; 430 431if (off < lfs -> free .size ) { 432lfs -> free .buffer [off /32 ] |=1U << (off %32 ); 433 } 434 435return 0 ; 436} 437 438static void lfs_alloc_ack (lfs_t * lfs ) { 439lfs -> free .ack = lfs -> cfg -> block_count ; 440} 441 442// Invalidate the lookahead buffer. This is done during mounting and 443// failed traversals 444static void lfs_alloc_reset (lfs_t * lfs ) { 445lfs -> free .off = lfs -> seed %lfs -> cfg -> block_size ; 446lfs -> free .size = 0 ; 447lfs -> free .i = 0 ; 448lfs_alloc_ack (lfs ); 449} 450 451static int lfs_alloc (lfs_t * lfs ,lfs_block_t * block ) { 452while (true) { 453while (lfs -> free .i != lfs -> free .size ) { 454lfs_block_t off = lfs -> free .i ; 455lfs -> free .i += 1 ; 456lfs -> free .ack -= 1 ; 457 458if (!(lfs -> free .buffer [off /32 ]& (1U << (off %32 )))) { 459// found a free block 460* block = (lfs -> free .off + off ) %lfs -> cfg -> block_count ; 461 462// eagerly find next off so an alloc ack can 463// discredit old lookahead blocks 464while (lfs -> free .i != lfs -> free .size && 465 (lfs -> free .buffer [lfs -> free .i /32 ]& 466 (1U << (lfs -> free .i %32 )))) { 467lfs -> free .i += 1 ; 468lfs -> free .ack -= 1 ; 469 } 470 471return 0 ; 472 } 473 } 474 475// check if we have looked at all blocks since last ack 476if (lfs -> free .ack == 0 ) { 477LFS_ERROR ("No more free space %" PRIu32 , 478lfs -> free .i + lfs -> free .off ); 479return LFS_ERR_NOSPC ; 480 } 481 482lfs -> free .off = 483 (lfs -> free .off + lfs -> free .size ) %lfs -> cfg -> block_count ; 484lfs -> free .size = lfs_min (8 * lfs -> cfg -> lookahead_size ,lfs -> free .ack ); 485lfs -> free .i = 0 ; 486 487// find mask of free blocks from tree 488memset (lfs -> free .buffer ,0 ,lfs -> cfg -> lookahead_size ); 489int err = lfs_fs_traverseraw (lfs ,lfs_alloc_lookahead ,lfs , true); 490if (err ) { 491lfs_alloc_reset (lfs ); 492return err ; 493 } 494 } 495} 496 497/// Metadata pair and directory operations /// 498static lfs_stag_t lfs_dir_getslice (lfs_t * lfs ,const lfs_mdir_t * dir , 499lfs_tag_t gmask ,lfs_tag_t gtag , 500lfs_off_t goff ,void * gbuffer , 501lfs_size_t gsize ) { 502lfs_off_t off = dir -> off ; 503lfs_tag_t ntag = dir -> etag ; 504lfs_stag_t gdiff = 0 ; 505 506if (lfs_gstate_hasmovehere (& lfs -> gdisk ,dir -> pair )&& 507lfs_tag_id (gmask )!= 0 && 508lfs_tag_id (lfs -> gdisk .tag ) <=lfs_tag_id (gtag )) { 509// synthetic moves 510gdiff -= LFS_MKTAG (0 ,1 ,0 ); 511 } 512 513// iterate over dir block backwards (for faster lookups) 514while (off >=sizeof (lfs_tag_t )+ lfs_tag_dsize (ntag )) { 515off -= lfs_tag_dsize (ntag ); 516lfs_tag_t tag = ntag ; 517int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,sizeof (ntag ), 518dir -> pair [0 ],off ,& ntag ,sizeof (ntag )); 519if (err ) { 520return err ; 521 } 522 523ntag = (lfs_frombe32 (ntag ) ^tag )& 0x7fffffff ; 524 525if (lfs_tag_id (gmask )!= 0 && lfs_tag_type1 (tag )== LFS_TYPE_SPLICE && 526lfs_tag_id (tag ) <=lfs_tag_id (gtag - gdiff )) { 527if (tag == (LFS_MKTAG (LFS_TYPE_CREATE ,0 ,0 ) | 528 (LFS_MKTAG (0 ,0x3ff ,0 )& (gtag - gdiff )))) { 529// found where we were created 530return LFS_ERR_NOENT ; 531 } 532 533// move around splices 534gdiff += LFS_MKTAG (0 ,lfs_tag_splice (tag ),0 ); 535 } 536 537if ((gmask & tag )== (gmask & (gtag - gdiff ))) { 538if (lfs_tag_isdelete (tag )) { 539return LFS_ERR_NOENT ; 540 } 541 542lfs_size_t diff = lfs_min (lfs_tag_size (tag ),gsize ); 543err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,diff ,dir -> pair [0 ], 544off + sizeof (tag )+ goff ,gbuffer ,diff ); 545if (err ) { 546return err ; 547 } 548 549memset ((uint8_t * )gbuffer + diff ,0 ,gsize - diff ); 550 551return tag + gdiff ; 552 } 553 } 554 555return LFS_ERR_NOENT ; 556} 557 558static lfs_stag_t lfs_dir_get (lfs_t * lfs ,const lfs_mdir_t * dir , 559lfs_tag_t gmask ,lfs_tag_t gtag ,void * buffer ) { 560return lfs_dir_getslice (lfs ,dir ,gmask ,gtag ,0 ,buffer , 561lfs_tag_size (gtag )); 562} 563 564static int lfs_dir_getread (lfs_t * lfs ,const lfs_mdir_t * dir , 565const lfs_cache_t * pcache ,lfs_cache_t * rcache , 566lfs_size_t hint ,lfs_tag_t gmask ,lfs_tag_t gtag , 567lfs_off_t off ,void * buffer ,lfs_size_t size ) { 568uint8_t * data = buffer ; 569if (off + size > lfs -> cfg -> block_size ) { 570return LFS_ERR_CORRUPT ; 571 } 572 573while (size > 0 ) { 574lfs_size_t diff = size ; 575 576if (pcache && pcache -> block == LFS_BLOCK_INLINE && 577off < pcache -> off + pcache -> size ) { 578if (off >=pcache -> off ) { 579// is already in pcache? 580diff = lfs_min (diff ,pcache -> size - (off - pcache -> off )); 581memcpy (data ,& pcache -> buffer [off - pcache -> off ],diff ); 582 583data += diff ; 584off += diff ; 585size -= diff ; 586continue ; 587 } 588 589// pcache takes priority 590diff = lfs_min (diff ,pcache -> off - off ); 591 } 592 593if (rcache -> block == LFS_BLOCK_INLINE && 594off < rcache -> off + rcache -> size ) { 595if (off >=rcache -> off ) { 596// is already in rcache? 597diff = lfs_min (diff ,rcache -> size - (off - rcache -> off )); 598memcpy (data ,& rcache -> buffer [off - rcache -> off ],diff ); 599 600data += diff ; 601off += diff ; 602size -= diff ; 603continue ; 604 } 605 606// rcache takes priority 607diff = lfs_min (diff ,rcache -> off - off ); 608 } 609 610// load to cache, first condition can no longer fail 611rcache -> block = LFS_BLOCK_INLINE ; 612rcache -> off = lfs_aligndown (off ,lfs -> cfg -> read_size ); 613rcache -> size = lfs_min (lfs_alignup (off + hint ,lfs -> cfg -> read_size ), 614lfs -> cfg -> cache_size ); 615int err = lfs_dir_getslice (lfs ,dir ,gmask ,gtag ,rcache -> off , 616rcache -> buffer ,rcache -> size ); 617if (err < 0 ) { 618return err ; 619 } 620 } 621 622return 0 ; 623} 624 625static int lfs_dir_traverse_filter (void * p ,lfs_tag_t tag ,const void * buffer ) { 626lfs_tag_t * filtertag = p ; 627 (void )buffer ; 628 629// which mask depends on unique bit in tag structure 630uint32_t mask = (tag & LFS_MKTAG (0x100 ,0 ,0 )) ?LFS_MKTAG (0x7ff ,0x3ff ,0 ) 631 :LFS_MKTAG (0x700 ,0x3ff ,0 ); 632 633// check for redundancy 634if ((mask & tag )== (mask & * filtertag )|| lfs_tag_isdelete (* filtertag )|| 635 (LFS_MKTAG (0x7ff ,0x3ff ,0 )& tag )== 636 (LFS_MKTAG (LFS_TYPE_DELETE ,0 ,0 ) | 637 (LFS_MKTAG (0 ,0x3ff ,0 )& * filtertag ))) { 638return true; 639 } 640 641// check if we need to adjust for created/deleted tags 642if (lfs_tag_type1 (tag )== LFS_TYPE_SPLICE && 643lfs_tag_id (tag ) <=lfs_tag_id (* filtertag )) { 644* filtertag += LFS_MKTAG (0 ,lfs_tag_splice (tag ),0 ); 645 } 646 647return false; 648} 649 650static int lfs_dir_traverse ( 651lfs_t * lfs ,const lfs_mdir_t * dir ,lfs_off_t off ,lfs_tag_t ptag , 652const struct lfs_mattr * attrs ,int attrcount ,lfs_tag_t tmask , 653lfs_tag_t ttag ,uint16_t begin ,uint16_t end ,int16_t diff , 654int (* cb )(void * data ,lfs_tag_t tag ,const void * buffer ),void * data ) { 655// iterate over directory and attrs 656while (true) { 657lfs_tag_t tag ; 658const void * buffer ; 659struct lfs_diskoff disk ; 660if (off + lfs_tag_dsize (ptag )< dir -> off ) { 661off += lfs_tag_dsize (ptag ); 662int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,sizeof (tag ), 663dir -> pair [0 ],off ,& tag ,sizeof (tag )); 664if (err ) { 665return err ; 666 } 667 668tag = (lfs_frombe32 (tag ) ^ptag ) |0x80000000 ; 669disk .block = dir -> pair [0 ]; 670disk .off = off + sizeof (lfs_tag_t ); 671buffer = & disk ; 672ptag = tag ; 673 }else if (attrcount > 0 ) { 674tag = attrs [0 ].tag ; 675buffer = attrs [0 ].buffer ; 676attrs += 1 ; 677attrcount -= 1 ; 678 }else { 679return 0 ; 680 } 681 682lfs_tag_t mask = LFS_MKTAG (0x7ff ,0 ,0 ); 683if ((mask & tmask & tag )!= (mask & tmask & ttag )) { 684continue ; 685 } 686 687// do we need to filter? inlining the filtering logic here allows 688// for some minor optimizations 689if (lfs_tag_id (tmask )!= 0 ) { 690// scan for duplicates and update tag based on creates/deletes 691int filter = 692lfs_dir_traverse (lfs ,dir ,off ,ptag ,attrs ,attrcount ,0 ,0 ,0 , 6930 ,0 ,lfs_dir_traverse_filter ,& tag ); 694if (filter < 0 ) { 695return filter ; 696 } 697 698if (filter ) { 699continue ; 700 } 701 702// in filter range? 703if (!(lfs_tag_id (tag ) >=begin && lfs_tag_id (tag )< end )) { 704continue ; 705 } 706 } 707 708// handle special cases for mcu-side operations 709if (lfs_tag_type3 (tag )== LFS_FROM_NOOP ) { 710// do nothing 711 }else if (lfs_tag_type3 (tag )== LFS_FROM_MOVE ) { 712uint16_t fromid = lfs_tag_size (tag ); 713uint16_t toid = lfs_tag_id (tag ); 714int err = lfs_dir_traverse ( 715lfs ,buffer ,0 ,0xffffffff ,NULL ,0 ,LFS_MKTAG (0x600 ,0x3ff ,0 ), 716LFS_MKTAG (LFS_TYPE_STRUCT ,0 ,0 ),fromid ,fromid + 1 , 717toid - fromid + diff ,cb ,data ); 718if (err ) { 719return err ; 720 } 721 }else if (lfs_tag_type3 (tag )== LFS_FROM_USERATTRS ) { 722for (unsigned i = 0 ;i < lfs_tag_size (tag );i ++ ) { 723const struct lfs_attr * a = buffer ; 724int err = cb (data , 725LFS_MKTAG (LFS_TYPE_USERATTR + a [i ].type , 726lfs_tag_id (tag )+ diff ,a [i ].size ), 727a [i ].buffer ); 728if (err ) { 729return err ; 730 } 731 } 732 }else { 733int err = cb (data ,tag + LFS_MKTAG (0 ,diff ,0 ),buffer ); 734if (err ) { 735return err ; 736 } 737 } 738 } 739} 740 741static lfs_stag_t 742lfs_dir_fetchmatch (lfs_t * lfs ,lfs_mdir_t * dir ,const lfs_block_t pair [2 ], 743lfs_tag_t fmask ,lfs_tag_t ftag ,uint16_t * id , 744int (* cb )(void * data ,lfs_tag_t tag ,const void * buffer ), 745void * data ) { 746// we can find tag very efficiently during a fetch, since we're already 747// scanning the entire directory 748lfs_stag_t besttag = -1 ; 749 750// if either block address is invalid we return LFS_ERR_CORRUPT here, 751// otherwise later writes to the pair could fail 752if (pair [0 ] >=lfs -> cfg -> block_count || pair [1 ] >=lfs -> cfg -> block_count ) { 753return LFS_ERR_CORRUPT ; 754 } 755 756// find the block with the most recent revision 757uint32_t revs [2 ]= {0 ,0 }; 758int r = 0 ; 759for (int i = 0 ;i < 2 ;i ++ ) { 760int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,sizeof (revs [i ]),pair [i ], 7610 ,& revs [i ],sizeof (revs [i ])); 762revs [i ]= lfs_fromle32 (revs [i ]); 763if (err && err != LFS_ERR_CORRUPT ) { 764return err ; 765 } 766 767if (err != LFS_ERR_CORRUPT && 768lfs_scmp (revs [i ],revs [(i + 1 ) %2 ])> 0 ) { 769r = i ; 770 } 771 } 772 773dir -> pair [0 ]= pair [(r + 0 ) %2 ]; 774dir -> pair [1 ]= pair [(r + 1 ) %2 ]; 775dir -> rev = revs [(r + 0 ) %2 ]; 776dir -> off = 0 ;// nonzero = found some commits 777 778// now scan tags to fetch the actual dir and find possible match 779for (int i = 0 ;i < 2 ;i ++ ) { 780lfs_off_t off = 0 ; 781lfs_tag_t ptag = 0xffffffff ; 782 783uint16_t tempcount = 0 ; 784lfs_block_t temptail [2 ]= {LFS_BLOCK_NULL ,LFS_BLOCK_NULL }; 785bool tempsplit = false; 786lfs_stag_t tempbesttag = besttag ; 787 788dir -> rev = lfs_tole32 (dir -> rev ); 789uint32_t crc = lfs_crc (0xffffffff ,& dir -> rev ,sizeof (dir -> rev )); 790dir -> rev = lfs_fromle32 (dir -> rev ); 791 792while (true) { 793// extract next tag 794lfs_tag_t tag ; 795off += lfs_tag_dsize (ptag ); 796int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,lfs -> cfg -> block_size , 797dir -> pair [0 ],off ,& tag ,sizeof (tag )); 798if (err ) { 799if (err == LFS_ERR_CORRUPT ) { 800// can't continue? 801dir -> erased = false; 802break ; 803 } 804return err ; 805 } 806 807crc = lfs_crc (crc ,& tag ,sizeof (tag )); 808tag = lfs_frombe32 (tag ) ^ptag ; 809 810// next commit not yet programmed or we're not in valid range 811if (!lfs_tag_isvalid (tag )) { 812dir -> erased = (lfs_tag_type1 (ptag )== LFS_TYPE_CRC && 813dir -> off %lfs -> cfg -> prog_size == 0 ); 814break ; 815 }else if (off + lfs_tag_dsize (tag )> lfs -> cfg -> block_size ) { 816dir -> erased = false; 817break ; 818 } 819 820ptag = tag ; 821 822if (lfs_tag_type1 (tag )== LFS_TYPE_CRC ) { 823// check the crc attr 824uint32_t dcrc ; 825err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,lfs -> cfg -> block_size , 826dir -> pair [0 ],off + sizeof (tag ),& dcrc , 827sizeof (dcrc )); 828if (err ) { 829if (err == LFS_ERR_CORRUPT ) { 830dir -> erased = false; 831break ; 832 } 833return err ; 834 } 835dcrc = lfs_fromle32 (dcrc ); 836 837if (crc != dcrc ) { 838dir -> erased = false; 839break ; 840 } 841 842// reset the next bit if we need to 843ptag ^= (lfs_tag_t )(lfs_tag_chunk (tag )& 1U ) <<31 ; 844 845// toss our crc into the filesystem seed for 846// pseudorandom numbers 847lfs -> seed ^=crc ; 848 849// update with what's found so far 850besttag = tempbesttag ; 851dir -> off = off + lfs_tag_dsize (tag ); 852dir -> etag = ptag ; 853dir -> count = tempcount ; 854dir -> tail [0 ]= temptail [0 ]; 855dir -> tail [1 ]= temptail [1 ]; 856dir -> split = tempsplit ; 857 858// reset crc 859crc = 0xffffffff ; 860continue ; 861 } 862 863// crc the entry first, hopefully leaving it in the cache 864for (lfs_off_t j = sizeof (tag );j < lfs_tag_dsize (tag );j ++ ) { 865uint8_t dat ; 866err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,lfs -> cfg -> block_size , 867dir -> pair [0 ],off + j ,& dat ,1 ); 868if (err ) { 869if (err == LFS_ERR_CORRUPT ) { 870dir -> erased = false; 871break ; 872 } 873return err ; 874 } 875 876crc = lfs_crc (crc ,& dat ,1 ); 877 } 878 879// directory modification tags? 880if (lfs_tag_type1 (tag )== LFS_TYPE_NAME ) { 881// increase count of files if necessary 882if (lfs_tag_id (tag ) >=tempcount ) { 883tempcount = lfs_tag_id (tag )+ 1 ; 884 } 885 }else if (lfs_tag_type1 (tag )== LFS_TYPE_SPLICE ) { 886tempcount += lfs_tag_splice (tag ); 887 888if (tag == (LFS_MKTAG (LFS_TYPE_DELETE ,0 ,0 ) | 889 (LFS_MKTAG (0 ,0x3ff ,0 )& tempbesttag ))) { 890tempbesttag |=0x80000000 ; 891 }else if (tempbesttag != -1 && 892lfs_tag_id (tag ) <=lfs_tag_id (tempbesttag )) { 893tempbesttag += LFS_MKTAG (0 ,lfs_tag_splice (tag ),0 ); 894 } 895 }else if (lfs_tag_type1 (tag )== LFS_TYPE_TAIL ) { 896tempsplit = (lfs_tag_chunk (tag )& 1 ); 897 898err = 899lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,lfs -> cfg -> block_size , 900dir -> pair [0 ],off + sizeof (tag ),& temptail ,8 ); 901if (err ) { 902if (err == LFS_ERR_CORRUPT ) { 903dir -> erased = false; 904break ; 905 } 906 } 907lfs_pair_fromle32 (temptail ); 908 } 909 910// found a match for our fetcher? 911if ((fmask & tag )== (fmask & ftag )) { 912int res = 913cb (data ,tag , 914& (struct lfs_diskoff ){dir -> pair [0 ],off + sizeof (tag )}); 915if (res < 0 ) { 916if (res == LFS_ERR_CORRUPT ) { 917dir -> erased = false; 918break ; 919 } 920return res ; 921 } 922 923if (res == LFS_CMP_EQ ) { 924// found a match 925tempbesttag = tag ; 926 }else if ((LFS_MKTAG (0x7ff ,0x3ff ,0 )& tag )== 927 (LFS_MKTAG (0x7ff ,0x3ff ,0 )& tempbesttag )) { 928// found an identical tag, but contents didn't match 929// this must mean that our besttag has been overwritten 930tempbesttag = -1 ; 931 }else if (res == LFS_CMP_GT && 932lfs_tag_id (tag ) <=lfs_tag_id (tempbesttag )) { 933// found a greater match, keep track to keep things sorted 934tempbesttag = tag |0x80000000 ; 935 } 936 } 937 } 938 939// consider what we have good enough 940if (dir -> off > 0 ) { 941// synthetic move 942if (lfs_gstate_hasmovehere (& lfs -> gdisk ,dir -> pair )) { 943if (lfs_tag_id (lfs -> gdisk .tag )== lfs_tag_id (besttag )) { 944besttag |=0x80000000 ; 945 }else if (besttag != -1 && 946lfs_tag_id (lfs -> gdisk .tag )< lfs_tag_id (besttag )) { 947besttag -= LFS_MKTAG (0 ,1 ,0 ); 948 } 949 } 950 951// found tag? or found best id? 952if (id ) { 953* id = lfs_min (lfs_tag_id (besttag ),dir -> count ); 954 } 955 956if (lfs_tag_isvalid (besttag )) { 957return besttag ; 958 }else if (lfs_tag_id (besttag )< dir -> count ) { 959return LFS_ERR_NOENT ; 960 }else { 961return 0 ; 962 } 963 } 964 965// failed, try the other block? 966lfs_pair_swap (dir -> pair ); 967dir -> rev = revs [(r + 1 ) %2 ]; 968 } 969 970LFS_ERROR ("Corrupted dir pair at {0x%" PRIx32 ", 0x%" PRIx32 "}" , 971dir -> pair [0 ],dir -> pair [1 ]); 972return LFS_ERR_CORRUPT ; 973} 974 975static int lfs_dir_fetch (lfs_t * lfs ,lfs_mdir_t * dir , 976const lfs_block_t pair [2 ]) { 977// note, mask=-1, tag=-1 can never match a tag since this 978// pattern has the invalid bit set 979return (int )lfs_dir_fetchmatch (lfs ,dir ,pair , (lfs_tag_t )- 1 , (lfs_tag_t )- 1 , 980NULL ,NULL ,NULL ); 981} 982 983static int lfs_dir_getgstate (lfs_t * lfs ,const lfs_mdir_t * dir , 984lfs_gstate_t * gstate ) { 985lfs_gstate_t temp ; 986lfs_stag_t res = 987lfs_dir_get (lfs ,dir ,LFS_MKTAG (0x7ff ,0 ,0 ), 988LFS_MKTAG (LFS_TYPE_MOVESTATE ,0 ,sizeof (temp )),& temp ); 989if (res < 0 && res != LFS_ERR_NOENT ) { 990return res ; 991 } 992 993if (res != LFS_ERR_NOENT ) { 994// xor together to find resulting gstate 995lfs_gstate_fromle32 (& temp ); 996lfs_gstate_xor (gstate ,& temp ); 997 } 998 999return 0 ; 1000} 1001 1002static int lfs_dir_getinfo (lfs_t * lfs ,lfs_mdir_t * dir ,uint16_t id , 1003struct lfs_info * info ) { 1004if (id == 0x3ff ) { 1005// special case for root 1006strcpy (info -> name ,"/" ); 1007info -> type = LFS_TYPE_DIR ; 1008return 0 ; 1009 } 1010 1011lfs_stag_t tag = lfs_dir_get ( 1012lfs ,dir ,LFS_MKTAG (0x780 ,0x3ff ,0 ), 1013LFS_MKTAG (LFS_TYPE_NAME ,id ,lfs -> name_max + 1 ),info -> name ); 1014if (tag < 0 ) { 1015return (int )tag ; 1016 } 1017 1018info -> type = lfs_tag_type3 (tag ); 1019 1020struct lfs_ctz ctz ; 1021tag = lfs_dir_get (lfs ,dir ,LFS_MKTAG (0x700 ,0x3ff ,0 ), 1022LFS_MKTAG (LFS_TYPE_STRUCT ,id ,sizeof (ctz )),& ctz ); 1023if (tag < 0 ) { 1024return (int )tag ; 1025 } 1026lfs_ctz_fromle32 (& ctz ); 1027 1028if (lfs_tag_type3 (tag )== LFS_TYPE_CTZSTRUCT ) { 1029info -> size = ctz .size ; 1030 }else if (lfs_tag_type3 (tag )== LFS_TYPE_INLINESTRUCT ) { 1031info -> size = lfs_tag_size (tag ); 1032 } 1033 1034return 0 ; 1035} 1036 1037struct lfs_dir_find_match { 1038lfs_t * lfs ; 1039const void * name ; 1040lfs_size_t size ; 1041}; 1042 1043static int lfs_dir_find_match (void * data ,lfs_tag_t tag ,const void * buffer ) { 1044struct lfs_dir_find_match * name = data ; 1045lfs_t * lfs = name -> lfs ; 1046const struct lfs_diskoff * disk = buffer ; 1047 1048// compare with disk 1049lfs_size_t diff = lfs_min (name -> size ,lfs_tag_size (tag )); 1050int res = lfs_bd_cmp (lfs ,NULL ,& lfs -> rcache ,diff ,disk -> block ,disk -> off , 1051name -> name ,diff ); 1052if (res != LFS_CMP_EQ ) { 1053return res ; 1054 } 1055 1056// only equal if our size is still the same 1057if (name -> size != lfs_tag_size (tag )) { 1058return (name -> size < lfs_tag_size (tag )) ?LFS_CMP_LT :LFS_CMP_GT ; 1059 } 1060 1061// found a match! 1062return LFS_CMP_EQ ; 1063} 1064 1065static lfs_stag_t lfs_dir_find (lfs_t * lfs ,lfs_mdir_t * dir ,const char ** path , 1066uint16_t * id ) { 1067// we reduce path to a single name if we can find it 1068const char * name = * path ; 1069if (id ) { 1070* id = 0x3ff ; 1071 } 1072 1073// default to root dir 1074lfs_stag_t tag = LFS_MKTAG (LFS_TYPE_DIR ,0x3ff ,0 ); 1075dir -> tail [0 ]= lfs -> root [0 ]; 1076dir -> tail [1 ]= lfs -> root [1 ]; 1077 1078while (true) { 1079nextname : 1080// skip slashes 1081name += strspn (name ,"/" ); 1082lfs_size_t namelen = strcspn (name ,"/" ); 1083 1084// skip '.' and root '..' 1085if ((namelen == 1 && memcmp (name ,"." ,1 )== 0 )|| 1086 (namelen == 2 && memcmp (name ,".." ,2 )== 0 )) { 1087name += namelen ; 1088 gotonextname ; 1089 } 1090 1091// skip if matched by '..' in name 1092const char * suffix = name + namelen ; 1093lfs_size_t sufflen ; 1094int depth = 1 ; 1095while (true) { 1096suffix += strspn (suffix ,"/" ); 1097sufflen = strcspn (suffix ,"/" ); 1098if (sufflen == 0 ) { 1099break ; 1100 } 1101 1102if (sufflen == 2 && memcmp (suffix ,".." ,2 )== 0 ) { 1103depth -= 1 ; 1104if (depth == 0 ) { 1105name = suffix + sufflen ; 1106 gotonextname ; 1107 } 1108 }else { 1109depth += 1 ; 1110 } 1111 1112suffix += sufflen ; 1113 } 1114 1115// found path 1116if (name [0 ]== '\0' ) { 1117return tag ; 1118 } 1119 1120// update what we've found so far 1121* path = name ; 1122 1123// only continue if we hit a directory 1124if (lfs_tag_type3 (tag )!= LFS_TYPE_DIR ) { 1125return LFS_ERR_NOTDIR ; 1126 } 1127 1128// grab the entry data 1129if (lfs_tag_id (tag )!= 0x3ff ) { 1130lfs_stag_t res = lfs_dir_get ( 1131lfs ,dir ,LFS_MKTAG (0x700 ,0x3ff ,0 ), 1132LFS_MKTAG (LFS_TYPE_STRUCT ,lfs_tag_id (tag ),8 ),dir -> tail ); 1133if (res < 0 ) { 1134return res ; 1135 } 1136lfs_pair_fromle32 (dir -> tail ); 1137 } 1138 1139// find entry matching name 1140while (true) { 1141tag = lfs_dir_fetchmatch ( 1142lfs ,dir ,dir -> tail ,LFS_MKTAG (0x780 ,0 ,0 ), 1143LFS_MKTAG (LFS_TYPE_NAME ,0 ,namelen ), 1144// are we last name? 1145 (strchr (name ,'/' )== NULL ) ?id :NULL ,lfs_dir_find_match , 1146& (struct lfs_dir_find_match ){lfs ,name ,namelen }); 1147if (tag < 0 ) { 1148return tag ; 1149 } 1150 1151if (tag ) { 1152break ; 1153 } 1154 1155if (!dir -> split ) { 1156return LFS_ERR_NOENT ; 1157 } 1158 } 1159 1160// to next name 1161name += namelen ; 1162 } 1163} 1164 1165// commit logic 1166struct lfs_commit { 1167lfs_block_t block ; 1168lfs_off_t off ; 1169lfs_tag_t ptag ; 1170uint32_t crc ; 1171 1172lfs_off_t begin ; 1173lfs_off_t end ; 1174}; 1175 1176static int lfs_dir_commitprog (lfs_t * lfs ,struct lfs_commit * commit , 1177const void * buffer ,lfs_size_t size ) { 1178int err = lfs_bd_prog (lfs ,& lfs -> pcache ,& lfs -> rcache , false,commit -> block , 1179commit -> off , (const uint8_t * )buffer ,size ); 1180if (err ) { 1181return err ; 1182 } 1183 1184commit -> crc = lfs_crc (commit -> crc ,buffer ,size ); 1185commit -> off += size ; 1186return 0 ; 1187} 1188 1189static int lfs_dir_commitattr (lfs_t * lfs ,struct lfs_commit * commit , 1190lfs_tag_t tag ,const void * buffer ) { 1191// check if we fit 1192lfs_size_t dsize = lfs_tag_dsize (tag ); 1193if (commit -> off + dsize > commit -> end ) { 1194return LFS_ERR_NOSPC ; 1195 } 1196 1197// write out tag 1198lfs_tag_t ntag = lfs_tobe32 ((tag & 0x7fffffff ) ^commit -> ptag ); 1199int err = lfs_dir_commitprog (lfs ,commit ,& ntag ,sizeof (ntag )); 1200if (err ) { 1201return err ; 1202 } 1203 1204if (!(tag & 0x80000000 )) { 1205// from memory 1206err = lfs_dir_commitprog (lfs ,commit ,buffer ,dsize - sizeof (tag )); 1207if (err ) { 1208return err ; 1209 } 1210 }else { 1211// from disk 1212const struct lfs_diskoff * disk = buffer ; 1213for (lfs_off_t i = 0 ;i < dsize - sizeof (tag );i ++ ) { 1214// rely on caching to make this efficient 1215uint8_t dat ; 1216err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,dsize - sizeof (tag )- i , 1217disk -> block ,disk -> off + i ,& dat ,1 ); 1218if (err ) { 1219return err ; 1220 } 1221 1222err = lfs_dir_commitprog (lfs ,commit ,& dat ,1 ); 1223if (err ) { 1224return err ; 1225 } 1226 } 1227 } 1228 1229commit -> ptag = tag & 0x7fffffff ; 1230return 0 ; 1231} 1232 1233static int lfs_dir_commitcrc (lfs_t * lfs ,struct lfs_commit * commit ) { 1234const lfs_off_t off1 = commit -> off ; 1235const uint32_t crc1 = commit -> crc ; 1236// align to program units 1237const lfs_off_t end = 1238lfs_alignup (off1 + 2 * sizeof (uint32_t ),lfs -> cfg -> prog_size ); 1239 1240// create crc tags to fill up remainder of commit, note that 1241// padding is not crced, which lets fetches skip padding but 1242// makes committing a bit more complicated 1243while (commit -> off < end ) { 1244lfs_off_t off = commit -> off + sizeof (lfs_tag_t ); 1245lfs_off_t noff = lfs_min (end - off ,0x3fe )+ off ; 1246if (noff < end ) { 1247noff = lfs_min (noff ,end - 2 * sizeof (uint32_t )); 1248 } 1249 1250// read erased state from next program unit 1251lfs_tag_t tag = 0xffffffff ; 1252int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,sizeof (tag ), 1253commit -> block ,noff ,& tag ,sizeof (tag )); 1254if (err && err != LFS_ERR_CORRUPT ) { 1255return err ; 1256 } 1257 1258// build crc tag 1259bool reset = ~lfs_frombe32 (tag ) >>31 ; 1260tag = LFS_MKTAG (LFS_TYPE_CRC + reset ,0x3ff ,noff - off ); 1261 1262// write out crc 1263uint32_t footer [2 ]; 1264footer [0 ]= lfs_tobe32 (tag ^commit -> ptag ); 1265commit -> crc = lfs_crc (commit -> crc ,& footer [0 ],sizeof (footer [0 ])); 1266footer [1 ]= lfs_tole32 (commit -> crc ); 1267err = lfs_bd_prog (lfs ,& lfs -> pcache ,& lfs -> rcache , false,commit -> block , 1268commit -> off ,& footer ,sizeof (footer )); 1269if (err ) { 1270return err ; 1271 } 1272 1273commit -> off += sizeof (tag )+ lfs_tag_size (tag ); 1274commit -> ptag = tag ^ ((lfs_tag_t )reset <<31 ); 1275commit -> crc = 0xffffffff ;// reset crc for next "commit" 1276 } 1277 1278// flush buffers 1279int err = lfs_bd_sync (lfs ,& lfs -> pcache ,& lfs -> rcache , false); 1280if (err ) { 1281return err ; 1282 } 1283 1284// successful commit, check checksums to make sure 1285lfs_off_t off = commit -> begin ; 1286lfs_off_t noff = off1 + sizeof (uint32_t ); 1287while (off < end ) { 1288uint32_t crc = 0xffffffff ; 1289for (lfs_off_t i = off ;i < noff + sizeof (uint32_t );i ++ ) { 1290// check against written crc, may catch blocks that 1291// become readonly and match our commit size exactly 1292if (i == off1 && crc != crc1 ) { 1293return LFS_ERR_CORRUPT ; 1294 } 1295 1296// leave it up to caching to make this efficient 1297uint8_t dat ; 1298err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache , 1299noff + sizeof (uint32_t )- i ,commit -> block ,i , 1300& dat ,1 ); 1301if (err ) { 1302return err ; 1303 } 1304 1305crc = lfs_crc (crc ,& dat ,1 ); 1306 } 1307 1308// detected write error? 1309if (crc != 0 ) { 1310return LFS_ERR_CORRUPT ; 1311 } 1312 1313// skip padding 1314off = lfs_min (end - noff ,0x3fe )+ noff ; 1315if (off < end ) { 1316off = lfs_min (off ,end - 2 * sizeof (uint32_t )); 1317 } 1318noff = off + sizeof (uint32_t ); 1319 } 1320 1321return 0 ; 1322} 1323 1324static int lfs_dir_alloc (lfs_t * lfs ,lfs_mdir_t * dir ) { 1325// allocate pair of dir blocks (backwards, so we write block 1 first) 1326for (int i = 0 ;i < 2 ;i ++ ) { 1327int err = lfs_alloc (lfs ,& dir -> pair [(i + 1 ) %2 ]); 1328if (err ) { 1329return err ; 1330 } 1331 } 1332 1333// zero for reproducability in case initial block is unreadable 1334dir -> rev = 0 ; 1335 1336// rather than clobbering one of the blocks we just pretend 1337// the revision may be valid 1338int err = lfs_bd_read (lfs ,NULL ,& lfs -> rcache ,sizeof (dir -> rev ), 1339dir -> pair [0 ],0 ,& dir -> rev ,sizeof (dir -> rev )); 1340dir -> rev = lfs_fromle32 (dir -> rev ); 1341if (err && err != LFS_ERR_CORRUPT ) { 1342return err ; 1343 } 1344 1345// make sure we don't immediately evict 1346dir -> rev += dir -> rev & 1 ; 1347 1348// set defaults 1349dir -> off = sizeof (dir -> rev ); 1350dir -> etag = 0xffffffff ; 1351dir -> count = 0 ; 1352dir -> tail [0 ]= LFS_BLOCK_NULL ; 1353dir -> tail [1 ]= LFS_BLOCK_NULL ; 1354dir -> erased = false; 1355dir -> split = false; 1356 1357// don't write out yet, let caller take care of that 1358return 0 ; 1359} 1360 1361static int lfs_dir_drop (lfs_t * lfs ,lfs_mdir_t * dir ,lfs_mdir_t * tail ) { 1362// steal state 1363int err = lfs_dir_getgstate (lfs ,tail ,& lfs -> gdelta ); 1364if (err ) { 1365return err ; 1366 } 1367 1368// steal tail 1369lfs_pair_tole32 (tail -> tail ); 1370err = lfs_dir_commit ( 1371lfs ,dir , 1372LFS_MKATTRS ( 1373 {LFS_MKTAG (LFS_TYPE_TAIL + tail -> split ,0x3ff ,8 ),tail -> tail })); 1374lfs_pair_fromle32 (tail -> tail ); 1375if (err ) { 1376return err ; 1377 } 1378 1379return 0 ; 1380} 1381 1382static int lfs_dir_split (lfs_t * lfs ,lfs_mdir_t * dir , 1383const struct lfs_mattr * attrs ,int attrcount , 1384lfs_mdir_t * source ,uint16_t split ,uint16_t end ) { 1385// create tail directory 1386lfs_alloc_ack (lfs ); 1387lfs_mdir_t tail ; 1388int err = lfs_dir_alloc (lfs ,& tail ); 1389if (err ) { 1390return err ; 1391 } 1392 1393tail .split = dir -> split ; 1394tail .tail [0 ]= dir -> tail [0 ]; 1395tail .tail [1 ]= dir -> tail [1 ]; 1396 1397err = lfs_dir_compact (lfs ,& tail ,attrs ,attrcount ,source ,split ,end ); 1398if (err ) { 1399return err ; 1400 } 1401 1402dir -> tail [0 ]= tail .pair [0 ]; 1403dir -> tail [1 ]= tail .pair [1 ]; 1404dir -> split = true; 1405 1406// update root if needed 1407if (lfs_pair_cmp (dir -> pair ,lfs -> root )== 0 && split == 0 ) { 1408lfs -> root [0 ]= tail .pair [0 ]; 1409lfs -> root [1 ]= tail .pair [1 ]; 1410 } 1411 1412return 0 ; 1413} 1414 1415static int lfs_dir_commit_size (void * p ,lfs_tag_t tag ,const void * buffer ) { 1416lfs_size_t * size = p ; 1417 (void )buffer ; 1418 1419* size += lfs_tag_dsize (tag ); 1420return 0 ; 1421} 1422 1423struct lfs_dir_commit_commit { 1424lfs_t * lfs ; 1425struct lfs_commit * commit ; 1426}; 1427 1428static int lfs_dir_commit_commit (void * p ,lfs_tag_t tag ,const void * buffer ) { 1429struct lfs_dir_commit_commit * commit = p ; 1430return lfs_dir_commitattr (commit -> lfs ,commit -> commit ,tag ,buffer ); 1431} 1432 1433static int lfs_dir_compact (lfs_t * lfs ,lfs_mdir_t * dir , 1434const struct lfs_mattr * attrs ,int attrcount , 1435lfs_mdir_t * source ,uint16_t begin ,uint16_t end ) { 1436// save some state in case block is bad 1437const lfs_block_t oldpair [2 ]= {dir -> pair [0 ],dir -> pair [1 ]}; 1438bool relocated = false; 1439bool tired = false; 1440 1441// should we split? 1442while (end - begin > 1 ) { 1443// find size 1444lfs_size_t size = 0 ; 1445int err = lfs_dir_traverse (lfs ,source ,0 ,0xffffffff ,attrs ,attrcount , 1446LFS_MKTAG (0x400 ,0x3ff ,0 ), 1447LFS_MKTAG (LFS_TYPE_NAME ,0 ,0 ),begin ,end , 1448- begin ,lfs_dir_commit_size ,& size ); 1449if (err ) { 1450return err ; 1451 } 1452 1453// space is complicated, we need room for tail, crc, gstate, 1454// cleanup delete, and we cap at half a block to give room 1455// for metadata updates. 1456if (end - begin < 0xff && 1457size <=lfs_min (lfs -> cfg -> block_size - 36 , 1458lfs_alignup (lfs -> cfg -> block_size /2 , 1459lfs -> cfg -> prog_size ))) { 1460break ; 1461 } 1462 1463// can't fit, need to split, we should really be finding the 1464// largest size that fits with a small binary search, but right now 1465// it's not worth the code size 1466uint16_t split = (end - begin ) /2 ; 1467err = lfs_dir_split (lfs ,dir ,attrs ,attrcount ,source ,begin + split , 1468end ); 1469if (err ) { 1470// if we fail to split, we may be able to overcompact, unless 1471// we're too big for even the full block, in which case our 1472// only option is to error 1473if (err == LFS_ERR_NOSPC && size <=lfs -> cfg -> block_size - 36 ) { 1474break ; 1475 } 1476return err ; 1477 } 1478 1479end = begin + split ; 1480 } 1481 1482// increment revision count 1483dir -> rev += 1 ; 1484// If our revision count == n * block_cycles, we should force a relocation, 1485// this is how littlefs wear-levels at the metadata-pair level. Note that we 1486// actually use (block_cycles+1)|1, this is to avoid two corner cases: 1487// 1. block_cycles = 1, which would prevent relocations from terminating 1488// 2. block_cycles = 2n, which, due to aliasing, would only ever relocate 1489// one metadata block in the pair, effectively making this useless 1490if (lfs -> cfg -> block_cycles > 0 && 1491 (dir -> rev % ((lfs -> cfg -> block_cycles + 1 ) |1 )== 0 )) { 1492if (lfs_pair_cmp (dir -> pair , (const lfs_block_t [2 ]){0 ,1 })== 0 ) { 1493// oh no! we're writing too much to the superblock, 1494// should we expand? 1495lfs_ssize_t res = lfs_fs_size (lfs ); 1496if (res < 0 ) { 1497return res ; 1498 } 1499 1500// do we have extra space? littlefs can't reclaim this space 1501// by itself, so expand cautiously 1502if ((lfs_size_t )res < lfs -> cfg -> block_count /2 ) { 1503LFS_DEBUG ("Expanding superblock at rev %" PRIu32 ,dir -> rev ); 1504int err = lfs_dir_split (lfs ,dir ,attrs ,attrcount ,source , 1505begin ,end ); 1506if (err && err != LFS_ERR_NOSPC ) { 1507return err ; 1508 } 1509 1510// welp, we tried, if we ran out of space there's not much 1511// we can do, we'll error later if we've become frozen 1512if (!err ) { 1513end = begin ; 1514 } 1515 } 1516#ifdef LFS_MIGRATE 1517} else if ( lfs -> lfs1 ) { 1518// do not proactively relocate blocks during migrations, this 1519// can cause a number of failure states such: clobbering the 1520// v1 superblock if we relocate root, and invalidating directory 1521// pointers if we relocate the head of a directory. On top of 1522// this, relocations increase the overall complexity of 1523// lfs_migration, which is already a delicate operation. 1524#endif 1525} else { 1526// we're writing too much, time to relocate 1527tired = true; 1528goto relocate ; 1529} 1530} 1531 1532// begin loop to commit compaction to blocks until a compact sticks 1533while (true) { 1534{ 1535// setup commit state 1536struct lfs_commit commit = { 1537. block = dir -> pair [ 1 ], 1538. off = 0 , 1539. ptag = 0xffffffff , 1540. crc = 0xffffffff , 1541 1542. begin = 0 , 1543. end = lfs -> cfg -> block_size - 8 , 1544}; 1545 1546// erase block to write to 1547int err = lfs_bd_erase ( lfs , dir -> pair [ 1 ]); 1548if ( err ) { 1549if ( err == LFS_ERR_CORRUPT ) { 1550goto relocate ; 1551} 1552return err ; 1553} 1554 1555// write out header 1556dir -> rev = lfs_tole32 ( dir -> rev ); 1557err = lfs_dir_commitprog ( lfs , & commit , & dir -> rev , sizeof( dir -> rev )); 1558dir -> rev = lfs_fromle32 ( dir -> rev ); 1559if ( err ) { 1560if ( err == LFS_ERR_CORRUPT ) { 1561goto relocate ; 1562} 1563return err ; 1564} 1565 1566// traverse the directory, this time writing out all unique tags 1567err = lfs_dir_traverse ( 1568lfs , source , 0 , 0xffffffff , attrs , attrcount , 1569LFS_MKTAG ( 0x400 , 0x3ff , 0 ), LFS_MKTAG ( LFS_TYPE_NAME , 0 , 0 ), 1570begin , end , - begin , lfs_dir_commit_commit , 1571& (struct lfs_dir_commit_commit ){ lfs , & commit }); 1572if ( err ) { 1573if ( err == LFS_ERR_CORRUPT ) { 1574goto relocate ; 1575} 1576return err ; 1577} 1578 1579// commit tail, which may be new after last size check 1580if (! lfs_pair_isnull ( dir -> tail )) { 1581lfs_pair_tole32 ( dir -> tail ); 1582err = lfs_dir_commitattr ( 1583lfs , & commit , 1584LFS_MKTAG ( LFS_TYPE_TAIL + dir -> split , 0x3ff , 8 ), dir -> tail ); 1585lfs_pair_fromle32 ( dir -> tail ); 1586if ( err ) { 1587if ( err == LFS_ERR_CORRUPT ) { 1588goto relocate ; 1589} 1590return err ; 1591} 1592} 1593 1594// bring over gstate? 1595lfs_gstate_t delta = { 0 }; 1596if (! relocated ) { 1597lfs_gstate_xor ( & delta , & lfs -> gdisk ); 1598lfs_gstate_xor ( & delta , & lfs -> gstate ); 1599} 1600lfs_gstate_xor ( & delta , & lfs -> gdelta ); 1601delta . tag &= ~ LFS_MKTAG ( 0 , 0 , 0x3ff ); 1602 1603err = lfs_dir_getgstate ( lfs , dir , & delta ); 1604if ( err ) { 1605return err ; 1606} 1607 1608if (! lfs_gstate_iszero ( & delta )) { 1609lfs_gstate_tole32 ( & delta ); 1610err = lfs_dir_commitattr ( 1611lfs , & commit , 1612LFS_MKTAG ( LFS_TYPE_MOVESTATE , 0x3ff , sizeof( delta )), 1613& delta ); 1614if ( err ) { 1615if ( err == LFS_ERR_CORRUPT ) { 1616goto relocate ; 1617} 1618return err ; 1619} 1620} 1621 1622// complete commit with crc 1623err = lfs_dir_commitcrc ( lfs , & commit ); 1624if ( err ) { 1625if ( err == LFS_ERR_CORRUPT ) { 1626goto relocate ; 1627} 1628return err ; 1629} 1630 1631// successful compaction, swap dir pair to indicate most recent 1632LFS_ASSERT ( commit . off % lfs -> cfg -> prog_size == 0 ); 1633lfs_pair_swap ( dir -> pair ); 1634dir -> count = end - begin ; 1635dir -> off = commit . off ; 1636dir -> etag = commit . ptag ; 1637// update gstate 1638lfs -> gdelta = ( lfs_gstate_t ){ 0 }; 1639if (! relocated ) { 1640lfs -> gdisk = lfs -> gstate ; 1641} 1642} 1643break; 1644 1645relocate : 1646// commit was corrupted, drop caches and prepare to relocate block 1647relocated = true; 1648lfs_cache_drop ( lfs , & lfs -> pcache ); 1649if (! tired ) { 1650LFS_DEBUG ( "Bad block at 0x%" PRIx32 , dir -> pair [ 1 ]); 1651} 1652 1653// can't relocate superblock, filesystem is now frozen 1654if ( lfs_pair_cmp ( dir -> pair , (const lfs_block_t [ 2 ]){ 0 , 1 }) == 0 ) { 1655LFS_WARN ( "Superblock 0x%" PRIx32 " has become unwritable" , 1656dir -> pair [ 1 ]); 1657return LFS_ERR_NOSPC ; 1658} 1659 1660// relocate half of pair 1661int err = lfs_alloc ( lfs , & dir -> pair [ 1 ]); 1662if ( err && ( err != LFS_ERR_NOSPC || ! tired )) { 1663return err ; 1664} 1665 1666tired = false; 1667continue; 1668} 1669 1670if ( relocated ) { 1671// update references if we relocated 1672LFS_DEBUG ( "Relocating {0x%" PRIx32 ", 0x%" PRIx32 "} " 1673"-> {0x%" PRIx32 ", 0x%" PRIx32 "}" , 1674oldpair [ 0 ], oldpair [ 1 ], dir -> pair [ 0 ], dir -> pair [ 1 ]); 1675int err = lfs_fs_relocate ( lfs , oldpair , dir -> pair ); 1676if ( err ) { 1677return err ; 1678} 1679} 1680 1681return 0 ; 1682} 1683 1684static int lfs_dir_commit ( lfs_t * lfs , lfs_mdir_t * dir , 1685const struct lfs_mattr * attrs , int attrcount ) { 1686// check for any inline files that aren't RAM backed and 1687// forcefully evict them, needed for filesystem consistency 1688for ( lfs_file_t * f = ( lfs_file_t * ) lfs -> mlist ; f ; f = f -> next ) { 1689if ( dir != & f -> m && lfs_pair_cmp ( f -> m . pair , dir -> pair ) == 0 && 1690f -> type == LFS_TYPE_REG && ( f -> flags & LFS_F_INLINE ) && 1691f -> ctz . size > lfs -> cfg -> cache_size ) { 1692int err = lfs_file_outline ( lfs , f ); 1693if ( err ) { 1694return err ; 1695} 1696 1697err = lfs_file_flush ( lfs , f ); 1698if ( err ) { 1699return err ; 1700} 1701} 1702} 1703 1704// calculate changes to the directory 1705lfs_mdir_t olddir = * dir ; 1706bool hasdelete = false; 1707for ( int i = 0 ; i < attrcount ; i ++ ) { 1708if ( lfs_tag_type3 ( attrs [ i ]. tag ) == LFS_TYPE_CREATE ) { 1709dir -> count += 1 ; 1710} else if ( lfs_tag_type3 ( attrs [ i ]. tag ) == LFS_TYPE_DELETE ) { 1711LFS_ASSERT ( dir -> count > 0 ); 1712dir -> count -= 1 ; 1713hasdelete = true; 1714} else if ( lfs_tag_type1 ( attrs [ i ]. tag ) == LFS_TYPE_TAIL ) { 1715dir -> tail [ 0 ] = (( lfs_block_t * ) attrs [ i ]. buffer )[ 0 ]; 1716dir -> tail [ 1 ] = (( lfs_block_t * ) attrs [ i ]. buffer )[ 1 ]; 1717dir -> split = ( lfs_tag_chunk ( attrs [ i ]. tag ) & 1 ); 1718lfs_pair_fromle32 ( dir -> tail ); 1719} 1720} 1721 1722// should we actually drop the directory block? 1723if ( hasdelete && dir -> count == 0 ) { 1724lfs_mdir_t pdir ; 1725int err = lfs_fs_pred ( lfs , dir -> pair , & pdir ); 1726if ( err && err != LFS_ERR_NOENT ) { 1727* dir = olddir ; 1728return err ; 1729} 1730 1731if ( err != LFS_ERR_NOENT && pdir . split ) { 1732err = lfs_dir_drop ( lfs , & pdir , dir ); 1733if ( err ) { 1734* dir = olddir ; 1735return err ; 1736} 1737} 1738} 1739 1740if ( dir -> erased || dir -> count >= 0xff ) { 1741// try to commit 1742struct lfs_commit commit = { 1743. block = dir -> pair [ 0 ], 1744. off = dir -> off , 1745. ptag = dir -> etag , 1746. crc = 0xffffffff , 1747 1748. begin = dir -> off , 1749. end = lfs -> cfg -> block_size - 8 , 1750}; 1751 1752// traverse attrs that need to be written out 1753lfs_pair_tole32 ( dir -> tail ); 1754int err = 1755lfs_dir_traverse ( lfs , dir , dir -> off , dir -> etag , attrs , attrcount , 0 , 17560 , 0 , 0 , 0 , lfs_dir_commit_commit , 1757& (struct lfs_dir_commit_commit ){ lfs , & commit }); 1758lfs_pair_fromle32 ( dir -> tail ); 1759if ( err ) { 1760if ( err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT ) { 1761goto compact ; 1762} 1763* dir = olddir ; 1764return err ; 1765} 1766 1767// commit any global diffs if we have any 1768lfs_gstate_t delta = { 0 }; 1769lfs_gstate_xor ( & delta , & lfs -> gstate ); 1770lfs_gstate_xor ( & delta , & lfs -> gdisk ); 1771lfs_gstate_xor ( & delta , & lfs -> gdelta ); 1772delta . tag &= ~ LFS_MKTAG ( 0 , 0 , 0x3ff ); 1773if (! lfs_gstate_iszero ( & delta )) { 1774err = lfs_dir_getgstate ( lfs , dir , & delta ); 1775if ( err ) { 1776* dir = olddir ; 1777return err ; 1778} 1779 1780lfs_gstate_tole32 ( & delta ); 1781err = lfs_dir_commitattr ( 1782lfs , & commit , 1783LFS_MKTAG ( LFS_TYPE_MOVESTATE , 0x3ff , sizeof( delta )), & delta ); 1784if ( err ) { 1785if ( err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT ) { 1786goto compact ; 1787} 1788* dir = olddir ; 1789return err ; 1790} 1791} 1792 1793// finalize commit with the crc 1794err = lfs_dir_commitcrc ( lfs , & commit ); 1795if ( err ) { 1796if ( err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT ) { 1797goto compact ; 1798} 1799* dir = olddir ; 1800return err ; 1801} 1802 1803// successful commit, update dir 1804LFS_ASSERT ( commit . off % lfs -> cfg -> prog_size == 0 ); 1805dir -> off = commit . off ; 1806dir -> etag = commit . ptag ; 1807// and update gstate 1808lfs -> gdisk = lfs -> gstate ; 1809lfs -> gdelta = ( lfs_gstate_t ){ 0 }; 1810} else { 1811compact : 1812// fall back to compaction 1813lfs_cache_drop ( lfs , & lfs -> pcache ); 1814 1815int err = 1816lfs_dir_compact ( lfs , dir , attrs , attrcount , dir , 0 , dir -> count ); 1817if ( err ) { 1818* dir = olddir ; 1819return err ; 1820} 1821} 1822 1823// this complicated bit of logic is for fixing up any active 1824// metadata-pairs that we may have affected 1825// 1826// note we have to make two passes since the mdir passed to 1827// lfs_dir_commit could also be in this list, and even then 1828// we need to copy the pair so they don't get clobbered if we refetch 1829// our mdir. 1830for (struct lfs_mlist * d = lfs -> mlist ; d ; d = d -> next ) { 1831if ( & d -> m != dir && lfs_pair_cmp ( d -> m . pair , olddir . pair ) == 0 ) { 1832d -> m = * dir ; 1833for ( int i = 0 ; i < attrcount ; i ++ ) { 1834if ( lfs_tag_type3 ( attrs [ i ]. tag ) == LFS_TYPE_DELETE && 1835d -> id == lfs_tag_id ( attrs [ i ]. tag )) { 1836d -> m . pair [ 0 ] = LFS_BLOCK_NULL ; 1837d -> m . pair [ 1 ] = LFS_BLOCK_NULL ; 1838} else if ( lfs_tag_type3 ( attrs [ i ]. tag ) == LFS_TYPE_DELETE && 1839d -> id > lfs_tag_id ( attrs [ i ]. tag )) { 1840d -> id -= 1 ; 1841if ( d -> type == LFS_TYPE_DIR ) { 1842(( lfs_dir_t * ) d ) -> pos -= 1 ; 1843} 1844} else if ( lfs_tag_type3 ( attrs [ i ]. tag ) == LFS_TYPE_CREATE && 1845d -> id >= lfs_tag_id ( attrs [ i ]. tag )) { 1846d -> id += 1 ; 1847if ( d -> type == LFS_TYPE_DIR ) { 1848(( lfs_dir_t * ) d ) -> pos += 1 ; 1849} 1850} 1851} 1852} 1853} 1854 1855for (struct lfs_mlist * d = lfs -> mlist ; d ; d = d -> next ) { 1856if ( lfs_pair_cmp ( d -> m . pair , olddir . pair ) == 0 ) { 1857while ( d -> id >= d -> m . count && d -> m . split ) { 1858// we split and id is on tail now 1859d -> id -= d -> m . count ; 1860int err = lfs_dir_fetch ( lfs , & d -> m , d -> m . tail ); 1861if ( err ) { 1862return err ; 1863} 1864} 1865} 1866} 1867 1868return 0 ; 1869} 1870 1871/// Top level directory operations /// 1872int lfs_mkdir ( lfs_t * lfs , const char * path ) { 1873LFS_TRACE ( "lfs_mkdir(%p, \"%s\")" , ( void * ) lfs , path ); 1874// deorphan if we haven't yet, needed at most once after poweron 1875int err = lfs_fs_forceconsistency ( lfs ); 1876if ( err ) { 1877LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1878return err ; 1879} 1880 1881struct lfs_mlist cwd ; 1882cwd . next = lfs -> mlist ; 1883uint16_t id ; 1884err = lfs_dir_find ( lfs , & cwd . m , & path , & id ); 1885if (!( err == LFS_ERR_NOENT && id != 0x3ff )) { 1886LFS_TRACE ( "lfs_mkdir -> %d" , ( err < 0 ) ? err : LFS_ERR_EXIST ); 1887return ( err < 0 ) ? err : LFS_ERR_EXIST ; 1888} 1889 1890// check that name fits 1891lfs_size_t nlen = strlen ( path ); 1892if ( nlen > lfs -> name_max ) { 1893LFS_TRACE ( "lfs_mkdir -> %d" , LFS_ERR_NAMETOOLONG ); 1894return LFS_ERR_NAMETOOLONG ; 1895} 1896 1897// build up new directory 1898lfs_alloc_ack ( lfs ); 1899lfs_mdir_t dir ; 1900err = lfs_dir_alloc ( lfs , & dir ); 1901if ( err ) { 1902LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1903return err ; 1904} 1905 1906// find end of list 1907lfs_mdir_t pred = cwd . m ; 1908while ( pred . split ) { 1909err = lfs_dir_fetch ( lfs , & pred , pred . tail ); 1910if ( err ) { 1911LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1912return err ; 1913} 1914} 1915 1916// setup dir 1917lfs_pair_tole32 ( pred . tail ); 1918err = lfs_dir_commit ( 1919lfs , & dir , 1920LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_SOFTTAIL , 0x3ff , 8 ), pred . tail })); 1921lfs_pair_fromle32 ( pred . tail ); 1922if ( err ) { 1923LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1924return err ; 1925} 1926 1927// current block end of list? 1928if ( cwd . m . split ) { 1929// update tails, this creates a desync 1930lfs_fs_preporphans ( lfs , +1 ); 1931 1932// it's possible our predecessor has to be relocated, and if 1933// our parent is our predecessor's predecessor, this could have 1934// caused our parent to go out of date, fortunately we can hook 1935// ourselves into littlefs to catch this 1936cwd . type = 0 ; 1937cwd . id = 0 ; 1938lfs -> mlist = & cwd ; 1939 1940lfs_pair_tole32 ( dir . pair ); 1941err = lfs_dir_commit ( 1942lfs , & pred , 1943LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_SOFTTAIL , 0x3ff , 8 ), dir . pair })); 1944lfs_pair_fromle32 ( dir . pair ); 1945if ( err ) { 1946lfs -> mlist = cwd . next ; 1947LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1948return err ; 1949} 1950 1951lfs -> mlist = cwd . next ; 1952lfs_fs_preporphans ( lfs , -1 ); 1953} 1954 1955// now insert into our parent block 1956lfs_pair_tole32 ( dir . pair ); 1957err = lfs_dir_commit ( 1958lfs , & cwd . m , 1959LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_CREATE , id , 0 ), NULL }, 1960{ LFS_MKTAG ( LFS_TYPE_DIR , id , nlen ), path }, 1961{ LFS_MKTAG ( LFS_TYPE_DIRSTRUCT , id , 8 ), dir . pair }, 1962{ LFS_MKTAG_IF (! cwd . m . split , LFS_TYPE_SOFTTAIL , 0x3ff , 8 ), 1963dir . pair })); 1964lfs_pair_fromle32 ( dir . pair ); 1965if ( err ) { 1966LFS_TRACE ( "lfs_mkdir -> %d" , err ); 1967return err ; 1968} 1969 1970LFS_TRACE ( "lfs_mkdir -> %d" , 0 ); 1971return 0 ; 1972} 1973 1974int lfs_dir_open ( lfs_t * lfs , lfs_dir_t * dir , const char * path ) { 1975LFS_TRACE ( "lfs_dir_open(%p, %p, \"%s\")" , ( void * ) lfs , ( void * ) dir , path ); 1976lfs_stag_t tag = lfs_dir_find ( lfs , & dir -> m , & path , NULL ); 1977if ( tag < 0 ) { 1978LFS_TRACE ( "lfs_dir_open -> %" PRId32 , tag ); 1979return tag ; 1980} 1981 1982if ( lfs_tag_type3 ( tag ) != LFS_TYPE_DIR ) { 1983LFS_TRACE ( "lfs_dir_open -> %d" , LFS_ERR_NOTDIR ); 1984return LFS_ERR_NOTDIR ; 1985} 1986 1987lfs_block_t pair [ 2 ]; 1988if ( lfs_tag_id ( tag ) == 0x3ff ) { 1989// handle root dir separately 1990pair [ 0 ] = lfs -> root [ 0 ]; 1991pair [ 1 ] = lfs -> root [ 1 ]; 1992} else { 1993// get dir pair from parent 1994lfs_stag_t res = 1995lfs_dir_get ( lfs , & dir -> m , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 1996LFS_MKTAG ( LFS_TYPE_STRUCT , lfs_tag_id ( tag ), 8 ), pair ); 1997if ( res < 0 ) { 1998LFS_TRACE ( "lfs_dir_open -> %" PRId32 , res ); 1999return res ; 2000} 2001lfs_pair_fromle32 ( pair ); 2002} 2003 2004// fetch first pair 2005int err = lfs_dir_fetch ( lfs , & dir -> m , pair ); 2006if ( err ) { 2007LFS_TRACE ( "lfs_dir_open -> %d" , err ); 2008return err ; 2009} 2010 2011// setup entry 2012dir -> head [ 0 ] = dir -> m . pair [ 0 ]; 2013dir -> head [ 1 ] = dir -> m . pair [ 1 ]; 2014dir -> id = 0 ; 2015dir -> pos = 0 ; 2016 2017// add to list of mdirs 2018dir -> type = LFS_TYPE_DIR ; 2019dir -> next = ( lfs_dir_t * ) lfs -> mlist ; 2020lfs -> mlist = (struct lfs_mlist * ) dir ; 2021 2022LFS_TRACE ( "lfs_dir_open -> %d" , 0 ); 2023return 0 ; 2024} 2025 2026int lfs_dir_close ( lfs_t * lfs , lfs_dir_t * dir ) { 2027LFS_TRACE ( "lfs_dir_close(%p, %p)" , ( void * ) lfs , ( void * ) dir ); 2028// remove from list of mdirs 2029for (struct lfs_mlist ** p = & lfs -> mlist ; * p ; p = & ( * p ) -> next ) { 2030if ( * p == (struct lfs_mlist * ) dir ) { 2031* p = ( * p ) -> next ; 2032break; 2033} 2034} 2035 2036LFS_TRACE ( "lfs_dir_close -> %d" , 0 ); 2037return 0 ; 2038} 2039 2040int lfs_dir_read ( lfs_t * lfs , lfs_dir_t * dir , struct lfs_info * info ) { 2041LFS_TRACE ( "lfs_dir_read(%p, %p, %p)" , ( void * ) lfs , ( void * ) dir , ( void * ) info ); 2042memset ( info , 0 , sizeof( * info )); 2043 2044// special offset for '.' and '..' 2045if ( dir -> pos == 0 ) { 2046info -> type = LFS_TYPE_DIR ; 2047strcpy ( info -> name , "." ); 2048dir -> pos += 1 ; 2049LFS_TRACE ( "lfs_dir_read -> %d" , true); 2050return true; 2051} else if ( dir -> pos == 1 ) { 2052info -> type = LFS_TYPE_DIR ; 2053strcpy ( info -> name , ".." ); 2054dir -> pos += 1 ; 2055LFS_TRACE ( "lfs_dir_read -> %d" , true); 2056return true; 2057} 2058 2059while (true) { 2060if ( dir -> id == dir -> m . count ) { 2061if (! dir -> m . split ) { 2062LFS_TRACE ( "lfs_dir_read -> %d" , false); 2063return false; 2064} 2065 2066int err = lfs_dir_fetch ( lfs , & dir -> m , dir -> m . tail ); 2067if ( err ) { 2068LFS_TRACE ( "lfs_dir_read -> %d" , err ); 2069return err ; 2070} 2071 2072dir -> id = 0 ; 2073} 2074 2075int err = lfs_dir_getinfo ( lfs , & dir -> m , dir -> id , info ); 2076if ( err && err != LFS_ERR_NOENT ) { 2077LFS_TRACE ( "lfs_dir_read -> %d" , err ); 2078return err ; 2079} 2080 2081dir -> id += 1 ; 2082if ( err != LFS_ERR_NOENT ) { 2083break; 2084} 2085} 2086 2087dir -> pos += 1 ; 2088LFS_TRACE ( "lfs_dir_read -> %d" , true); 2089return true; 2090} 2091 2092int lfs_dir_seek ( lfs_t * lfs , lfs_dir_t * dir , lfs_off_t off ) { 2093LFS_TRACE ( "lfs_dir_seek(%p, %p, %" PRIu32 ")" , ( void * ) lfs , ( void * ) dir , off ); 2094// simply walk from head dir 2095int err = lfs_dir_rewind ( lfs , dir ); 2096if ( err ) { 2097LFS_TRACE ( "lfs_dir_seek -> %d" , err ); 2098return err ; 2099} 2100 2101// first two for ./.. 2102dir -> pos = lfs_min ( 2 , off ); 2103off -= dir -> pos ; 2104 2105// skip superblock entry 2106dir -> id = ( off > 0 && lfs_pair_cmp ( dir -> head , lfs -> root ) == 0 ); 2107 2108while ( off > 0 ) { 2109int diff = lfs_min ( dir -> m . count - dir -> id , off ); 2110dir -> id += diff ; 2111dir -> pos += diff ; 2112off -= diff ; 2113 2114if ( dir -> id == dir -> m . count ) { 2115if (! dir -> m . split ) { 2116LFS_TRACE ( "lfs_dir_seek -> %d" , LFS_ERR_INVAL ); 2117return LFS_ERR_INVAL ; 2118} 2119 2120err = lfs_dir_fetch ( lfs , & dir -> m , dir -> m . tail ); 2121if ( err ) { 2122LFS_TRACE ( "lfs_dir_seek -> %d" , err ); 2123return err ; 2124} 2125 2126dir -> id = 0 ; 2127} 2128} 2129 2130LFS_TRACE ( "lfs_dir_seek -> %d" , 0 ); 2131return 0 ; 2132} 2133 2134lfs_soff_t lfs_dir_tell ( lfs_t * lfs , lfs_dir_t * dir ) { 2135LFS_TRACE ( "lfs_dir_tell(%p, %p)" , ( void * ) lfs , ( void * ) dir ); 2136( void ) lfs ; 2137LFS_TRACE ( "lfs_dir_tell -> %" PRId32 , dir -> pos ); 2138return dir -> pos ; 2139} 2140 2141int lfs_dir_rewind ( lfs_t * lfs , lfs_dir_t * dir ) { 2142LFS_TRACE ( "lfs_dir_rewind(%p, %p)" , ( void * ) lfs , ( void * ) dir ); 2143// reload the head dir 2144int err = lfs_dir_fetch ( lfs , & dir -> m , dir -> head ); 2145if ( err ) { 2146LFS_TRACE ( "lfs_dir_rewind -> %d" , err ); 2147return err ; 2148} 2149 2150dir -> id = 0 ; 2151dir -> pos = 0 ; 2152LFS_TRACE ( "lfs_dir_rewind -> %d" , 0 ); 2153return 0 ; 2154} 2155 2156/// File index list operations /// 2157static int lfs_ctz_index ( lfs_t * lfs , lfs_off_t * off ) { 2158lfs_off_t size = * off ; 2159lfs_off_t b = lfs -> cfg -> block_size - 2 * 4 ; 2160lfs_off_t i = size / b ; 2161if ( i == 0 ) { 2162return 0 ; 2163} 2164 2165i = ( size - 4 * ( lfs_popc ( i - 1 ) + 2 )) / b ; 2166* off = size - b * i - 4 * lfs_popc ( i ); 2167return i ; 2168} 2169 2170static int lfs_ctz_find ( lfs_t * lfs , const lfs_cache_t * pcache , 2171lfs_cache_t * rcache , lfs_block_t head , lfs_size_t size , 2172lfs_size_t pos , lfs_block_t * block , lfs_off_t * off ) { 2173if ( size == 0 ) { 2174* block = LFS_BLOCK_NULL ; 2175* off = 0 ; 2176return 0 ; 2177} 2178 2179lfs_off_t current = lfs_ctz_index ( lfs , & ( lfs_off_t ){ size - 1 }); 2180lfs_off_t target = lfs_ctz_index ( lfs , & pos ); 2181 2182while ( current > target ) { 2183lfs_size_t skip = 2184lfs_min ( lfs_npw2 ( current - target + 1 ) - 1 , lfs_ctz ( current )); 2185 2186int err = lfs_bd_read ( lfs , pcache , rcache , sizeof( head ), head , 4 * skip , 2187& head , sizeof( head )); 2188head = lfs_fromle32 ( head ); 2189if ( err ) { 2190return err ; 2191} 2192 2193current -= 1 << skip ; 2194} 2195 2196* block = head ; 2197* off = pos ; 2198return 0 ; 2199} 2200 2201static int lfs_ctz_extend ( lfs_t * lfs , lfs_cache_t * pcache , lfs_cache_t * rcache , 2202lfs_block_t head , lfs_size_t size , lfs_block_t * block , 2203lfs_off_t * off ) { 2204while (true) { 2205// go ahead and grab a block 2206lfs_block_t nblock ; 2207int err = lfs_alloc ( lfs , & nblock ); 2208if ( err ) { 2209return err ; 2210} 2211 2212{ 2213err = lfs_bd_erase ( lfs , nblock ); 2214if ( err ) { 2215if ( err == LFS_ERR_CORRUPT ) { 2216goto relocate ; 2217} 2218return err ; 2219} 2220 2221if ( size == 0 ) { 2222* block = nblock ; 2223* off = 0 ; 2224return 0 ; 2225} 2226 2227lfs_size_t noff = size - 1 ; 2228lfs_off_t index = lfs_ctz_index ( lfs , & noff ); 2229noff = noff + 1 ; 2230 2231// just copy out the last block if it is incomplete 2232if ( noff != lfs -> cfg -> block_size ) { 2233for ( lfs_off_t i = 0 ; i < noff ; i ++ ) { 2234uint8_t data ; 2235err = lfs_bd_read ( lfs , NULL , rcache , noff - i , head , i , 2236& data , 1 ); 2237if ( err ) { 2238return err ; 2239} 2240 2241err = lfs_bd_prog ( lfs , pcache , rcache , true, nblock , i , 2242& data , 1 ); 2243if ( err ) { 2244if ( err == LFS_ERR_CORRUPT ) { 2245goto relocate ; 2246} 2247return err ; 2248} 2249} 2250 2251* block = nblock ; 2252* off = noff ; 2253return 0 ; 2254} 2255 2256// append block 2257index += 1 ; 2258lfs_size_t skips = lfs_ctz ( index ) + 1 ; 2259lfs_block_t nhead = head ; 2260for ( lfs_off_t i = 0 ; i < skips ; i ++ ) { 2261nhead = lfs_tole32 ( nhead ); 2262err = lfs_bd_prog ( lfs , pcache , rcache , true, nblock , 4 * i , 2263& nhead , 4 ); 2264nhead = lfs_fromle32 ( nhead ); 2265if ( err ) { 2266if ( err == LFS_ERR_CORRUPT ) { 2267goto relocate ; 2268} 2269return err ; 2270} 2271 2272if ( i != skips - 1 ) { 2273err = lfs_bd_read ( lfs , NULL , rcache , sizeof( nhead ), nhead , 22744 * i , & nhead , sizeof( nhead )); 2275nhead = lfs_fromle32 ( nhead ); 2276if ( err ) { 2277return err ; 2278} 2279} 2280} 2281 2282* block = nblock ; 2283* off = 4 * skips ; 2284return 0 ; 2285} 2286 2287relocate : 2288LFS_DEBUG ( "Bad block at 0x%" PRIx32 , nblock ); 2289 2290// just clear cache and try a new block 2291lfs_cache_drop ( lfs , pcache ); 2292} 2293} 2294 2295static int lfs_ctz_traverse ( lfs_t * lfs , const lfs_cache_t * pcache , 2296lfs_cache_t * rcache , lfs_block_t head , 2297lfs_size_t size , int ( * cb )( void * , lfs_block_t ), 2298void * data ) { 2299if ( size == 0 ) { 2300return 0 ; 2301} 2302 2303lfs_off_t index = lfs_ctz_index ( lfs , & ( lfs_off_t ){ size - 1 }); 2304 2305while (true) { 2306int err = cb ( data , head ); 2307if ( err ) { 2308return err ; 2309} 2310 2311if ( index == 0 ) { 2312return 0 ; 2313} 2314 2315lfs_block_t heads [ 2 ]; 2316int count = 2 - ( index & 1 ); 2317err = lfs_bd_read ( lfs , pcache , rcache , count * sizeof( head ), head , 0 , 2318& heads , count * sizeof( head )); 2319heads [ 0 ] = lfs_fromle32 ( heads [ 0 ]); 2320heads [ 1 ] = lfs_fromle32 ( heads [ 1 ]); 2321if ( err ) { 2322return err ; 2323} 2324 2325for ( int i = 0 ; i < count - 1 ; i ++ ) { 2326err = cb ( data , heads [ i ]); 2327if ( err ) { 2328return err ; 2329} 2330} 2331 2332head = heads [ count - 1 ]; 2333index -= count ; 2334} 2335} 2336 2337/// Top level file operations /// 2338int lfs_file_opencfg ( lfs_t * lfs , lfs_file_t * file , const char * path , int flags , 2339const struct lfs_file_config * cfg ) { 2340LFS_TRACE ( "lfs_file_opencfg(%p, %p, \"%s\", %x, %p {" 2341".buffer=%p, .attrs=%p, .attr_count=%" PRIu32 "})" , 2342( void * ) lfs , ( void * ) file , path , flags , ( void * ) cfg , cfg -> buffer , 2343( void * ) cfg -> attrs , cfg -> attr_count ); 2344 2345// deorphan if we haven't yet, needed at most once after poweron 2346if (( flags & 3 ) != LFS_O_RDONLY ) { 2347int err = lfs_fs_forceconsistency ( lfs ); 2348if ( err ) { 2349LFS_TRACE ( "lfs_file_opencfg -> %d" , err ); 2350return err ; 2351} 2352} 2353 2354// setup simple file details 2355int err ; 2356file -> cfg = cfg ; 2357file -> flags = flags | LFS_F_OPENED ; 2358file -> pos = 0 ; 2359file -> off = 0 ; 2360file -> cache . buffer = NULL ; 2361 2362// allocate entry for file if it doesn't exist 2363lfs_stag_t tag = lfs_dir_find ( lfs , & file -> m , & path , & file -> id ); 2364if ( tag < 0 && !( tag == LFS_ERR_NOENT && file -> id != 0x3ff )) { 2365err = tag ; 2366goto cleanup ; 2367} 2368 2369// get id, add to list of mdirs to catch update changes 2370file -> type = LFS_TYPE_REG ; 2371file -> next = ( lfs_file_t * ) lfs -> mlist ; 2372lfs -> mlist = (struct lfs_mlist * ) file ; 2373 2374if ( tag == LFS_ERR_NOENT ) { 2375if (!( flags & LFS_O_CREAT )) { 2376err = LFS_ERR_NOENT ; 2377goto cleanup ; 2378} 2379 2380// check that name fits 2381lfs_size_t nlen = strlen ( path ); 2382if ( nlen > lfs -> name_max ) { 2383err = LFS_ERR_NAMETOOLONG ; 2384goto cleanup ; 2385} 2386 2387// get next slot and create entry to remember name 2388err = lfs_dir_commit ( 2389lfs , & file -> m , 2390LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_CREATE , file -> id , 0 ), NULL }, 2391{ LFS_MKTAG ( LFS_TYPE_REG , file -> id , nlen ), path }, 2392{ LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , file -> id , 0 ), NULL })); 2393if ( err ) { 2394err = LFS_ERR_NAMETOOLONG ; 2395goto cleanup ; 2396} 2397 2398tag = LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , 0 , 0 ); 2399} else if ( flags & LFS_O_EXCL ) { 2400err = LFS_ERR_EXIST ; 2401goto cleanup ; 2402} else if ( lfs_tag_type3 ( tag ) != LFS_TYPE_REG ) { 2403err = LFS_ERR_ISDIR ; 2404goto cleanup ; 2405} else if ( flags & LFS_O_TRUNC ) { 2406// truncate if requested 2407tag = LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , file -> id , 0 ); 2408file -> flags |= LFS_F_DIRTY ; 2409} else { 2410// try to load what's on disk, if it's inlined we'll fix it later 2411tag = lfs_dir_get ( lfs , & file -> m , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 2412LFS_MKTAG ( LFS_TYPE_STRUCT , file -> id , 8 ), & file -> ctz ); 2413if ( tag < 0 ) { 2414err = tag ; 2415goto cleanup ; 2416} 2417lfs_ctz_fromle32 ( & file -> ctz ); 2418} 2419 2420// fetch attrs 2421for ( unsigned i = 0 ; i < file -> cfg -> attr_count ; i ++ ) { 2422if (( file -> flags & 3 ) != LFS_O_WRONLY ) { 2423lfs_stag_t res = lfs_dir_get ( 2424lfs , & file -> m , LFS_MKTAG ( 0x7ff , 0x3ff , 0 ), 2425LFS_MKTAG ( LFS_TYPE_USERATTR + file -> cfg -> attrs [ i ]. type , 2426file -> id , file -> cfg -> attrs [ i ]. size ), 2427file -> cfg -> attrs [ i ]. buffer ); 2428if ( res < 0 && res != LFS_ERR_NOENT ) { 2429err = res ; 2430goto cleanup ; 2431} 2432} 2433 2434if (( file -> flags & 3 ) != LFS_O_RDONLY ) { 2435if ( file -> cfg -> attrs [ i ]. size > lfs -> attr_max ) { 2436err = LFS_ERR_NOSPC ; 2437goto cleanup ; 2438} 2439 2440file -> flags |= LFS_F_DIRTY ; 2441} 2442} 2443 2444// allocate buffer if needed 2445if ( file -> cfg -> buffer ) { 2446file -> cache . buffer = file -> cfg -> buffer ; 2447} else { 2448file -> cache . buffer = lfs_malloc ( lfs -> cfg -> cache_size ); 2449if (! file -> cache . buffer ) { 2450err = LFS_ERR_NOMEM ; 2451goto cleanup ; 2452} 2453} 2454 2455// zero to avoid information leak 2456lfs_cache_zero ( lfs , & file -> cache ); 2457 2458if ( lfs_tag_type3 ( tag ) == LFS_TYPE_INLINESTRUCT ) { 2459// load inline files 2460file -> ctz . head = LFS_BLOCK_INLINE ; 2461file -> ctz . size = lfs_tag_size ( tag ); 2462file -> flags |= LFS_F_INLINE ; 2463file -> cache . block = file -> ctz . head ; 2464file -> cache . off = 0 ; 2465file -> cache . size = lfs -> cfg -> cache_size ; 2466 2467// don't always read (may be new/trunc file) 2468if ( file -> ctz . size > 0 ) { 2469lfs_stag_t res = 2470lfs_dir_get ( lfs , & file -> m , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 2471LFS_MKTAG ( LFS_TYPE_STRUCT , file -> id , 2472lfs_min ( file -> cache . size , 0x3fe )), 2473file -> cache . buffer ); 2474if ( res < 0 ) { 2475err = res ; 2476goto cleanup ; 2477} 2478} 2479} 2480 2481LFS_TRACE ( "lfs_file_opencfg -> %d" , 0 ); 2482return 0 ; 2483 2484cleanup : 2485// clean up lingering resources 2486file -> flags |= LFS_F_ERRED ; 2487lfs_file_close ( lfs , file ); 2488LFS_TRACE ( "lfs_file_opencfg -> %d" , err ); 2489return err ; 2490} 2491 2492int lfs_file_open ( lfs_t * lfs , lfs_file_t * file , const char * path , int flags ) { 2493LFS_TRACE ( "lfs_file_open(%p, %p, \"%s\", %x)" , ( void * ) lfs , ( void * ) file , 2494path , flags ); 2495static const struct lfs_file_config defaults = { 0 }; 2496int err = lfs_file_opencfg ( lfs , file , path , flags , & defaults ); 2497LFS_TRACE ( "lfs_file_open -> %d" , err ); 2498return err ; 2499} 2500 2501int lfs_file_close ( lfs_t * lfs , lfs_file_t * file ) { 2502LFS_TRACE ( "lfs_file_close(%p, %p)" , ( void * ) lfs , ( void * ) file ); 2503LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2504 2505int err = lfs_file_sync ( lfs , file ); 2506 2507// remove from list of mdirs 2508for (struct lfs_mlist ** p = & lfs -> mlist ; * p ; p = & ( * p ) -> next ) { 2509if ( * p == (struct lfs_mlist * ) file ) { 2510* p = ( * p ) -> next ; 2511break; 2512} 2513} 2514 2515// clean up memory 2516if (! file -> cfg -> buffer && file -> cache . buffer ) { 2517lfs_free ( file -> cache . buffer ); 2518} 2519 2520file -> flags &= ~ LFS_F_OPENED ; 2521LFS_TRACE ( "lfs_file_close -> %d" , err ); 2522return err ; 2523} 2524 2525static int lfs_file_relocate ( lfs_t * lfs , lfs_file_t * file ) { 2526LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2527 2528while (true) { 2529// just relocate what exists into new block 2530lfs_block_t nblock ; 2531int err = lfs_alloc ( lfs , & nblock ); 2532if ( err ) { 2533return err ; 2534} 2535 2536err = lfs_bd_erase ( lfs , nblock ); 2537if ( err ) { 2538if ( err == LFS_ERR_CORRUPT ) { 2539goto relocate ; 2540} 2541return err ; 2542} 2543 2544// either read from dirty cache or disk 2545for ( lfs_off_t i = 0 ; i < file -> off ; i ++ ) { 2546uint8_t data ; 2547if ( file -> flags & LFS_F_INLINE ) { 2548err = lfs_dir_getread ( 2549lfs , & file -> m , 2550// note we evict inline files before they can be dirty 2551NULL , & file -> cache , file -> off - i , 2552LFS_MKTAG ( 0xfff , 0x1ff , 0 ), 2553LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , file -> id , 0 ), i , & data , 1 ); 2554if ( err ) { 2555return err ; 2556} 2557} else { 2558err = lfs_bd_read ( lfs , & file -> cache , & lfs -> rcache , 2559file -> off - i , file -> block , i , & data , 1 ); 2560if ( err ) { 2561return err ; 2562} 2563} 2564 2565err = lfs_bd_prog ( lfs , & lfs -> pcache , & lfs -> rcache , true, nblock , i , 2566& data , 1 ); 2567if ( err ) { 2568if ( err == LFS_ERR_CORRUPT ) { 2569goto relocate ; 2570} 2571return err ; 2572} 2573} 2574 2575// copy over new state of file 2576memcpy ( file -> cache . buffer , lfs -> pcache . buffer , lfs -> cfg -> cache_size ); 2577file -> cache . block = lfs -> pcache . block ; 2578file -> cache . off = lfs -> pcache . off ; 2579file -> cache . size = lfs -> pcache . size ; 2580lfs_cache_zero ( lfs , & lfs -> pcache ); 2581 2582file -> block = nblock ; 2583file -> flags |= LFS_F_WRITING ; 2584return 0 ; 2585 2586relocate : 2587LFS_DEBUG ( "Bad block at 0x%" PRIx32 , nblock ); 2588 2589// just clear cache and try a new block 2590lfs_cache_drop ( lfs , & lfs -> pcache ); 2591} 2592} 2593 2594static int lfs_file_outline ( lfs_t * lfs , lfs_file_t * file ) { 2595file -> off = file -> pos ; 2596lfs_alloc_ack ( lfs ); 2597int err = lfs_file_relocate ( lfs , file ); 2598if ( err ) { 2599return err ; 2600} 2601 2602file -> flags &= ~ LFS_F_INLINE ; 2603return 0 ; 2604} 2605 2606static int lfs_file_flush ( lfs_t * lfs , lfs_file_t * file ) { 2607LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2608 2609if ( file -> flags & LFS_F_READING ) { 2610if (!( file -> flags & LFS_F_INLINE )) { 2611lfs_cache_drop ( lfs , & file -> cache ); 2612} 2613file -> flags &= ~ LFS_F_READING ; 2614} 2615 2616if ( file -> flags & LFS_F_WRITING ) { 2617lfs_off_t pos = file -> pos ; 2618 2619if (!( file -> flags & LFS_F_INLINE )) { 2620// copy over anything after current branch 2621lfs_file_t orig = { 2622. ctz . head = file -> ctz . head , 2623. ctz . size = file -> ctz . size , 2624. flags = LFS_O_RDONLY | LFS_F_OPENED , 2625. pos = file -> pos , 2626. cache = lfs -> rcache , 2627}; 2628lfs_cache_drop ( lfs , & lfs -> rcache ); 2629 2630while ( file -> pos < file -> ctz . size ) { 2631// copy over a byte at a time, leave it up to caching 2632// to make this efficient 2633uint8_t data ; 2634lfs_ssize_t res = lfs_file_read ( lfs , & orig , & data , 1 ); 2635if ( res < 0 ) { 2636return res ; 2637} 2638 2639res = lfs_file_write ( lfs , file , & data , 1 ); 2640if ( res < 0 ) { 2641return res ; 2642} 2643 2644// keep our reference to the rcache in sync 2645if ( lfs -> rcache . block != LFS_BLOCK_NULL ) { 2646lfs_cache_drop ( lfs , & orig . cache ); 2647lfs_cache_drop ( lfs , & lfs -> rcache ); 2648} 2649} 2650 2651// write out what we have 2652while (true) { 2653int err = lfs_bd_flush ( lfs , & file -> cache , & lfs -> rcache , true); 2654if ( err ) { 2655if ( err == LFS_ERR_CORRUPT ) { 2656goto relocate ; 2657} 2658return err ; 2659} 2660 2661break; 2662 2663relocate : 2664LFS_DEBUG ( "Bad block at 0x%" PRIx32 , file -> block ); 2665err = lfs_file_relocate ( lfs , file ); 2666if ( err ) { 2667return err ; 2668} 2669} 2670} else { 2671file -> pos = lfs_max ( file -> pos , file -> ctz . size ); 2672} 2673 2674// actual file updates 2675file -> ctz . head = file -> block ; 2676file -> ctz . size = file -> pos ; 2677file -> flags &= ~ LFS_F_WRITING ; 2678file -> flags |= LFS_F_DIRTY ; 2679 2680file -> pos = pos ; 2681} 2682 2683return 0 ; 2684} 2685 2686int lfs_file_sync ( lfs_t * lfs , lfs_file_t * file ) { 2687LFS_TRACE ( "lfs_file_sync(%p, %p)" , ( void * ) lfs , ( void * ) file ); 2688LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2689 2690if ( file -> flags & LFS_F_ERRED ) { 2691// it's not safe to do anything if our file errored 2692LFS_TRACE ( "lfs_file_sync -> %d" , 0 ); 2693return 0 ; 2694} 2695 2696int err = lfs_file_flush ( lfs , file ); 2697if ( err ) { 2698file -> flags |= LFS_F_ERRED ; 2699LFS_TRACE ( "lfs_file_sync -> %d" , err ); 2700return err ; 2701} 2702 2703if (( file -> flags & LFS_F_DIRTY ) && ! lfs_pair_isnull ( file -> m . pair )) { 2704// update dir entry 2705uint16_t type ; 2706const void * buffer ; 2707lfs_size_t size ; 2708struct lfs_ctz ctz ; 2709if ( file -> flags & LFS_F_INLINE ) { 2710// inline the whole file 2711type = LFS_TYPE_INLINESTRUCT ; 2712buffer = file -> cache . buffer ; 2713size = file -> ctz . size ; 2714} else { 2715// update the ctz reference 2716type = LFS_TYPE_CTZSTRUCT ; 2717// copy ctz so alloc will work during a relocate 2718ctz = file -> ctz ; 2719lfs_ctz_tole32 ( & ctz ); 2720buffer = & ctz ; 2721size = sizeof( ctz ); 2722} 2723 2724// commit file data and attributes 2725err = lfs_dir_commit ( 2726lfs , & file -> m , 2727LFS_MKATTRS ( 2728{ LFS_MKTAG ( type , file -> id , size ), buffer }, 2729{ LFS_MKTAG ( LFS_FROM_USERATTRS , file -> id , file -> cfg -> attr_count ), 2730file -> cfg -> attrs })); 2731if ( err ) { 2732file -> flags |= LFS_F_ERRED ; 2733LFS_TRACE ( "lfs_file_sync -> %d" , err ); 2734return err ; 2735} 2736 2737file -> flags &= ~ LFS_F_DIRTY ; 2738} 2739 2740LFS_TRACE ( "lfs_file_sync -> %d" , 0 ); 2741return 0 ; 2742} 2743 2744lfs_ssize_t lfs_file_read ( lfs_t * lfs , lfs_file_t * file , void * buffer , 2745lfs_size_t size ) { 2746LFS_TRACE ( "lfs_file_read(%p, %p, %p, %" PRIu32 ")" , ( void * ) lfs , ( void * ) file , 2747buffer , size ); 2748LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2749LFS_ASSERT (( file -> flags & 3 ) != LFS_O_WRONLY ); 2750 2751uint8_t * data = buffer ; 2752lfs_size_t nsize = size ; 2753 2754if ( file -> flags & LFS_F_WRITING ) { 2755// flush out any writes 2756int err = lfs_file_flush ( lfs , file ); 2757if ( err ) { 2758LFS_TRACE ( "lfs_file_read -> %d" , err ); 2759return err ; 2760} 2761} 2762 2763if ( file -> pos >= file -> ctz . size ) { 2764// eof if past end 2765LFS_TRACE ( "lfs_file_read -> %d" , 0 ); 2766return 0 ; 2767} 2768 2769size = lfs_min ( size , file -> ctz . size - file -> pos ); 2770nsize = size ; 2771 2772while ( nsize > 0 ) { 2773// check if we need a new block 2774if (!( file -> flags & LFS_F_READING ) || 2775file -> off == lfs -> cfg -> block_size ) { 2776if (!( file -> flags & LFS_F_INLINE )) { 2777int err = lfs_ctz_find ( lfs , NULL , & file -> cache , file -> ctz . head , 2778file -> ctz . size , file -> pos , & file -> block , 2779& file -> off ); 2780if ( err ) { 2781LFS_TRACE ( "lfs_file_read -> %d" , err ); 2782return err ; 2783} 2784} else { 2785file -> block = LFS_BLOCK_INLINE ; 2786file -> off = file -> pos ; 2787} 2788 2789file -> flags |= LFS_F_READING ; 2790} 2791 2792// read as much as we can in current block 2793lfs_size_t diff = lfs_min ( nsize , lfs -> cfg -> block_size - file -> off ); 2794if ( file -> flags & LFS_F_INLINE ) { 2795int err = lfs_dir_getread ( 2796lfs , & file -> m , NULL , & file -> cache , lfs -> cfg -> block_size , 2797LFS_MKTAG ( 0xfff , 0x1ff , 0 ), 2798LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , file -> id , 0 ), file -> off , data , 2799diff ); 2800if ( err ) { 2801LFS_TRACE ( "lfs_file_read -> %d" , err ); 2802return err ; 2803} 2804} else { 2805int err = lfs_bd_read ( lfs , NULL , & file -> cache , lfs -> cfg -> block_size , 2806file -> block , file -> off , data , diff ); 2807if ( err ) { 2808LFS_TRACE ( "lfs_file_read -> %d" , err ); 2809return err ; 2810} 2811} 2812 2813file -> pos += diff ; 2814file -> off += diff ; 2815data += diff ; 2816nsize -= diff ; 2817} 2818 2819LFS_TRACE ( "lfs_file_read -> %" PRId32 , size ); 2820return size ; 2821} 2822 2823lfs_ssize_t lfs_file_write ( lfs_t * lfs , lfs_file_t * file , const void * buffer , 2824lfs_size_t size ) { 2825LFS_TRACE ( "lfs_file_write(%p, %p, %p, %" PRIu32 ")" , ( void * ) lfs , 2826( void * ) file , buffer , size ); 2827LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2828LFS_ASSERT (( file -> flags & 3 ) != LFS_O_RDONLY ); 2829 2830const uint8_t * data = buffer ; 2831lfs_size_t nsize = size ; 2832 2833if ( file -> flags & LFS_F_READING ) { 2834// drop any reads 2835int err = lfs_file_flush ( lfs , file ); 2836if ( err ) { 2837LFS_TRACE ( "lfs_file_write -> %d" , err ); 2838return err ; 2839} 2840} 2841 2842if (( file -> flags & LFS_O_APPEND ) && file -> pos < file -> ctz . size ) { 2843file -> pos = file -> ctz . size ; 2844} 2845 2846if ( file -> pos + size > lfs -> file_max ) { 2847// Larger than file limit? 2848LFS_TRACE ( "lfs_file_write -> %d" , LFS_ERR_FBIG ); 2849return LFS_ERR_FBIG ; 2850} 2851 2852if (!( file -> flags & LFS_F_WRITING ) && file -> pos > file -> ctz . size ) { 2853// fill with zeros 2854lfs_off_t pos = file -> pos ; 2855file -> pos = file -> ctz . size ; 2856 2857while ( file -> pos < pos ) { 2858lfs_ssize_t res = lfs_file_write ( lfs , file , & ( uint8_t ){ 0 }, 1 ); 2859if ( res < 0 ) { 2860LFS_TRACE ( "lfs_file_write -> %" PRId32 , res ); 2861return res ; 2862} 2863} 2864} 2865 2866if (( file -> flags & LFS_F_INLINE ) && 2867lfs_max ( file -> pos + nsize , file -> ctz . size ) > 2868lfs_min ( 0x3fe , 2869lfs_min ( lfs -> cfg -> cache_size , lfs -> cfg -> block_size / 8 ))) { 2870// inline file doesn't fit anymore 2871int err = lfs_file_outline ( lfs , file ); 2872if ( err ) { 2873file -> flags |= LFS_F_ERRED ; 2874LFS_TRACE ( "lfs_file_write -> %d" , err ); 2875return err ; 2876} 2877} 2878 2879while ( nsize > 0 ) { 2880// check if we need a new block 2881if (!( file -> flags & LFS_F_WRITING ) || 2882file -> off == lfs -> cfg -> block_size ) { 2883if (!( file -> flags & LFS_F_INLINE )) { 2884if (!( file -> flags & LFS_F_WRITING ) && file -> pos > 0 ) { 2885// find out which block we're extending from 2886int err = lfs_ctz_find ( 2887lfs , NULL , & file -> cache , file -> ctz . head , file -> ctz . size , 2888file -> pos - 1 , & file -> block , & file -> off ); 2889if ( err ) { 2890file -> flags |= LFS_F_ERRED ; 2891LFS_TRACE ( "lfs_file_write -> %d" , err ); 2892return err ; 2893} 2894 2895// mark cache as dirty since we may have read data into it 2896lfs_cache_zero ( lfs , & file -> cache ); 2897} 2898 2899// extend file with new blocks 2900lfs_alloc_ack ( lfs ); 2901int err = 2902lfs_ctz_extend ( lfs , & file -> cache , & lfs -> rcache , file -> block , 2903file -> pos , & file -> block , & file -> off ); 2904if ( err ) { 2905file -> flags |= LFS_F_ERRED ; 2906LFS_TRACE ( "lfs_file_write -> %d" , err ); 2907return err ; 2908} 2909} else { 2910file -> block = LFS_BLOCK_INLINE ; 2911file -> off = file -> pos ; 2912} 2913 2914file -> flags |= LFS_F_WRITING ; 2915} 2916 2917// program as much as we can in current block 2918lfs_size_t diff = lfs_min ( nsize , lfs -> cfg -> block_size - file -> off ); 2919while (true) { 2920int err = lfs_bd_prog ( lfs , & file -> cache , & lfs -> rcache , true, 2921file -> block , file -> off , data , diff ); 2922if ( err ) { 2923if ( err == LFS_ERR_CORRUPT ) { 2924goto relocate ; 2925} 2926file -> flags |= LFS_F_ERRED ; 2927LFS_TRACE ( "lfs_file_write -> %d" , err ); 2928return err ; 2929} 2930 2931break; 2932relocate : 2933err = lfs_file_relocate ( lfs , file ); 2934if ( err ) { 2935file -> flags |= LFS_F_ERRED ; 2936LFS_TRACE ( "lfs_file_write -> %d" , err ); 2937return err ; 2938} 2939} 2940 2941file -> pos += diff ; 2942file -> off += diff ; 2943data += diff ; 2944nsize -= diff ; 2945 2946lfs_alloc_ack ( lfs ); 2947} 2948 2949file -> flags &= ~ LFS_F_ERRED ; 2950LFS_TRACE ( "lfs_file_write -> %" PRId32 , size ); 2951return size ; 2952} 2953 2954lfs_soff_t lfs_file_seek ( lfs_t * lfs , lfs_file_t * file , lfs_soff_t off , 2955int whence ) { 2956LFS_TRACE ( "lfs_file_seek(%p, %p, %" PRId32 ", %d)" , ( void * ) lfs , ( void * ) file , 2957off , whence ); 2958LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2959 2960// write out everything beforehand, may be noop if rdonly 2961int err = lfs_file_flush ( lfs , file ); 2962if ( err ) { 2963LFS_TRACE ( "lfs_file_seek -> %d" , err ); 2964return err ; 2965} 2966 2967// find new pos 2968lfs_off_t npos = file -> pos ; 2969if ( whence == LFS_SEEK_SET ) { 2970npos = off ; 2971} else if ( whence == LFS_SEEK_CUR ) { 2972npos = file -> pos + off ; 2973} else if ( whence == LFS_SEEK_END ) { 2974npos = file -> ctz . size + off ; 2975} 2976 2977if ( npos > lfs -> file_max ) { 2978// file position out of range 2979LFS_TRACE ( "lfs_file_seek -> %d" , LFS_ERR_INVAL ); 2980return LFS_ERR_INVAL ; 2981} 2982 2983// update pos 2984file -> pos = npos ; 2985LFS_TRACE ( "lfs_file_seek -> %" PRId32 , npos ); 2986return npos ; 2987} 2988 2989int lfs_file_truncate ( lfs_t * lfs , lfs_file_t * file , lfs_off_t size ) { 2990LFS_TRACE ( "lfs_file_truncate(%p, %p, %" PRIu32 ")" , ( void * ) lfs , ( void * ) file , 2991size ); 2992LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 2993LFS_ASSERT (( file -> flags & 3 ) != LFS_O_RDONLY ); 2994 2995if ( size > LFS_FILE_MAX ) { 2996LFS_TRACE ( "lfs_file_truncate -> %d" , LFS_ERR_INVAL ); 2997return LFS_ERR_INVAL ; 2998} 2999 3000lfs_off_t pos = file -> pos ; 3001lfs_off_t oldsize = lfs_file_size ( lfs , file ); 3002if ( size < oldsize ) { 3003// need to flush since directly changing metadata 3004int err = lfs_file_flush ( lfs , file ); 3005if ( err ) { 3006LFS_TRACE ( "lfs_file_truncate -> %d" , err ); 3007return err ; 3008} 3009 3010// lookup new head in ctz skip list 3011err = lfs_ctz_find ( lfs , NULL , & file -> cache , file -> ctz . head , 3012file -> ctz . size , size , & file -> block , & file -> off ); 3013if ( err ) { 3014LFS_TRACE ( "lfs_file_truncate -> %d" , err ); 3015return err ; 3016} 3017 3018file -> ctz . head = file -> block ; 3019file -> ctz . size = size ; 3020file -> flags |= LFS_F_DIRTY | LFS_F_READING ; 3021} else if ( size > oldsize ) { 3022// flush+seek if not already at end 3023if ( file -> pos != oldsize ) { 3024lfs_soff_t res = lfs_file_seek ( lfs , file , 0 , LFS_SEEK_END ); 3025if ( res < 0 ) { 3026LFS_TRACE ( "lfs_file_truncate -> %" PRId32 , res ); 3027return ( int ) res ; 3028} 3029} 3030 3031// fill with zeros 3032while ( file -> pos < size ) { 3033lfs_ssize_t res = lfs_file_write ( lfs , file , & ( uint8_t ){ 0 }, 1 ); 3034if ( res < 0 ) { 3035LFS_TRACE ( "lfs_file_truncate -> %" PRId32 , res ); 3036return ( int ) res ; 3037} 3038} 3039} 3040 3041// restore pos 3042lfs_soff_t res = lfs_file_seek ( lfs , file , pos , LFS_SEEK_SET ); 3043if ( res < 0 ) { 3044LFS_TRACE ( "lfs_file_truncate -> %" PRId32 , res ); 3045return ( int ) res ; 3046} 3047 3048LFS_TRACE ( "lfs_file_truncate -> %d" , 0 ); 3049return 0 ; 3050} 3051 3052lfs_soff_t lfs_file_tell ( lfs_t * lfs , lfs_file_t * file ) { 3053LFS_TRACE ( "lfs_file_tell(%p, %p)" , ( void * ) lfs , ( void * ) file ); 3054LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 3055( void ) lfs ; 3056LFS_TRACE ( "lfs_file_tell -> %" PRId32 , file -> pos ); 3057return file -> pos ; 3058} 3059 3060int lfs_file_rewind ( lfs_t * lfs , lfs_file_t * file ) { 3061LFS_TRACE ( "lfs_file_rewind(%p, %p)" , ( void * ) lfs , ( void * ) file ); 3062lfs_soff_t res = lfs_file_seek ( lfs , file , 0 , LFS_SEEK_SET ); 3063if ( res < 0 ) { 3064LFS_TRACE ( "lfs_file_rewind -> %" PRId32 , res ); 3065return ( int ) res ; 3066} 3067 3068LFS_TRACE ( "lfs_file_rewind -> %d" , 0 ); 3069return 0 ; 3070} 3071 3072lfs_soff_t lfs_file_size ( lfs_t * lfs , lfs_file_t * file ) { 3073LFS_TRACE ( "lfs_file_size(%p, %p)" , ( void * ) lfs , ( void * ) file ); 3074LFS_ASSERT ( file -> flags & LFS_F_OPENED ); 3075( void ) lfs ; 3076if ( file -> flags & LFS_F_WRITING ) { 3077LFS_TRACE ( "lfs_file_size -> %" PRId32 , 3078lfs_max ( file -> pos , file -> ctz . size )); 3079return lfs_max ( file -> pos , file -> ctz . size ); 3080} else { 3081LFS_TRACE ( "lfs_file_size -> %" PRId32 , file -> ctz . size ); 3082return file -> ctz . size ; 3083} 3084} 3085 3086/// General fs operations /// 3087int lfs_stat ( lfs_t * lfs , const char * path , struct lfs_info * info ) { 3088LFS_TRACE ( "lfs_stat(%p, \"%s\", %p)" , ( void * ) lfs , path , ( void * ) info ); 3089lfs_mdir_t cwd ; 3090lfs_stag_t tag = lfs_dir_find ( lfs , & cwd , & path , NULL ); 3091if ( tag < 0 ) { 3092LFS_TRACE ( "lfs_stat -> %" PRId32 , tag ); 3093return ( int ) tag ; 3094} 3095 3096int err = lfs_dir_getinfo ( lfs , & cwd , lfs_tag_id ( tag ), info ); 3097LFS_TRACE ( "lfs_stat -> %d" , err ); 3098return err ; 3099} 3100 3101int lfs_remove ( lfs_t * lfs , const char * path ) { 3102LFS_TRACE ( "lfs_remove(%p, \"%s\")" , ( void * ) lfs , path ); 3103// deorphan if we haven't yet, needed at most once after poweron 3104int err = lfs_fs_forceconsistency ( lfs ); 3105if ( err ) { 3106LFS_TRACE ( "lfs_remove -> %d" , err ); 3107return err ; 3108} 3109 3110lfs_mdir_t cwd ; 3111lfs_stag_t tag = lfs_dir_find ( lfs , & cwd , & path , NULL ); 3112if ( tag < 0 || lfs_tag_id ( tag ) == 0x3ff ) { 3113LFS_TRACE ( "lfs_remove -> %" PRId32 , ( tag < 0 ) ? tag : LFS_ERR_INVAL ); 3114return ( tag < 0 ) ? ( int ) tag : LFS_ERR_INVAL ; 3115} 3116 3117struct lfs_mlist dir ; 3118dir . next = lfs -> mlist ; 3119if ( lfs_tag_type3 ( tag ) == LFS_TYPE_DIR ) { 3120// must be empty before removal 3121lfs_block_t pair [ 2 ]; 3122lfs_stag_t res = 3123lfs_dir_get ( lfs , & cwd , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 3124LFS_MKTAG ( LFS_TYPE_STRUCT , lfs_tag_id ( tag ), 8 ), pair ); 3125if ( res < 0 ) { 3126LFS_TRACE ( "lfs_remove -> %" PRId32 , res ); 3127return ( int ) res ; 3128} 3129lfs_pair_fromle32 ( pair ); 3130 3131err = lfs_dir_fetch ( lfs , & dir . m , pair ); 3132if ( err ) { 3133LFS_TRACE ( "lfs_remove -> %d" , err ); 3134return err ; 3135} 3136 3137if ( dir . m . count > 0 || dir . m . split ) { 3138LFS_TRACE ( "lfs_remove -> %d" , LFS_ERR_NOTEMPTY ); 3139return LFS_ERR_NOTEMPTY ; 3140} 3141 3142// mark fs as orphaned 3143lfs_fs_preporphans ( lfs , +1 ); 3144 3145// I know it's crazy but yes, dir can be changed by our parent's 3146// commit (if predecessor is child) 3147dir . type = 0 ; 3148dir . id = 0 ; 3149lfs -> mlist = & dir ; 3150} 3151 3152// delete the entry 3153err = lfs_dir_commit ( 3154lfs , & cwd , 3155LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_DELETE , lfs_tag_id ( tag ), 0 ), NULL })); 3156if ( err ) { 3157lfs -> mlist = dir . next ; 3158LFS_TRACE ( "lfs_remove -> %d" , err ); 3159return err ; 3160} 3161 3162lfs -> mlist = dir . next ; 3163if ( lfs_tag_type3 ( tag ) == LFS_TYPE_DIR ) { 3164// fix orphan 3165lfs_fs_preporphans ( lfs , -1 ); 3166 3167err = lfs_fs_pred ( lfs , dir . m . pair , & cwd ); 3168if ( err ) { 3169LFS_TRACE ( "lfs_remove -> %d" , err ); 3170return err ; 3171} 3172 3173err = lfs_dir_drop ( lfs , & cwd , & dir . m ); 3174if ( err ) { 3175LFS_TRACE ( "lfs_remove -> %d" , err ); 3176return err ; 3177} 3178} 3179 3180LFS_TRACE ( "lfs_remove -> %d" , 0 ); 3181return 0 ; 3182} 3183 3184int lfs_rename ( lfs_t * lfs , const char * oldpath , const char * newpath ) { 3185LFS_TRACE ( "lfs_rename(%p, \"%s\", \"%s\")" , ( void * ) lfs , oldpath , newpath ); 3186 3187// deorphan if we haven't yet, needed at most once after poweron 3188int err = lfs_fs_forceconsistency ( lfs ); 3189if ( err ) { 3190LFS_TRACE ( "lfs_rename -> %d" , err ); 3191return err ; 3192} 3193 3194// find old entry 3195lfs_mdir_t oldcwd ; 3196lfs_stag_t oldtag = lfs_dir_find ( lfs , & oldcwd , & oldpath , NULL ); 3197if ( oldtag < 0 || lfs_tag_id ( oldtag ) == 0x3ff ) { 3198LFS_TRACE ( "lfs_rename -> %" PRId32 , 3199( oldtag < 0 ) ? oldtag : LFS_ERR_INVAL ); 3200return ( oldtag < 0 ) ? ( int ) oldtag : LFS_ERR_INVAL ; 3201} 3202 3203// find new entry 3204lfs_mdir_t newcwd ; 3205uint16_t newid ; 3206lfs_stag_t prevtag = lfs_dir_find ( lfs , & newcwd , & newpath , & newid ); 3207if (( prevtag < 0 || lfs_tag_id ( prevtag ) == 0x3ff ) && 3208!( prevtag == LFS_ERR_NOENT && newid != 0x3ff )) { 3209LFS_TRACE ( "lfs_rename -> %" PRId32 , 3210( prevtag < 0 ) ? prevtag : LFS_ERR_INVAL ); 3211return ( prevtag < 0 ) ? ( int ) prevtag : LFS_ERR_INVAL ; 3212} 3213 3214// if we're in the same pair there's a few special cases... 3215bool samepair = ( lfs_pair_cmp ( oldcwd . pair , newcwd . pair ) == 0 ); 3216uint16_t newoldid = lfs_tag_id ( oldtag ); 3217 3218struct lfs_mlist prevdir ; 3219prevdir . next = lfs -> mlist ; 3220if ( prevtag == LFS_ERR_NOENT ) { 3221// check that name fits 3222lfs_size_t nlen = strlen ( newpath ); 3223if ( nlen > lfs -> name_max ) { 3224LFS_TRACE ( "lfs_rename -> %d" , LFS_ERR_NAMETOOLONG ); 3225return LFS_ERR_NAMETOOLONG ; 3226} 3227 3228// there is a small chance we are being renamed in the same 3229// directory/ to an id less than our old id, the global update 3230// to handle this is a bit messy 3231if ( samepair && newid <= newoldid ) { 3232newoldid += 1 ; 3233} 3234} else if ( lfs_tag_type3 ( prevtag ) != lfs_tag_type3 ( oldtag )) { 3235LFS_TRACE ( "lfs_rename -> %d" , LFS_ERR_ISDIR ); 3236return LFS_ERR_ISDIR ; 3237} else if ( samepair && newid == newoldid ) { 3238// we're renaming to ourselves?? 3239LFS_TRACE ( "lfs_rename -> %d" , 0 ); 3240return 0 ; 3241} else if ( lfs_tag_type3 ( prevtag ) == LFS_TYPE_DIR ) { 3242// must be empty before removal 3243lfs_block_t prevpair [ 2 ]; 3244lfs_stag_t res = 3245lfs_dir_get ( lfs , & newcwd , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 3246LFS_MKTAG ( LFS_TYPE_STRUCT , newid , 8 ), prevpair ); 3247if ( res < 0 ) { 3248LFS_TRACE ( "lfs_rename -> %" PRId32 , res ); 3249return ( int ) res ; 3250} 3251lfs_pair_fromle32 ( prevpair ); 3252 3253// must be empty before removal 3254err = lfs_dir_fetch ( lfs , & prevdir . m , prevpair ); 3255if ( err ) { 3256LFS_TRACE ( "lfs_rename -> %d" , err ); 3257return err ; 3258} 3259 3260if ( prevdir . m . count > 0 || prevdir . m . split ) { 3261LFS_TRACE ( "lfs_rename -> %d" , LFS_ERR_NOTEMPTY ); 3262return LFS_ERR_NOTEMPTY ; 3263} 3264 3265// mark fs as orphaned 3266lfs_fs_preporphans ( lfs , +1 ); 3267 3268// I know it's crazy but yes, dir can be changed by our parent's 3269// commit (if predecessor is child) 3270prevdir . type = 0 ; 3271prevdir . id = 0 ; 3272lfs -> mlist = & prevdir ; 3273} 3274 3275if (! samepair ) { 3276lfs_fs_prepmove ( lfs , newoldid , oldcwd . pair ); 3277} 3278 3279// move over all attributes 3280err = lfs_dir_commit ( 3281lfs , & newcwd , 3282LFS_MKATTRS ( 3283{ LFS_MKTAG_IF ( prevtag != LFS_ERR_NOENT , LFS_TYPE_DELETE , newid , 0 ), 3284NULL }, 3285{ LFS_MKTAG ( LFS_TYPE_CREATE , newid , 0 ), NULL }, 3286{ LFS_MKTAG ( lfs_tag_type3 ( oldtag ), newid , strlen ( newpath )), newpath }, 3287{ LFS_MKTAG ( LFS_FROM_MOVE , newid , lfs_tag_id ( oldtag )), & oldcwd }, 3288{ LFS_MKTAG_IF ( samepair , LFS_TYPE_DELETE , newoldid , 0 ), NULL })); 3289if ( err ) { 3290lfs -> mlist = prevdir . next ; 3291LFS_TRACE ( "lfs_rename -> %d" , err ); 3292return err ; 3293} 3294 3295// let commit clean up after move (if we're different! otherwise move 3296// logic already fixed it for us) 3297if (! samepair && lfs_gstate_hasmove ( & lfs -> gstate )) { 3298// prep gstate and delete move id 3299lfs_fs_prepmove ( lfs , 0x3ff , NULL ); 3300err = lfs_dir_commit ( 3301lfs , & oldcwd , 3302LFS_MKATTRS ( 3303{ LFS_MKTAG ( LFS_TYPE_DELETE , lfs_tag_id ( oldtag ), 0 ), NULL })); 3304if ( err ) { 3305lfs -> mlist = prevdir . next ; 3306LFS_TRACE ( "lfs_rename -> %d" , err ); 3307return err ; 3308} 3309} 3310 3311lfs -> mlist = prevdir . next ; 3312if ( prevtag != LFS_ERR_NOENT && lfs_tag_type3 ( prevtag ) == LFS_TYPE_DIR ) { 3313// fix orphan 3314lfs_fs_preporphans ( lfs , -1 ); 3315 3316err = lfs_fs_pred ( lfs , prevdir . m . pair , & newcwd ); 3317if ( err ) { 3318LFS_TRACE ( "lfs_rename -> %d" , err ); 3319return err ; 3320} 3321 3322err = lfs_dir_drop ( lfs , & newcwd , & prevdir . m ); 3323if ( err ) { 3324LFS_TRACE ( "lfs_rename -> %d" , err ); 3325return err ; 3326} 3327} 3328 3329LFS_TRACE ( "lfs_rename -> %d" , 0 ); 3330return 0 ; 3331} 3332 3333lfs_ssize_t lfs_getattr ( lfs_t * lfs , const char * path , uint8_t type , 3334void * buffer , lfs_size_t size ) { 3335LFS_TRACE ( "lfs_getattr(%p, \"%s\", %" PRIu8 ", %p, %" PRIu32 ")" , 3336( void * ) lfs , path , type , buffer , size ); 3337lfs_mdir_t cwd ; 3338lfs_stag_t tag = lfs_dir_find ( lfs , & cwd , & path , NULL ); 3339if ( tag < 0 ) { 3340LFS_TRACE ( "lfs_getattr -> %" PRId32 , tag ); 3341return tag ; 3342} 3343 3344uint16_t id = lfs_tag_id ( tag ); 3345if ( id == 0x3ff ) { 3346// special case for root 3347id = 0 ; 3348int err = lfs_dir_fetch ( lfs , & cwd , lfs -> root ); 3349if ( err ) { 3350LFS_TRACE ( "lfs_getattr -> %d" , err ); 3351return err ; 3352} 3353} 3354 3355tag = lfs_dir_get ( 3356lfs , & cwd , LFS_MKTAG ( 0x7ff , 0x3ff , 0 ), 3357LFS_MKTAG ( LFS_TYPE_USERATTR + type , id , lfs_min ( size , lfs -> attr_max )), 3358buffer ); 3359if ( tag < 0 ) { 3360if ( tag == LFS_ERR_NOENT ) { 3361LFS_TRACE ( "lfs_getattr -> %d" , LFS_ERR_NOATTR ); 3362return LFS_ERR_NOATTR ; 3363} 3364 3365LFS_TRACE ( "lfs_getattr -> %" PRId32 , tag ); 3366return tag ; 3367} 3368 3369size = lfs_tag_size ( tag ); 3370LFS_TRACE ( "lfs_getattr -> %" PRId32 , size ); 3371return size ; 3372} 3373 3374static int lfs_commitattr ( lfs_t * lfs , const char * path , uint8_t type , 3375const void * buffer , lfs_size_t size ) { 3376lfs_mdir_t cwd ; 3377lfs_stag_t tag = lfs_dir_find ( lfs , & cwd , & path , NULL ); 3378if ( tag < 0 ) { 3379return tag ; 3380} 3381 3382uint16_t id = lfs_tag_id ( tag ); 3383if ( id == 0x3ff ) { 3384// special case for root 3385id = 0 ; 3386int err = lfs_dir_fetch ( lfs , & cwd , lfs -> root ); 3387if ( err ) { 3388return err ; 3389} 3390} 3391 3392return lfs_dir_commit ( 3393lfs , & cwd , 3394LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_USERATTR + type , id , size ), buffer })); 3395} 3396 3397int lfs_setattr ( lfs_t * lfs , const char * path , uint8_t type , const void * buffer , 3398lfs_size_t size ) { 3399LFS_TRACE ( "lfs_setattr(%p, \"%s\", %" PRIu8 ", %p, %" PRIu32 ")" , 3400( void * ) lfs , path , type , buffer , size ); 3401if ( size > lfs -> attr_max ) { 3402LFS_TRACE ( "lfs_setattr -> %d" , LFS_ERR_NOSPC ); 3403return LFS_ERR_NOSPC ; 3404} 3405 3406int err = lfs_commitattr ( lfs , path , type , buffer , size ); 3407LFS_TRACE ( "lfs_setattr -> %d" , err ); 3408return err ; 3409} 3410 3411int lfs_removeattr ( lfs_t * lfs , const char * path , uint8_t type ) { 3412LFS_TRACE ( "lfs_removeattr(%p, \"%s\", %" PRIu8 ")" , ( void * ) lfs , path , type ); 3413int err = lfs_commitattr ( lfs , path , type , NULL , 0x3ff ); 3414LFS_TRACE ( "lfs_removeattr -> %d" , err ); 3415return err ; 3416} 3417 3418/// Filesystem operations /// 3419static int lfs_init ( lfs_t * lfs , const struct lfs_config * cfg ) { 3420lfs -> cfg = cfg ; 3421int err = 0 ; 3422 3423// validate that the lfs-cfg sizes were initiated properly before 3424// performing any arithmetic logics with them 3425LFS_ASSERT ( lfs -> cfg -> read_size != 0 ); 3426LFS_ASSERT ( lfs -> cfg -> prog_size != 0 ); 3427LFS_ASSERT ( lfs -> cfg -> cache_size != 0 ); 3428 3429// check that block size is a multiple of cache size is a multiple 3430// of prog and read sizes 3431LFS_ASSERT ( lfs -> cfg -> cache_size % lfs -> cfg -> read_size == 0 ); 3432LFS_ASSERT ( lfs -> cfg -> cache_size % lfs -> cfg -> prog_size == 0 ); 3433LFS_ASSERT ( lfs -> cfg -> block_size % lfs -> cfg -> cache_size == 0 ); 3434 3435// check that the block size is large enough to fit ctz pointers 3436LFS_ASSERT ( 4 * lfs_npw2 ( 0xffffffff / ( lfs -> cfg -> block_size - 2 * 4 )) <= 3437lfs -> cfg -> block_size ); 3438 3439// block_cycles = 0 is no longer supported. 3440// 3441// block_cycles is the number of erase cycles before littlefs evicts 3442// metadata logs as a part of wear leveling. Suggested values are in the 3443// range of 100-1000, or set block_cycles to -1 to disable block-level 3444// wear-leveling. 3445LFS_ASSERT ( lfs -> cfg -> block_cycles != 0 ); 3446 3447// setup read cache 3448if ( lfs -> cfg -> read_buffer ) { 3449lfs -> rcache . buffer = lfs -> cfg -> read_buffer ; 3450} else { 3451lfs -> rcache . buffer = lfs_malloc ( lfs -> cfg -> cache_size ); 3452if (! lfs -> rcache . buffer ) { 3453err = LFS_ERR_NOMEM ; 3454goto cleanup ; 3455} 3456} 3457 3458// setup program cache 3459if ( lfs -> cfg -> prog_buffer ) { 3460lfs -> pcache . buffer = lfs -> cfg -> prog_buffer ; 3461} else { 3462lfs -> pcache . buffer = lfs_malloc ( lfs -> cfg -> cache_size ); 3463if (! lfs -> pcache . buffer ) { 3464err = LFS_ERR_NOMEM ; 3465goto cleanup ; 3466} 3467} 3468 3469// zero to avoid information leaks 3470lfs_cache_zero ( lfs , & lfs -> rcache ); 3471lfs_cache_zero ( lfs , & lfs -> pcache ); 3472 3473// setup lookahead, must be multiple of 64-bits, 32-bit aligned 3474LFS_ASSERT ( lfs -> cfg -> lookahead_size > 0 ); 3475LFS_ASSERT ( lfs -> cfg -> lookahead_size % 8 == 0 && 3476( uintptr_t ) lfs -> cfg -> lookahead_buffer % 4 == 0 ); 3477if ( lfs -> cfg -> lookahead_buffer ) { 3478lfs -> free . buffer = lfs -> cfg -> lookahead_buffer ; 3479} else { 3480lfs -> free . buffer = lfs_malloc ( lfs -> cfg -> lookahead_size ); 3481if (! lfs -> free . buffer ) { 3482err = LFS_ERR_NOMEM ; 3483goto cleanup ; 3484} 3485} 3486 3487// check that the size limits are sane 3488LFS_ASSERT ( lfs -> cfg -> name_max <= LFS_NAME_MAX ); 3489lfs -> name_max = lfs -> cfg -> name_max ; 3490if (! lfs -> name_max ) { 3491lfs -> name_max = LFS_NAME_MAX ; 3492} 3493 3494LFS_ASSERT ( lfs -> cfg -> file_max <= LFS_FILE_MAX ); 3495lfs -> file_max = lfs -> cfg -> file_max ; 3496if (! lfs -> file_max ) { 3497lfs -> file_max = LFS_FILE_MAX ; 3498} 3499 3500LFS_ASSERT ( lfs -> cfg -> attr_max <= LFS_ATTR_MAX ); 3501lfs -> attr_max = lfs -> cfg -> attr_max ; 3502if (! lfs -> attr_max ) { 3503lfs -> attr_max = LFS_ATTR_MAX ; 3504} 3505 3506// setup default state 3507lfs -> root [ 0 ] = LFS_BLOCK_NULL ; 3508lfs -> root [ 1 ] = LFS_BLOCK_NULL ; 3509lfs -> mlist = NULL ; 3510lfs -> seed = 0 ; 3511lfs -> gdisk = ( lfs_gstate_t ){ 0 }; 3512lfs -> gstate = ( lfs_gstate_t ){ 0 }; 3513lfs -> gdelta = ( lfs_gstate_t ){ 0 }; 3514#ifdef LFS_MIGRATE 3515lfs -> lfs1 = NULL ; 3516#endif 3517 3518return 0 ; 3519 3520cleanup : 3521lfs_deinit ( lfs ); 3522return err ; 3523} 3524 3525static int lfs_deinit ( lfs_t * lfs ) { 3526// free allocated memory 3527if (! lfs -> cfg -> read_buffer ) { 3528lfs_free ( lfs -> rcache . buffer ); 3529} 3530 3531if (! lfs -> cfg -> prog_buffer ) { 3532lfs_free ( lfs -> pcache . buffer ); 3533} 3534 3535if (! lfs -> cfg -> lookahead_buffer ) { 3536lfs_free ( lfs -> free . buffer ); 3537} 3538 3539return 0 ; 3540} 3541 3542int lfs_format ( lfs_t * lfs , const struct lfs_config * cfg ) { 3543LFS_TRACE ( "lfs_format(%p, %p {.context=%p, " 3544".read=%p, .prog=%p, .erase=%p, .sync=%p, " 3545".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", " 3546".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", " 3547".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", " 3548".lookahead_size=%" PRIu32 ", .read_buffer=%p, " 3549".prog_buffer=%p, .lookahead_buffer=%p, " 3550".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", " 3551".attr_max=%" PRIu32 "})" , 3552( void * ) lfs , ( void * ) cfg , cfg -> context , ( void * )( uintptr_t ) cfg -> read , 3553( void * )( uintptr_t ) cfg -> prog , ( void * )( uintptr_t ) cfg -> erase , 3554( void * )( uintptr_t ) cfg -> sync , cfg -> read_size , cfg -> prog_size , 3555cfg -> block_size , cfg -> block_count , cfg -> block_cycles , 3556cfg -> cache_size , cfg -> lookahead_size , cfg -> read_buffer , 3557cfg -> prog_buffer , cfg -> lookahead_buffer , cfg -> name_max , 3558cfg -> file_max , cfg -> attr_max ); 3559int err = 0 ; 3560{ 3561err = lfs_init ( lfs , cfg ); 3562if ( err ) { 3563LFS_TRACE ( "lfs_format -> %d" , err ); 3564return err ; 3565} 3566 3567// create free lookahead 3568memset ( lfs -> free . buffer , 0 , lfs -> cfg -> lookahead_size ); 3569lfs -> free . off = 0 ; 3570lfs -> free . size = 3571lfs_min ( 8 * lfs -> cfg -> lookahead_size , lfs -> cfg -> block_count ); 3572lfs -> free . i = 0 ; 3573lfs_alloc_ack ( lfs ); 3574 3575// create root dir 3576lfs_mdir_t root ; 3577err = lfs_dir_alloc ( lfs , & root ); 3578if ( err ) { 3579goto cleanup ; 3580} 3581 3582// write one superblock 3583lfs_superblock_t superblock = { 3584. version = LFS_DISK_VERSION , 3585. block_size = lfs -> cfg -> block_size , 3586. block_count = lfs -> cfg -> block_count , 3587. name_max = lfs -> name_max , 3588. file_max = lfs -> file_max , 3589. attr_max = lfs -> attr_max , 3590}; 3591 3592lfs_superblock_tole32 ( & superblock ); 3593err = lfs_dir_commit ( 3594lfs , & root , 3595LFS_MKATTRS ( 3596{ LFS_MKTAG ( LFS_TYPE_CREATE , 0 , 0 ), NULL }, 3597{ LFS_MKTAG ( LFS_TYPE_SUPERBLOCK , 0 , 8 ), "littlefs" }, 3598{ LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , 0 , sizeof( superblock )), 3599& superblock })); 3600if ( err ) { 3601goto cleanup ; 3602} 3603 3604// sanity check that fetch works 3605err = lfs_dir_fetch ( lfs , & root , (const lfs_block_t [ 2 ]){ 0 , 1 }); 3606if ( err ) { 3607goto cleanup ; 3608} 3609 3610// force compaction to prevent accidentally mounting any 3611// older version of littlefs that may live on disk 3612root . erased = false; 3613err = lfs_dir_commit ( lfs , & root , NULL , 0 ); 3614if ( err ) { 3615goto cleanup ; 3616} 3617} 3618 3619cleanup : 3620lfs_deinit ( lfs ); 3621LFS_TRACE ( "lfs_format -> %d" , err ); 3622return err ; 3623} 3624 3625int lfs_mount ( lfs_t * lfs , const struct lfs_config * cfg ) { 3626LFS_TRACE ( "lfs_mount(%p, %p {.context=%p, " 3627".read=%p, .prog=%p, .erase=%p, .sync=%p, " 3628".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", " 3629".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", " 3630".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", " 3631".lookahead_size=%" PRIu32 ", .read_buffer=%p, " 3632".prog_buffer=%p, .lookahead_buffer=%p, " 3633".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", " 3634".attr_max=%" PRIu32 "})" , 3635( void * ) lfs , ( void * ) cfg , cfg -> context , ( void * )( uintptr_t ) cfg -> read , 3636( void * )( uintptr_t ) cfg -> prog , ( void * )( uintptr_t ) cfg -> erase , 3637( void * )( uintptr_t ) cfg -> sync , cfg -> read_size , cfg -> prog_size , 3638cfg -> block_size , cfg -> block_count , cfg -> block_cycles , 3639cfg -> cache_size , cfg -> lookahead_size , cfg -> read_buffer , 3640cfg -> prog_buffer , cfg -> lookahead_buffer , cfg -> name_max , 3641cfg -> file_max , cfg -> attr_max ); 3642int err = lfs_init ( lfs , cfg ); 3643if ( err ) { 3644LFS_TRACE ( "lfs_mount -> %d" , err ); 3645return err ; 3646} 3647 3648// scan directory blocks for superblock and any global updates 3649lfs_mdir_t dir = {. tail = { 0 , 1 }}; 3650lfs_block_t cycle = 0 ; 3651while (! lfs_pair_isnull ( dir . tail )) { 3652if ( cycle >= lfs -> cfg -> block_count / 2 ) { 3653// loop detected 3654err = LFS_ERR_CORRUPT ; 3655goto cleanup ; 3656} 3657cycle += 1 ; 3658 3659// fetch next block in tail list 3660lfs_stag_t tag = lfs_dir_fetchmatch ( 3661lfs , & dir , dir . tail , LFS_MKTAG ( 0x7ff , 0x3ff , 0 ), 3662LFS_MKTAG ( LFS_TYPE_SUPERBLOCK , 0 , 8 ), NULL , lfs_dir_find_match , 3663& (struct lfs_dir_find_match ){ lfs , "littlefs" , 8 }); 3664if ( tag < 0 ) { 3665err = tag ; 3666goto cleanup ; 3667} 3668 3669// has superblock? 3670if ( tag && ! lfs_tag_isdelete ( tag )) { 3671// update root 3672lfs -> root [ 0 ] = dir . pair [ 0 ]; 3673lfs -> root [ 1 ] = dir . pair [ 1 ]; 3674 3675// grab superblock 3676lfs_superblock_t superblock ; 3677tag = lfs_dir_get ( 3678lfs , & dir , LFS_MKTAG ( 0x7ff , 0x3ff , 0 ), 3679LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , 0 , sizeof( superblock )), 3680& superblock ); 3681if ( tag < 0 ) { 3682err = tag ; 3683goto cleanup ; 3684} 3685lfs_superblock_fromle32 ( & superblock ); 3686 3687// check version 3688uint16_t major_version = ( 0xffff & ( superblock . version >> 16 )); 3689uint16_t minor_version = ( 0xffff & ( superblock . version >> 0 )); 3690if (( major_version != LFS_DISK_VERSION_MAJOR || 3691minor_version > LFS_DISK_VERSION_MINOR )) { 3692LFS_ERROR ( "Invalid version v%" PRIu16 ".%" PRIu16 , 3693major_version , minor_version ); 3694err = LFS_ERR_INVAL ; 3695goto cleanup ; 3696} 3697 3698// check superblock configuration 3699if ( superblock . name_max ) { 3700if ( superblock . name_max > lfs -> name_max ) { 3701LFS_ERROR ( "Unsupported name_max (%" PRIu32 " > %" PRIu32 3702")" , 3703superblock . name_max , lfs -> name_max ); 3704err = LFS_ERR_INVAL ; 3705goto cleanup ; 3706} 3707 3708lfs -> name_max = superblock . name_max ; 3709} 3710 3711if ( superblock . file_max ) { 3712if ( superblock . file_max > lfs -> file_max ) { 3713LFS_ERROR ( "Unsupported file_max (%" PRIu32 " > %" PRIu32 3714")" , 3715superblock . file_max , lfs -> file_max ); 3716err = LFS_ERR_INVAL ; 3717goto cleanup ; 3718} 3719 3720lfs -> file_max = superblock . file_max ; 3721} 3722 3723if ( superblock . attr_max ) { 3724if ( superblock . attr_max > lfs -> attr_max ) { 3725LFS_ERROR ( "Unsupported attr_max (%" PRIu32 " > %" PRIu32 3726")" , 3727superblock . attr_max , lfs -> attr_max ); 3728err = LFS_ERR_INVAL ; 3729goto cleanup ; 3730} 3731 3732lfs -> attr_max = superblock . attr_max ; 3733} 3734} 3735 3736// has gstate? 3737err = lfs_dir_getgstate ( lfs , & dir , & lfs -> gstate ); 3738if ( err ) { 3739goto cleanup ; 3740} 3741} 3742 3743// found superblock? 3744if ( lfs_pair_isnull ( lfs -> root )) { 3745err = LFS_ERR_INVAL ; 3746goto cleanup ; 3747} 3748 3749// update littlefs with gstate 3750if (! lfs_gstate_iszero ( & lfs -> gstate )) { 3751LFS_DEBUG ( "Found pending gstate 0x%08" PRIx32 "%08" PRIx32 "%08" PRIx32 , 3752lfs -> gstate . tag , lfs -> gstate . pair [ 0 ], lfs -> gstate . pair [ 1 ]); 3753} 3754lfs -> gstate . tag += ! lfs_tag_isvalid ( lfs -> gstate . tag ); 3755lfs -> gdisk = lfs -> gstate ; 3756 3757// setup free lookahead 3758lfs_alloc_reset ( lfs ); 3759 3760LFS_TRACE ( "lfs_mount -> %d" , 0 ); 3761return 0 ; 3762 3763cleanup : 3764lfs_unmount ( lfs ); 3765LFS_TRACE ( "lfs_mount -> %d" , err ); 3766return err ; 3767} 3768 3769int lfs_unmount ( lfs_t * lfs ) { 3770LFS_TRACE ( "lfs_unmount(%p)" , ( void * ) lfs ); 3771int err = lfs_deinit ( lfs ); 3772LFS_TRACE ( "lfs_unmount -> %d" , err ); 3773return err ; 3774} 3775 3776/// Filesystem filesystem operations /// 3777int lfs_fs_traverseraw ( lfs_t * lfs , int ( * cb )( void * data , lfs_block_t block ), 3778void * data , bool includeorphans ) { 3779// iterate over metadata pairs 3780lfs_mdir_t dir = {. tail = { 0 , 1 }}; 3781 3782#ifdef LFS_MIGRATE 3783// also consider v1 blocks during migration 3784if ( lfs -> lfs1 ) { 3785int err = lfs1_traverse ( lfs , cb , data ); 3786if ( err ) { 3787return err ; 3788} 3789 3790dir . tail [ 0 ] = lfs -> root [ 0 ]; 3791dir . tail [ 1 ] = lfs -> root [ 1 ]; 3792} 3793#endif 3794 3795lfs_block_t cycle = 0 ; 3796while (! lfs_pair_isnull ( dir . tail )) { 3797if ( cycle >= lfs -> cfg -> block_count / 2 ) { 3798// loop detected 3799return LFS_ERR_CORRUPT ; 3800} 3801cycle += 1 ; 3802 3803for ( int i = 0 ; i < 2 ; i ++ ) { 3804int err = cb ( data , dir . tail [ i ]); 3805if ( err ) { 3806return err ; 3807} 3808} 3809 3810// iterate through ids in directory 3811int err = lfs_dir_fetch ( lfs , & dir , dir . tail ); 3812if ( err ) { 3813return err ; 3814} 3815 3816for ( uint16_t id = 0 ; id < dir . count ; id ++ ) { 3817struct lfs_ctz ctz ; 3818lfs_stag_t tag = 3819lfs_dir_get ( lfs , & dir , LFS_MKTAG ( 0x700 , 0x3ff , 0 ), 3820LFS_MKTAG ( LFS_TYPE_STRUCT , id , sizeof( ctz )), & ctz ); 3821if ( tag < 0 ) { 3822if ( tag == LFS_ERR_NOENT ) { 3823continue; 3824} 3825return tag ; 3826} 3827lfs_ctz_fromle32 ( & ctz ); 3828 3829if ( lfs_tag_type3 ( tag ) == LFS_TYPE_CTZSTRUCT ) { 3830err = lfs_ctz_traverse ( lfs , NULL , & lfs -> rcache , ctz . head , 3831ctz . size , cb , data ); 3832if ( err ) { 3833return err ; 3834} 3835} else if ( includeorphans && 3836lfs_tag_type3 ( tag ) == LFS_TYPE_DIRSTRUCT ) { 3837for ( int i = 0 ; i < 2 ; i ++ ) { 3838err = cb ( data , ( & ctz . head )[ i ]); 3839if ( err ) { 3840return err ; 3841} 3842} 3843} 3844} 3845} 3846 3847// iterate over any open files 3848for ( lfs_file_t * f = ( lfs_file_t * ) lfs -> mlist ; f ; f = f -> next ) { 3849if ( f -> type != LFS_TYPE_REG ) { 3850continue; 3851} 3852 3853if (( f -> flags & LFS_F_DIRTY ) && !( f -> flags & LFS_F_INLINE )) { 3854int err = lfs_ctz_traverse ( lfs , & f -> cache , & lfs -> rcache , 3855f -> ctz . head , f -> ctz . size , cb , data ); 3856if ( err ) { 3857return err ; 3858} 3859} 3860 3861if (( f -> flags & LFS_F_WRITING ) && !( f -> flags & LFS_F_INLINE )) { 3862int err = lfs_ctz_traverse ( lfs , & f -> cache , & lfs -> rcache , f -> block , 3863f -> pos , cb , data ); 3864if ( err ) { 3865return err ; 3866} 3867} 3868} 3869 3870return 0 ; 3871} 3872 3873int lfs_fs_traverse ( lfs_t * lfs , int ( * cb )( void * data , lfs_block_t block ), 3874void * data ) { 3875LFS_TRACE ( "lfs_fs_traverse(%p, %p, %p)" , ( void * ) lfs , ( void * )( uintptr_t ) cb , 3876data ); 3877int err = lfs_fs_traverseraw ( lfs , cb , data , true); 3878LFS_TRACE ( "lfs_fs_traverse -> %d" , 0 ); 3879return err ; 3880} 3881 3882static int lfs_fs_pred ( lfs_t * lfs , const lfs_block_t pair [ 2 ], 3883lfs_mdir_t * pdir ) { 3884// iterate over all directory directory entries 3885pdir -> tail [ 0 ] = 0 ; 3886pdir -> tail [ 1 ] = 1 ; 3887lfs_block_t cycle = 0 ; 3888while (! lfs_pair_isnull ( pdir -> tail )) { 3889if ( cycle >= lfs -> cfg -> block_count / 2 ) { 3890// loop detected 3891return LFS_ERR_CORRUPT ; 3892} 3893cycle += 1 ; 3894 3895if ( lfs_pair_cmp ( pdir -> tail , pair ) == 0 ) { 3896return 0 ; 3897} 3898 3899int err = lfs_dir_fetch ( lfs , pdir , pdir -> tail ); 3900if ( err ) { 3901return err ; 3902} 3903} 3904 3905return LFS_ERR_NOENT ; 3906} 3907 3908struct lfs_fs_parent_match { 3909lfs_t * lfs ; 3910const lfs_block_t pair [ 2 ]; 3911}; 3912 3913static int lfs_fs_parent_match ( void * data , lfs_tag_t tag , const void * buffer ) { 3914struct lfs_fs_parent_match * find = data ; 3915lfs_t * lfs = find -> lfs ; 3916const struct lfs_diskoff * disk = buffer ; 3917( void ) tag ; 3918 3919lfs_block_t child [ 2 ]; 3920int err = lfs_bd_read ( lfs , & lfs -> pcache , & lfs -> rcache , lfs -> cfg -> block_size , 3921disk -> block , disk -> off , & child , sizeof( child )); 3922if ( err ) { 3923return err ; 3924} 3925 3926lfs_pair_fromle32 ( child ); 3927return ( lfs_pair_cmp ( child , find -> pair ) == 0 ) ? LFS_CMP_EQ : LFS_CMP_LT ; 3928} 3929 3930static lfs_stag_t lfs_fs_parent ( lfs_t * lfs , const lfs_block_t pair [ 2 ], 3931lfs_mdir_t * parent ) { 3932// use fetchmatch with callback to find pairs 3933parent -> tail [ 0 ] = 0 ; 3934parent -> tail [ 1 ] = 1 ; 3935lfs_block_t cycle = 0 ; 3936while (! lfs_pair_isnull ( parent -> tail )) { 3937if ( cycle >= lfs -> cfg -> block_count / 2 ) { 3938// loop detected 3939return LFS_ERR_CORRUPT ; 3940} 3941cycle += 1 ; 3942 3943lfs_stag_t tag = lfs_dir_fetchmatch ( 3944lfs , parent , parent -> tail , LFS_MKTAG ( 0x7ff , 0 , 0x3ff ), 3945LFS_MKTAG ( LFS_TYPE_DIRSTRUCT , 0 , 8 ), NULL , lfs_fs_parent_match , 3946& (struct lfs_fs_parent_match ){ lfs , { pair [ 0 ], pair [ 1 ]}}); 3947if ( tag && tag != LFS_ERR_NOENT ) { 3948return tag ; 3949} 3950} 3951 3952return LFS_ERR_NOENT ; 3953} 3954 3955static int lfs_fs_relocate ( lfs_t * lfs , const lfs_block_t oldpair [ 2 ], 3956lfs_block_t newpair [ 2 ]) { 3957// update internal root 3958if ( lfs_pair_cmp ( oldpair , lfs -> root ) == 0 ) { 3959lfs -> root [ 0 ] = newpair [ 0 ]; 3960lfs -> root [ 1 ] = newpair [ 1 ]; 3961} 3962 3963// update internally tracked dirs 3964for (struct lfs_mlist * d = lfs -> mlist ; d ; d = d -> next ) { 3965if ( lfs_pair_cmp ( oldpair , d -> m . pair ) == 0 ) { 3966d -> m . pair [ 0 ] = newpair [ 0 ]; 3967d -> m . pair [ 1 ] = newpair [ 1 ]; 3968} 3969 3970if ( d -> type == LFS_TYPE_DIR && 3971lfs_pair_cmp ( oldpair , (( lfs_dir_t * ) d ) -> head ) == 0 ) { 3972(( lfs_dir_t * ) d ) -> head [ 0 ] = newpair [ 0 ]; 3973(( lfs_dir_t * ) d ) -> head [ 1 ] = newpair [ 1 ]; 3974} 3975} 3976 3977// find parent 3978lfs_mdir_t parent ; 3979lfs_stag_t tag = lfs_fs_parent ( lfs , oldpair , & parent ); 3980if ( tag < 0 && tag != LFS_ERR_NOENT ) { 3981return tag ; 3982} 3983 3984if ( tag != LFS_ERR_NOENT ) { 3985// update disk, this creates a desync 3986lfs_fs_preporphans ( lfs , +1 ); 3987 3988// fix pending move in this pair? this looks like an optimization but 3989// is in fact _required_ since relocating may outdate the move. 3990uint16_t moveid = 0x3ff ; 3991if ( lfs_gstate_hasmovehere ( & lfs -> gstate , parent . pair )) { 3992moveid = lfs_tag_id ( lfs -> gstate . tag ); 3993LFS_DEBUG ( "Fixing move while relocating " 3994"{0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 "\n" , 3995parent . pair [ 0 ], parent . pair [ 1 ], moveid ); 3996lfs_fs_prepmove ( lfs , 0x3ff , NULL ); 3997if ( moveid < lfs_tag_id ( tag )) { 3998tag -= LFS_MKTAG ( 0 , 1 , 0 ); 3999} 4000} 4001 4002lfs_pair_tole32 ( newpair ); 4003int err = lfs_dir_commit ( 4004lfs , & parent , 4005LFS_MKATTRS ( 4006{ LFS_MKTAG_IF ( moveid != 0x3ff , LFS_TYPE_DELETE , moveid , 0 ), 4007NULL }, 4008{ tag , newpair })); 4009lfs_pair_fromle32 ( newpair ); 4010if ( err ) { 4011return err ; 4012} 4013 4014// next step, clean up orphans 4015lfs_fs_preporphans ( lfs , -1 ); 4016} 4017 4018// find pred 4019int err = lfs_fs_pred ( lfs , oldpair , & parent ); 4020if ( err && err != LFS_ERR_NOENT ) { 4021return err ; 4022} 4023 4024// if we can't find dir, it must be new 4025if ( err != LFS_ERR_NOENT ) { 4026// fix pending move in this pair? this looks like an optimization but 4027// is in fact _required_ since relocating may outdate the move. 4028uint16_t moveid = 0x3ff ; 4029if ( lfs_gstate_hasmovehere ( & lfs -> gstate , parent . pair )) { 4030moveid = lfs_tag_id ( lfs -> gstate . tag ); 4031LFS_DEBUG ( "Fixing move while relocating " 4032"{0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 "\n" , 4033parent . pair [ 0 ], parent . pair [ 1 ], moveid ); 4034lfs_fs_prepmove ( lfs , 0x3ff , NULL ); 4035} 4036 4037// replace bad pair, either we clean up desync, or no desync occured 4038lfs_pair_tole32 ( newpair ); 4039err = lfs_dir_commit ( 4040lfs , & parent , 4041LFS_MKATTRS ( 4042{ LFS_MKTAG_IF ( moveid != 0x3ff , LFS_TYPE_DELETE , moveid , 0 ), 4043NULL }, 4044{ LFS_MKTAG ( LFS_TYPE_TAIL + parent . split , 0x3ff , 8 ), newpair })); 4045lfs_pair_fromle32 ( newpair ); 4046if ( err ) { 4047return err ; 4048} 4049} 4050 4051return 0 ; 4052} 4053 4054static void lfs_fs_preporphans ( lfs_t * lfs , int8_t orphans ) { 4055LFS_ASSERT ( lfs_tag_size ( lfs -> gstate . tag ) > 0 || orphans >= 0 ); 4056lfs -> gstate . tag += orphans ; 4057lfs -> gstate . tag = (( lfs -> gstate . tag & ~ LFS_MKTAG ( 0x800 , 0 , 0 )) | 4058(( uint32_t ) lfs_gstate_hasorphans ( & lfs -> gstate ) << 31 )); 4059} 4060 4061static void lfs_fs_prepmove ( lfs_t * lfs , uint16_t id , 4062const lfs_block_t pair [ 2 ]) { 4063lfs -> gstate . tag = (( lfs -> gstate . tag & ~ LFS_MKTAG ( 0x7ff , 0x3ff , 0 )) | 4064(( id != 0x3ff ) ? LFS_MKTAG ( LFS_TYPE_DELETE , id , 0 ) : 0 )); 4065lfs -> gstate . pair [ 0 ] = ( id != 0x3ff ) ? pair [ 0 ] : 0 ; 4066lfs -> gstate . pair [ 1 ] = ( id != 0x3ff ) ? pair [ 1 ] : 0 ; 4067} 4068 4069static int lfs_fs_demove ( lfs_t * lfs ) { 4070if (! lfs_gstate_hasmove ( & lfs -> gdisk )) { 4071return 0 ; 4072} 4073 4074// Fix bad moves 4075LFS_DEBUG ( "Fixing move {0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 , 4076lfs -> gdisk . pair [ 0 ], lfs -> gdisk . pair [ 1 ], 4077lfs_tag_id ( lfs -> gdisk . tag )); 4078 4079// fetch and delete the moved entry 4080lfs_mdir_t movedir ; 4081int err = lfs_dir_fetch ( lfs , & movedir , lfs -> gdisk . pair ); 4082if ( err ) { 4083return err ; 4084} 4085 4086// prep gstate and delete move id 4087uint16_t moveid = lfs_tag_id ( lfs -> gdisk . tag ); 4088lfs_fs_prepmove ( lfs , 0x3ff , NULL ); 4089err = lfs_dir_commit ( 4090lfs , & movedir , 4091LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_DELETE , moveid , 0 ), NULL })); 4092if ( err ) { 4093return err ; 4094} 4095 4096return 0 ; 4097} 4098 4099static int lfs_fs_deorphan ( lfs_t * lfs ) { 4100if (! lfs_gstate_hasorphans ( & lfs -> gstate )) { 4101return 0 ; 4102} 4103 4104// Fix any orphans 4105lfs_mdir_t pdir = {. split = true, . tail = { 0 , 1 }}; 4106lfs_mdir_t dir ; 4107 4108// iterate over all directory directory entries 4109while (! lfs_pair_isnull ( pdir . tail )) { 4110int err = lfs_dir_fetch ( lfs , & dir , pdir . tail ); 4111if ( err ) { 4112return err ; 4113} 4114 4115// check head blocks for orphans 4116if (! pdir . split ) { 4117// check if we have a parent 4118lfs_mdir_t parent ; 4119lfs_stag_t tag = lfs_fs_parent ( lfs , pdir . tail , & parent ); 4120if ( tag < 0 && tag != LFS_ERR_NOENT ) { 4121return tag ; 4122} 4123 4124if ( tag == LFS_ERR_NOENT ) { 4125// we are an orphan 4126LFS_DEBUG ( "Fixing orphan {0x%" PRIx32 ", 0x%" PRIx32 "}" , 4127pdir . tail [ 0 ], pdir . tail [ 1 ]); 4128 4129err = lfs_dir_drop ( lfs , & pdir , & dir ); 4130if ( err ) { 4131return err ; 4132} 4133 4134// refetch tail 4135continue; 4136} 4137 4138lfs_block_t pair [ 2 ]; 4139lfs_stag_t res = lfs_dir_get ( lfs , & parent , 4140LFS_MKTAG ( 0x7ff , 0x3ff , 0 ), tag , pair ); 4141if ( res < 0 ) { 4142return res ; 4143} 4144lfs_pair_fromle32 ( pair ); 4145 4146if (! lfs_pair_sync ( pair , pdir . tail )) { 4147// we have desynced 4148LFS_DEBUG ( "Fixing half-orphan {0x%" PRIx32 ", 0x%" PRIx32 "} " 4149"-> {0x%" PRIx32 ", 0x%" PRIx32 "}" , 4150pdir . tail [ 0 ], pdir . tail [ 1 ], pair [ 0 ], pair [ 1 ]); 4151 4152lfs_pair_tole32 ( pair ); 4153err = lfs_dir_commit ( 4154lfs , & pdir , 4155LFS_MKATTRS ( 4156{ LFS_MKTAG ( LFS_TYPE_SOFTTAIL , 0x3ff , 8 ), pair })); 4157lfs_pair_fromle32 ( pair ); 4158if ( err ) { 4159return err ; 4160} 4161 4162// refetch tail 4163continue; 4164} 4165} 4166 4167pdir = dir ; 4168} 4169 4170// mark orphans as fixed 4171lfs_fs_preporphans ( lfs , - lfs_gstate_getorphans ( & lfs -> gstate )); 4172return 0 ; 4173} 4174 4175static int lfs_fs_forceconsistency ( lfs_t * lfs ) { 4176int err = lfs_fs_demove ( lfs ); 4177if ( err ) { 4178return err ; 4179} 4180 4181err = lfs_fs_deorphan ( lfs ); 4182if ( err ) { 4183return err ; 4184} 4185 4186return 0 ; 4187} 4188 4189static int lfs_fs_size_count ( void * p , lfs_block_t block ) { 4190( void ) block ; 4191lfs_size_t * size = p ; 4192* size += 1 ; 4193return 0 ; 4194} 4195 4196lfs_ssize_t lfs_fs_size ( lfs_t * lfs ) { 4197LFS_TRACE ( "lfs_fs_size(%p)" , ( void * ) lfs ); 4198lfs_size_t size = 0 ; 4199int err = lfs_fs_traverseraw ( lfs , lfs_fs_size_count , & size , false); 4200if ( err ) { 4201LFS_TRACE ( "lfs_fs_size -> %d" , err ); 4202return err ; 4203} 4204 4205LFS_TRACE ( "lfs_fs_size -> %d" , err ); 4206return size ; 4207} 4208 4209#ifdef LFS_MIGRATE 4210////// Migration from littelfs v1 below this ////// 4211 4212/// Version info /// 4213 4214// Software library version 4215// Major (top-nibble), incremented on backwards incompatible changes 4216// Minor (bottom-nibble), incremented on feature additions 4217#define LFS1_VERSION 0x00010007 4218#define LFS1_VERSION_MAJOR (0xffff & (LFS1_VERSION >> 16)) 4219#define LFS1_VERSION_MINOR (0xffff & (LFS1_VERSION >> 0)) 4220 4221// Version of On-disk data structures 4222// Major (top-nibble), incremented on backwards incompatible changes 4223// Minor (bottom-nibble), incremented on feature additions 4224#define LFS1_DISK_VERSION 0x00010001 4225#define LFS1_DISK_VERSION_MAJOR (0xffff & (LFS1_DISK_VERSION >> 16)) 4226#define LFS1_DISK_VERSION_MINOR (0xffff & (LFS1_DISK_VERSION >> 0)) 4227 4228/// v1 Definitions /// 4229 4230// File types 4231enum lfs1_type { 4232LFS1_TYPE_REG = 0x11 , 4233LFS1_TYPE_DIR = 0x22 , 4234LFS1_TYPE_SUPERBLOCK = 0x2e , 4235}; 4236 4237typedef struct lfs1 { 4238lfs_block_t root [ 2 ]; 4239} lfs1_t ; 4240 4241typedef struct lfs1_entry { 4242lfs_off_t off ; 4243 4244struct lfs1_disk_entry { 4245uint8_t type ; 4246uint8_t elen ; 4247uint8_t alen ; 4248uint8_t nlen ; 4249union { 4250struct { 4251lfs_block_t head ; 4252lfs_size_t size ; 4253} file ; 4254lfs_block_t dir [ 2 ]; 4255} u ; 4256} d ; 4257} lfs1_entry_t ; 4258 4259typedef struct lfs1_dir { 4260struct lfs1_dir * next ; 4261lfs_block_t pair [ 2 ]; 4262lfs_off_t off ; 4263 4264lfs_block_t head [ 2 ]; 4265lfs_off_t pos ; 4266 4267struct lfs1_disk_dir { 4268uint32_t rev ; 4269lfs_size_t size ; 4270lfs_block_t tail [ 2 ]; 4271} d ; 4272} lfs1_dir_t ; 4273 4274typedef struct lfs1_superblock { 4275lfs_off_t off ; 4276 4277struct lfs1_disk_superblock { 4278uint8_t type ; 4279uint8_t elen ; 4280uint8_t alen ; 4281uint8_t nlen ; 4282lfs_block_t root [ 2 ]; 4283uint32_t block_size ; 4284uint32_t block_count ; 4285uint32_t version ; 4286char magic [ 8 ]; 4287} d ; 4288} lfs1_superblock_t ; 4289 4290/// Low-level wrappers v1->v2 /// 4291static void lfs1_crc ( uint32_t * crc , const void * buffer , size_t size ) { 4292* crc = lfs_crc ( * crc , buffer , size ); 4293} 4294 4295static int lfs1_bd_read ( lfs_t * lfs , lfs_block_t block , lfs_off_t off , 4296void * buffer , lfs_size_t size ) { 4297// if we ever do more than writes to alternating pairs, 4298// this may need to consider pcache 4299return lfs_bd_read ( lfs , & lfs -> pcache , & lfs -> rcache , size , block , off , 4300buffer , size ); 4301} 4302 4303static int lfs1_bd_crc ( lfs_t * lfs , lfs_block_t block , lfs_off_t off , 4304lfs_size_t size , uint32_t * crc ) { 4305for ( lfs_off_t i = 0 ; i < size ; i ++ ) { 4306uint8_t c ; 4307int err = lfs1_bd_read ( lfs , block , off + i , & c , 1 ); 4308if ( err ) { 4309return err ; 4310} 4311 4312lfs1_crc ( crc , & c , 1 ); 4313} 4314 4315return 0 ; 4316} 4317 4318/// Endian swapping functions /// 4319static void lfs1_dir_fromle32 (struct lfs1_disk_dir * d ) { 4320d -> rev = lfs_fromle32 ( d -> rev ); 4321d -> size = lfs_fromle32 ( d -> size ); 4322d -> tail [ 0 ] = lfs_fromle32 ( d -> tail [ 0 ]); 4323d -> tail [ 1 ] = lfs_fromle32 ( d -> tail [ 1 ]); 4324} 4325 4326static void lfs1_dir_tole32 (struct lfs1_disk_dir * d ) { 4327d -> rev = lfs_tole32 ( d -> rev ); 4328d -> size = lfs_tole32 ( d -> size ); 4329d -> tail [ 0 ] = lfs_tole32 ( d -> tail [ 0 ]); 4330d -> tail [ 1 ] = lfs_tole32 ( d -> tail [ 1 ]); 4331} 4332 4333static void lfs1_entry_fromle32 (struct lfs1_disk_entry * d ) { 4334d -> u . dir [ 0 ] = lfs_fromle32 ( d -> u . dir [ 0 ]); 4335d -> u . dir [ 1 ] = lfs_fromle32 ( d -> u . dir [ 1 ]); 4336} 4337 4338static void lfs1_entry_tole32 (struct lfs1_disk_entry * d ) { 4339d -> u . dir [ 0 ] = lfs_tole32 ( d -> u . dir [ 0 ]); 4340d -> u . dir [ 1 ] = lfs_tole32 ( d -> u . dir [ 1 ]); 4341} 4342 4343static void lfs1_superblock_fromle32 (struct lfs1_disk_superblock * d ) { 4344d -> root [ 0 ] = lfs_fromle32 ( d -> root [ 0 ]); 4345d -> root [ 1 ] = lfs_fromle32 ( d -> root [ 1 ]); 4346d -> block_size = lfs_fromle32 ( d -> block_size ); 4347d -> block_count = lfs_fromle32 ( d -> block_count ); 4348d -> version = lfs_fromle32 ( d -> version ); 4349} 4350 4351///// Metadata pair and directory operations /// 4352static inline lfs_size_t lfs1_entry_size (const lfs1_entry_t * entry ) { 4353return 4 + entry -> d . elen + entry -> d . alen + entry -> d . nlen ; 4354} 4355 4356static int lfs1_dir_fetch ( lfs_t * lfs , lfs1_dir_t * dir , 4357const lfs_block_t pair [ 2 ]) { 4358// copy out pair, otherwise may be aliasing dir 4359const lfs_block_t tpair [ 2 ] = { pair [ 0 ], pair [ 1 ]}; 4360bool valid = false; 4361 4362// check both blocks for the most recent revision 4363for ( int i = 0 ; i < 2 ; i ++ ) { 4364struct lfs1_disk_dir test ; 4365int err = lfs1_bd_read ( lfs , tpair [ i ], 0 , & test , sizeof( test )); 4366lfs1_dir_fromle32 ( & test ); 4367if ( err ) { 4368if ( err == LFS_ERR_CORRUPT ) { 4369continue; 4370} 4371return err ; 4372} 4373 4374if ( valid && lfs_scmp ( test . rev , dir -> d . rev ) < 0 ) { 4375continue; 4376} 4377 4378if (( 0x7fffffff & test . size ) < sizeof( test ) + 4 || 4379( 0x7fffffff & test . size ) > lfs -> cfg -> block_size ) { 4380continue; 4381} 4382 4383uint32_t crc = 0xffffffff ; 4384lfs1_dir_tole32 ( & test ); 4385lfs1_crc ( & crc , & test , sizeof( test )); 4386lfs1_dir_fromle32 ( & test ); 4387err = lfs1_bd_crc ( lfs , tpair [ i ], sizeof( test ), 4388( 0x7fffffff & test . size ) - sizeof( test ), & crc ); 4389if ( err ) { 4390if ( err == LFS_ERR_CORRUPT ) { 4391continue; 4392} 4393return err ; 4394} 4395 4396if ( crc != 0 ) { 4397continue; 4398} 4399 4400valid = true; 4401 4402// setup dir in case it's valid 4403dir -> pair [ 0 ] = tpair [( i + 0 ) % 2 ]; 4404dir -> pair [ 1 ] = tpair [( i + 1 ) % 2 ]; 4405dir -> off = sizeof( dir -> d ); 4406dir -> d = test ; 4407} 4408 4409if (! valid ) { 4410LFS_ERROR ( "Corrupted dir pair at {0x%" PRIx32 ", 0x%" PRIx32 "}" , 4411tpair [ 0 ], tpair [ 1 ]); 4412return LFS_ERR_CORRUPT ; 4413} 4414 4415return 0 ; 4416} 4417 4418static int lfs1_dir_next ( lfs_t * lfs , lfs1_dir_t * dir , lfs1_entry_t * entry ) { 4419while ( dir -> off + sizeof( entry -> d ) > ( 0x7fffffff & dir -> d . size ) - 4 ) { 4420if (!( 0x80000000 & dir -> d . size )) { 4421entry -> off = dir -> off ; 4422return LFS_ERR_NOENT ; 4423} 4424 4425int err = lfs1_dir_fetch ( lfs , dir , dir -> d . tail ); 4426if ( err ) { 4427return err ; 4428} 4429 4430dir -> off = sizeof( dir -> d ); 4431dir -> pos += sizeof( dir -> d ) + 4 ; 4432} 4433 4434int err = 4435lfs1_bd_read ( lfs , dir -> pair [ 0 ], dir -> off , & entry -> d , sizeof( entry -> d )); 4436lfs1_entry_fromle32 ( & entry -> d ); 4437if ( err ) { 4438return err ; 4439} 4440 4441entry -> off = dir -> off ; 4442dir -> off += lfs1_entry_size ( entry ); 4443dir -> pos += lfs1_entry_size ( entry ); 4444return 0 ; 4445} 4446 4447/// littlefs v1 specific operations /// 4448int lfs1_traverse ( lfs_t * lfs , int ( * cb )( void * , lfs_block_t ), void * data ) { 4449if ( lfs_pair_isnull ( lfs -> lfs1 -> root )) { 4450return 0 ; 4451} 4452 4453// iterate over metadata pairs 4454lfs1_dir_t dir ; 4455lfs1_entry_t entry ; 4456lfs_block_t cwd [ 2 ] = { 0 , 1 }; 4457 4458while (true) { 4459for ( int i = 0 ; i < 2 ; i ++ ) { 4460int err = cb ( data , cwd [ i ]); 4461if ( err ) { 4462return err ; 4463} 4464} 4465 4466int err = lfs1_dir_fetch ( lfs , & dir , cwd ); 4467if ( err ) { 4468return err ; 4469} 4470 4471// iterate over contents 4472while ( dir . off + sizeof( entry . d ) <= ( 0x7fffffff & dir . d . size ) - 4 ) { 4473err = lfs1_bd_read ( lfs , dir . pair [ 0 ], dir . off , & entry . d , 4474sizeof( entry . d )); 4475lfs1_entry_fromle32 ( & entry . d ); 4476if ( err ) { 4477return err ; 4478} 4479 4480dir . off += lfs1_entry_size ( & entry ); 4481if (( 0x70 & entry . d . type ) == ( 0x70 & LFS1_TYPE_REG )) { 4482err = lfs_ctz_traverse ( lfs , NULL , & lfs -> rcache , 4483entry . d . u . file . head , entry . d . u . file . size , 4484cb , data ); 4485if ( err ) { 4486return err ; 4487} 4488} 4489} 4490 4491// we also need to check if we contain a threaded v2 directory 4492lfs_mdir_t dir2 = {. split = true, . tail = { cwd [ 0 ], cwd [ 1 ]}}; 4493while ( dir2 . split ) { 4494err = lfs_dir_fetch ( lfs , & dir2 , dir2 . tail ); 4495if ( err ) { 4496break; 4497} 4498 4499for ( int i = 0 ; i < 2 ; i ++ ) { 4500err = cb ( data , dir2 . pair [ i ]); 4501if ( err ) { 4502return err ; 4503} 4504} 4505} 4506 4507cwd [ 0 ] = dir . d . tail [ 0 ]; 4508cwd [ 1 ] = dir . d . tail [ 1 ]; 4509 4510if ( lfs_pair_isnull ( cwd )) { 4511break; 4512} 4513} 4514 4515return 0 ; 4516} 4517 4518static int lfs1_moved ( lfs_t * lfs , const void * e ) { 4519if ( lfs_pair_isnull ( lfs -> lfs1 -> root )) { 4520return 0 ; 4521} 4522 4523// skip superblock 4524lfs1_dir_t cwd ; 4525int err = lfs1_dir_fetch ( lfs , & cwd , (const lfs_block_t [ 2 ]){ 0 , 1 }); 4526if ( err ) { 4527return err ; 4528} 4529 4530// iterate over all directory directory entries 4531lfs1_entry_t entry ; 4532while (! lfs_pair_isnull ( cwd . d . tail )) { 4533err = lfs1_dir_fetch ( lfs , & cwd , cwd . d . tail ); 4534if ( err ) { 4535return err ; 4536} 4537 4538while (true) { 4539err = lfs1_dir_next ( lfs , & cwd , & entry ); 4540if ( err && err != LFS_ERR_NOENT ) { 4541return err ; 4542} 4543 4544if ( err == LFS_ERR_NOENT ) { 4545break; 4546} 4547 4548if (!( 0x80 & entry . d . type ) && 4549memcmp ( & entry . d . u , e , sizeof( entry . d . u )) == 0 ) { 4550return true; 4551} 4552} 4553} 4554 4555return false; 4556} 4557 4558/// Filesystem operations /// 4559static int lfs1_mount ( lfs_t * lfs , struct lfs1 * lfs1 , 4560const struct lfs_config * cfg ) { 4561int err = 0 ; 4562{ 4563err = lfs_init ( lfs , cfg ); 4564if ( err ) { 4565return err ; 4566} 4567 4568lfs -> lfs1 = lfs1 ; 4569lfs -> lfs1 -> root [ 0 ] = LFS_BLOCK_NULL ; 4570lfs -> lfs1 -> root [ 1 ] = LFS_BLOCK_NULL ; 4571 4572// setup free lookahead 4573lfs -> free . off = 0 ; 4574lfs -> free . size = 0 ; 4575lfs -> free . i = 0 ; 4576lfs_alloc_ack ( lfs ); 4577 4578// load superblock 4579lfs1_dir_t dir ; 4580lfs1_superblock_t superblock ; 4581err = lfs1_dir_fetch ( lfs , & dir , (const lfs_block_t [ 2 ]){ 0 , 1 }); 4582if ( err && err != LFS_ERR_CORRUPT ) { 4583goto cleanup ; 4584} 4585 4586if (! err ) { 4587err = lfs1_bd_read ( lfs , dir . pair [ 0 ], sizeof( dir . d ), & superblock . d , 4588sizeof( superblock . d )); 4589lfs1_superblock_fromle32 ( & superblock . d ); 4590if ( err ) { 4591goto cleanup ; 4592} 4593 4594lfs -> lfs1 -> root [ 0 ] = superblock . d . root [ 0 ]; 4595lfs -> lfs1 -> root [ 1 ] = superblock . d . root [ 1 ]; 4596} 4597 4598if ( err || memcmp ( superblock . d . magic , "littlefs" , 8 ) != 0 ) { 4599LFS_ERROR ( "Invalid superblock at {0x%" PRIx32 ", 0x%" PRIx32 "}" , 0 , 46001 ); 4601err = LFS_ERR_CORRUPT ; 4602goto cleanup ; 4603} 4604 4605uint16_t major_version = ( 0xffff & ( superblock . d . version >> 16 )); 4606uint16_t minor_version = ( 0xffff & ( superblock . d . version >> 0 )); 4607if (( major_version != LFS1_DISK_VERSION_MAJOR || 4608minor_version > LFS1_DISK_VERSION_MINOR )) { 4609LFS_ERROR ( "Invalid version v%d.%d" , major_version , minor_version ); 4610err = LFS_ERR_INVAL ; 4611goto cleanup ; 4612} 4613 4614return 0 ; 4615} 4616 4617cleanup : 4618lfs_deinit ( lfs ); 4619return err ; 4620} 4621 4622static int lfs1_unmount ( lfs_t * lfs ) { 4623return lfs_deinit ( lfs ); 4624} 4625 4626/// v1 migration /// 4627int lfs_migrate ( lfs_t * lfs , const struct lfs_config * cfg ) { 4628LFS_TRACE ( "lfs_migrate(%p, %p {.context=%p, " 4629".read=%p, .prog=%p, .erase=%p, .sync=%p, " 4630".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", " 4631".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", " 4632".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", " 4633".lookahead_size=%" PRIu32 ", .read_buffer=%p, " 4634".prog_buffer=%p, .lookahead_buffer=%p, " 4635".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", " 4636".attr_max=%" PRIu32 "})" , 4637( void * ) lfs , ( void * ) cfg , cfg -> context , ( void * )( uintptr_t ) cfg -> read , 4638( void * )( uintptr_t ) cfg -> prog , ( void * )( uintptr_t ) cfg -> erase , 4639( void * )( uintptr_t ) cfg -> sync , cfg -> read_size , cfg -> prog_size , 4640cfg -> block_size , cfg -> block_count , cfg -> block_cycles , 4641cfg -> cache_size , cfg -> lookahead_size , cfg -> read_buffer , 4642cfg -> prog_buffer , cfg -> lookahead_buffer , cfg -> name_max , 4643cfg -> file_max , cfg -> attr_max ); 4644struct lfs1 lfs1 ; 4645int err = lfs1_mount ( lfs , & lfs1 , cfg ); 4646if ( err ) { 4647LFS_TRACE ( "lfs_migrate -> %d" , err ); 4648return err ; 4649} 4650 4651{ 4652// iterate through each directory, copying over entries 4653// into new directory 4654lfs1_dir_t dir1 ; 4655lfs_mdir_t dir2 ; 4656dir1 . d . tail [ 0 ] = lfs -> lfs1 -> root [ 0 ]; 4657dir1 . d . tail [ 1 ] = lfs -> lfs1 -> root [ 1 ]; 4658while (! lfs_pair_isnull ( dir1 . d . tail )) { 4659// iterate old dir 4660err = lfs1_dir_fetch ( lfs , & dir1 , dir1 . d . tail ); 4661if ( err ) { 4662goto cleanup ; 4663} 4664 4665// create new dir and bind as temporary pretend root 4666err = lfs_dir_alloc ( lfs , & dir2 ); 4667if ( err ) { 4668goto cleanup ; 4669} 4670 4671dir2 . rev = dir1 . d . rev ; 4672dir1 . head [ 0 ] = dir1 . pair [ 0 ]; 4673dir1 . head [ 1 ] = dir1 . pair [ 1 ]; 4674lfs -> root [ 0 ] = dir2 . pair [ 0 ]; 4675lfs -> root [ 1 ] = dir2 . pair [ 1 ]; 4676 4677err = lfs_dir_commit ( lfs , & dir2 , NULL , 0 ); 4678if ( err ) { 4679goto cleanup ; 4680} 4681 4682while (true) { 4683lfs1_entry_t entry1 ; 4684err = lfs1_dir_next ( lfs , & dir1 , & entry1 ); 4685if ( err && err != LFS_ERR_NOENT ) { 4686goto cleanup ; 4687} 4688 4689if ( err == LFS_ERR_NOENT ) { 4690break; 4691} 4692 4693// check that entry has not been moved 4694if ( entry1 . d . type & 0x80 ) { 4695int moved = lfs1_moved ( lfs , & entry1 . d . u ); 4696if ( moved < 0 ) { 4697err = moved ; 4698goto cleanup ; 4699} 4700 4701if ( moved ) { 4702continue; 4703} 4704 4705entry1 . d . type &= ~ 0x80 ; 4706} 4707 4708// also fetch name 4709char name [ LFS_NAME_MAX + 1 ]; 4710memset ( name , 0 , sizeof( name )); 4711err = 4712lfs1_bd_read ( lfs , dir1 . pair [ 0 ], 4713entry1 . off + 4 + entry1 . d . elen + entry1 . d . alen , 4714name , entry1 . d . nlen ); 4715if ( err ) { 4716goto cleanup ; 4717} 4718 4719bool isdir = ( entry1 . d . type == LFS1_TYPE_DIR ); 4720 4721// create entry in new dir 4722err = lfs_dir_fetch ( lfs , & dir2 , lfs -> root ); 4723if ( err ) { 4724goto cleanup ; 4725} 4726 4727uint16_t id ; 4728err = lfs_dir_find ( lfs , & dir2 , & (const char * ){ name }, & id ); 4729if (!( err == LFS_ERR_NOENT && id != 0x3ff )) { 4730err = ( err < 0 ) ? err : LFS_ERR_EXIST ; 4731goto cleanup ; 4732} 4733 4734lfs1_entry_tole32 ( & entry1 . d ); 4735err = lfs_dir_commit ( 4736lfs , & dir2 , 4737LFS_MKATTRS ({ LFS_MKTAG ( LFS_TYPE_CREATE , id , 0 )}, 4738{ LFS_MKTAG_IF_ELSE ( isdir , LFS_TYPE_DIR , id , 4739entry1 . d . nlen , LFS_TYPE_REG , 4740id , entry1 . d . nlen ), 4741name }, 4742{ LFS_MKTAG_IF_ELSE ( isdir , LFS_TYPE_DIRSTRUCT , 4743id , sizeof( entry1 . d . u ), 4744LFS_TYPE_CTZSTRUCT , id , 4745sizeof( entry1 . d . u )), 4746& entry1 . d . u })); 4747lfs1_entry_fromle32 ( & entry1 . d ); 4748if ( err ) { 4749goto cleanup ; 4750} 4751} 4752 4753if (! lfs_pair_isnull ( dir1 . d . tail )) { 4754// find last block and update tail to thread into fs 4755err = lfs_dir_fetch ( lfs , & dir2 , lfs -> root ); 4756if ( err ) { 4757goto cleanup ; 4758} 4759 4760while ( dir2 . split ) { 4761err = lfs_dir_fetch ( lfs , & dir2 , dir2 . tail ); 4762if ( err ) { 4763goto cleanup ; 4764} 4765} 4766 4767lfs_pair_tole32 ( dir2 . pair ); 4768err = lfs_dir_commit ( 4769lfs , & dir2 , 4770LFS_MKATTRS ( 4771{ LFS_MKTAG ( LFS_TYPE_SOFTTAIL , 0x3ff , 8 ), dir1 . d . tail })); 4772lfs_pair_fromle32 ( dir2 . pair ); 4773if ( err ) { 4774goto cleanup ; 4775} 4776} 4777 4778// Copy over first block to thread into fs. Unfortunately 4779// if this fails there is not much we can do. 4780LFS_DEBUG ( "Migrating {0x%" PRIx32 ", 0x%" PRIx32 "} " 4781"-> {0x%" PRIx32 ", 0x%" PRIx32 "}" , 4782lfs -> root [ 0 ], lfs -> root [ 1 ], dir1 . head [ 0 ], dir1 . head [ 1 ]); 4783 4784err = lfs_bd_erase ( lfs , dir1 . head [ 1 ]); 4785if ( err ) { 4786goto cleanup ; 4787} 4788 4789err = lfs_dir_fetch ( lfs , & dir2 , lfs -> root ); 4790if ( err ) { 4791goto cleanup ; 4792} 4793 4794for ( lfs_off_t i = 0 ; i < dir2 . off ; i ++ ) { 4795uint8_t dat ; 4796err = lfs_bd_read ( lfs , NULL , & lfs -> rcache , dir2 . off , 4797dir2 . pair [ 0 ], i , & dat , 1 ); 4798if ( err ) { 4799goto cleanup ; 4800} 4801 4802err = lfs_bd_prog ( lfs , & lfs -> pcache , & lfs -> rcache , true, 4803dir1 . head [ 1 ], i , & dat , 1 ); 4804if ( err ) { 4805goto cleanup ; 4806} 4807} 4808 4809err = lfs_bd_flush ( lfs , & lfs -> pcache , & lfs -> rcache , true); 4810if ( err ) { 4811goto cleanup ; 4812} 4813} 4814 4815// Create new superblock. This marks a successful migration! 4816err = lfs1_dir_fetch ( lfs , & dir1 , (const lfs_block_t [ 2 ]){ 0 , 1 }); 4817if ( err ) { 4818goto cleanup ; 4819} 4820 4821dir2 . pair [ 0 ] = dir1 . pair [ 0 ]; 4822dir2 . pair [ 1 ] = dir1 . pair [ 1 ]; 4823dir2 . rev = dir1 . d . rev ; 4824dir2 . off = sizeof( dir2 . rev ); 4825dir2 . etag = 0xffffffff ; 4826dir2 . count = 0 ; 4827dir2 . tail [ 0 ] = lfs -> lfs1 -> root [ 0 ]; 4828dir2 . tail [ 1 ] = lfs -> lfs1 -> root [ 1 ]; 4829dir2 . erased = false; 4830dir2 . split = true; 4831 4832lfs_superblock_t superblock = { 4833. version = LFS_DISK_VERSION , 4834. block_size = lfs -> cfg -> block_size , 4835. block_count = lfs -> cfg -> block_count , 4836. name_max = lfs -> name_max , 4837. file_max = lfs -> file_max , 4838. attr_max = lfs -> attr_max , 4839}; 4840 4841lfs_superblock_tole32 ( & superblock ); 4842err = lfs_dir_commit ( 4843lfs , & dir2 , 4844LFS_MKATTRS ( 4845{ LFS_MKTAG ( LFS_TYPE_CREATE , 0 , 0 )}, 4846{ LFS_MKTAG ( LFS_TYPE_SUPERBLOCK , 0 , 8 ), "littlefs" }, 4847{ LFS_MKTAG ( LFS_TYPE_INLINESTRUCT , 0 , sizeof( superblock )), 4848& superblock })); 4849if ( err ) { 4850goto cleanup ; 4851} 4852 4853// sanity check that fetch works 4854err = lfs_dir_fetch ( lfs , & dir2 , (const lfs_block_t [ 2 ]){ 0 , 1 }); 4855if ( err ) { 4856goto cleanup ; 4857} 4858 4859// force compaction to prevent accidentally mounting v1 4860dir2 . erased = false; 4861err = lfs_dir_commit ( lfs , & dir2 , NULL , 0 ); 4862if ( err ) { 4863goto cleanup ; 4864} 4865} 4866 4867cleanup : 4868lfs1_unmount ( lfs ); 4869LFS_TRACE ( "lfs_migrate -> %d" , err ); 4870return err ; 4871} 4872 4873#endif