326 lines
7.1 KiB
C
326 lines
7.1 KiB
C
/*
|
|
* YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
|
|
*
|
|
* Copyright (C) 2002-2018 Aleph One Ltd.
|
|
*
|
|
* Created by Charles Manning <charles@aleph1.co.uk>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include "yaffs_cache.h"
|
|
|
|
/*------------------------ Short Operations Cache ------------------------------
|
|
* In many situations where there is no high level buffering a lot of
|
|
* reads might be short sequential reads, and a lot of writes may be short
|
|
* sequential writes. eg. scanning/writing a jpeg file.
|
|
* In these cases, a short read/write cache can provide a huge perfomance
|
|
* benefit with dumb-as-a-rock code.
|
|
* In Linux, the page cache provides read buffering and the short op cache
|
|
* provides write buffering.
|
|
*
|
|
* There are a small number (~10) of cache chunks per device so that we don't
|
|
* need a very intelligent search.
|
|
*/
|
|
|
|
int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
|
|
{
|
|
struct yaffs_dev *dev = obj->my_dev;
|
|
int i;
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
|
|
if (cache->object == obj && cache->dirty)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void yaffs_flush_single_cache(struct yaffs_cache *cache, int discard)
|
|
{
|
|
|
|
if (!cache || cache->locked)
|
|
return;
|
|
|
|
/* Write it out and free it up if need be.*/
|
|
if (cache->dirty) {
|
|
yaffs_wr_data_obj(cache->object,
|
|
cache->chunk_id,
|
|
cache->data,
|
|
cache->n_bytes,
|
|
1);
|
|
|
|
cache->dirty = 0;
|
|
}
|
|
|
|
if (discard)
|
|
cache->object = NULL;
|
|
}
|
|
|
|
void yaffs_flush_file_cache(struct yaffs_obj *obj, int discard)
|
|
{
|
|
struct yaffs_dev *dev = obj->my_dev;
|
|
int i;
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
|
|
if (mgr->n_caches < 1)
|
|
return;
|
|
|
|
|
|
/* Find the chunks for this object and flush them. */
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
|
|
if (cache->object == obj)
|
|
yaffs_flush_single_cache(cache, discard);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
struct yaffs_obj *obj;
|
|
int i;
|
|
|
|
/* Find a dirty object in the cache and flush it...
|
|
* until there are no further dirty objects.
|
|
*/
|
|
do {
|
|
obj = NULL;
|
|
for (i = 0; i < mgr->n_caches && !obj; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
if (cache->object && cache->dirty)
|
|
obj = cache->object;
|
|
}
|
|
if (obj)
|
|
yaffs_flush_file_cache(obj, discard);
|
|
} while (obj);
|
|
|
|
}
|
|
|
|
/* Grab us an unused cache chunk for use.
|
|
* First look for an empty one.
|
|
* Then look for the least recently used non-dirty one.
|
|
* Then look for the least recently used dirty one...., flush and look again.
|
|
*/
|
|
static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
int i;
|
|
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
if (!cache->object)
|
|
return cache;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
struct yaffs_cache *cache;
|
|
int usage;
|
|
int i;
|
|
|
|
if (mgr->n_caches < 1)
|
|
return NULL;
|
|
|
|
/* First look for an unused cache */
|
|
|
|
cache = yaffs_grab_chunk_worker(dev);
|
|
|
|
if (cache)
|
|
return cache;
|
|
|
|
/*
|
|
* Thery were all in use.
|
|
* Find the LRU cache and flush it if it is dirty.
|
|
*/
|
|
|
|
usage = -1;
|
|
cache = NULL;
|
|
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *this_cache = &mgr->cache[i];
|
|
|
|
if (this_cache->object &&
|
|
!this_cache->locked &&
|
|
(this_cache->last_use < usage || !cache)) {
|
|
usage = this_cache->last_use;
|
|
cache = this_cache;
|
|
}
|
|
}
|
|
|
|
#if 1
|
|
yaffs_flush_single_cache(cache, 1);
|
|
#else
|
|
yaffs_flush_file_cache(cache->object, 1);
|
|
cache = yaffs_grab_chunk_worker(dev);
|
|
#endif
|
|
|
|
return cache;
|
|
}
|
|
|
|
/* Find a cached chunk */
|
|
struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
|
|
int chunk_id)
|
|
{
|
|
struct yaffs_dev *dev = obj->my_dev;
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
int i;
|
|
|
|
if (mgr->n_caches < 1)
|
|
return NULL;
|
|
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
|
|
if (cache->object == obj &&
|
|
cache->chunk_id == chunk_id) {
|
|
dev->cache_hits++;
|
|
return cache;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* Mark the chunk for the least recently used algorithym */
|
|
void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
|
|
int is_write)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
int i;
|
|
|
|
if (mgr->n_caches < 1)
|
|
return;
|
|
|
|
if (mgr->cache_last_use < 0 ||
|
|
mgr->cache_last_use > 100000000) {
|
|
/* Reset the cache usages */
|
|
for (i = 1; i < mgr->n_caches; i++)
|
|
mgr->cache[i].last_use = 0;
|
|
|
|
mgr->cache_last_use = 0;
|
|
}
|
|
mgr->cache_last_use++;
|
|
cache->last_use = mgr->cache_last_use;
|
|
|
|
if (is_write)
|
|
cache->dirty = 1;
|
|
}
|
|
|
|
/* Invalidate a single cache page.
|
|
* Do this when a whole page gets written,
|
|
* ie the short cache for this page is no longer valid.
|
|
*/
|
|
void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
|
|
{
|
|
struct yaffs_cache *cache;
|
|
|
|
cache = yaffs_find_chunk_cache(object, chunk_id);
|
|
if (cache)
|
|
cache->object = NULL;
|
|
}
|
|
|
|
/* Invalidate all the cache pages associated with this object
|
|
* Do this whenever the file is deleted or resized.
|
|
*/
|
|
void yaffs_invalidate_file_cache(struct yaffs_obj *in)
|
|
{
|
|
int i;
|
|
struct yaffs_dev *dev = in->my_dev;
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
|
|
/* Invalidate it. */
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
|
|
if (cache->object == in)
|
|
cache->object = NULL;
|
|
}
|
|
}
|
|
|
|
int yaffs_count_dirty_caches(struct yaffs_dev *dev)
|
|
{
|
|
int n_dirty;
|
|
int i;
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
|
|
for (n_dirty= 0, i = 0; i < mgr->n_caches; i++) {
|
|
if (mgr->cache[i].dirty)
|
|
n_dirty++;
|
|
}
|
|
|
|
return n_dirty;
|
|
}
|
|
|
|
int yaffs_cache_init(struct yaffs_dev *dev)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
int init_failed = 0;
|
|
|
|
if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
|
|
dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
|
|
|
|
mgr->n_caches = dev->param.n_caches;
|
|
if (mgr->n_caches > 0) {
|
|
int i;
|
|
void *buf;
|
|
u32 cache_bytes =
|
|
mgr->n_caches * sizeof(struct yaffs_cache);
|
|
|
|
|
|
|
|
mgr->cache = kmalloc(cache_bytes, GFP_NOFS);
|
|
|
|
buf = (u8 *) mgr->cache;
|
|
|
|
if (mgr->cache)
|
|
memset(mgr->cache, 0, cache_bytes);
|
|
|
|
for (i = 0; i < mgr->n_caches && buf; i++) {
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
|
|
cache->object = NULL;
|
|
cache->last_use = 0;
|
|
cache->dirty = 0;
|
|
cache->data = buf =
|
|
kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
|
|
}
|
|
if (!buf)
|
|
init_failed = 1;
|
|
|
|
mgr->cache_last_use = 0;
|
|
}
|
|
|
|
return init_failed ? -1 : 0;
|
|
}
|
|
|
|
void yaffs_cache_deinit(struct yaffs_dev *dev)
|
|
{
|
|
struct yaffs_cache_manager *mgr = &dev->cache_mgr;
|
|
int i;
|
|
|
|
if (mgr->n_caches < 1 || !mgr->cache)
|
|
return;
|
|
|
|
for (i = 0; i < mgr->n_caches; i++) {
|
|
|
|
struct yaffs_cache *cache = &mgr->cache[i];
|
|
kfree(cache->data);
|
|
cache->data = NULL;
|
|
}
|
|
|
|
kfree(mgr->cache);
|
|
mgr->cache = NULL;
|
|
}
|