自学教程：C++ spiffs_get_cache函数代码示例

// frees cached pagestatic s32_t ICACHE_FLASH_ATTRspiffs_cache_page_free(spiffs *fs, int ix, u8_t write_back) {  s32_t res = SPIFFS_OK;  spiffs_cache *cache = spiffs_get_cache(fs);  spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, ix);  if (cache->cpage_use_map & (1<<ix)) {    if (write_back &&        (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) == 0 &&        (cp->flags & SPIFFS_CACHE_FLAG_DIRTY)) {      u8_t *mem =  spiffs_get_cache_page(fs, cache, ix);      res = fs->cfg.hal_write_f(SPIFFS_PAGE_TO_PADDR(fs, cp->pix), SPIFFS_CFG_LOG_PAGE_SZ(fs), mem);    }    cp->flags = 0;    cache->cpage_use_map &= ~(1 << ix);    if (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) {      SPIFFS_CACHE_DBG("CACHE_FREE: free cache page %d objid %04x/n", ix, cp->obj_id);    } else {      SPIFFS_CACHE_DBG("CACHE_FREE: free cache page %d pix %04x/n", ix, cp->pix);    }  }  return res;}

// removes the oldest accessed cached pagestatic s32_t ICACHE_FLASH_ATTRspiffs_cache_page_remove_oldest(spiffs *fs, u8_t flag_mask, u8_t flags) {  s32_t res = SPIFFS_OK;  spiffs_cache *cache = spiffs_get_cache(fs);  if ((cache->cpage_use_map & cache->cpage_use_mask) != cache->cpage_use_mask) {    // at least one free cpage    return SPIFFS_OK;  }  // all busy, scan thru all to find the cpage which has oldest access  int i;  int cand_ix = -1;  u32_t oldest_val = 0;  for (i = 0; i < cache->cpage_count; i++) {    spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);    if ((cache->last_access - cp->last_access) > oldest_val &&        (cp->flags & flag_mask) == flags) {      oldest_val = cache->last_access - cp->last_access;      cand_ix = i;    }  }  if (cand_ix >= 0) {    res = spiffs_cache_page_free(fs, cand_ix, 1);  }  return res;}

// Checks if there are any cached writes for the object id associated with// given filehandle. If so, these writes are flushed.static s32_t spiffs_fflush_cache(spiffs *fs, spiffs_file fh) {  s32_t res = SPIFFS_OK;#if SPIFFS_CACHE_WR  spiffs_fd *fd;  res = spiffs_fd_get(fs, fh, &fd);  SPIFFS_API_CHECK_RES(fs, res);  if ((fd->flags & SPIFFS_DIRECT) == 0) {    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);    }    if (fd->cache_page) {      SPIFFS_CACHE_DBG("CACHE_WR_DUMP: dumping cache page %d for fd %d:%04x, flush, 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);      if (res < SPIFFS_OK) {        fs->errno = res;      }      spiffs_cache_fd_release(fs, fd->cache_page);    }  }#endif  return res;}

// initializes the cachevoid ICACHE_FLASH_ATTRspiffs_cache_init(spiffs *fs) {  if (fs->cache == 0) return;  u32_t sz = fs->cache_size;  u32_t cache_mask = 0;  int i;  int cache_entries =      (sz - sizeof(spiffs_cache)) / (SPIFFS_CACHE_PAGE_SIZE(fs));  if (cache_entries <= 0) return;  for (i = 0; i < cache_entries; i++) {    cache_mask <<= 1;    cache_mask |= 1;  }  spiffs_cache cache;  memset(&cache, 0, sizeof(spiffs_cache));  cache.cpage_count = cache_entries;  cache.cpages = (u8_t *)((u8_t *)fs->cache + sizeof(spiffs_cache));  cache.cpage_use_map = 0xffffffff;  cache.cpage_use_mask = cache_mask;  memcpy(fs->cache, &cache, sizeof(spiffs_cache));  spiffs_cache *c = spiffs_get_cache(fs);  memset(c->cpages, 0, c->cpage_count * SPIFFS_CACHE_PAGE_SIZE(fs));  c->cpage_use_map &= ~(c->cpage_use_mask);  for (i = 0; i < cache.cpage_count; i++) {    spiffs_get_cache_page_hdr(fs, c, i)->ix = i;  }}

// reads from spi flash or the caches32_t spiffs_phys_rd(    spiffs *fs,    u8_t op,    spiffs_file fh,    u32_t addr,    u32_t len,    u8_t *dst) {  (void)fh;  s32_t res = SPIFFS_OK;  spiffs_cache *cache = spiffs_get_cache(fs);  spiffs_cache_page *cp =  spiffs_cache_page_get(fs, SPIFFS_PADDR_TO_PAGE(fs, addr));  cache->last_access++;  if (cp) {    // we've already got one, you see#if SPIFFS_CACHE_STATS    fs->cache_hits++;#endif    cp->last_access = cache->last_access;    u8_t *mem =  spiffs_get_cache_page(fs, cache, cp->ix);    memcpy(dst, &mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], len);  } else {    if ((op & SPIFFS_OP_TYPE_MASK) == SPIFFS_OP_T_OBJ_LU2) {      // for second layer lookup functions, we do not cache in order to prevent shredding      return SPIFFS_HAL_READ(fs, addr, len, dst);    }#if SPIFFS_CACHE_STATS    fs->cache_misses++;#endif    // this operation will always free one cache page (unless all already free),    // the result code stems from the write operation of the possibly freed cache page    res = spiffs_cache_page_remove_oldest(fs, SPIFFS_CACHE_FLAG_TYPE_WR, 0);    cp = spiffs_cache_page_allocate(fs);    if (cp) {      cp->flags = SPIFFS_CACHE_FLAG_WRTHRU;      cp->pix = SPIFFS_PADDR_TO_PAGE(fs, addr);      s32_t res2 = SPIFFS_HAL_READ(fs,          addr - SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr),          SPIFFS_CFG_LOG_PAGE_SZ(fs),          spiffs_get_cache_page(fs, cache, cp->ix));      if (res2 != SPIFFS_OK) {        // honor read failure before possible write failure (bad idea?)        res = res2;      }      u8_t *mem =  spiffs_get_cache_page(fs, cache, cp->ix);      memcpy(dst, &mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], len);    } else {      // this will never happen, last resort for sake of symmetry      s32_t res2 = SPIFFS_HAL_READ(fs, addr, len, dst);      if (res2 != SPIFFS_OK) {        // honor read failure before possible write failure (bad idea?)        res = res2;      }    }  }  return res;}

// reads from spi flash or the caches32_t ICACHE_FLASH_ATTRspiffs_phys_rd(    spiffs *fs,    u8_t op,    spiffs_file fh,    u32_t addr,    u32_t len,    u8_t *dst) {  (void)fh;  s32_t res = SPIFFS_OK;  spiffs_cache *cache = spiffs_get_cache(fs);  spiffs_cache_page *cp =  spiffs_cache_page_get(fs, SPIFFS_PADDR_TO_PAGE(fs, addr));  cache->last_access++;  if (cp) {#if SPIFFS_CACHE_STATS    fs->cache_hits++;#endif    cp->last_access = cache->last_access;  } else {    if ((op & SPIFFS_OP_TYPE_MASK) == SPIFFS_OP_T_OBJ_LU2) {      // for second layer lookup functions, we do not cache in order to prevent shredding      return fs->cfg.hal_read_f(          addr ,          len,          dst);    }#if SPIFFS_CACHE_STATS    fs->cache_misses++;#endif    res = spiffs_cache_page_remove_oldest(fs, SPIFFS_CACHE_FLAG_TYPE_WR, 0);    cp = spiffs_cache_page_allocate(fs);    if (cp) {      cp->flags = SPIFFS_CACHE_FLAG_WRTHRU;      cp->pix = SPIFFS_PADDR_TO_PAGE(fs, addr);    }    s32_t res2 = fs->cfg.hal_read_f(        addr - SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr),        SPIFFS_CFG_LOG_PAGE_SZ(fs),        spiffs_get_cache_page(fs, cache, cp->ix));    if (res2 != SPIFFS_OK) {      res = res2;    }  }  u8_t *mem =  spiffs_get_cache_page(fs, cache, cp->ix);  memcpy(dst, &mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], len);  return res;}

// returns cached page for give page index, or null if no such cached pagestatic spiffs_cache_page *ICACHE_FLASH_ATTR spiffs_cache_page_get(spiffs *fs, spiffs_page_ix pix) {  spiffs_cache *cache = spiffs_get_cache(fs);  if ((cache->cpage_use_map & cache->cpage_use_mask) == 0) return 0;  int i;  for (i = 0; i < cache->cpage_count; i++) {    spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);    if ((cache->cpage_use_map & (1<<i)) &&        (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) == 0 &&        cp->pix == pix ) {      SPIFFS_CACHE_DBG("CACHE_GET: have cache page %i for %04x/n", i, pix);      cp->last_access = cache->last_access;      return cp;    }  }  //SPIFFS_CACHE_DBG("CACHE_GET: no cache for %04x/n", pix);  return 0;}

// allocates a new cached page and returns it, or null if all cache pages are busystatic spiffs_cache_page *ICACHE_FLASH_ATTR spiffs_cache_page_allocate(spiffs *fs) {  spiffs_cache *cache = spiffs_get_cache(fs);  if (cache->cpage_use_map == 0xffffffff) {    // out of cache memory    return 0;  }  int i;  for (i = 0; i < cache->cpage_count; i++) {    if ((cache->cpage_use_map & (1<<i)) == 0) {      spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);      cache->cpage_use_map |= (1<<i);      cp->last_access = cache->last_access;      SPIFFS_CACHE_DBG("CACHE_ALLO: allocated cache page %i/n", i);      return cp;    }  }  // out of cache entries  return 0;}

// returns the cache page that this fd refers, or null if no cache pagespiffs_cache_page *ICACHE_FLASH_ATTR spiffs_cache_page_get_by_fd(spiffs *fs, spiffs_fd *fd) {  spiffs_cache *cache = spiffs_get_cache(fs);  if ((cache->cpage_use_map & cache->cpage_use_mask) == 0) {    // all cpages free, no cpage cannot be assigned to obj_id    return 0;  }  int i;  for (i = 0; i < cache->cpage_count; i++) {    spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);    if ((cache->cpage_use_map & (1<<i)) &&        (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) &&        cp->obj_id == fd->obj_id) {      return cp;    }  }  return 0;}

// writes to spi flash and/or the caches32_t ICACHE_FLASH_ATTRspiffs_phys_wr(    spiffs *fs,    u8_t op,    spiffs_file fh,    u32_t addr,    u32_t len,    u8_t *src) {  (void)fh;  spiffs_page_ix pix = SPIFFS_PADDR_TO_PAGE(fs, addr);  spiffs_cache *cache = spiffs_get_cache(fs);  spiffs_cache_page *cp =  spiffs_cache_page_get(fs, pix);  if (cp && (op & SPIFFS_OP_COM_MASK) != SPIFFS_OP_C_WRTHRU) {    // have a cache page    // copy in data to cache page    if ((op & SPIFFS_OP_COM_MASK) == SPIFFS_OP_C_DELE &&        (op & SPIFFS_OP_TYPE_MASK) != SPIFFS_OP_T_OBJ_LU) {      // page is being deleted, wipe from cache - unless it is a lookup page      spiffs_cache_page_free(fs, cp->ix, 0);      return fs->cfg.hal_write_f(addr, len, src);    }    u8_t *mem =  spiffs_get_cache_page(fs, cache, cp->ix);    memcpy(&mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], src, len);    cache->last_access++;    cp->last_access = cache->last_access;    if (cp->flags && SPIFFS_CACHE_FLAG_WRTHRU) {      // page is being updated, no write-cache, just pass thru      return fs->cfg.hal_write_f(addr, len, src);    } else {      return SPIFFS_OK;    }  } else {    // no cache page, no write cache - just write thru    return fs->cfg.hal_write_f(addr, len, src);  }}

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),//.........这里部分代码省略.........