MultiTech
fota lib for mdot
Embed:
(wiki syntax)
Show/hide line numbers
spiffs_nucleus.h
00001 /* 00002 * spiffs_nucleus.h 00003 * 00004 * Created on: Jun 15, 2013 00005 * Author: petera 00006 */ 00007 00008 /* SPIFFS layout 00009 * 00010 * spiffs is designed for following spi flash characteristics: 00011 * - only big areas of data (blocks) can be erased 00012 * - erasing resets all bits in a block to ones 00013 * - writing pulls ones to zeroes 00014 * - zeroes cannot be pulled to ones, without erase 00015 * - wear leveling 00016 * 00017 * spiffs is also meant to be run on embedded, memory constraint devices. 00018 * 00019 * Entire area is divided in blocks. Entire area is also divided in pages. 00020 * Each block contains same number of pages. A page cannot be erased, but a 00021 * block can be erased. 00022 * 00023 * Entire area must be block_size * x 00024 * page_size must be block_size / (2^y) where y > 2 00025 * 00026 * ex: area = 1024*1024 bytes, block size = 65536 bytes, page size = 256 bytes 00027 * 00028 * BLOCK 0 PAGE 0 object lookup 1 00029 * PAGE 1 object lookup 2 00030 * ... 00031 * PAGE n-1 object lookup n 00032 * PAGE n object data 1 00033 * PAGE n+1 object data 2 00034 * ... 00035 * PAGE n+m-1 object data m 00036 * 00037 * BLOCK 1 PAGE n+m object lookup 1 00038 * PAGE n+m+1 object lookup 2 00039 * ... 00040 * PAGE 2n+m-1 object lookup n 00041 * PAGE 2n+m object data 1 00042 * PAGE 2n+m object data 2 00043 * ... 00044 * PAGE 2n+2m-1 object data m 00045 * ... 00046 * 00047 * n is number of object lookup pages, which is number of pages needed to index all pages 00048 * in a block by object id 00049 * : block_size / page_size * sizeof(obj_id) / page_size 00050 * m is number data pages, which is number of pages in block minus number of lookup pages 00051 * : block_size / page_size - block_size / page_size * sizeof(obj_id) / page_size 00052 * thus, n+m is total number of pages in a block 00053 * : block_size / page_size 00054 * 00055 * ex: n = 65536/256*2/256 = 2, m = 65536/256 - 2 = 254 => n+m = 65536/256 = 256 00056 * 00057 * Object lookup pages contain object id entries. Each entry represent the corresponding 00058 * data page. 00059 * Assuming a 16 bit object id, an object id being 0xffff represents a free page. 00060 * An object id being 0x0000 represents a deleted page. 00061 * 00062 * ex: page 0 : lookup : 0008 0001 0aaa ffff ffff ffff ffff ffff .. 00063 * page 1 : lookup : ffff ffff ffff ffff ffff ffff ffff ffff .. 00064 * page 2 : data : data for object id 0008 00065 * page 3 : data : data for object id 0001 00066 * page 4 : data : data for object id 0aaa 00067 * ... 00068 * 00069 * 00070 * Object data pages can be either object index pages or object content. 00071 * All object data pages contains a data page header, containing object id and span index. 00072 * The span index denotes the object page ordering amongst data pages with same object id. 00073 * This applies to both object index pages (when index spans more than one page of entries), 00074 * and object data pages. 00075 * An object index page contains page entries pointing to object content page. The entry index 00076 * in a object index page correlates to the span index in the actual object data page. 00077 * The first object index page (span index 0) is called object index header page, and also 00078 * contains object flags (directory/file), size, object name etc. 00079 * 00080 * ex: 00081 * BLOCK 1 00082 * PAGE 256: objectl lookup page 1 00083 * [*123] [ 123] [ 123] [ 123] 00084 * [ 123] [*123] [ 123] [ 123] 00085 * [free] [free] [free] [free] ... 00086 * PAGE 257: objectl lookup page 2 00087 * [free] [free] [free] [free] ... 00088 * PAGE 258: object index page (header) 00089 * obj.id:0123 span.ix:0000 flags:INDEX 00090 * size:1600 name:ex.txt type:file 00091 * [259] [260] [261] [262] 00092 * PAGE 259: object data page 00093 * obj.id:0123 span.ix:0000 flags:DATA 00094 * PAGE 260: object data page 00095 * obj.id:0123 span.ix:0001 flags:DATA 00096 * PAGE 261: object data page 00097 * obj.id:0123 span.ix:0002 flags:DATA 00098 * PAGE 262: object data page 00099 * obj.id:0123 span.ix:0003 flags:DATA 00100 * PAGE 263: object index page 00101 * obj.id:0123 span.ix:0001 flags:INDEX 00102 * [264] [265] [fre] [fre] 00103 * [fre] [fre] [fre] [fre] 00104 * PAGE 264: object data page 00105 * obj.id:0123 span.ix:0004 flags:DATA 00106 * PAGE 265: object data page 00107 * obj.id:0123 span.ix:0005 flags:DATA 00108 * 00109 */ 00110 #ifndef SPIFFS_NUCLEUS_H_ 00111 #define SPIFFS_NUCLEUS_H_ 00112 00113 #define _SPIFFS_ERR_CHECK_FIRST (SPIFFS_ERR_INTERNAL - 1) 00114 #define SPIFFS_ERR_CHECK_OBJ_ID_MISM (SPIFFS_ERR_INTERNAL - 1) 00115 #define SPIFFS_ERR_CHECK_SPIX_MISM (SPIFFS_ERR_INTERNAL - 2) 00116 #define SPIFFS_ERR_CHECK_FLAGS_BAD (SPIFFS_ERR_INTERNAL - 3) 00117 #define _SPIFFS_ERR_CHECK_LAST (SPIFFS_ERR_INTERNAL - 4) 00118 00119 #define SPIFFS_VIS_COUNTINUE (SPIFFS_ERR_INTERNAL - 20) 00120 #define SPIFFS_VIS_COUNTINUE_RELOAD (SPIFFS_ERR_INTERNAL - 21) 00121 #define SPIFFS_VIS_END (SPIFFS_ERR_INTERNAL - 22) 00122 00123 #define SPIFFS_EV_IX_UPD 0 00124 #define SPIFFS_EV_IX_NEW 1 00125 #define SPIFFS_EV_IX_DEL 2 00126 00127 #define SPIFFS_OBJ_ID_IX_FLAG (1<<(8*sizeof(spiffs_obj_id)-1)) 00128 00129 #define SPIFFS_UNDEFINED_LEN (-1) 00130 00131 #define SPIFFS_OBJ_ID_DELETED ((spiffs_obj_id)0) 00132 #define SPIFFS_OBJ_ID_FREE ((spiffs_obj_id)-1) 00133 00134 #if SPIFFS_SINGLETON == 0 00135 #define SPIFFS_CFG_LOG_PAGE_SZ(fs) \ 00136 ((fs)->cfg.log_page_size) 00137 #define SPIFFS_CFG_LOG_BLOCK_SZ(fs) \ 00138 ((fs)->cfg.log_block_size) 00139 #define SPIFFS_CFG_PHYS_SZ(fs) \ 00140 ((fs)->cfg.phys_size) 00141 #define SPIFFS_CFG_PHYS_ERASE_SZ(fs) \ 00142 ((fs)->cfg.phys_erase_block) 00143 #define SPIFFS_CFG_PHYS_ADDR(fs) \ 00144 ((fs)->cfg.phys_addr) 00145 #endif 00146 00147 // total number of pages 00148 #define SPIFFS_MAX_PAGES(fs) \ 00149 ( SPIFFS_CFG_PHYS_SZ(fs)/SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00150 // total number of pages per block, including object lookup pages 00151 #define SPIFFS_PAGES_PER_BLOCK(fs) \ 00152 ( SPIFFS_CFG_LOG_BLOCK_SZ(fs)/SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00153 // number of object lookup pages per block 00154 #define SPIFFS_OBJ_LOOKUP_PAGES(fs) \ 00155 (MAX(1, (SPIFFS_PAGES_PER_BLOCK(fs) * sizeof(spiffs_obj_id)) / SPIFFS_CFG_LOG_PAGE_SZ(fs)) ) 00156 // checks if page index belongs to object lookup 00157 #define SPIFFS_IS_LOOKUP_PAGE(fs,pix) \ 00158 (((pix) % SPIFFS_PAGES_PER_BLOCK(fs)) < SPIFFS_OBJ_LOOKUP_PAGES(fs)) 00159 // number of object lookup entries in all object lookup pages 00160 #define SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) \ 00161 (SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) 00162 // converts a block to physical address 00163 #define SPIFFS_BLOCK_TO_PADDR(fs, block) \ 00164 ( SPIFFS_CFG_PHYS_ADDR(fs) + (block)* SPIFFS_CFG_LOG_BLOCK_SZ(fs) ) 00165 // converts a object lookup entry to page index 00166 #define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, block, entry) \ 00167 ((block)*SPIFFS_PAGES_PER_BLOCK(fs) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry)) 00168 // converts a object lookup entry to physical address of corresponding page 00169 #define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PADDR(fs, block, entry) \ 00170 (SPIFFS_BLOCK_TO_PADDR(fs, block) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry) * SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00171 // converts a page to physical address 00172 #define SPIFFS_PAGE_TO_PADDR(fs, page) \ 00173 ( SPIFFS_CFG_PHYS_ADDR(fs) + (page) * SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00174 // converts a physical address to page 00175 #define SPIFFS_PADDR_TO_PAGE(fs, addr) \ 00176 ( ((addr) - SPIFFS_CFG_PHYS_ADDR(fs)) / SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00177 // gives index in page for a physical address 00178 #define SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr) \ 00179 ( ((addr) - SPIFFS_CFG_PHYS_ADDR(fs)) % SPIFFS_CFG_LOG_PAGE_SZ(fs) ) 00180 // returns containing block for given page 00181 #define SPIFFS_BLOCK_FOR_PAGE(fs, page) \ 00182 ( (page) / SPIFFS_PAGES_PER_BLOCK(fs) ) 00183 // returns starting page for block 00184 #define SPIFFS_PAGE_FOR_BLOCK(fs, block) \ 00185 ( (block) * SPIFFS_PAGES_PER_BLOCK(fs) ) 00186 // converts page to entry in object lookup page 00187 #define SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, page) \ 00188 ( (page) % SPIFFS_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs) ) 00189 // returns data size in a data page 00190 #define SPIFFS_DATA_PAGE_SIZE(fs) \ 00191 ( SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(spiffs_page_header) ) 00192 // returns physical address for block's erase count 00193 #define SPIFFS_ERASE_COUNT_PADDR(fs, bix) \ 00194 ( SPIFFS_BLOCK_TO_PADDR(fs, bix) + SPIFFS_OBJ_LOOKUP_PAGES(fs) * SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(spiffs_obj_id) ) 00195 00196 // define helpers object 00197 00198 // entries in an object header page index 00199 #define SPIFFS_OBJ_HDR_IX_LEN(fs) \ 00200 ((SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(spiffs_page_object_ix_header))/sizeof(spiffs_page_ix)) 00201 // entries in an object page index 00202 #define SPIFFS_OBJ_IX_LEN(fs) \ 00203 ((SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(spiffs_page_object_ix))/sizeof(spiffs_page_ix)) 00204 // object index entry for given data span index 00205 #define SPIFFS_OBJ_IX_ENTRY(fs, spix) \ 00206 ((spix) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? (spix) : (((spix)-SPIFFS_OBJ_HDR_IX_LEN(fs))%SPIFFS_OBJ_IX_LEN(fs))) 00207 // object index span index number for given data span index or entry 00208 #define SPIFFS_OBJ_IX_ENTRY_SPAN_IX(fs, spix) \ 00209 ((spix) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? 0 : (1+((spix)-SPIFFS_OBJ_HDR_IX_LEN(fs))/SPIFFS_OBJ_IX_LEN(fs))) 00210 00211 00212 #define SPIFFS_OP_T_OBJ_LU (0<<0) 00213 #define SPIFFS_OP_T_OBJ_LU2 (1<<0) 00214 #define SPIFFS_OP_T_OBJ_IX (2<<0) 00215 #define SPIFFS_OP_T_OBJ_DA (3<<0) 00216 #define SPIFFS_OP_C_DELE (0<<2) 00217 #define SPIFFS_OP_C_UPDT (1<<2) 00218 #define SPIFFS_OP_C_MOVS (2<<2) 00219 #define SPIFFS_OP_C_MOVD (3<<2) 00220 #define SPIFFS_OP_C_FLSH (4<<2) 00221 #define SPIFFS_OP_C_READ (5<<2) 00222 #define SPIFFS_OP_C_WRTHRU (6<<2) 00223 00224 #define SPIFFS_OP_TYPE_MASK (3<<0) 00225 #define SPIFFS_OP_COM_MASK (7<<2) 00226 00227 00228 // if 0, this page is written to, else clean 00229 #define SPIFFS_PH_FLAG_USED (1<<0) 00230 // if 0, writing is finalized, else under modification 00231 #define SPIFFS_PH_FLAG_FINAL (1<<1) 00232 // if 0, this is an index page, else a data page 00233 #define SPIFFS_PH_FLAG_INDEX (1<<2) 00234 // if 0, page is deleted, else valid 00235 #define SPIFFS_PH_FLAG_DELET (1<<7) 00236 // if 0, this index header is being deleted 00237 #define SPIFFS_PH_FLAG_IXDELE (1<<6) 00238 00239 00240 #define SPIFFS_CHECK_MOUNT(fs) \ 00241 ((fs)->block_count > 0) 00242 00243 #define SPIFFS_CHECK_RES(res) \ 00244 do { \ 00245 if ((res) < SPIFFS_OK) return (res); \ 00246 } while (0); 00247 00248 #define SPIFFS_API_CHECK_MOUNT(fs) \ 00249 if (!SPIFFS_CHECK_MOUNT((fs))) { \ 00250 (fs)->err_code = SPIFFS_ERR_NOT_MOUNTED; \ 00251 return -1; \ 00252 } 00253 00254 #define SPIFFS_API_CHECK_RES(fs, res) \ 00255 if ((res) < SPIFFS_OK) { \ 00256 (fs)->err_code = (res); \ 00257 return -1; \ 00258 } 00259 00260 #define SPIFFS_API_CHECK_RES_UNLOCK(fs, res) \ 00261 if ((res) < SPIFFS_OK) { \ 00262 (fs)->err_code = (res); \ 00263 SPIFFS_UNLOCK(fs); \ 00264 return -1; \ 00265 } 00266 00267 #define SPIFFS_VALIDATE_OBJIX(ph, objid, spix) \ 00268 if (((ph).flags & SPIFFS_PH_FLAG_USED) != 0) return SPIFFS_ERR_IS_FREE; \ 00269 if (((ph).flags & SPIFFS_PH_FLAG_DELET) == 0) return SPIFFS_ERR_DELETED; \ 00270 if (((ph).flags & SPIFFS_PH_FLAG_FINAL) != 0) return SPIFFS_ERR_NOT_FINALIZED; \ 00271 if (((ph).flags & SPIFFS_PH_FLAG_INDEX) != 0) return SPIFFS_ERR_NOT_INDEX; \ 00272 if (((objid) & SPIFFS_OBJ_ID_IX_FLAG) == 0) return SPIFFS_ERR_NOT_INDEX; \ 00273 if ((ph).span_ix != (spix)) return SPIFFS_ERR_INDEX_SPAN_MISMATCH; 00274 //if ((spix) == 0 && ((ph).flags & SPIFFS_PH_FLAG_IXDELE) == 0) return SPIFFS_ERR_DELETED; 00275 00276 #define SPIFFS_VALIDATE_DATA(ph, objid, spix) \ 00277 if (((ph).flags & SPIFFS_PH_FLAG_USED) != 0) return SPIFFS_ERR_IS_FREE; \ 00278 if (((ph).flags & SPIFFS_PH_FLAG_DELET) == 0) return SPIFFS_ERR_DELETED; \ 00279 if (((ph).flags & SPIFFS_PH_FLAG_FINAL) != 0) return SPIFFS_ERR_NOT_FINALIZED; \ 00280 if (((ph).flags & SPIFFS_PH_FLAG_INDEX) == 0) return SPIFFS_ERR_IS_INDEX; \ 00281 if ((objid) & SPIFFS_OBJ_ID_IX_FLAG) return SPIFFS_ERR_IS_INDEX; \ 00282 if ((ph).span_ix != (spix)) return SPIFFS_ERR_DATA_SPAN_MISMATCH; 00283 00284 00285 // check id 00286 #define SPIFFS_VIS_CHECK_ID (1<<0) 00287 // report argument object id to visitor - else object lookup id is reported 00288 #define SPIFFS_VIS_CHECK_PH (1<<1) 00289 // stop searching at end of all look up pages 00290 #define SPIFFS_VIS_NO_WRAP (1<<2) 00291 00292 #if SPIFFS_CACHE 00293 00294 #define SPIFFS_CACHE_FLAG_DIRTY (1<<0) 00295 #define SPIFFS_CACHE_FLAG_WRTHRU (1<<1) 00296 #define SPIFFS_CACHE_FLAG_OBJLU (1<<2) 00297 #define SPIFFS_CACHE_FLAG_OBJIX (1<<3) 00298 #define SPIFFS_CACHE_FLAG_DATA (1<<4) 00299 #define SPIFFS_CACHE_FLAG_TYPE_WR (1<<7) 00300 00301 #define SPIFFS_CACHE_PAGE_SIZE(fs) \ 00302 (sizeof(spiffs_cache_page) + SPIFFS_CFG_LOG_PAGE_SZ(fs)) 00303 00304 #define spiffs_get_cache(fs) \ 00305 ((spiffs_cache *)((fs)->cache)) 00306 00307 #define spiffs_get_cache_page_hdr(fs, c, ix) \ 00308 ((spiffs_cache_page *)(&((c)->cpages[(ix) * SPIFFS_CACHE_PAGE_SIZE(fs)]))) 00309 00310 #define spiffs_get_cache_page(fs, c, ix) \ 00311 ((u8_t *)(&((c)->cpages[(ix) * SPIFFS_CACHE_PAGE_SIZE(fs)])) + sizeof(spiffs_cache_page)) 00312 00313 // cache page struct 00314 typedef struct { 00315 // cache flags 00316 u8_t flags; 00317 // cache page index 00318 u8_t ix; 00319 // last access of this cache page 00320 u32_t last_access; 00321 union { 00322 // type read cache 00323 struct { 00324 // read cache page index 00325 spiffs_page_ix pix; 00326 }; 00327 #if SPIFFS_CACHE_WR 00328 // type write cache 00329 struct { 00330 // write cache 00331 spiffs_obj_id obj_id; 00332 // offset in cache page 00333 u32_t offset; 00334 // size of cache page 00335 u16_t size; 00336 }; 00337 #endif 00338 }; 00339 } spiffs_cache_page; 00340 00341 // cache struct 00342 typedef struct { 00343 u8_t cpage_count; 00344 u32_t last_access; 00345 u32_t cpage_use_map; 00346 u32_t cpage_use_mask; 00347 u8_t *cpages; 00348 } spiffs_cache; 00349 00350 #endif 00351 00352 00353 // spiffs nucleus file descriptor 00354 typedef struct { 00355 // the filesystem of this descriptor 00356 spiffs *fs; 00357 // number of file descriptor - if 0, the file descriptor is closed 00358 spiffs_file file_nbr; 00359 // object id - if SPIFFS_OBJ_ID_ERASED, the file was deleted 00360 spiffs_obj_id obj_id; 00361 // size of the file 00362 u32_t size; 00363 // cached object index header page index 00364 spiffs_page_ix objix_hdr_pix; 00365 // cached offset object index page index 00366 spiffs_page_ix cursor_objix_pix; 00367 // cached offset object index span index 00368 spiffs_span_ix cursor_objix_spix; 00369 // current absolute offset 00370 u32_t offset; 00371 // current file descriptor offset 00372 u32_t fdoffset; 00373 // fd flags 00374 spiffs_flags flags; 00375 #if SPIFFS_CACHE_WR 00376 spiffs_cache_page *cache_page; 00377 #endif 00378 } spiffs_fd; 00379 00380 00381 // object structs 00382 00383 // page header, part of each page except object lookup pages 00384 #ifdef __ICCARM__ 00385 typedef __packed struct { 00386 #else 00387 typedef struct __attribute(( packed )) { 00388 #endif 00389 // object id 00390 spiffs_obj_id obj_id; 00391 // object span index 00392 spiffs_span_ix span_ix; 00393 // flags 00394 u8_t flags; 00395 } spiffs_page_header; 00396 00397 // object index header page header 00398 #ifdef __ICCARM__ 00399 typedef __packed struct { 00400 #else 00401 typedef struct __attribute(( packed )) { 00402 #endif 00403 // common page header 00404 spiffs_page_header p_hdr; 00405 // alignment 00406 u8_t _align[4 - (sizeof(spiffs_page_header)&3)==0 ? 4 : (sizeof(spiffs_page_header)&3)]; 00407 // size of object 00408 u32_t size; 00409 // type of object 00410 spiffs_obj_type type; 00411 // name of object 00412 u8_t name[SPIFFS_OBJ_NAME_LEN]; 00413 } spiffs_page_object_ix_header; 00414 00415 // object index page header 00416 #ifdef __ICCARM__ 00417 typedef __packed struct { 00418 #else 00419 typedef struct __attribute(( packed )) { 00420 #endif 00421 spiffs_page_header p_hdr; 00422 u8_t _align[4 - (sizeof(spiffs_page_header)&3)==0 ? 4 : (sizeof(spiffs_page_header)&3)]; 00423 } spiffs_page_object_ix; 00424 00425 // callback func for object lookup visitor 00426 typedef s32_t (*spiffs_visitor_f)(spiffs *fs, spiffs_obj_id id, spiffs_block_ix bix, int ix_entry, 00427 u32_t user_data, void *user_p); 00428 00429 00430 #if SPIFFS_CACHE 00431 #define _spiffs_rd(fs, op, fh, addr, len, dst) \ 00432 spiffs_phys_rd((fs), (op), (fh), (addr), (len), (dst)) 00433 #define _spiffs_wr(fs, op, fh, addr, len, src) \ 00434 spiffs_phys_wr((fs), (op), (fh), (addr), (len), (src)) 00435 #else 00436 #define _spiffs_rd(fs, op, fh, addr, len, dst) \ 00437 spiffs_phys_rd((fs), (addr), (len), (dst)) 00438 #define _spiffs_wr(fs, op, fh, addr, len, src) \ 00439 spiffs_phys_wr((fs), (addr), (len), (src)) 00440 #endif 00441 00442 #ifndef MIN 00443 #define MIN(a,b) ((a) < (b) ? (a) : (b)) 00444 #endif 00445 #ifndef MAX 00446 #define MAX(a,b) ((a) > (b) ? (a) : (b)) 00447 #endif 00448 00449 // --------------- 00450 00451 s32_t spiffs_phys_rd( 00452 spiffs *fs, 00453 #if SPIFFS_CACHE 00454 u8_t op, 00455 spiffs_file fh, 00456 #endif 00457 u32_t addr, 00458 u32_t len, 00459 u8_t *dst); 00460 00461 s32_t spiffs_phys_wr( 00462 spiffs *fs, 00463 #if SPIFFS_CACHE 00464 u8_t op, 00465 spiffs_file fh, 00466 #endif 00467 u32_t addr, 00468 u32_t len, 00469 u8_t *src); 00470 00471 s32_t spiffs_phys_cpy( 00472 spiffs *fs, 00473 spiffs_file fh, 00474 u32_t dst, 00475 u32_t src, 00476 u32_t len); 00477 00478 s32_t spiffs_phys_count_free_blocks( 00479 spiffs *fs); 00480 00481 s32_t spiffs_obj_lu_find_entry_visitor( 00482 spiffs *fs, 00483 spiffs_block_ix starting_block, 00484 int starting_lu_entry, 00485 u8_t flags, 00486 spiffs_obj_id obj_id, 00487 spiffs_visitor_f v, 00488 u32_t user_data, 00489 void *user_p, 00490 spiffs_block_ix *block_ix, 00491 int *lu_entry); 00492 00493 // --------------- 00494 00495 s32_t spiffs_obj_lu_scan( 00496 spiffs *fs); 00497 00498 s32_t spiffs_obj_lu_find_free_obj_id( 00499 spiffs *fs, 00500 spiffs_obj_id *obj_id); 00501 00502 s32_t spiffs_obj_lu_find_free( 00503 spiffs *fs, 00504 spiffs_block_ix starting_block, 00505 int starting_lu_entry, 00506 spiffs_block_ix *block_ix, 00507 int *lu_entry); 00508 00509 s32_t spiffs_obj_lu_find_id( 00510 spiffs *fs, 00511 spiffs_block_ix starting_block, 00512 int starting_lu_entry, 00513 spiffs_obj_id obj_id, 00514 spiffs_block_ix *block_ix, 00515 int *lu_entry); 00516 00517 s32_t spiffs_obj_lu_find_id_and_span( 00518 spiffs *fs, 00519 spiffs_obj_id obj_id, 00520 spiffs_span_ix spix, 00521 spiffs_page_ix exclusion_pix, 00522 spiffs_page_ix *pix); 00523 00524 s32_t spiffs_obj_lu_find_id_and_span_by_phdr( 00525 spiffs *fs, 00526 spiffs_obj_id obj_id, 00527 spiffs_span_ix spix, 00528 spiffs_page_ix exclusion_pix, 00529 spiffs_page_ix *pix); 00530 00531 // --------------- 00532 00533 s32_t spiffs_page_allocate_data( 00534 spiffs *fs, 00535 spiffs_obj_id obj_id, 00536 spiffs_page_header *ph, 00537 u8_t *data, 00538 u32_t len, 00539 u32_t page_offs, 00540 u8_t finalize, 00541 spiffs_page_ix *pix); 00542 00543 s32_t spiffs_page_move( 00544 spiffs *fs, 00545 spiffs_file fh, 00546 u8_t *page_data, 00547 spiffs_obj_id obj_id, 00548 spiffs_page_header *page_hdr, 00549 spiffs_page_ix src_pix, 00550 spiffs_page_ix *dst_pix); 00551 00552 s32_t spiffs_page_delete( 00553 spiffs *fs, 00554 spiffs_page_ix pix); 00555 00556 // --------------- 00557 00558 s32_t spiffs_object_create( 00559 spiffs *fs, 00560 spiffs_obj_id obj_id, 00561 u8_t name[SPIFFS_OBJ_NAME_LEN], 00562 spiffs_obj_type type, 00563 spiffs_page_ix *objix_hdr_pix); 00564 00565 s32_t spiffs_object_update_index_hdr( 00566 spiffs *fs, 00567 spiffs_fd *fd, 00568 spiffs_obj_id obj_id, 00569 spiffs_page_ix objix_hdr_pix, 00570 u8_t *new_objix_hdr_data, 00571 u8_t name[SPIFFS_OBJ_NAME_LEN], 00572 u32_t size, 00573 spiffs_page_ix *new_pix); 00574 00575 void spiffs_cb_object_event( 00576 spiffs *fs, 00577 spiffs_fd *fd, 00578 int ev, 00579 spiffs_obj_id obj_id, 00580 spiffs_span_ix spix, 00581 spiffs_page_ix new_pix, 00582 u32_t new_size); 00583 00584 s32_t spiffs_object_open_by_id( 00585 spiffs *fs, 00586 spiffs_obj_id obj_id, 00587 spiffs_fd *f, 00588 spiffs_flags flags, 00589 spiffs_mode mode); 00590 00591 s32_t spiffs_object_open_by_page( 00592 spiffs *fs, 00593 spiffs_page_ix pix, 00594 spiffs_fd *f, 00595 spiffs_flags flags, 00596 spiffs_mode mode); 00597 00598 s32_t spiffs_object_append( 00599 spiffs_fd *fd, 00600 u32_t offset, 00601 u8_t *data, 00602 u32_t len); 00603 00604 s32_t spiffs_object_modify( 00605 spiffs_fd *fd, 00606 u32_t offset, 00607 u8_t *data, 00608 u32_t len); 00609 00610 s32_t spiffs_object_read( 00611 spiffs_fd *fd, 00612 u32_t offset, 00613 u32_t len, 00614 u8_t *dst); 00615 00616 s32_t spiffs_object_truncate( 00617 spiffs_fd *fd, 00618 u32_t new_len, 00619 u8_t remove_object); 00620 00621 s32_t spiffs_object_find_object_index_header_by_name( 00622 spiffs *fs, 00623 u8_t name[SPIFFS_OBJ_NAME_LEN], 00624 spiffs_page_ix *pix); 00625 00626 // --------------- 00627 00628 s32_t spiffs_gc_check( 00629 spiffs *fs, 00630 u32_t len); 00631 00632 s32_t spiffs_gc_erase_page_stats( 00633 spiffs *fs, 00634 spiffs_block_ix bix); 00635 00636 s32_t spiffs_gc_find_candidate( 00637 spiffs *fs, 00638 spiffs_block_ix **block_candidate, 00639 int *candidate_count); 00640 00641 s32_t spiffs_gc_clean( 00642 spiffs *fs, 00643 spiffs_block_ix bix); 00644 00645 s32_t spiffs_gc_quick( 00646 spiffs *fs); 00647 00648 // --------------- 00649 00650 s32_t spiffs_fd_find_new( 00651 spiffs *fs, 00652 spiffs_fd **fd); 00653 00654 s32_t spiffs_fd_return( 00655 spiffs *fs, 00656 spiffs_file f); 00657 00658 s32_t spiffs_fd_get( 00659 spiffs *fs, 00660 spiffs_file f, 00661 spiffs_fd **fd); 00662 00663 #if SPIFFS_CACHE 00664 void spiffs_cache_init( 00665 spiffs *fs); 00666 00667 void spiffs_cache_drop_page( 00668 spiffs *fs, 00669 spiffs_page_ix pix); 00670 00671 #if SPIFFS_CACHE_WR 00672 spiffs_cache_page *spiffs_cache_page_allocate_by_fd( 00673 spiffs *fs, 00674 spiffs_fd *fd); 00675 00676 void spiffs_cache_fd_release( 00677 spiffs *fs, 00678 spiffs_cache_page *cp); 00679 00680 spiffs_cache_page *spiffs_cache_page_get_by_fd( 00681 spiffs *fs, 00682 spiffs_fd *fd); 00683 #endif 00684 #endif 00685 00686 s32_t spiffs_lookup_consistency_check( 00687 spiffs *fs, 00688 u8_t check_all_objects); 00689 00690 s32_t spiffs_page_consistency_check( 00691 spiffs *fs); 00692 00693 s32_t spiffs_object_index_consistency_check( 00694 spiffs *fs); 00695 00696 #endif /* SPIFFS_NUCLEUS_H_ */
Generated on Tue Jul 12 2022 12:07:34 by
1.7.2