Move cache handling into its own file
authorCharles Manning <cdhmanning@gmail.com>
Thu, 9 Jul 2020 01:31:03 +0000 (13:31 +1200)
committerCharles Manning <cdhmanning@gmail.com>
Thu, 9 Jul 2020 01:31:03 +0000 (13:31 +1200)
Signed-off-by: Charles Manning <cdhmanning@gmail.com>
yaffs_cache.c [new file with mode: 0644]
yaffs_cache.h [new file with mode: 0644]
yaffs_guts.c
yaffs_guts.h

diff --git a/yaffs_cache.c b/yaffs_cache.c
new file mode 100644 (file)
index 0000000..27f54e2
--- /dev/null
@@ -0,0 +1,298 @@
+/*
+ * 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 *cache;
+       int n_caches = obj->my_dev->param.n_caches;
+
+       for (i = 0; i < n_caches; i++) {
+               cache = &dev->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 *cache;
+       int n_caches = obj->my_dev->param.n_caches;
+
+       if (n_caches < 1)
+               return;
+
+
+       /* Find the chunks for this object and flush them. */
+       for (i = 0; i < n_caches; i++) {
+               cache = &dev->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_obj *obj;
+       int n_caches = dev->param.n_caches;
+       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 < n_caches && !obj; i++) {
+                       if (dev->cache[i].object && dev->cache[i].dirty)
+                               obj = dev->cache[i].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)
+{
+       u32 i;
+
+       if (dev->param.n_caches > 0) {
+               for (i = 0; i < dev->param.n_caches; i++) {
+                       if (!dev->cache[i].object)
+                               return &dev->cache[i];
+               }
+       }
+
+       return NULL;
+}
+
+struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
+{
+       struct yaffs_cache *cache;
+       int usage;
+       u32 i;
+
+       if (dev->param.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 < dev->param.n_caches; i++) {
+               if (dev->cache[i].object &&
+                   !dev->cache[i].locked &&
+                   (dev->cache[i].last_use < usage || !cache)) {
+                               usage = dev->cache[i].last_use;
+                               cache = &dev->cache[i];
+               }
+       }
+
+#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;
+       u32 i;
+
+       if (dev->param.n_caches < 1)
+               return NULL;
+
+       for (i = 0; i < dev->param.n_caches; i++) {
+               if (dev->cache[i].object == obj &&
+                   dev->cache[i].chunk_id == chunk_id) {
+                       dev->cache_hits++;
+
+                       return &dev->cache[i];
+               }
+       }
+       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)
+{
+       u32 i;
+
+       if (dev->param.n_caches < 1)
+               return;
+
+       if (dev->cache_last_use < 0 ||
+               dev->cache_last_use > 100000000) {
+               /* Reset the cache usages */
+               for (i = 1; i < dev->param.n_caches; i++)
+                       dev->cache[i].last_use = 0;
+
+               dev->cache_last_use = 0;
+       }
+       dev->cache_last_use++;
+       cache->last_use = dev->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;
+
+       if (object->my_dev->param.n_caches > 0) {
+               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 ther file is deleted or resized.
+ */
+void yaffs_invalidate_file_cache(struct yaffs_obj *in)
+{
+       u32 i;
+       struct yaffs_dev *dev = in->my_dev;
+
+       if (dev->param.n_caches > 0) {
+               /* Invalidate it. */
+               for (i = 0; i < dev->param.n_caches; i++) {
+                       if (dev->cache[i].object == in)
+                               dev->cache[i].object = NULL;
+               }
+       }
+}
+
+
+int yaffs_cache_init(struct yaffs_dev *dev)
+{
+       int init_failed;
+
+       if (dev->param.n_caches > 0) {
+               u32 i;
+               void *buf;
+               u32 cache_bytes =
+                   dev->param.n_caches * sizeof(struct yaffs_cache);
+
+               if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
+                       dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
+
+               dev->cache = kmalloc(cache_bytes, GFP_NOFS);
+
+               buf = (u8 *) dev->cache;
+
+               if (dev->cache)
+                       memset(dev->cache, 0, cache_bytes);
+
+               for (i = 0; i < dev->param.n_caches && buf; i++) {
+                       dev->cache[i].object = NULL;
+                       dev->cache[i].last_use = 0;
+                       dev->cache[i].dirty = 0;
+                       dev->cache[i].data = buf =
+                           kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
+               }
+               if (!buf)
+                       init_failed = 1;
+
+               dev->cache_last_use = 0;
+       }
+
+       return init_failed ? -1 : 0;
+}
+
+void yaffs_cache_deinit(struct yaffs_dev *dev)
+{
+
+       if (dev->param.n_caches > 0 && dev->cache) {
+               u32 i;
+
+               for (i = 0; i < dev->param.n_caches; i++) {
+                       kfree(dev->cache[i].data);
+                       dev->cache[i].data = NULL;
+               }
+
+               kfree(dev->cache);
+               dev->cache = NULL;
+       }
+}
diff --git a/yaffs_cache.h b/yaffs_cache.h
new file mode 100644 (file)
index 0000000..1dcd7e7
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+#ifndef __YAFFS_CACHE_H__
+#define __YAFFS_CACHE_H__
+
+#include "yaffs_guts.h"
+
+
+/* Does the object have a dirty cache ? */
+int yaffs_obj_cache_dirty(struct yaffs_obj *obj);
+
+/* Flush the cache associated with a file, either discarding or keeping */
+void yaffs_flush_file_cache(struct yaffs_obj *obj, int discard);
+
+/* Flush everything in the cache, either discarding or keeping */
+void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard);
+
+/* Grab a cache item during read or write. */
+struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev);
+
+/* Find a cached chunk */
+struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
+                                                 int chunk_id);
+
+/* Mark the chunk for the least recently used algorithym */
+void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
+                           int is_write);
+
+
+/* Invalidate a single cache page. The cache no longer holds valid data. */
+void yaffs_invalidate_chunk_cache(struct yaffs_obj *object,
+                                        int chunk_id);
+
+/* Invalidate all the cache pages associated with this object
+ * Do this whenever ther file is deleted or resized.
+ */
+void yaffs_invalidate_file_cache(struct yaffs_obj *in);
+
+/* Init/deinit. */
+int yaffs_cache_init(struct yaffs_dev *dev);
+void yaffs_cache_deinit(struct yaffs_dev *dev);
+
+#endif
index c52ff84..3023011 100644 (file)
@@ -14,6 +14,8 @@
 #include "yaffs_trace.h"
 
 #include "yaffs_guts.h"
+
+#include "yaffs_cache.h"
 #include "yaffs_endian.h"
 #include "yaffs_getblockinfo.h"
 #include "yaffs_tagscompat.h"
@@ -38,9 +40,6 @@
 
 /* Forward declarations */
 
-static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
-                            const u8 *buffer, int n_bytes, int use_reserve);
-
 static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name,
                                int buffer_size);
 
@@ -1422,237 +1421,6 @@ static int yaffs_change_obj_name(struct yaffs_obj *obj,
        return YAFFS_FAIL;
 }
 
-/*------------------------ 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.
- */
-
-static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       int i;
-       struct yaffs_cache *cache;
-       int n_caches = obj->my_dev->param.n_caches;
-
-       for (i = 0; i < n_caches; i++) {
-               cache = &dev->cache[i];
-               if (cache->object == obj && cache->dirty)
-                       return 1;
-       }
-
-       return 0;
-}
-
-static 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;
-}
-
-static void yaffs_flush_file_cache(struct yaffs_obj *obj, int discard)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       int i;
-       struct yaffs_cache *cache;
-       int n_caches = obj->my_dev->param.n_caches;
-
-       if (n_caches < 1)
-               return;
-
-
-       /* Find the chunks for this object and flush them. */
-       for (i = 0; i < n_caches; i++) {
-               cache = &dev->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_obj *obj;
-       int n_caches = dev->param.n_caches;
-       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 < n_caches && !obj; i++) {
-                       if (dev->cache[i].object && dev->cache[i].dirty)
-                               obj = dev->cache[i].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)
-{
-       u32 i;
-
-       if (dev->param.n_caches > 0) {
-               for (i = 0; i < dev->param.n_caches; i++) {
-                       if (!dev->cache[i].object)
-                               return &dev->cache[i];
-               }
-       }
-
-       return NULL;
-}
-
-static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
-{
-       struct yaffs_cache *cache;
-       int usage;
-       u32 i;
-
-       if (dev->param.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 < dev->param.n_caches; i++) {
-               if (dev->cache[i].object &&
-                   !dev->cache[i].locked &&
-                   (dev->cache[i].last_use < usage || !cache)) {
-                               usage = dev->cache[i].last_use;
-                               cache = &dev->cache[i];
-               }
-       }
-
-#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 */
-static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
-                                                 int chunk_id)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       u32 i;
-
-       if (dev->param.n_caches < 1)
-               return NULL;
-
-       for (i = 0; i < dev->param.n_caches; i++) {
-               if (dev->cache[i].object == obj &&
-                   dev->cache[i].chunk_id == chunk_id) {
-                       dev->cache_hits++;
-
-                       return &dev->cache[i];
-               }
-       }
-       return NULL;
-}
-
-/* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
-                           int is_write)
-{
-       u32 i;
-
-       if (dev->param.n_caches < 1)
-               return;
-
-       if (dev->cache_last_use < 0 ||
-               dev->cache_last_use > 100000000) {
-               /* Reset the cache usages */
-               for (i = 1; i < dev->param.n_caches; i++)
-                       dev->cache[i].last_use = 0;
-
-               dev->cache_last_use = 0;
-       }
-       dev->cache_last_use++;
-       cache->last_use = dev->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.
- */
-static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
-{
-       struct yaffs_cache *cache;
-
-       if (object->my_dev->param.n_caches > 0) {
-               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 ther file is deleted or resized.
- */
-static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
-{
-       u32 i;
-       struct yaffs_dev *dev = in->my_dev;
-
-       if (dev->param.n_caches > 0) {
-               /* Invalidate it. */
-               for (i = 0; i < dev->param.n_caches; i++) {
-                       if (dev->cache[i].object == in)
-                               dev->cache[i].object = NULL;
-               }
-       }
-}
 
 static void yaffs_unhash_obj(struct yaffs_obj *obj)
 {
@@ -1708,7 +1476,7 @@ void yaffs_handle_defered_free(struct yaffs_obj *obj)
 static int yaffs_generic_obj_del(struct yaffs_obj *in)
 {
        /* Iinvalidate the file's data in the cache, without flushing. */
-       yaffs_invalidate_whole_cache(in);
+       yaffs_invalidate_file_cache(in);
 
        if (in->my_dev->param.is_yaffs2 && in->parent != in->my_dev->del_dir) {
                /* Move to unlinked directory so we have a deletion record */
@@ -2701,7 +2469,7 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
        int prioritised = 0;
        int prioritised_exist = 0;
        struct yaffs_block_info *bi;
-       u32 threshold;
+       u32 threshold = dev->param.chunks_per_block;
 
        /* First let's see if we need to grab a prioritised block */
        if (dev->has_pending_prioritised_gc && !aggressive) {
@@ -3041,8 +2809,8 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
        }
 }
 
-static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
-                            const u8 *buffer, int n_bytes, int use_reserve)
+int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
+                       const u8 *buffer, int n_bytes, int use_reserve)
 {
        /* Find old chunk Need to do this to get serial number
         * Write new one and patch into tree.
@@ -3791,7 +3559,7 @@ int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
        loff_t old_size = in->variant.file_variant.file_size;
 
        yaffs_flush_file_cache(in, 1);
-       yaffs_invalidate_whole_cache(in);
+       yaffs_invalidate_file_cache(in);
 
        yaffs_check_gc(dev, 0);
 
@@ -4924,37 +4692,13 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        if (!yaffs_init_tmp_buffers(dev))
                init_failed = 1;
 
-       dev->cache = NULL;
        dev->gc_cleanup_list = NULL;
 
-       if (!init_failed && dev->param.n_caches > 0) {
-               u32 i;
-               void *buf;
-               u32 cache_bytes =
-                   dev->param.n_caches * sizeof(struct yaffs_cache);
-
-               if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
-                       dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
 
-               dev->cache = kmalloc(cache_bytes, GFP_NOFS);
-
-               buf = (u8 *) dev->cache;
-
-               if (dev->cache)
-                       memset(dev->cache, 0, cache_bytes);
-
-               for (i = 0; i < dev->param.n_caches && buf; i++) {
-                       dev->cache[i].object = NULL;
-                       dev->cache[i].last_use = 0;
-                       dev->cache[i].dirty = 0;
-                       dev->cache[i].data = buf =
-                           kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
-               }
-               if (!buf)
-                       init_failed = 1;
+       dev->cache = NULL;
 
-               dev->cache_last_use = 0;
-       }
+       if (!init_failed)
+               init_failed = yaffs_cache_init(dev) < 0;
 
        dev->cache_hits = 0;
 
@@ -5065,17 +4809,7 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
                yaffs_deinit_blocks(dev);
                yaffs_deinit_tnodes_and_objs(dev);
                yaffs_summary_deinit(dev);
-
-               if (dev->param.n_caches > 0 && dev->cache) {
-
-                       for (i = 0; i < dev->param.n_caches; i++) {
-                               kfree(dev->cache[i].data);
-                               dev->cache[i].data = NULL;
-                       }
-
-                       kfree(dev->cache);
-                       dev->cache = NULL;
-               }
+               yaffs_cache_deinit(dev);
 
                kfree(dev->gc_cleanup_list);
 
index 124e4c9..5fa1877 100644 (file)
@@ -1040,6 +1040,11 @@ loff_t yaffs_oh_to_size(struct yaffs_dev *dev, struct yaffs_obj_hdr *oh,
                        int do_endian);
 loff_t yaffs_max_file_size(struct yaffs_dev *dev);
 
+
+/* yaffs_wr_data_obj needs to be exposed to allow the cache to access it. */
+int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
+                            const u8 *buffer, int n_bytes, int use_reserve);
+
 /*
  * Debug function to count number of blocks in each state
  * NB Needs to be called with correct number of integers