s32_t ICACHE_FLASH_ATTR SPIFFS_mount(spiffs *fs, spiffs_config *config, u8_t *work, u8_t *fd_space, u32_t fd_space_size, void *cache, u32_t cache_size, spiffs_check_callback check_cb_f) { SPIFFS_LOCK(fs); memset(fs, 0, sizeof(spiffs)); memcpy(&fs->cfg, config, sizeof(spiffs_config)); fs->block_count = SPIFFS_CFG_PHYS_SZ(fs) / SPIFFS_CFG_LOG_BLOCK_SZ(fs); fs->work = &work[0]; fs->lu_work = &work[SPIFFS_CFG_LOG_PAGE_SZ(fs)]; memset(fd_space, 0, fd_space_size); // align fd_space pointer to pointer size byte boundary, below is safe u8_t ptr_size = sizeof(void*); // #pragma GCC diagnostic push // #pragma GCC diagnostic ignored "-Wpointer-to-int-cast" u8_t addr_lsb = (u8_t)(((u32_t)fd_space) & (ptr_size-1)); // #pragma GCC diagnostic pop if (addr_lsb) { fd_space += (ptr_size-addr_lsb); fd_space_size -= (ptr_size-addr_lsb); } fs->fd_space = fd_space; fs->fd_count = (fd_space_size/sizeof(spiffs_fd)); // align cache pointer to 4 byte boundary, below is safe // #pragma GCC diagnostic push // #pragma GCC diagnostic ignored "-Wpointer-to-int-cast" addr_lsb = (u8_t)(((u32_t)cache) & (ptr_size-1)); // #pragma GCC diagnostic pop if (addr_lsb) { cache = (u8_t *)cache + (ptr_size-addr_lsb); cache_size -= (ptr_size-addr_lsb); } if (cache_size & (ptr_size-1)) { cache_size -= (cache_size & (ptr_size-1)); } #if SPIFFS_CACHE fs->cache = cache; fs->cache_size = cache_size; spiffs_cache_init(fs); #endif s32_t res = spiffs_obj_lu_scan(fs); SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_DBG("page index byte len: %i\n", SPIFFS_CFG_LOG_PAGE_SZ(fs)); SPIFFS_DBG("object lookup pages: %i\n", SPIFFS_OBJ_LOOKUP_PAGES(fs)); SPIFFS_DBG("page pages per block: %i\n", SPIFFS_PAGES_PER_BLOCK(fs)); SPIFFS_DBG("page header length: %i\n", sizeof(spiffs_page_header)); SPIFFS_DBG("object header index entries: %i\n", SPIFFS_OBJ_HDR_IX_LEN(fs)); SPIFFS_DBG("object index entries: %i\n", SPIFFS_OBJ_IX_LEN(fs)); SPIFFS_DBG("available file descriptors: %i\n", fs->fd_count); SPIFFS_DBG("free blocks: %i\n", fs->free_blocks); fs->check_cb_f = check_cb_f; SPIFFS_UNLOCK(fs); return 0; }
s32_t SPIFFS_write(spiffs *fs, spiffs_file fh, void *buf, u32_t len) { SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_LOCK(fs); spiffs_fd *fd; s32_t res; u32_t offset; res = spiffs_fd_get(fs, fh, &fd); SPIFFS_API_CHECK_RES_UNLOCK(fs, res); if ((fd->flags & SPIFFS_WRONLY) == 0) { res = SPIFFS_ERR_NOT_WRITABLE; SPIFFS_API_CHECK_RES_UNLOCK(fs, res); } offset = fd->fdoffset; #if SPIFFS_CACHE_WR if (fd->cache_page == 0) { // see if object id is associated with cache already fd->cache_page = spiffs_cache_page_get_by_fd(fs, fd); } #endif if (fd->flags & SPIFFS_APPEND) { if (fd->size == SPIFFS_UNDEFINED_LEN) { offset = 0; } else { offset = fd->size; } #if SPIFFS_CACHE_WR if (fd->cache_page) { offset = MAX(offset, fd->cache_page->offset + fd->cache_page->size); } #endif } SPIFFS_DBG("SPIFFS_write %d %04x offs:%d len %d\n", fh, fd->obj_id, offset, len); #if SPIFFS_CACHE_WR if ((fd->flags & SPIFFS_DIRECT) == 0) { if (len < (s32_t)SPIFFS_CFG_LOG_PAGE_SZ(fs)) { // small write, try to cache it u8_t alloc_cpage = 1; if (fd->cache_page) { // have a cached page for this fd already, check cache page boundaries if (offset < fd->cache_page->offset || // writing before cache offset > fd->cache_page->offset + fd->cache_page->size || // writing after cache offset + len > fd->cache_page->offset + SPIFFS_CFG_LOG_PAGE_SZ(fs)) // writing beyond cache page { // boundary violation, write back cache first and allocate new SPIFFS_CACHE_DBG("CACHE_WR_DUMP: dumping cache page %d for fd %d:&04x, boundary viol, offs:%d size:%d\n", fd->cache_page->ix, fd->file_nbr, fd->obj_id, fd->cache_page->offset, fd->cache_page->size); res = spiffs_hydro_write(fs, fd, spiffs_get_cache_page(fs, spiffs_get_cache(fs), fd->cache_page->ix), fd->cache_page->offset, fd->cache_page->size); spiffs_cache_fd_release(fs, fd->cache_page); } else { // writing within cache alloc_cpage = 0; } } if (alloc_cpage) { fd->cache_page = spiffs_cache_page_allocate_by_fd(fs, fd); if (fd->cache_page) { fd->cache_page->offset = offset; fd->cache_page->size = 0; SPIFFS_CACHE_DBG("CACHE_WR_ALLO: allocating cache page %d for fd %d:%04x\n", fd->cache_page->ix, fd->file_nbr, fd->obj_id); } } if (fd->cache_page) { u32_t offset_in_cpage = offset - fd->cache_page->offset; SPIFFS_CACHE_DBG("CACHE_WR_WRITE: storing to cache page %d for fd %d:%04x, offs %d:%d len %d\n", fd->cache_page->ix, fd->file_nbr, fd->obj_id, offset, offset_in_cpage, len); spiffs_cache *cache = spiffs_get_cache(fs); u8_t *cpage_data = spiffs_get_cache_page(fs, cache, fd->cache_page->ix); c_memcpy(&cpage_data[offset_in_cpage], buf, len); fd->cache_page->size = MAX(fd->cache_page->size, offset_in_cpage + len); fd->fdoffset += len; SPIFFS_UNLOCK(fs); return len; } else { res = spiffs_hydro_write(fs, fd, buf, offset, len); SPIFFS_API_CHECK_RES(fs, res); fd->fdoffset += len; SPIFFS_UNLOCK(fs); return res; } } else { // big write, no need to cache it - but first check if there is a cached write already if (fd->cache_page) { // write back cache first SPIFFS_CACHE_DBG("CACHE_WR_DUMP: dumping cache page %d for fd %d:%04x, big write, offs:%d size:%d\n", fd->cache_page->ix, fd->file_nbr, fd->obj_id, fd->cache_page->offset, fd->cache_page->size); res = spiffs_hydro_write(fs, fd, spiffs_get_cache_page(fs, spiffs_get_cache(fs), fd->cache_page->ix), fd->cache_page->offset, fd->cache_page->size); spiffs_cache_fd_release(fs, fd->cache_page); res = spiffs_hydro_write(fs, fd, buf, offset, len); SPIFFS_API_CHECK_RES(fs, res); } } } #endif res = spiffs_hydro_write(fs, fd, buf, offset, len); SPIFFS_API_CHECK_RES(fs, res); fd->fdoffset += len; SPIFFS_UNLOCK(fs); return res; }
s32_t SPIFFS_mount(spiffs *fs, spiffs_config *config, u8_t *work, u8_t *fd_space, u32_t fd_space_size, void *cache, u32_t cache_size, spiffs_check_callback check_cb_f) { void *user_data; SPIFFS_LOCK(fs); user_data = fs->user_data; memset(fs, 0, sizeof(spiffs)); memcpy(&fs->cfg, config, sizeof(spiffs_config)); fs->user_data = user_data; fs->block_count = SPIFFS_CFG_PHYS_SZ(fs) / SPIFFS_CFG_LOG_BLOCK_SZ(fs); fs->work = &work[0]; fs->lu_work = &work[SPIFFS_CFG_LOG_PAGE_SZ(fs)]; memset(fd_space, 0, fd_space_size); // align fd_space pointer to pointer size byte boundary u8_t ptr_size = sizeof(void*); u8_t addr_lsb = ((u8_t)(intptr_t)fd_space) & (ptr_size-1); if (addr_lsb) { fd_space += (ptr_size-addr_lsb); fd_space_size -= (ptr_size-addr_lsb); } fs->fd_space = fd_space; fs->fd_count = (fd_space_size/sizeof(spiffs_fd)); // align cache pointer to 4 byte boundary addr_lsb = ((u8_t)(intptr_t)cache) & (ptr_size-1); if (addr_lsb) { u8_t *cache_8 = (u8_t *)cache; cache_8 += (ptr_size-addr_lsb); cache = cache_8; cache_size -= (ptr_size-addr_lsb); } if (cache_size & (ptr_size-1)) { cache_size -= (cache_size & (ptr_size-1)); } #if SPIFFS_CACHE fs->cache = cache; fs->cache_size = (cache_size > (SPIFFS_CFG_LOG_PAGE_SZ(fs)*32)) ? SPIFFS_CFG_LOG_PAGE_SZ(fs)*32 : cache_size; spiffs_cache_init(fs); #endif s32_t res; #if SPIFFS_USE_MAGIC res = SPIFFS_CHECK_MAGIC_POSSIBLE(fs) ? SPIFFS_OK : SPIFFS_ERR_MAGIC_NOT_POSSIBLE; SPIFFS_API_CHECK_RES_UNLOCK(fs, res); #endif fs->config_magic = SPIFFS_CONFIG_MAGIC; res = spiffs_obj_lu_scan(fs); SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_DBG("page index byte len: %i\n", SPIFFS_CFG_LOG_PAGE_SZ(fs)); SPIFFS_DBG("object lookup pages: %i\n", SPIFFS_OBJ_LOOKUP_PAGES(fs)); SPIFFS_DBG("page pages per block: %i\n", SPIFFS_PAGES_PER_BLOCK(fs)); SPIFFS_DBG("page header length: %i\n", sizeof(spiffs_page_header)); SPIFFS_DBG("object header index entries: %i\n", SPIFFS_OBJ_HDR_IX_LEN(fs)); SPIFFS_DBG("object index entries: %i\n", SPIFFS_OBJ_IX_LEN(fs)); SPIFFS_DBG("available file descriptors: %i\n", fs->fd_count); SPIFFS_DBG("free blocks: %i\n", fs->free_blocks); fs->check_cb_f = check_cb_f; fs->mounted = 1; SPIFFS_UNLOCK(fs); return 0; }