qemu/block/qed-l2-cache.c

9  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
10  * See the COPYING.LIB file in the top-level directory.
17  * An open image has one L2 table cache that is used to avoid accessing the
20  * Cluster offset lookup translates the logical offset within the block device
21  * to a cluster offset within the image file.  This is done by indexing into
22  * the L1 and L2 tables which store cluster offsets.  It is here where the L2
25  * If there is a cache miss, that L2 table is read from the image file and
26  * committed to the cache.  Subsequent accesses to that L2 table will be served
27  * from the cache until the table is evicted from the cache.
29  * L2 tables are also committed to the cache when new L2 tables are allocated
30  * in the image file.  Since the L2 table cache is write-through, the new L2
31  * table is first written out to the image file and then committed to the
36  * reference counting is needed to free the entry at the correct time.  In
37  * particular, an entry evicted from the cache will only be freed once all
41  * the period during which it needs to access the L2 table.  This includes
46  * is not in the cache.  Since the operation to read the table from the image
48  * start reading the L2 table from the image file.  The first to finish will
49  * commit its L2 table into the cache.  When the second tries to commit its
50  * table will be deleted in favor of the existing cache entry.
62  * Initialize the L2 cache
71  * Free the L2 cache
84  * Allocate an uninitialized entry from the cache
86  * The returned entry has a reference count of 1 and is owned by the caller.
87  * The caller must allocate the actual table field for this entry and it must
103  * Decrease an entry's reference count and free if necessary when the reference
123  * Find an entry in the L2 cache.  This may return NULL and it's up to the
124  * caller to satisfy the cache miss.
126  * For a cached entry, this function increases the reference count and returns
127  * the entry.
146  * Commit an L2 cache entry into the cache.  This is meant to be used as part of
147  * the process to satisfy a cache miss.  A caller would allocate an entry which
148  * is not actually in the L2 cache and then once the entry was valid and
149  * present on disk, the entry can be committed into the cache.
151  * Since the cache is write-through, it's important that this function is not
152  * called until the entry is present on disk and the L1 has been updated to
153  * point to the entry.
155  * N.B. This function steals a reference to the l2_table from the caller so the
173      * we can grow the cache temporarily and we try to shrink back down later.  in qed_commit_l2_cache_entry()