2009-04-03 09:42:36 -06:00
|
|
|
/* Internal definitions for FS-Cache
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
|
|
|
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Lock order, in the order in which multiple locks should be obtained:
|
|
|
|
|
* - fscache_addremove_sem
|
|
|
|
|
* - cookie->lock
|
|
|
|
|
* - cookie->parent->lock
|
|
|
|
|
* - cache->object_list_lock
|
|
|
|
|
* - object->lock
|
|
|
|
|
* - object->parent->lock
|
|
|
|
|
* - fscache_thread_lock
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/fscache-cache.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
|
|
|
|
|
#define FSCACHE_MIN_THREADS 4
|
|
|
|
|
#define FSCACHE_MAX_THREADS 32
|
|
|
|
|
|
2009-04-03 09:42:37 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-cache.c
|
|
|
|
|
*/
|
|
|
|
|
extern struct list_head fscache_cache_list;
|
|
|
|
|
extern struct rw_semaphore fscache_addremove_sem;
|
|
|
|
|
|
|
|
|
|
extern struct fscache_cache *fscache_select_cache_for_object(
|
|
|
|
|
struct fscache_cookie *);
|
|
|
|
|
|
2009-04-03 09:42:38 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-cookie.c
|
|
|
|
|
*/
|
|
|
|
|
extern struct kmem_cache *fscache_cookie_jar;
|
|
|
|
|
|
|
|
|
|
extern void fscache_cookie_init_once(void *);
|
|
|
|
|
extern void __fscache_cookie_put(struct fscache_cookie *);
|
|
|
|
|
|
2009-04-03 09:42:37 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-fsdef.c
|
|
|
|
|
*/
|
|
|
|
|
extern struct fscache_cookie fscache_fsdef_index;
|
|
|
|
|
extern struct fscache_cookie_def fscache_fsdef_netfs_def;
|
|
|
|
|
|
2009-04-03 09:42:37 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-histogram.c
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_FSCACHE_HISTOGRAM
|
|
|
|
|
extern atomic_t fscache_obj_instantiate_histogram[HZ];
|
|
|
|
|
extern atomic_t fscache_objs_histogram[HZ];
|
|
|
|
|
extern atomic_t fscache_ops_histogram[HZ];
|
|
|
|
|
extern atomic_t fscache_retrieval_delay_histogram[HZ];
|
|
|
|
|
extern atomic_t fscache_retrieval_histogram[HZ];
|
|
|
|
|
|
|
|
|
|
static inline void fscache_hist(atomic_t histogram[], unsigned long start_jif)
|
|
|
|
|
{
|
|
|
|
|
unsigned long jif = jiffies - start_jif;
|
|
|
|
|
if (jif >= HZ)
|
|
|
|
|
jif = HZ - 1;
|
|
|
|
|
atomic_inc(&histogram[jif]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern const struct file_operations fscache_histogram_fops;
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
#define fscache_hist(hist, start_jif) do {} while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-04-03 09:42:36 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-main.c
|
|
|
|
|
*/
|
|
|
|
|
extern unsigned fscache_defer_lookup;
|
|
|
|
|
extern unsigned fscache_defer_create;
|
|
|
|
|
extern unsigned fscache_debug;
|
|
|
|
|
extern struct kobject *fscache_root;
|
|
|
|
|
|
2009-04-03 09:42:38 -06:00
|
|
|
extern int fscache_wait_bit(void *);
|
|
|
|
|
extern int fscache_wait_bit_interruptible(void *);
|
|
|
|
|
|
FS-Cache: Object management state machine
Implement the cache object management state machine.
The following documentation is added to illuminate the working of this state
machine. It will also be added as:
Documentation/filesystems/caching/object.txt
====================================================
IN-KERNEL CACHE OBJECT REPRESENTATION AND MANAGEMENT
====================================================
==============
REPRESENTATION
==============
FS-Cache maintains an in-kernel representation of each object that a netfs is
currently interested in. Such objects are represented by the fscache_cookie
struct and are referred to as cookies.
FS-Cache also maintains a separate in-kernel representation of the objects that
a cache backend is currently actively caching. Such objects are represented by
the fscache_object struct. The cache backends allocate these upon request, and
are expected to embed them in their own representations. These are referred to
as objects.
There is a 1:N relationship between cookies and objects. A cookie may be
represented by multiple objects - an index may exist in more than one cache -
or even by no objects (it may not be cached).
Furthermore, both cookies and objects are hierarchical. The two hierarchies
correspond, but the cookies tree is a superset of the union of the object trees
of multiple caches:
NETFS INDEX TREE : CACHE 1 : CACHE 2
: :
: +-----------+ :
+----------->| IObject | :
+-----------+ | : +-----------+ :
| ICookie |-------+ : | :
+-----------+ | : | : +-----------+
| +------------------------------>| IObject |
| : | : +-----------+
| : V : |
| : +-----------+ : |
V +----------->| IObject | : |
+-----------+ | : +-----------+ : |
| ICookie |-------+ : | : V
+-----------+ | : | : +-----------+
| +------------------------------>| IObject |
+-----+-----+ : | : +-----------+
| | : | : |
V | : V : |
+-----------+ | : +-----------+ : |
| ICookie |------------------------->| IObject | : |
+-----------+ | : +-----------+ : |
| V : | : V
| +-----------+ : | : +-----------+
| | ICookie |-------------------------------->| IObject |
| +-----------+ : | : +-----------+
V | : V : |
+-----------+ | : +-----------+ : |
| DCookie |------------------------->| DObject | : |
+-----------+ | : +-----------+ : |
| : : |
+-------+-------+ : : |
| | : : |
V V : : V
+-----------+ +-----------+ : : +-----------+
| DCookie | | DCookie |------------------------>| DObject |
+-----------+ +-----------+ : : +-----------+
: :
In the above illustration, ICookie and IObject represent indices and DCookie
and DObject represent data storage objects. Indices may have representation in
multiple caches, but currently, non-index objects may not. Objects of any type
may also be entirely unrepresented.
As far as the netfs API goes, the netfs is only actually permitted to see
pointers to the cookies. The cookies themselves and any objects attached to
those cookies are hidden from it.
===============================
OBJECT MANAGEMENT STATE MACHINE
===============================
Within FS-Cache, each active object is managed by its own individual state
machine. The state for an object is kept in the fscache_object struct, in
object->state. A cookie may point to a set of objects that are in different
states.
Each state has an action associated with it that is invoked when the machine
wakes up in that state. There are four logical sets of states:
(1) Preparation: states that wait for the parent objects to become ready. The
representations are hierarchical, and it is expected that an object must
be created or accessed with respect to its parent object.
(2) Initialisation: states that perform lookups in the cache and validate
what's found and that create on disk any missing metadata.
(3) Normal running: states that allow netfs operations on objects to proceed
and that update the state of objects.
(4) Termination: states that detach objects from their netfs cookies, that
delete objects from disk, that handle disk and system errors and that free
up in-memory resources.
In most cases, transitioning between states is in response to signalled events.
When a state has finished processing, it will usually set the mask of events in
which it is interested (object->event_mask) and relinquish the worker thread.
Then when an event is raised (by calling fscache_raise_event()), if the event
is not masked, the object will be queued for processing (by calling
fscache_enqueue_object()).
PROVISION OF CPU TIME
---------------------
The work to be done by the various states is given CPU time by the threads of
the slow work facility (see Documentation/slow-work.txt). This is used in
preference to the workqueue facility because:
(1) Threads may be completely occupied for very long periods of time by a
particular work item. These state actions may be doing sequences of
synchronous, journalled disk accesses (lookup, mkdir, create, setxattr,
getxattr, truncate, unlink, rmdir, rename).
(2) Threads may do little actual work, but may rather spend a lot of time
sleeping on I/O. This means that single-threaded and 1-per-CPU-threaded
workqueues don't necessarily have the right numbers of threads.
LOCKING SIMPLIFICATION
----------------------
Because only one worker thread may be operating on any particular object's
state machine at once, this simplifies the locking, particularly with respect
to disconnecting the netfs's representation of a cache object (fscache_cookie)
from the cache backend's representation (fscache_object) - which may be
requested from either end.
=================
THE SET OF STATES
=================
The object state machine has a set of states that it can be in. There are
preparation states in which the object sets itself up and waits for its parent
object to transit to a state that allows access to its children:
(1) State FSCACHE_OBJECT_INIT.
Initialise the object and wait for the parent object to become active. In
the cache, it is expected that it will not be possible to look an object
up from the parent object, until that parent object itself has been looked
up.
There are initialisation states in which the object sets itself up and accesses
disk for the object metadata:
(2) State FSCACHE_OBJECT_LOOKING_UP.
Look up the object on disk, using the parent as a starting point.
FS-Cache expects the cache backend to probe the cache to see whether this
object is represented there, and if it is, to see if it's valid (coherency
management).
The cache should call fscache_object_lookup_negative() to indicate lookup
failure for whatever reason, and should call fscache_obtained_object() to
indicate success.
At the completion of lookup, FS-Cache will let the netfs go ahead with
read operations, no matter whether the file is yet cached. If not yet
cached, read operations will be immediately rejected with ENODATA until
the first known page is uncached - as to that point there can be no data
to be read out of the cache for that file that isn't currently also held
in the pagecache.
(3) State FSCACHE_OBJECT_CREATING.
Create an object on disk, using the parent as a starting point. This
happens if the lookup failed to find the object, or if the object's
coherency data indicated what's on disk is out of date. In this state,
FS-Cache expects the cache to create
The cache should call fscache_obtained_object() if creation completes
successfully, fscache_object_lookup_negative() otherwise.
At the completion of creation, FS-Cache will start processing write
operations the netfs has queued for an object. If creation failed, the
write ops will be transparently discarded, and nothing recorded in the
cache.
There are some normal running states in which the object spends its time
servicing netfs requests:
(4) State FSCACHE_OBJECT_AVAILABLE.
A transient state in which pending operations are started, child objects
are permitted to advance from FSCACHE_OBJECT_INIT state, and temporary
lookup data is freed.
(5) State FSCACHE_OBJECT_ACTIVE.
The normal running state. In this state, requests the netfs makes will be
passed on to the cache.
(6) State FSCACHE_OBJECT_UPDATING.
The state machine comes here to update the object in the cache from the
netfs's records. This involves updating the auxiliary data that is used
to maintain coherency.
And there are terminal states in which an object cleans itself up, deallocates
memory and potentially deletes stuff from disk:
(7) State FSCACHE_OBJECT_LC_DYING.
The object comes here if it is dying because of a lookup or creation
error. This would be due to a disk error or system error of some sort.
Temporary data is cleaned up, and the parent is released.
(8) State FSCACHE_OBJECT_DYING.
The object comes here if it is dying due to an error, because its parent
cookie has been relinquished by the netfs or because the cache is being
withdrawn.
Any child objects waiting on this one are given CPU time so that they too
can destroy themselves. This object waits for all its children to go away
before advancing to the next state.
(9) State FSCACHE_OBJECT_ABORT_INIT.
The object comes to this state if it was waiting on its parent in
FSCACHE_OBJECT_INIT, but its parent died. The object will destroy itself
so that the parent may proceed from the FSCACHE_OBJECT_DYING state.
(10) State FSCACHE_OBJECT_RELEASING.
(11) State FSCACHE_OBJECT_RECYCLING.
The object comes to one of these two states when dying once it is rid of
all its children, if it is dying because the netfs relinquished its
cookie. In the first state, the cached data is expected to persist, and
in the second it will be deleted.
(12) State FSCACHE_OBJECT_WITHDRAWING.
The object transits to this state if the cache decides it wants to
withdraw the object from service, perhaps to make space, but also due to
error or just because the whole cache is being withdrawn.
(13) State FSCACHE_OBJECT_DEAD.
The object transits to this state when the in-memory object record is
ready to be deleted. The object processor shouldn't ever see an object in
this state.
THE SET OF EVENTS
-----------------
There are a number of events that can be raised to an object state machine:
(*) FSCACHE_OBJECT_EV_UPDATE
The netfs requested that an object be updated. The state machine will ask
the cache backend to update the object, and the cache backend will ask the
netfs for details of the change through its cookie definition ops.
(*) FSCACHE_OBJECT_EV_CLEARED
This is signalled in two circumstances:
(a) when an object's last child object is dropped and
(b) when the last operation outstanding on an object is completed.
This is used to proceed from the dying state.
(*) FSCACHE_OBJECT_EV_ERROR
This is signalled when an I/O error occurs during the processing of some
object.
(*) FSCACHE_OBJECT_EV_RELEASE
(*) FSCACHE_OBJECT_EV_RETIRE
These are signalled when the netfs relinquishes a cookie it was using.
The event selected depends on whether the netfs asks for the backing
object to be retired (deleted) or retained.
(*) FSCACHE_OBJECT_EV_WITHDRAW
This is signalled when the cache backend wants to withdraw an object.
This means that the object will have to be detached from the netfs's
cookie.
Because the withdrawing releasing/retiring events are all handled by the object
state machine, it doesn't matter if there's a collision with both ends trying
to sever the connection at the same time. The state machine can just pick
which one it wants to honour, and that effects the other.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Steve Dickson <steved@redhat.com>
Acked-by: Trond Myklebust <Trond.Myklebust@netapp.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Tested-by: Daire Byrne <Daire.Byrne@framestore.com>
2009-04-03 09:42:38 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-object.c
|
|
|
|
|
*/
|
|
|
|
|
extern void fscache_withdrawing_object(struct fscache_cache *,
|
|
|
|
|
struct fscache_object *);
|
|
|
|
|
extern void fscache_enqueue_object(struct fscache_object *);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* fsc-operation.c
|
|
|
|
|
*/
|
|
|
|
|
#define fscache_start_operations(obj) BUG()
|
|
|
|
|
|
2009-04-03 09:42:37 -06:00
|
|
|
/*
|
|
|
|
|
* fsc-proc.c
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
extern int __init fscache_proc_init(void);
|
|
|
|
|
extern void fscache_proc_cleanup(void);
|
|
|
|
|
#else
|
|
|
|
|
#define fscache_proc_init() (0)
|
|
|
|
|
#define fscache_proc_cleanup() do {} while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* fsc-stats.c
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_FSCACHE_STATS
|
|
|
|
|
extern atomic_t fscache_n_ops_processed[FSCACHE_MAX_THREADS];
|
|
|
|
|
extern atomic_t fscache_n_objs_processed[FSCACHE_MAX_THREADS];
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_op_pend;
|
|
|
|
|
extern atomic_t fscache_n_op_run;
|
|
|
|
|
extern atomic_t fscache_n_op_enqueue;
|
|
|
|
|
extern atomic_t fscache_n_op_deferred_release;
|
|
|
|
|
extern atomic_t fscache_n_op_release;
|
|
|
|
|
extern atomic_t fscache_n_op_gc;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_attr_changed;
|
|
|
|
|
extern atomic_t fscache_n_attr_changed_ok;
|
|
|
|
|
extern atomic_t fscache_n_attr_changed_nobufs;
|
|
|
|
|
extern atomic_t fscache_n_attr_changed_nomem;
|
|
|
|
|
extern atomic_t fscache_n_attr_changed_calls;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_allocs;
|
|
|
|
|
extern atomic_t fscache_n_allocs_ok;
|
|
|
|
|
extern atomic_t fscache_n_allocs_wait;
|
|
|
|
|
extern atomic_t fscache_n_allocs_nobufs;
|
|
|
|
|
extern atomic_t fscache_n_alloc_ops;
|
|
|
|
|
extern atomic_t fscache_n_alloc_op_waits;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_retrievals;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_ok;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_wait;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_nodata;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_nobufs;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_intr;
|
|
|
|
|
extern atomic_t fscache_n_retrievals_nomem;
|
|
|
|
|
extern atomic_t fscache_n_retrieval_ops;
|
|
|
|
|
extern atomic_t fscache_n_retrieval_op_waits;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_stores;
|
|
|
|
|
extern atomic_t fscache_n_stores_ok;
|
|
|
|
|
extern atomic_t fscache_n_stores_again;
|
|
|
|
|
extern atomic_t fscache_n_stores_nobufs;
|
|
|
|
|
extern atomic_t fscache_n_stores_oom;
|
|
|
|
|
extern atomic_t fscache_n_store_ops;
|
|
|
|
|
extern atomic_t fscache_n_store_calls;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_marks;
|
|
|
|
|
extern atomic_t fscache_n_uncaches;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_acquires;
|
|
|
|
|
extern atomic_t fscache_n_acquires_null;
|
|
|
|
|
extern atomic_t fscache_n_acquires_no_cache;
|
|
|
|
|
extern atomic_t fscache_n_acquires_ok;
|
|
|
|
|
extern atomic_t fscache_n_acquires_nobufs;
|
|
|
|
|
extern atomic_t fscache_n_acquires_oom;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_updates;
|
|
|
|
|
extern atomic_t fscache_n_updates_null;
|
|
|
|
|
extern atomic_t fscache_n_updates_run;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_relinquishes;
|
|
|
|
|
extern atomic_t fscache_n_relinquishes_null;
|
|
|
|
|
extern atomic_t fscache_n_relinquishes_waitcrt;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_cookie_index;
|
|
|
|
|
extern atomic_t fscache_n_cookie_data;
|
|
|
|
|
extern atomic_t fscache_n_cookie_special;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_object_alloc;
|
|
|
|
|
extern atomic_t fscache_n_object_no_alloc;
|
|
|
|
|
extern atomic_t fscache_n_object_lookups;
|
|
|
|
|
extern atomic_t fscache_n_object_lookups_negative;
|
|
|
|
|
extern atomic_t fscache_n_object_lookups_positive;
|
|
|
|
|
extern atomic_t fscache_n_object_created;
|
|
|
|
|
extern atomic_t fscache_n_object_avail;
|
|
|
|
|
extern atomic_t fscache_n_object_dead;
|
|
|
|
|
|
|
|
|
|
extern atomic_t fscache_n_checkaux_none;
|
|
|
|
|
extern atomic_t fscache_n_checkaux_okay;
|
|
|
|
|
extern atomic_t fscache_n_checkaux_update;
|
|
|
|
|
extern atomic_t fscache_n_checkaux_obsolete;
|
|
|
|
|
|
|
|
|
|
static inline void fscache_stat(atomic_t *stat)
|
|
|
|
|
{
|
|
|
|
|
atomic_inc(stat);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern const struct file_operations fscache_stats_fops;
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define fscache_stat(stat) do {} while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-04-03 09:42:37 -06:00
|
|
|
/*
|
|
|
|
|
* raise an event on an object
|
|
|
|
|
* - if the event is not masked for that object, then the object is
|
|
|
|
|
* queued for attention by the thread pool.
|
|
|
|
|
*/
|
|
|
|
|
static inline void fscache_raise_event(struct fscache_object *object,
|
|
|
|
|
unsigned event)
|
|
|
|
|
{
|
FS-Cache: Object management state machine
Implement the cache object management state machine.
The following documentation is added to illuminate the working of this state
machine. It will also be added as:
Documentation/filesystems/caching/object.txt
====================================================
IN-KERNEL CACHE OBJECT REPRESENTATION AND MANAGEMENT
====================================================
==============
REPRESENTATION
==============
FS-Cache maintains an in-kernel representation of each object that a netfs is
currently interested in. Such objects are represented by the fscache_cookie
struct and are referred to as cookies.
FS-Cache also maintains a separate in-kernel representation of the objects that
a cache backend is currently actively caching. Such objects are represented by
the fscache_object struct. The cache backends allocate these upon request, and
are expected to embed them in their own representations. These are referred to
as objects.
There is a 1:N relationship between cookies and objects. A cookie may be
represented by multiple objects - an index may exist in more than one cache -
or even by no objects (it may not be cached).
Furthermore, both cookies and objects are hierarchical. The two hierarchies
correspond, but the cookies tree is a superset of the union of the object trees
of multiple caches:
NETFS INDEX TREE : CACHE 1 : CACHE 2
: :
: +-----------+ :
+----------->| IObject | :
+-----------+ | : +-----------+ :
| ICookie |-------+ : | :
+-----------+ | : | : +-----------+
| +------------------------------>| IObject |
| : | : +-----------+
| : V : |
| : +-----------+ : |
V +----------->| IObject | : |
+-----------+ | : +-----------+ : |
| ICookie |-------+ : | : V
+-----------+ | : | : +-----------+
| +------------------------------>| IObject |
+-----+-----+ : | : +-----------+
| | : | : |
V | : V : |
+-----------+ | : +-----------+ : |
| ICookie |------------------------->| IObject | : |
+-----------+ | : +-----------+ : |
| V : | : V
| +-----------+ : | : +-----------+
| | ICookie |-------------------------------->| IObject |
| +-----------+ : | : +-----------+
V | : V : |
+-----------+ | : +-----------+ : |
| DCookie |------------------------->| DObject | : |
+-----------+ | : +-----------+ : |
| : : |
+-------+-------+ : : |
| | : : |
V V : : V
+-----------+ +-----------+ : : +-----------+
| DCookie | | DCookie |------------------------>| DObject |
+-----------+ +-----------+ : : +-----------+
: :
In the above illustration, ICookie and IObject represent indices and DCookie
and DObject represent data storage objects. Indices may have representation in
multiple caches, but currently, non-index objects may not. Objects of any type
may also be entirely unrepresented.
As far as the netfs API goes, the netfs is only actually permitted to see
pointers to the cookies. The cookies themselves and any objects attached to
those cookies are hidden from it.
===============================
OBJECT MANAGEMENT STATE MACHINE
===============================
Within FS-Cache, each active object is managed by its own individual state
machine. The state for an object is kept in the fscache_object struct, in
object->state. A cookie may point to a set of objects that are in different
states.
Each state has an action associated with it that is invoked when the machine
wakes up in that state. There are four logical sets of states:
(1) Preparation: states that wait for the parent objects to become ready. The
representations are hierarchical, and it is expected that an object must
be created or accessed with respect to its parent object.
(2) Initialisation: states that perform lookups in the cache and validate
what's found and that create on disk any missing metadata.
(3) Normal running: states that allow netfs operations on objects to proceed
and that update the state of objects.
(4) Termination: states that detach objects from their netfs cookies, that
delete objects from disk, that handle disk and system errors and that free
up in-memory resources.
In most cases, transitioning between states is in response to signalled events.
When a state has finished processing, it will usually set the mask of events in
which it is interested (object->event_mask) and relinquish the worker thread.
Then when an event is raised (by calling fscache_raise_event()), if the event
is not masked, the object will be queued for processing (by calling
fscache_enqueue_object()).
PROVISION OF CPU TIME
---------------------
The work to be done by the various states is given CPU time by the threads of
the slow work facility (see Documentation/slow-work.txt). This is used in
preference to the workqueue facility because:
(1) Threads may be completely occupied for very long periods of time by a
particular work item. These state actions may be doing sequences of
synchronous, journalled disk accesses (lookup, mkdir, create, setxattr,
getxattr, truncate, unlink, rmdir, rename).
(2) Threads may do little actual work, but may rather spend a lot of time
sleeping on I/O. This means that single-threaded and 1-per-CPU-threaded
workqueues don't necessarily have the right numbers of threads.
LOCKING SIMPLIFICATION
----------------------
Because only one worker thread may be operating on any particular object's
state machine at once, this simplifies the locking, particularly with respect
to disconnecting the netfs's representation of a cache object (fscache_cookie)
from the cache backend's representation (fscache_object) - which may be
requested from either end.
=================
THE SET OF STATES
=================
The object state machine has a set of states that it can be in. There are
preparation states in which the object sets itself up and waits for its parent
object to transit to a state that allows access to its children:
(1) State FSCACHE_OBJECT_INIT.
Initialise the object and wait for the parent object to become active. In
the cache, it is expected that it will not be possible to look an object
up from the parent object, until that parent object itself has been looked
up.
There are initialisation states in which the object sets itself up and accesses
disk for the object metadata:
(2) State FSCACHE_OBJECT_LOOKING_UP.
Look up the object on disk, using the parent as a starting point.
FS-Cache expects the cache backend to probe the cache to see whether this
object is represented there, and if it is, to see if it's valid (coherency
management).
The cache should call fscache_object_lookup_negative() to indicate lookup
failure for whatever reason, and should call fscache_obtained_object() to
indicate success.
At the completion of lookup, FS-Cache will let the netfs go ahead with
read operations, no matter whether the file is yet cached. If not yet
cached, read operations will be immediately rejected with ENODATA until
the first known page is uncached - as to that point there can be no data
to be read out of the cache for that file that isn't currently also held
in the pagecache.
(3) State FSCACHE_OBJECT_CREATING.
Create an object on disk, using the parent as a starting point. This
happens if the lookup failed to find the object, or if the object's
coherency data indicated what's on disk is out of date. In this state,
FS-Cache expects the cache to create
The cache should call fscache_obtained_object() if creation completes
successfully, fscache_object_lookup_negative() otherwise.
At the completion of creation, FS-Cache will start processing write
operations the netfs has queued for an object. If creation failed, the
write ops will be transparently discarded, and nothing recorded in the
cache.
There are some normal running states in which the object spends its time
servicing netfs requests:
(4) State FSCACHE_OBJECT_AVAILABLE.
A transient state in which pending operations are started, child objects
are permitted to advance from FSCACHE_OBJECT_INIT state, and temporary
lookup data is freed.
(5) State FSCACHE_OBJECT_ACTIVE.
The normal running state. In this state, requests the netfs makes will be
passed on to the cache.
(6) State FSCACHE_OBJECT_UPDATING.
The state machine comes here to update the object in the cache from the
netfs's records. This involves updating the auxiliary data that is used
to maintain coherency.
And there are terminal states in which an object cleans itself up, deallocates
memory and potentially deletes stuff from disk:
(7) State FSCACHE_OBJECT_LC_DYING.
The object comes here if it is dying because of a lookup or creation
error. This would be due to a disk error or system error of some sort.
Temporary data is cleaned up, and the parent is released.
(8) State FSCACHE_OBJECT_DYING.
The object comes here if it is dying due to an error, because its parent
cookie has been relinquished by the netfs or because the cache is being
withdrawn.
Any child objects waiting on this one are given CPU time so that they too
can destroy themselves. This object waits for all its children to go away
before advancing to the next state.
(9) State FSCACHE_OBJECT_ABORT_INIT.
The object comes to this state if it was waiting on its parent in
FSCACHE_OBJECT_INIT, but its parent died. The object will destroy itself
so that the parent may proceed from the FSCACHE_OBJECT_DYING state.
(10) State FSCACHE_OBJECT_RELEASING.
(11) State FSCACHE_OBJECT_RECYCLING.
The object comes to one of these two states when dying once it is rid of
all its children, if it is dying because the netfs relinquished its
cookie. In the first state, the cached data is expected to persist, and
in the second it will be deleted.
(12) State FSCACHE_OBJECT_WITHDRAWING.
The object transits to this state if the cache decides it wants to
withdraw the object from service, perhaps to make space, but also due to
error or just because the whole cache is being withdrawn.
(13) State FSCACHE_OBJECT_DEAD.
The object transits to this state when the in-memory object record is
ready to be deleted. The object processor shouldn't ever see an object in
this state.
THE SET OF EVENTS
-----------------
There are a number of events that can be raised to an object state machine:
(*) FSCACHE_OBJECT_EV_UPDATE
The netfs requested that an object be updated. The state machine will ask
the cache backend to update the object, and the cache backend will ask the
netfs for details of the change through its cookie definition ops.
(*) FSCACHE_OBJECT_EV_CLEARED
This is signalled in two circumstances:
(a) when an object's last child object is dropped and
(b) when the last operation outstanding on an object is completed.
This is used to proceed from the dying state.
(*) FSCACHE_OBJECT_EV_ERROR
This is signalled when an I/O error occurs during the processing of some
object.
(*) FSCACHE_OBJECT_EV_RELEASE
(*) FSCACHE_OBJECT_EV_RETIRE
These are signalled when the netfs relinquishes a cookie it was using.
The event selected depends on whether the netfs asks for the backing
object to be retired (deleted) or retained.
(*) FSCACHE_OBJECT_EV_WITHDRAW
This is signalled when the cache backend wants to withdraw an object.
This means that the object will have to be detached from the netfs's
cookie.
Because the withdrawing releasing/retiring events are all handled by the object
state machine, it doesn't matter if there's a collision with both ends trying
to sever the connection at the same time. The state machine can just pick
which one it wants to honour, and that effects the other.
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Steve Dickson <steved@redhat.com>
Acked-by: Trond Myklebust <Trond.Myklebust@netapp.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Tested-by: Daire Byrne <Daire.Byrne@framestore.com>
2009-04-03 09:42:38 -06:00
|
|
|
if (!test_and_set_bit(event, &object->events) &&
|
|
|
|
|
test_bit(event, &object->event_mask))
|
|
|
|
|
fscache_enqueue_object(object);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* drop a reference to a cookie
|
|
|
|
|
*/
|
|
|
|
|
static inline void fscache_cookie_put(struct fscache_cookie *cookie)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(atomic_read(&cookie->usage) <= 0);
|
|
|
|
|
if (atomic_dec_and_test(&cookie->usage))
|
|
|
|
|
__fscache_cookie_put(cookie);
|
2009-04-03 09:42:37 -06:00
|
|
|
}
|
|
|
|
|
|
2009-04-03 09:42:36 -06:00
|
|
|
/*****************************************************************************/
|
|
|
|
|
/*
|
|
|
|
|
* debug tracing
|
|
|
|
|
*/
|
|
|
|
|
#define dbgprintk(FMT, ...) \
|
|
|
|
|
printk(KERN_DEBUG "[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
/* make sure we maintain the format strings, even when debugging is disabled */
|
|
|
|
|
static inline __attribute__((format(printf, 1, 2)))
|
|
|
|
|
void _dbprintk(const char *fmt, ...)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define kenter(FMT, ...) dbgprintk("==> %s("FMT")", __func__, ##__VA_ARGS__)
|
|
|
|
|
#define kleave(FMT, ...) dbgprintk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
|
|
|
|
|
#define kdebug(FMT, ...) dbgprintk(FMT, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
#define kjournal(FMT, ...) _dbprintk(FMT, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
#ifdef __KDEBUG
|
|
|
|
|
#define _enter(FMT, ...) kenter(FMT, ##__VA_ARGS__)
|
|
|
|
|
#define _leave(FMT, ...) kleave(FMT, ##__VA_ARGS__)
|
|
|
|
|
#define _debug(FMT, ...) kdebug(FMT, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
#elif defined(CONFIG_FSCACHE_DEBUG)
|
|
|
|
|
#define _enter(FMT, ...) \
|
|
|
|
|
do { \
|
|
|
|
|
if (__do_kdebug(ENTER)) \
|
|
|
|
|
kenter(FMT, ##__VA_ARGS__); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define _leave(FMT, ...) \
|
|
|
|
|
do { \
|
|
|
|
|
if (__do_kdebug(LEAVE)) \
|
|
|
|
|
kleave(FMT, ##__VA_ARGS__); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define _debug(FMT, ...) \
|
|
|
|
|
do { \
|
|
|
|
|
if (__do_kdebug(DEBUG)) \
|
|
|
|
|
kdebug(FMT, ##__VA_ARGS__); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
#define _enter(FMT, ...) _dbprintk("==> %s("FMT")", __func__, ##__VA_ARGS__)
|
|
|
|
|
#define _leave(FMT, ...) _dbprintk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
|
|
|
|
|
#define _debug(FMT, ...) _dbprintk(FMT, ##__VA_ARGS__)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* determine whether a particular optional debugging point should be logged
|
|
|
|
|
* - we need to go through three steps to persuade cpp to correctly join the
|
|
|
|
|
* shorthand in FSCACHE_DEBUG_LEVEL with its prefix
|
|
|
|
|
*/
|
|
|
|
|
#define ____do_kdebug(LEVEL, POINT) \
|
|
|
|
|
unlikely((fscache_debug & \
|
|
|
|
|
(FSCACHE_POINT_##POINT << (FSCACHE_DEBUG_ ## LEVEL * 3))))
|
|
|
|
|
#define ___do_kdebug(LEVEL, POINT) \
|
|
|
|
|
____do_kdebug(LEVEL, POINT)
|
|
|
|
|
#define __do_kdebug(POINT) \
|
|
|
|
|
___do_kdebug(FSCACHE_DEBUG_LEVEL, POINT)
|
|
|
|
|
|
|
|
|
|
#define FSCACHE_DEBUG_CACHE 0
|
|
|
|
|
#define FSCACHE_DEBUG_COOKIE 1
|
|
|
|
|
#define FSCACHE_DEBUG_PAGE 2
|
|
|
|
|
#define FSCACHE_DEBUG_OPERATION 3
|
|
|
|
|
|
|
|
|
|
#define FSCACHE_POINT_ENTER 1
|
|
|
|
|
#define FSCACHE_POINT_LEAVE 2
|
|
|
|
|
#define FSCACHE_POINT_DEBUG 4
|
|
|
|
|
|
|
|
|
|
#ifndef FSCACHE_DEBUG_LEVEL
|
|
|
|
|
#define FSCACHE_DEBUG_LEVEL CACHE
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* assertions
|
|
|
|
|
*/
|
|
|
|
|
#if 1 /* defined(__KDEBUGALL) */
|
|
|
|
|
|
|
|
|
|
#define ASSERT(X) \
|
|
|
|
|
do { \
|
|
|
|
|
if (unlikely(!(X))) { \
|
|
|
|
|
printk(KERN_ERR "\n"); \
|
|
|
|
|
printk(KERN_ERR "FS-Cache: Assertion failed\n"); \
|
|
|
|
|
BUG(); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define ASSERTCMP(X, OP, Y) \
|
|
|
|
|
do { \
|
|
|
|
|
if (unlikely(!((X) OP (Y)))) { \
|
|
|
|
|
printk(KERN_ERR "\n"); \
|
|
|
|
|
printk(KERN_ERR "FS-Cache: Assertion failed\n"); \
|
|
|
|
|
printk(KERN_ERR "%lx " #OP " %lx is false\n", \
|
|
|
|
|
(unsigned long)(X), (unsigned long)(Y)); \
|
|
|
|
|
BUG(); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define ASSERTIF(C, X) \
|
|
|
|
|
do { \
|
|
|
|
|
if (unlikely((C) && !(X))) { \
|
|
|
|
|
printk(KERN_ERR "\n"); \
|
|
|
|
|
printk(KERN_ERR "FS-Cache: Assertion failed\n"); \
|
|
|
|
|
BUG(); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define ASSERTIFCMP(C, X, OP, Y) \
|
|
|
|
|
do { \
|
|
|
|
|
if (unlikely((C) && !((X) OP (Y)))) { \
|
|
|
|
|
printk(KERN_ERR "\n"); \
|
|
|
|
|
printk(KERN_ERR "FS-Cache: Assertion failed\n"); \
|
|
|
|
|
printk(KERN_ERR "%lx " #OP " %lx is false\n", \
|
|
|
|
|
(unsigned long)(X), (unsigned long)(Y)); \
|
|
|
|
|
BUG(); \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define ASSERT(X) do {} while (0)
|
|
|
|
|
#define ASSERTCMP(X, OP, Y) do {} while (0)
|
|
|
|
|
#define ASSERTIF(C, X) do {} while (0)
|
|
|
|
|
#define ASSERTIFCMP(C, X, OP, Y) do {} while (0)
|
|
|
|
|
|
|
|
|
|
#endif /* assert or not */
|