spiffs_cache.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  1. /*
  2. * spiffs_cache.c
  3. *
  4. * Created on: Jun 23, 2013
  5. * Author: petera
  6. */
  7. #include "spiffs.h"
  8. #include "spiffs_nucleus.h"
  9. #if SPIFFS_CACHE
  10. // returns cached page for give page index, or null if no such cached page
  11. static spiffs_cache_page *spiffs_cache_page_get(spiffs *fs, spiffs_page_ix pix) {
  12. spiffs_cache *cache = spiffs_get_cache(fs);
  13. if ((cache->cpage_use_map & cache->cpage_use_mask) == 0) return 0;
  14. int i;
  15. for (i = 0; i < cache->cpage_count; i++) {
  16. spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);
  17. if ((cache->cpage_use_map & (1<<i)) &&
  18. (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) == 0 &&
  19. cp->pix == pix ) {
  20. SPIFFS_CACHE_DBG("CACHE_GET: have cache page %i for %04x\n", i, pix);
  21. cp->last_access = cache->last_access;
  22. return cp;
  23. }
  24. }
  25. //SPIFFS_CACHE_DBG("CACHE_GET: no cache for %04x\n", pix);
  26. return 0;
  27. }
  28. // frees cached page
  29. static s32_t spiffs_cache_page_free(spiffs *fs, int ix, u8_t write_back) {
  30. s32_t res = SPIFFS_OK;
  31. spiffs_cache *cache = spiffs_get_cache(fs);
  32. spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, ix);
  33. if (cache->cpage_use_map & (1<<ix)) {
  34. if (write_back &&
  35. (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) == 0 &&
  36. (cp->flags & SPIFFS_CACHE_FLAG_DIRTY)) {
  37. u8_t *mem = spiffs_get_cache_page(fs, cache, ix);
  38. res = SPIFFS_HAL_WRITE(fs, SPIFFS_PAGE_TO_PADDR(fs, cp->pix), SPIFFS_CFG_LOG_PAGE_SZ(fs), mem);
  39. }
  40. cp->flags = 0;
  41. cache->cpage_use_map &= ~(1 << ix);
  42. if (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) {
  43. SPIFFS_CACHE_DBG("CACHE_FREE: free cache page %i objid %04x\n", ix, cp->obj_id);
  44. } else {
  45. SPIFFS_CACHE_DBG("CACHE_FREE: free cache page %i pix %04x\n", ix, cp->pix);
  46. }
  47. }
  48. return res;
  49. }
  50. // removes the oldest accessed cached page
  51. static s32_t spiffs_cache_page_remove_oldest(spiffs *fs, u8_t flag_mask, u8_t flags) {
  52. s32_t res = SPIFFS_OK;
  53. spiffs_cache *cache = spiffs_get_cache(fs);
  54. if ((cache->cpage_use_map & cache->cpage_use_mask) != cache->cpage_use_mask) {
  55. // at least one free cpage
  56. return SPIFFS_OK;
  57. }
  58. // all busy, scan thru all to find the cpage which has oldest access
  59. int i;
  60. int cand_ix = -1;
  61. u32_t oldest_val = 0;
  62. for (i = 0; i < cache->cpage_count; i++) {
  63. spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);
  64. if ((cache->last_access - cp->last_access) > oldest_val &&
  65. (cp->flags & flag_mask) == flags) {
  66. oldest_val = cache->last_access - cp->last_access;
  67. cand_ix = i;
  68. }
  69. }
  70. if (cand_ix >= 0) {
  71. res = spiffs_cache_page_free(fs, cand_ix, 1);
  72. }
  73. return res;
  74. }
  75. // allocates a new cached page and returns it, or null if all cache pages are busy
  76. static spiffs_cache_page *spiffs_cache_page_allocate(spiffs *fs) {
  77. spiffs_cache *cache = spiffs_get_cache(fs);
  78. if (cache->cpage_use_map == 0xffffffff) {
  79. // out of cache memory
  80. return 0;
  81. }
  82. int i;
  83. for (i = 0; i < cache->cpage_count; i++) {
  84. if ((cache->cpage_use_map & (1<<i)) == 0) {
  85. spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);
  86. cache->cpage_use_map |= (1<<i);
  87. cp->last_access = cache->last_access;
  88. SPIFFS_CACHE_DBG("CACHE_ALLO: allocated cache page %i\n", i);
  89. return cp;
  90. }
  91. }
  92. // out of cache entries
  93. return 0;
  94. }
  95. // drops the cache page for give page index
  96. void spiffs_cache_drop_page(spiffs *fs, spiffs_page_ix pix) {
  97. spiffs_cache_page *cp = spiffs_cache_page_get(fs, pix);
  98. if (cp) {
  99. spiffs_cache_page_free(fs, cp->ix, 0);
  100. }
  101. }
  102. // ------------------------------
  103. // reads from spi flash or the cache
  104. s32_t spiffs_phys_rd(
  105. spiffs *fs,
  106. u8_t op,
  107. spiffs_file fh,
  108. u32_t addr,
  109. u32_t len,
  110. u8_t *dst) {
  111. (void)fh;
  112. s32_t res = SPIFFS_OK;
  113. spiffs_cache *cache = spiffs_get_cache(fs);
  114. spiffs_cache_page *cp = spiffs_cache_page_get(fs, SPIFFS_PADDR_TO_PAGE(fs, addr));
  115. cache->last_access++;
  116. if (cp) {
  117. #if SPIFFS_CACHE_STATS
  118. fs->cache_hits++;
  119. #endif
  120. cp->last_access = cache->last_access;
  121. } else {
  122. if ((op & SPIFFS_OP_TYPE_MASK) == SPIFFS_OP_T_OBJ_LU2) {
  123. // for second layer lookup functions, we do not cache in order to prevent shredding
  124. return SPIFFS_HAL_READ(fs, addr, len, dst);
  125. }
  126. #if SPIFFS_CACHE_STATS
  127. fs->cache_misses++;
  128. #endif
  129. res = spiffs_cache_page_remove_oldest(fs, SPIFFS_CACHE_FLAG_TYPE_WR, 0);
  130. cp = spiffs_cache_page_allocate(fs);
  131. if (cp) {
  132. cp->flags = SPIFFS_CACHE_FLAG_WRTHRU;
  133. cp->pix = SPIFFS_PADDR_TO_PAGE(fs, addr);
  134. }
  135. s32_t res2 = SPIFFS_HAL_READ(fs,
  136. addr - SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr),
  137. SPIFFS_CFG_LOG_PAGE_SZ(fs),
  138. spiffs_get_cache_page(fs, cache, cp->ix));
  139. if (res2 != SPIFFS_OK) {
  140. res = res2;
  141. }
  142. }
  143. u8_t *mem = spiffs_get_cache_page(fs, cache, cp->ix);
  144. memcpy(dst, &mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], len);
  145. return res;
  146. }
  147. // writes to spi flash and/or the cache
  148. s32_t spiffs_phys_wr(
  149. spiffs *fs,
  150. u8_t op,
  151. spiffs_file fh,
  152. u32_t addr,
  153. u32_t len,
  154. u8_t *src) {
  155. (void)fh;
  156. spiffs_page_ix pix = SPIFFS_PADDR_TO_PAGE(fs, addr);
  157. spiffs_cache *cache = spiffs_get_cache(fs);
  158. spiffs_cache_page *cp = spiffs_cache_page_get(fs, pix);
  159. if (cp && (op & SPIFFS_OP_COM_MASK) != SPIFFS_OP_C_WRTHRU) {
  160. // have a cache page
  161. // copy in data to cache page
  162. if ((op & SPIFFS_OP_COM_MASK) == SPIFFS_OP_C_DELE &&
  163. (op & SPIFFS_OP_TYPE_MASK) != SPIFFS_OP_T_OBJ_LU) {
  164. // page is being deleted, wipe from cache - unless it is a lookup page
  165. spiffs_cache_page_free(fs, cp->ix, 0);
  166. return SPIFFS_HAL_WRITE(fs, addr, len, src);
  167. }
  168. u8_t *mem = spiffs_get_cache_page(fs, cache, cp->ix);
  169. memcpy(&mem[SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr)], src, len);
  170. cache->last_access++;
  171. cp->last_access = cache->last_access;
  172. if (cp->flags & SPIFFS_CACHE_FLAG_WRTHRU) {
  173. // page is being updated, no write-cache, just pass thru
  174. return SPIFFS_HAL_WRITE(fs, addr, len, src);
  175. } else {
  176. return SPIFFS_OK;
  177. }
  178. } else {
  179. // no cache page, no write cache - just write thru
  180. return SPIFFS_HAL_WRITE(fs, addr, len, src);
  181. }
  182. }
  183. #if SPIFFS_CACHE_WR
  184. // returns the cache page that this fd refers, or null if no cache page
  185. spiffs_cache_page *spiffs_cache_page_get_by_fd(spiffs *fs, spiffs_fd *fd) {
  186. spiffs_cache *cache = spiffs_get_cache(fs);
  187. if ((cache->cpage_use_map & cache->cpage_use_mask) == 0) {
  188. // all cpages free, no cpage cannot be assigned to obj_id
  189. return 0;
  190. }
  191. int i;
  192. for (i = 0; i < cache->cpage_count; i++) {
  193. spiffs_cache_page *cp = spiffs_get_cache_page_hdr(fs, cache, i);
  194. if ((cache->cpage_use_map & (1<<i)) &&
  195. (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) &&
  196. cp->obj_id == fd->obj_id) {
  197. return cp;
  198. }
  199. }
  200. return 0;
  201. }
  202. // allocates a new cache page and refers this to given fd - flushes an old cache
  203. // page if all cache is busy
  204. spiffs_cache_page *spiffs_cache_page_allocate_by_fd(spiffs *fs, spiffs_fd *fd) {
  205. // before this function is called, it is ensured that there is no already existing
  206. // cache page with same object id
  207. spiffs_cache_page_remove_oldest(fs, SPIFFS_CACHE_FLAG_TYPE_WR, 0);
  208. spiffs_cache_page *cp = spiffs_cache_page_allocate(fs);
  209. if (cp == 0) {
  210. // could not get cache page
  211. return 0;
  212. }
  213. cp->flags = SPIFFS_CACHE_FLAG_TYPE_WR;
  214. cp->obj_id = fd->obj_id;
  215. fd->cache_page = cp;
  216. return cp;
  217. }
  218. // unrefers all fds that this cache page refers to and releases the cache page
  219. void spiffs_cache_fd_release(spiffs *fs, spiffs_cache_page *cp) {
  220. if (cp == 0) return;
  221. u32_t i;
  222. spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
  223. for (i = 0; i < fs->fd_count; i++) {
  224. spiffs_fd *cur_fd = &fds[i];
  225. if (cur_fd->file_nbr != 0 && cur_fd->cache_page == cp) {
  226. cur_fd->cache_page = 0;
  227. }
  228. }
  229. spiffs_cache_page_free(fs, cp->ix, 0);
  230. cp->obj_id = 0;
  231. }
  232. #endif
  233. // initializes the cache
  234. void spiffs_cache_init(spiffs *fs) {
  235. if (fs->cache == 0) return;
  236. u32_t sz = fs->cache_size;
  237. u32_t cache_mask = 0;
  238. int i;
  239. int cache_entries =
  240. (sz - sizeof(spiffs_cache)) / (SPIFFS_CACHE_PAGE_SIZE(fs));
  241. if (cache_entries <= 0) return;
  242. for (i = 0; i < cache_entries; i++) {
  243. cache_mask <<= 1;
  244. cache_mask |= 1;
  245. }
  246. spiffs_cache cache;
  247. memset(&cache, 0, sizeof(spiffs_cache));
  248. cache.cpage_count = cache_entries;
  249. cache.cpages = (u8_t *)((u8_t *)fs->cache + sizeof(spiffs_cache));
  250. cache.cpage_use_map = 0xffffffff;
  251. cache.cpage_use_mask = cache_mask;
  252. memcpy(fs->cache, &cache, sizeof(spiffs_cache));
  253. spiffs_cache *c = spiffs_get_cache(fs);
  254. memset(c->cpages, 0, c->cpage_count * SPIFFS_CACHE_PAGE_SIZE(fs));
  255. c->cpage_use_map &= ~(c->cpage_use_mask);
  256. for (i = 0; i < cache.cpage_count; i++) {
  257. spiffs_get_cache_page_hdr(fs, c, i)->ix = i;
  258. }
  259. }
  260. #endif // SPIFFS_CACHE