There are a number of reasons why I'm not using i_mapping to do this.These have been discussed a lot on the LKML and CacheFS mailing lists,but to summarise the basics:

(1) Most filesystems don't do hole reportage. Holes in files are treated as blocks of zeros and can't be distinguished otherwise, making it difficult to distinguish blocks that have been read from the network and cached from those that haven't.

(2) The backing inode must be fully populated before being exposed to userspace through the main inode because the VM/VFS goes directly to the backing inode and does not interrogate the front inode on VM ops.

Therefore:

(a) The backing inode must fit entirely within the cache.

(b) All backed files currently open must fit entirely within the cache at the same time.

(c) A working set of files in total larger than the cache may not be cached.

(d) A file may not grow larger than the available space in the cache.

(e) A file that's open and cached, and remotely grows larger than the cache is potentially stuffed.

(3) Writes go to the backing filesystem, and can only be transferred to the network when the file is closed.

(4) There's no record of what changes have been made, so the whole file must be written back.

(5) The pages belong to the backing filesystem, and all metadata associated with that page are relevant only to the backing filesystem, and not anything stacked atop it.

The attached patch adds a generic core to which both networking filesystems andcaches may bind. It transfers requests from networking filesystems toappropriate caches if possible, or else gracefully denies them.

If this facility is disabled in the kernel configuration, then all itsoperations will be trivially reducible to nothing by the compiler.

FS-Cache provides the following facilities:

(1) Caches can be added / removed at any time, even whilst in use.

(2) Adds a facility by which tags can be used to refer to caches, even if they're not mounted yet.

(3) More than one cache can be used at once. Caches can be selected explicitly by use of tags.

(4) The netfs is provided with an interface that allows either party to withdraw caching facilities from a file (required for (1)).

(5) A netfs may annotate cache objects that belongs to it.

(6) Cache objects can be pinned and reservations made.

(7) The interface to the netfs returns as few errors as possible, preferring rather to let the netfs remain oblivious.

(8) Cookies are used to represent indices, files and other objects to the netfs. The simplest cookie is just a NULL pointer - indicating nothing cached there.

(9) The netfs is allowed to propose - dynamically - any index hierarchy it desires, though it must be aware that the index search function is recursive, stack space is limited, and indices can only be children of indices.

(10) Indices can be used to group files together to reduce key size and to make group invalidation easier. The use of indices may make lookup quicker, but that's cache dependent.

(11) Data I/O is effectively done directly to and from the netfs's pages. The netfs indicates that page A is at index B of the data-file represented by cookie C, and that it should be read or written. The cache backend may or may not start I/O on that page, but if it does, a netfs callback will be invoked to indicate completion. The I/O may be either synchronous or asynchronous.

(12) Cookies can be "retired" upon release. At this point FS-Cache will mark them as obsolete and the index hierarchy rooted at that point will get recycled.

(13) The netfs provides a "match" function for index searches. In addition to saying whether a match was made or not, this can also specify that an entry should be updated or deleted.

FS-Cache maintains a virtual indexing tree in which all indices, files, objectsand pages are kept. Bits of this tree may actually reside in one or morecaches.

(*) The NFS primary index will probably contain per-server indices. Each server index is indexed by NFS file handles to get data file objects. Each data file objects can have an array of pages, but may also have further child objects, such as extended attributes and directory entries. Extended attribute objects themselves have page-array contents.

(*) The AFS primary index contains per-cell indices. Each cell index contains per-logical-volume indices. Each of volume index contains up to three indices for the read-write, read-only and backup mirrors of those volumes. Each of these contains vnode data file objects, each of which contains an array of pages.

The very top index is the FS-Cache master index in which individual netfs'shave entries.

Any index object may reside in more than one cache, provided it only has indexchildren. Any index with non-index object children will be assumed to onlyreside in one cache.

diff --git a/Documentation/filesystems/caching/backend-api.txt b/Documentation/filesystems/caching/backend-api.txtnew file mode 100644index 0000000..a7e58eb--- /dev/null+++ b/Documentation/filesystems/caching/backend-api.txt@@ -0,0 +1,625 @@+ ==========================+ FS-CACHE CACHE BACKEND API+ ==========================++The FS-Cache system provides an API by which actual caches can be supplied to+FS-Cache for it to then serve out to network filesystems and other interested+parties.++This API is declared in <linux/fscache-cache.h>.+++====================================+INITIALISING AND REGISTERING A CACHE+====================================++To start off, a cache definition must be initialised and registered for each+cache the backend wants to make available. For instance, CacheFS does this in+the fill_super() operation on mounting.++The cache definition (struct fscache_cache) should be initialised by calling:++ void fscache_init_cache(struct fscache_cache *cache,+ struct fscache_cache_ops *ops,+ const char *idfmt,+ ...);++Where:++ (*) "cache" is a pointer to the cache definition;++ (*) "ops" is a pointer to the table of operations that the backend supports on+ this cache; and++ (*) "idfmt" is a format and printf-style arguments for constructing a label+ for the cache.+++The cache should then be registered with FS-Cache by passing a pointer to the+previously initialised cache definition to:++ int fscache_add_cache(struct fscache_cache *cache,+ struct fscache_object *fsdef,+ const char *tagname);++Two extra arguments should also be supplied:++ (*) "fsdef" which should point to the object representation for the FS-Cache+ master index in this cache. Netfs primary index entries will be created+ here.++ (*) "tagname" which, if given, should be a text string naming this cache. If+ this is NULL, the identifier will be used instead. For CacheFS, the+ identifier is set to name the underlying block device and the tag can be+ supplied by mount.++This function may return -ENOMEM if it ran out of memory or -EEXIST if the tag+is already in use. 0 will be returned on success.+++=====================+UNREGISTERING A CACHE+=====================++A cache can be withdrawn from the system by calling this function with a+pointer to the cache definition:++ void fscache_withdraw_cache(struct fscache_cache *cache);++In CacheFS's case, this is called by put_super().+++========+SECURITY+========++The cache methods are executed one of two contexts:++ (1) that of the userspace process that issued the netfs operation that caused+ the cache method to be invoked, or++ (2) that of one of the processes in the FS-Cache thread pool.++In either case, this may not be an appropriate context in which to access the+cache.++The calling process's fsuid, fsgid and SELinux security identities may need to+be masqueraded for the duration of the cache driver's access to the cache.+This is left to the cache to handle; FS-Cache makes no effort in this regard.+++===================================+CONTROL AND STATISTICS PRESENTATION+===================================++The cache may present data to the outside world through FS-Cache's interfaces+in sysfs and procfs - the former for control and the latter for statistics.++A sysfs directory called /sys/fs/fscache/<cachetag>/ is created if CONFIG_SYSFS+is enabled. This is accessible through the kobject struct fscache_cache::kobj+and is for use by the cache as it sees fit.++The cache driver may create itself a directory named for the cache type in the+/proc/fs/fscache/ directory. This is available if CONFIG_FSCACHE_PROC is+enabled and is accessible through:++ struct proc_dir_entry *proc_fscache;+++========================+RELEVANT DATA STRUCTURES+========================++ (*) Index/Data file FS-Cache representation cookie:++ struct fscache_cookie {+ struct fscache_object_def *def;+ struct fscache_netfs *netfs;+ void *netfs_data;+ ...+ };++ The fields that might be of use to the backend describe the object+ definition, the netfs definition and the netfs's data for this cookie.+ The object definition contain functions supplied by the netfs for loading+ and matching index entries; these are required to provide some of the+ cache operations.+++ (*) In-cache object representation:++ struct fscache_object {+ int debug_id;+ enum {+ FSCACHE_OBJECT_RECYCLING,+ ...+ } state;+ spinlock_t lock+ struct fscache_cache *cache;+ struct fscache_cookie *cookie;+ ...+ };++ Structures of this type should be allocated by the cache backend and+ passed to FS-Cache when requested by the appropriate cache operation. In+ the case of CacheFS, they're embedded in CacheFS's internal object+ structures.++ The debug_id is a simple integer that can be used in debugging messages+ that refer to a particular object. In such a case it should be printed+ using "OBJ%x" to be consistent with FS-Cache.++ Each object contains a pointer to the cookie that represents the object it+ is backing. An object should retired when put_object() is called if it is+ in state FSCACHE_OBJECT_RECYCLING. The fscache_object struct should be+ initialised by calling fscache_object_init(object).+++ (*) FS-Cache operation record:++ struct fscache_operation {+ atomic_t usage;+ struct fscache_object *object;+ unsigned long flags;+ #define FSCACHE_OP_EXCLUSIVE+ void (*processor)(struct fscache_operation *op);+ void (*release)(struct fscache_operation *op);+ ...+ };++ FS-Cache has a pool of threads that it uses to give CPU time to the+ various asynchronous operations that need to be done as part of driving+ the cache. These are represented by the above structure. The processor+ method is called to give the op CPU time, and the release method to get+ rid of it when its usage count reaches 0.++ An operation can be made exclusive upon an object by setting the+ appropriate flag before enqueuing it with fscache_enqueue_operation(). If+ an operation needs more processing time, it should be enqueued again.+++ (*) FS-Cache retrieval operation record:++ struct fscache_retrieval {+ struct fscache_operation op;+ struct address_space *mapping;+ struct list_head *to_do;+ ...+ };++ A structure of this type is allocated by FS-Cache to record retrieval and+ allocation requests made by the netfs. This struct is then passed to the+ backend to do the operation. The backend may get extra refs to it by+ calling fscache_get_retrieval() and refs may be discarded by calling+ fscache_put_retrieval().++ A retrieval operation can be used by the backend to do retrieval work. To+ do this, the retrieval->op.processor method pointer should be set+ appropriately by the backend and fscache_enqueue_retrieval() called to+ submit it to the thread pool. CacheFiles, for example, uses this to queue+ page examination when it detects PG_lock being cleared.++ The to_do field is an empty list available for the cache backend to use as+ it sees fit.+++ (*) FS-Cache storage operation record:++ struct fscache_storage {+ struct fscache_operation op;+ pgoff_t store_limit;+ ...+ };++ A structure of this type is allocated by FS-Cache to record outstanding+ writes to be made. FS-Cache itself enqueues this operation and invokes+ the write_page() method on the object at appropriate times to effect+ storage.+++================+CACHE OPERATIONS+================++The cache backend provides FS-Cache with a table of operations that can be+performed on the denizens of the cache. These are held in a structure of type:++ struct fscache_cache_ops++ (*) Name of cache provider [mandatory]:++ const char *name++ This isn't strictly an operation, but should be pointed at a string naming+ the backend.+++ (*) Allocate a new object [mandatory]:++ struct fscache_object *(*alloc_object)(struct fscache_cache *cache,+ struct fscache_cookie *cookie)++ This method is used to allocate a cache object representation to back a+ cookie in a particular cache. fscache_object_init() should be called on+ the object to initialise it prior to returning.++ This function may also be used to parse the index key to be used for+ multiple lookup calls to turn it into a more convenient form. FS-Cache+ will call the lookup_complete() method to allow the cache to release the+ form once lookup is complete or aborted.+++ (*) Look up and create object [mandatory]:++ void (*lookup_object)(struct fscache_object *object)++ This method is used to look up an object, given that the object is already+ allocated and attached to the cookie. This should instantiate that object+ in the cache if it can.++ The method should call fscache_object_lookup_negative() as soon as+ possible if it determines the object doesn't exist in the cache. If the+ object is found to exist and the netfs indicates that it is valid then+ fscache_obtained_object() should be called once the object is in a+ position to have data stored in it. Similarly, fscache_obtained_object()+ should also be called once a non-present object has been created.++ If a lookup error occurs, fscache_object_lookup_error() should be called+ to abort the lookup of that object.+++ (*) Release lookup data [mandatory]:++ void (*lookup_complete)(struct fscache_object *object)++ This method is called to ask the cache to release any resources it was+ using to perform a lookup.+++ (*) Increment object refcount [mandatory]:++ struct fscache_object *(*grab_object)(struct fscache_object *object)++ This method is called to increment the reference count on an object. It+ may fail (for instance if the cache is being withdrawn) by returning NULL.+ It should return the object pointer if successful.+++ (*) Lock/Unlock object [mandatory]:++ void (*lock_object)(struct fscache_object *object)+ void (*unlock_object)(struct fscache_object *object)++ These methods are used to exclusively lock an object. It must be possible+ to schedule with the lock held, so a spinlock isn't sufficient.+++ (*) Pin/Unpin object [optional]:++ int (*pin_object)(struct fscache_object *object)+ void (*unpin_object)(struct fscache_object *object)++ These methods are used to pin an object into the cache. Once pinned an+ object cannot be reclaimed to make space. Return -ENOSPC if there's not+ enough space in the cache to permit this.+++ (*) Update object [mandatory]:++ int (*update_object)(struct fscache_object *object)++ This is called to update the index entry for the specified object. The+ new information should be in object->cookie->netfs_data. This can be+ obtained by calling object->cookie->def->get_aux()/get_attr().+++ (*) Discard object [mandatory]:++ void (*drop_object)(struct fscache_object *object)++ This method is called to indicate that an object has been unbound from its+ cookie, and that the cache should release the object's resources and+ retire it if it's in state FSCACHE_OBJECT_RECYCLING.++ This method should not attempt to release any references held by the+ caller. The caller will invoke the put_object() method as appropriate.+++ (*) Release object reference [mandatory]:++ void (*put_object)(struct fscache_object *object)++ This method is used to discard a reference to an object. The object may+ be freed when all the references to it are released.+++ (*) Synchronise a cache [mandatory]:++ void (*sync)(struct fscache_cache *cache)++ This is called to ask the backend to synchronise a cache with its backing+ device.+++ (*) Dissociate a cache [mandatory]:++ void (*dissociate_pages)(struct fscache_cache *cache)++ This is called to ask a cache to perform any page dissociations as part of+ cache withdrawal.+++ (*) Notification that the attributes on a netfs file changed [mandatory]:++ int (*attr_changed)(struct fscache_object *object);++ This is called to indicate to the cache that certain attributes on a netfs+ file have changed (for example the maximum size a file may reach). The+ cache can read these from the netfs by calling the cookie's get_attr()+ method.++ The cache may use the file size information to reserve space on the cache.+ It should also call fscache_set_store_limit() to indicate to FS-Cache the+ highest byte it's willing to store for an object.++ This method may return -ve if an error occurred or the cache object cannot+ be expanded. In such a case, the object will be withdrawn from service.++ This operation is run asynchronously from FS-Cache's thread pool, and+ storage and retrieval operations from the netfs are excluded during the+ execution of this operation.+++ (*) Reserve cache space for an object's data [optional]:++ int (*reserve_space)(struct fscache_object *object, loff_t size);++ This is called to request that cache space be reserved to hold the data+ for an object and the metadata used to track it. Zero size should be+ taken as request to cancel a reservation.++ This should return 0 if successful, -ENOSPC if there isn't enough space+ available, or -ENOMEM or -EIO on other errors.++ The reservation may exceed the current size of the object, thus permitting+ future expansion. If the amount of space consumed by an object would+ exceed the reservation, it's permitted to refuse requests to allocate+ pages, but not required. An object may be pruned down to its reservation+ size if larger than that already.+++ (*) Request page be read from cache [mandatory]:++ int (*read_or_alloc_page)(struct fscache_retrieval *op,+ struct page *page,+ gfp_t gfp)++ This is called to attempt to read a netfs page from the cache, or to+ reserve a backing block if not. FS-Cache will have done as much checking+ as it can before calling, but most of the work belongs to the backend.++ If there's no page in the cache, then -ENODATA should be returned if the+ backend managed to reserve a backing block; -ENOBUFS or -ENOMEM if it+ didn't.++ If there is suitable data in the cache, then a read operation should be+ queued and 0 returned. When the read finishes, fscache_end_io() should be+ called.++ The fscache_mark_pages_cached() should be called for the page if any cache+ metadata is retained. This will indicate to the netfs that the page needs+ explicit uncaching. This operation takes a pagevec, thus allowing several+ pages to be marked at once.++ The retrieval record pointed to by op should be retained for each page+ queued and released when I/O on the page has been formally ended.+ fscache_get/put_retrieval() are available for this purpose.++ The retrieval record may be used to get CPU time via the FS-Cache thread+ pool. If this is desired, the op->op.processor should be set to point to+ the appropriate processing routine, and fscache_enqueue_retrieval() should+ be called at an appropriate point to request CPU time. For instance, the+ retrieval routine could be enqueued upon the completion of a disk read.+ The to_do field in the retrieval record is provided to aid in this.++ If an I/O error occurs, fscache_io_error() should be called and -ENOBUFS+ returned if possible or fscache_end_io() called with a suitable error+ code..+++ (*) Request pages be read from cache [mandatory]:++ int (*read_or_alloc_pages)(struct fscache_retrieval *op,+ struct list_head *pages,+ unsigned *nr_pages,+ gfp_t gfp)++ This is like the read_or_alloc_page() method, except it is handed a list+ of pages instead of one page. Any pages on which a read operation is+ started must be added to the page cache for the specified mapping and also+ to the LRU. Such pages must also be removed from the pages list and+ *nr_pages decremented per page.++ If there was an error such as -ENOMEM, then that should be returned; else+ if one or more pages couldn't be read or allocated, then -ENOBUFS should+ be returned; else if one or more pages couldn't be read, then -ENODATA+ should be returned. If all the pages are dispatched then 0 should be+ returned.+++ (*) Request page be allocated in the cache [mandatory]:++ int (*allocate_page)(struct fscache_retrieval *op,+ struct page *page,+ gfp_t gfp)++ This is like the read_or_alloc_page() method, except that it shouldn't+ read from the cache, even if there's data there that could be retrieved.+ It should, however, set up any internal metadata required such that+ the write_page() method can write to the cache.++ If there's no backing block available, then -ENOBUFS should be returned+ (or -ENOMEM if there were other problems). If a block is successfully+ allocated, then the netfs page should be marked and 0 returned.+++ (*) Request pages be allocated in the cache [mandatory]:++ int (*allocate_pages)(struct fscache_retrieval *op,+ struct list_head *pages,+ unsigned *nr_pages,+ gfp_t gfp)++ This is an multiple page version of the allocate_page() method. pages and+ nr_pages should be treated as for the read_or_alloc_pages() method.+++ (*) Request page be written to cache [mandatory]:++ int (*write_page)(struct fscache_storage *op,+ struct page *page);++ This is called to write from a page on which there was a previously+ successful read_or_alloc_page() call or similar. FS-Cache filters out+ pages that don't have mappings.++ This method is called asynchronously from the FS-Cache thread pool. It is+ not required to actually store anything, provided -ENODATA is then+ returned to the next read of this page.++ If an error occurred, then a negative error code should be returned,+ otherwise zero should be returned. FS-Cache will take appropriate action+ in response to an error, such as withdrawing this object.++ If this method returns success then FS-Cache will inform the netfs+ appropriately.+++ (*) Discard retained per-page metadata [mandatory]:++ void (*uncache_page)(struct fscache_object *object, struct page *page)++ This is called when a netfs page is being evicted from the pagecache. The+ cache backend should tear down any internal representation or tracking it+ maintains for this page.+++==================+FS-CACHE UTILITIES+==================++FS-Cache provides some utilities that a cache backend may make use of:++ (*) Note occurrence of an I/O error in a cache:++ void fscache_io_error(struct fscache_cache *cache)++ This tells FS-Cache that an I/O error occurred in the cache. After this+ has been called, only resource dissociation operations (object and page+ release) will be passed from the netfs to the cache backend for the+ specified cache.++ This does not actually withdraw the cache. That must be done separately.+++ (*) Invoke the retrieval I/O completion function:++ void fscache_end_io(struct fscache_retrieval *op, struct page *page,+ int error);++ This is called to note the end of an attempt to retrieve a page. The+ error value should be 0 if successful and an error otherwise.+++ (*) Set highest store limit:++ void fscache_set_store_limit(struct fscache_object *object,+ loff_t i_size);++ This sets the limit FS-Cache imposes on the highest byte it's willing to+ try and store for a netfs. Any page over this limit is automatically+ rejected by fscache_read_alloc_page() and co with -ENOBUFS.+++ (*) Mark pages as being cached:++ void fscache_mark_pages_cached(struct fscache_retrieval *op,+ struct pagevec *pagevec);++ This marks a set of pages as being cached. After this has been called,+ the netfs must call fscache_uncache_page() to unmark the pages.+++ (*) Initialise a freshly allocated object:++ void fscache_object_init(struct fscache_object *object);++ This initialises all the fields in an object representation.+++ (*) Indicate negative lookup on an object:++ void fscache_object_lookup_negative(struct fscache_object *object);++ This is called to indicate to FS-Cache that a lookup process for an object+ found a negative result.++ This changes the state of an object to permit reads pending on lookup+ completion to go off and start fetching data from the netfs server as it's+ known at this point that there can't be any data in the cache.++ This may be called multiple times on an object. Only the first call is+ significant - all subsequent calls are ignored.+++ (*) Indicate an object has been obtained:++ void fscache_obtained_object(struct fscache_object *object);++ This is called to indicate to FS-Cache that a lookup process for an object+ produced a positive result, or that an object was created. This should+ only be called once for any particular object.++ This changes the state of an object to indicate:++ (1) if no call to fscache_object_lookup_negative() has been made on+ this object, that there may be data available, and that reads can+ now go and look for it; and++ (2) that writes may now proceed against this object.+++ (*) Indicate that object lookup failed:++ void fscache_object_lookup_error(struct fscache_object *object);++ This marks an object as having encountered a fatal error (usually EIO)+ and causes it to move into a state whereby it will be withdrawn as soon+ as possible.+++ (*) Get and release references on a retrieval record:++ void fscache_get_retrieval(struct fscache_retrieval *op);+ void fscache_put_retrieval(struct fscache_retrieval *op);++ These two functions are used to retain a retrieval record whilst doing+ asynchronous data retrieval and block allocation.+++ (*) Enqueue a retrieval record for processing.++ void fscache_enqueue_retrieval(struct fscache_retrieval *op);++ This enqueues a retrieval record for processing by the FS-Cache thread+ pool. One of the threads in the pool will invoke the retrieval record's+ op->op.processor callback function. This function may be called from+ within the callback function.+++ (*) List of object state names:++ const char *fscache_object_states[];++ For debugging purposes, this may be used to turn the state that an object+ is in into a text string for display purposes.diff --git a/Documentation/filesystems/caching/fscache.txt b/Documentation/filesystems/caching/fscache.txtnew file mode 100644index 0000000..7a6169f--- /dev/null+++ b/Documentation/filesystems/caching/fscache.txt@@ -0,0 +1,331 @@+ ==========================+ General Filesystem Caching+ ==========================++========+OVERVIEW+========++This facility is a general purpose cache for network filesystems, though it+could be used for caching other things such as ISO9660 filesystems too.++FS-Cache mediates between cache backends (such as CacheFS) and network+filesystems:++ +---------++ | | +--------------++ | NFS |--+ | |+ | | | +-->| CacheFS |+ +---------+ | +----------+ | | /dev/hda5 |+ | | | | +--------------++ +---------+ +-->| | |+ | | | |--++ | AFS |----->| FS-Cache |+ | | | |--++ +---------+ +-->| | |+ | | | | +--------------++ +---------+ | +----------+ | | |+ | | | +-->| CacheFiles |+ | ISOFS |--+ | /var/cache |+ | | +--------------++ +---------+++Or to look at it another way, FS-Cache is a module that provides a caching+facility to a network filesystem such that the cache is transparent to the+user:++ +---------++ | |+ | Server |+ | |+ +---------++ | NETWORK+ ~~~~~|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+ |+ | +----------++ V | |+ +---------+ | |+ | | | |+ | NFS |----->| FS-Cache |+ | | | |--++ +---------+ | | | +--------------+ +--------------++ | | | | | | | |+ V +----------+ +-->| CacheFiles |-->| Ext3 |+ +---------+ | /var/cache | | /dev/sda6 |+ | | +--------------+ +--------------++ | VFS | ^ ^+ | | | |+ +---------+ +--------------+ |+ | KERNEL SPACE | |+ ~~~~~|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|~~~~~~|~~~~+ | USER SPACE | |+ V | |+ +---------+ +--------------++ | | | |+ | Process | | cachefilesd |+ | | | |+ +---------+ +--------------++++FS-Cache does not follow the idea of completely loading every netfs file+opened in its entirety into a cache before permitting it to be accessed and+then serving the pages out of that cache rather than the netfs inode because:++ (1) It must be practical to operate without a cache.++ (2) The size of any accessible file must not be limited to the size of the+ cache.++ (3) The combined size of all opened files (this includes mapped libraries)+ must not be limited to the size of the cache.++ (4) The user should not be forced to download an entire file just to do a+ one-off access of a small portion of it (such as might be done with the+ "file" program).++It instead serves the cache out in PAGE_SIZE chunks as and when requested by+the netfs('s) using it.+++FS-Cache provides the following facilities:++ (1) More than one cache can be used at once. Caches can be selected+ explicitly by use of tags.++ (2) Caches can be added / removed at any time.++ (3) The netfs is provided with an interface that allows either party to+ withdraw caching facilities from a file (required for (2)).++ (4) The interface to the netfs returns as few errors as possible, preferring+ rather to let the netfs remain oblivious.++ (5) Cookies are used to represent indices, files and other objects to the+ netfs. The simplest cookie is just a NULL pointer - indicating nothing+ cached there.++ (6) The netfs is allowed to propose - dynamically - any index hierarchy it+ desires, though it must be aware that the index search function is+ recursive, stack space is limited, and indices can only be children of+ indices.++ (7) Data I/O is done direct to and from the netfs's pages. The netfs+ indicates that page A is at index B of the data-file represented by cookie+ C, and that it should be read or written. The cache backend may or may+ not start I/O on that page, but if it does, a netfs callback will be+ invoked to indicate completion. The I/O may be either synchronous or+ asynchronous.++ (8) Cookies can be "retired" upon release. At this point FS-Cache will mark+ them as obsolete and the index hierarchy rooted at that point will get+ recycled.++ (9) The netfs provides a "match" function for index searches. In addition to+ saying whether a match was made or not, this can also specify that an+ entry should be updated or deleted.++(10) As much as possible is done asynchronously.+++FS-Cache maintains a virtual indexing tree in which all indices, files, objects+and pages are kept. Bits of this tree may actually reside in one or more+caches.++ FSDEF+ |+ +------------------------------------++ | |+ NFS AFS+ | |+ +--------------------------+ +-----------++ | | | |+ homedir mirror afs.org redhat.com+ | | |+ +------------+ +---------------+ +----------++ | | | | | |+ 00001 00002 00007 00125 vol00001 vol00002+ | | | | |+ +---+---+ +-----+ +---+ +------+------+ +-----+----++ | | | | | | | | | | | | |+PG0 PG1 PG2 PG0 XATTR PG0 PG1 DIRENT DIRENT DIRENT R/W R/O Bak+ | |+ PG0 +-------++ | |+ 00001 00003+ |+ +---+---++ | | |+ PG0 PG1 PG2++In the example above, you can see two netfs's being backed: NFS and AFS. These+have different index hierarchies:++ (*) The NFS primary index contains per-server indices. Each server index is+ indexed by NFS file handles to get data file objects. Each data file+ objects can have an array of pages, but may also have further child+ objects, such as extended attributes and directory entries. Extended+ attribute objects themselves have page-array contents.++ (*) The AFS primary index contains per-cell indices. Each cell index contains+ per-logical-volume indices. Each of volume index contains up to three+ indices for the read-write, read-only and backup mirrors of those volumes.+ Each of these contains vnode data file objects, each of which contains an+ array of pages.++The very top index is the FS-Cache master index in which individual netfs's+have entries.++Any index object may reside in more than one cache, provided it only has index+children. Any index with non-index object children will be assumed to only+reside in one cache.+++The netfs API to FS-Cache can be found in:++ Documentation/filesystems/caching/netfs-api.txt++The cache backend API to FS-Cache can be found in:++ Documentation/filesystems/caching/backend-api.txt+++=======================+STATISTICAL INFORMATION+=======================++If FS-Cache is compiled with the following options enabled:++ CONFIG_FSCACHE_PROC=y (implied by the following two)+ CONFIG_FSCACHE_STATS=y+ CONFIG_FSCACHE_HISTOGRAM=y++then it will gather certain statistics and display them through a number of+proc files.++ (*) /proc/fs/fscache/stats++ This shows counts of a number of events that can happen in FS-Cache:++ CLASS EVENT MEANING+ ======= ======= =======================================================+ Cookies idx=N Number of index cookies allocated+ dat=N Number of data storage cookies allocated+ spc=N Number of special cookies allocated+ Objects alc=N Number of objects allocated+ nal=N Number of object allocation failures+ avl=N Number of objects that reached the available state+ Pages mrk=N Number of pages marked as being cached+ unc=N Number of uncache page requests seen+ Acquire n=N Number of acquire cookie requests seen+ nul=N Number of acq reqs given a NULL parent+ noc=N Number of acq reqs rejected due to no cache available+ ok=N Number of acq reqs succeeded+ nbf=N Number of acq reqs rejected due to error+ oom=N Number of acq reqs failed on ENOMEM+ Lookups n=N Number of lookup calls made on cache backends+ neg=N Number of negative lookups made+ pos=N Number of positive lookups made+ crt=N Number of objects created by lookup+ bst=N Number of objects with boosted lookup priority+ Updates n=N Number of update cookie requests seen+ nul=N Number of upd reqs given a NULL parent+ run=N Number of upd reqs granted CPU time+ Relinqs n=N Number of relinquish cookie requests seen+ nul=N Number of rlq reqs given a NULL parent+ wcr=N Number of rlq reqs waited on completion of creation+ AttrChg n=N Number of attribute changed requests seen+ ok=N Number of attr changed requests queued+ nbf=N Number of attr changed rejected -ENOBUFS+ oom=N Number of attr changed failed -ENOMEM+ run=N Number of attr changed ops given CPU time+ Allocs n=N Number of allocation requests seen+ ok=N Number of successful alloc reqs+ wt=N Number of alloc reqs that waited on lookup completion+ nbf=N Number of alloc reqs rejected -ENOBUFS+ ops=N Number of alloc reqs submitted+ owt=N Number of alloc reqs waited for CPU time+ Retrvls n=N Number of retrieval (read) requests seen+ ok=N Number of successful retr reqs+ wt=N Number of retr reqs that waited on lookup completion+ nod=N Number of retr reqs returned -ENODATA+ nbf=N Number of retr reqs rejected -ENOBUFS+ int=N Number of retr reqs aborted -ERESTARTSYS+ oom=N Number of retr reqs failed -ENOMEM+ ops=N Number of retr reqs submitted+ owt=N Number of retr reqs waited for CPU time+ Stores n=N Number of storage (write) requests seen+ ok=N Number of successful store reqs+ agn=N Number of store reqs on a page already pending storage+ nbf=N Number of store reqs rejected -ENOBUFS+ oom=N Number of store reqs failed -ENOMEM+ ops=N Number of store reqs submitted+ run=N Number of store reqs granted CPU time+ Ops pend=N Number of times async ops added to pending queues+ run=N Number of times async ops given CPU time+ enq=N Number of times async ops queued for processing+ req=N Number of times async ops requeued for processing+ rel=N Number of times async ops released+++ (*) /proc/fs/fscache/pool++ This shows the number of objects and operations each thread in the thread+ pool has given CPU time to.+++ (*) /proc/fs/fscache/histogram++ cat /proc/fs/fscache/histogram + +HZ +TIME OBJ INST OP RUNS OBJ RUNS RETRV DLY RETRIEVLS+ ===== ===== ========= ========= ========= ========= =========++ This shows the breakdown of the number of times each amount of time+ between 0 jiffies and HZ-1 jiffies a variety of tasks took to run. The+ columns are as follows:++ COLUMN TIME MEASUREMENT+ ======= =======================================================+ OBJ INST Length of time to instantiate an object+ OP RUNS Length of time a call to process an operation took+ OBJ RUNS Length of time a call to process an object event took+ RETRV DLY Time between an requesting a read and lookup completing+ RETRIEVLS Time between beginning and end of a retrieval++ Each row shows the number of events that took a particular range of times.+ Each step is 1 jiffy in size. The +HZ column indicates the particular+ jiffy range covered, and the +TIME field the equivalent number of seconds.+++=========+DEBUGGING+=========++The FS-Cache facility can have runtime debugging enabled by adjusting the value+in:++ /sys/module/fscache/parameters/debug++This is a bitmask of debugging streams to enable:++ BIT VALUE STREAM POINT+ ======= ======= =============================== =======================+ 0 1 Cache management Function entry trace+ 1 2 Function exit trace+ 2 4 General+ 3 8 Cookie management Function entry trace+ 4 16 Function exit trace+ 5 32 General+ 6 64 Page handling Function entry trace+ 7 128 Function exit trace+ 8 256 General+ 9 512 Thread pool management Function entry trace+ 10 1024 Function exit trace+ 11 2048 General++The appropriate set of values should be OR'd together and the result written to+the control file. For example:++ echo $((1|8|64)) >/sys/module/fscache/parameters/debug++will turn on all function entry debugging.+diff --git a/Documentation/filesystems/caching/netfs-api.txt b/Documentation/filesystems/caching/netfs-api.txtnew file mode 100644index 0000000..67f9418--- /dev/null+++ b/Documentation/filesystems/caching/netfs-api.txt@@ -0,0 +1,812 @@+ ===============================+ FS-CACHE NETWORK FILESYSTEM API+ ===============================++There's an API by which a network filesystem can make use of the FS-Cache+facilities. This is based around a number of principles:++ (1) Caches can store a number of different object types. There are two main+ object types: indices and files. The first is a special type used by+ FS-Cache to make finding objects faster and to make retiring of groups of+ objects easier.++ (2) Every index, file or other object is represented by a cookie. This cookie+ may or may not have anything associated with it, but the netfs doesn't+ need to care.++ (3) Barring the top-level index (one entry per cached netfs), the index+ hierarchy for each netfs is structured according the whim of the netfs.++This API is declared in <linux/fscache.h>.++This document contains the following sections:++ (1) Network filesystem definition+ (2) Index definition+ (3) Object definition+ (4) Network filesystem (un)registration+ (5) Cache tag lookup+ (6) Index registration+ (7) Data file registration+ (8) Miscellaneous object registration+ (9) Setting the data file size+ (10) Page alloc/read/write+ (11) Page uncaching+ (12) Index and data file update+ (13) Miscellaneous cookie operations+ (14) Cookie unregistration+ (15) Index and data file invalidation+ (16) FS-Cache specific page flags.+++=============================+NETWORK FILESYSTEM DEFINITION+=============================++FS-Cache needs a description of the network filesystem. This is specified+using a record of the following structure:++ struct fscache_netfs {+ uint32_t version;+ const char *name;+ struct fscache_netfs_operations *ops;+ struct fscache_cookie *primary_index;+ ...+ };++This first three fields should be filled in before registration, and the fourth+will be filled in by the registration function; any other fields should just be+ignored and are for internal use only.++The fields are:++ (1) The name of the netfs (used as the key in the toplevel index).++ (2) The version of the netfs (if the name matches but the version doesn't, the+ entire in-cache hierarchy for this netfs will be scrapped and begun+ afresh).++ (3) The operations table is defined as follows:++ struct fscache_netfs_operations {+ };++ Currently there aren't any functions here.++ (4) The cookie representing the primary index will be allocated according to+ another parameter passed into the registration function.++For example, kAFS (linux/fs/afs/) uses the following definitions to describe+itself:++ static struct fscache_netfs_operations afs_cache_ops = {+ };++ struct fscache_netfs afs_cache_netfs = {+ .version = 0,+ .name = "afs",+ .ops = &afs_cache_ops,+ };+++================+INDEX DEFINITION+================++Indices are used for two purposes:++ (1) To aid the finding of a file based on a series of keys (such as AFS's+ "cell", "volume ID", "vnode ID").++ (2) To make it easier to discard a subset of all the files cached based around+ a particular key - for instance to mirror the removal of an AFS volume.++However, since it's unlikely that any two netfs's are going to want to define+their index hierarchies in quite the same way, FS-Cache tries to impose as few+restraints as possible on how an index is structured and where it is placed in+the tree. The netfs can even mix indices and data files at the same level, but+it's not recommended.++Each index entry consists of a key of indeterminate length plus some auxilliary+data, also of indeterminate length.++There are some limits on indices:++ (1) Any index containing non-index objects should be restricted to a single+ cache. Any such objects created within an index will be created in the+ first cache only. The cache in which an index is created can be+ controlled by cache tags (see below).++ (2) The entry data must be atomically journallable, so it is limited to about+ 400 bytes at present. At least 400 bytes will be available.++ (3) The depth of the index tree should be judged with care as the search+ function is recursive. Too many layers will run the kernel out of stack.+++=================+OBJECT DEFINITION+=================++To define an object, a structure of the following type should be filled out:++ struct fscache_cookie_def+ {+ uint8_t name[16];+ uint8_t type;++ struct fscache_cache_tag *(*select_cache)(+ const void *parent_netfs_data,+ const void *cookie_netfs_data);++ uint16_t (*get_key)(const void *cookie_netfs_data,+ void *buffer,+ uint16_t bufmax);++ void (*get_attr)(const void *cookie_netfs_data,+ uint64_t *size);++ uint16_t (*get_aux)(const void *cookie_netfs_data,+ void *buffer,+ uint16_t bufmax);++ enum fscache_checkaux (*check_aux)(void *cookie_netfs_data,+ const void *data,+ uint16_t datalen);++ void (*get_context)(void *cookie_netfs_data, void *context);++ void (*put_context)(void *cookie_netfs_data, void *context);++ void (*mark_pages_cached)(void *cookie_netfs_data,+ struct address_space *mapping,+ struct pagevec *cached_pvec);++ void (*now_uncached)(void *cookie_netfs_data);+ };++This has the following fields:++ (1) The type of the object [mandatory].++ This is one of the following values:++ (*) FSCACHE_COOKIE_TYPE_INDEX++ This defines an index, which is a special FS-Cache type.++ (*) FSCACHE_COOKIE_TYPE_DATAFILE++ This defines an ordinary data file.++ (*) Any other value between 2 and 255++ This defines an extraordinary object such as an XATTR.++ (2) The name of the object type (NUL terminated unless all 16 chars are used)+ [optional].++ (3) A function to select the cache in which to store an index [optional].++ This function is invoked when an index needs to be instantiated in a cache+ during the instantiation of a non-index object. Only the immediate index+ parent for the non-index object will be queried. Any indices above that+ in the hierarchy may be stored in multiple caches. This function does not+ need to be supplied for any non-index object or any index that will only+ have index children.++ If this function is not supplied or if it returns NULL then the first+ cache in the parent's list will be chosed, or failing that, the first+ cache in the master list.++ (4) A function to retrieve an object's key from the netfs [mandatory].++ This function will be called with the netfs data that was passed to the+ cookie acquisition function and the maximum length of key data that it may+ provide. It should write the required key data into the given buffer and+ return the quantity it wrote.++ (5) A function to retrieve attribute data from the netfs [optional].++ This function will be called with the netfs data that was passed to the+ cookie acquisition function. It should return the size of the file if+ this is a data file. The size may be used to govern how much cache must+ be reserved for this file in the cache.++ If the function is absent, a file size of 0 is assumed.++ (6) A function to retrieve auxilliary data from the netfs [optional].++ This function will be called with the netfs data that was passed to the+ cookie acquisition function and the maximum length of auxilliary data that+ it may provide. It should write the auxilliary data into the given buffer+ and return the quantity it wrote.++ If this function is absent, the auxilliary data length will be set to 0.++ The length of the auxilliary data buffer may be dependent on the key+ length. A netfs mustn't rely on being able to provide more than 400 bytes+ for both.++ (7) A function to check the auxilliary data [optional].++ This function will be called to check that a match found in the cache for+ this object is valid. For instance with AFS it could check the auxilliary+ data against the data version number returned by the server to determine+ whether the index entry in a cache is still valid.++ If this function is absent, it will be assumed that matching objects in a+ cache are always valid.++ If present, the function should return one of the following values:++ (*) FSCACHE_CHECKAUX_OKAY - the entry is okay as is+ (*) FSCACHE_CHECKAUX_NEEDS_UPDATE - the entry requires update+ (*) FSCACHE_CHECKAUX_OBSOLETE - the entry should be deleted++ This function can also be used to extract data from the auxilliary data in+ the cache and copy it into the netfs's structures.++ (8) A pair of functions to manage contexts for the completion callback+ [optional].++ The cache read/write functions are passed a context which is then passed+ to the I/O completion callback function. To ensure this context remains+ valid until after the I/O completion is called, two functions may be+ provided: one to get an extra reference on the context, and one to drop a+ reference to it.++ If the context is not used or is a type of object that won't go out of+ scope, then these functions are not required. These functions are not+ required for indices as indices may not contain data. These functions may+ be called in interrupt context and so may not sleep.++ (9) A function to mark a page as retaining cache metadata [optional].++ This is called by the cache to indicate that it is retaining in-memory+ information for this page and that the netfs should uncache the page when+ it has finished. This does not indicate whether there's data on the disk+ or not. Note that several pages at once may be presented for marking.++ The PG_fscache bit is set on the pages before this function would be+ called, so the function need not be provided if this is sufficient.++ This function is not required for indices as they're not permitted data.++(10) A function to unmark all the pages retaining cache metadata [mandatory].++ This is called by FS-Cache to indicate that a backing store is being+ unbound from a cookie and that all the marks on the pages should be+ cleared to prevent confusion. Note that the cache will have torn down all+ its tracking information so that the pages don't need to be explicitly+ uncached.++ This function is not required for indices as they're not permitted data.+++===================================+NETWORK FILESYSTEM (UN)REGISTRATION+===================================++The first step is to declare the network filesystem to the cache. This also+involves specifying the layout of the primary index (for AFS, this would be the+"cell" level).++The registration function is:++ int fscache_register_netfs(struct fscache_netfs *netfs);++It just takes a pointer to the netfs definition. It returns 0 or an error as+appropriate.++For kAFS, registration is done as follows:++ ret = fscache_register_netfs(&afs_cache_netfs);++The last step is, of course, unregistration:++ void fscache_unregister_netfs(struct fscache_netfs *netfs);+++================+CACHE TAG LOOKUP+================++FS-Cache permits the use of more than one cache. To permit particular index+subtrees to be bound to particular caches, the second step is to look up cache+representation tags. This step is optional; it can be left entirely up to+FS-Cache as to which cache should be used. The problem with doing that is that+FS-Cache will always pick the first cache that was registered.++To get the representation for a named tag:++ struct fscache_cache_tag *fscache_lookup_cache_tag(const char *name);++This takes a text string as the name and returns a representation of a tag. It+will never return an error. It may return a dummy tag, however, if it runs out+of memory; this will inhibit caching with this tag.++Any representation so obtained must be released by passing it to this function:++ void fscache_release_cache_tag(struct fscache_cache_tag *tag);++The tag will be retrieved by FS-Cache when it calls the object definition+operation select_cache().+++==================+INDEX REGISTRATION+==================++The third step is to inform FS-Cache about part of an index hierarchy that can+be used to locate files. This is done by requesting a cookie for each index in+the path to the file:++ struct fscache_cookie *+ fscache_acquire_cookie(struct fscache_cookie *parent,+ const struct fscache_object_def *def,+ void *netfs_data);++This function creates an index entry in the index represented by parent,+filling in the index entry by calling the operations pointed to by def.++Note that this function never returns an error - all errors are handled+internally. It may, however, return NULL to indicate no cookie. It is quite+acceptable to pass this token back to this function as the parent to another+acquisition (or even to the relinquish cookie, read page and write page+functions - see below).++Note also that no indices are actually created in a cache until a non-index+object needs to be created somewhere down the hierarchy. Furthermore, an index+may be created in several different caches independently at different times.+This is all handled transparently, and the netfs doesn't see any of it.++For example, with AFS, a cell would be added to the primary index. This index+entry would have a dependent inode containing a volume location index for the+volume mappings within this cell:++ cell->cache =+ fscache_acquire_cookie(afs_cache_netfs.primary_index,+ &afs_cell_cache_index_def,+ cell);++Then when a volume location was accessed, it would be entered into the cell's+index and an inode would be allocated that acts as a volume type and hash chain+combination:++ vlocation->cache =+ fscache_acquire_cookie(cell->cache,+ &afs_vlocation_cache_index_def,+ vlocation);++And then a particular flavour of volume (R/O for example) could be added to+that index, creating another index for vnodes (AFS inode equivalents):++ volume->cache =+ fscache_acquire_cookie(vlocation->cache,+ &afs_volume_cache_index_def,+ volume);+++======================+DATA FILE REGISTRATION+======================++The fourth step is to request a data file be created in the cache. This is+identical to index cookie acquisition. The only difference is that the type in+the object definition should be something other than index type.++ vnode->cache =+ fscache_acquire_cookie(volume->cache,+ &afs_vnode_cache_object_def,+ vnode);+++=================================+MISCELLANEOUS OBJECT REGISTRATION+=================================++An optional step is to request an object of miscellaneous type be created in+the cache. This is almost identical to index cookie acquisition. The only+difference is that the type in the object definition should be something other+than index type. Whilst the parent object could be an index, it's more likely+it would be some other type of object such as a data file.++ xattr->cache =+ fscache_acquire_cookie(vnode->cache,+ &afs_xattr_cache_object_def,+ xattr);++Miscellaneous objects might be used to store extended attributes or directory+entries for example.+++==========================+SETTING THE DATA FILE SIZE+==========================++The fifth step is to set the physical attributes of the file, such as its size.+This doesn't automatically reserve any space in the cache, but permits the+cache to adjust its metadata for data tracking appropriately:++ int fscache_attr_changed(struct fscache_cookie *cookie);++The cache will return -ENOBUFS if there is no backing cache or if there is no+space to allocate any extra metadata required in the cache. The attributes+will be accessed with the get_attr() cookie definition operation.++Note that attempts to read or write data pages in the cache over this size may+be rebuffed with -ENOBUFS.++This operation schedules an attribute adjustment to happen asynchronously at+some point in the future, and as such, it may happen after the function returns+to the caller. The attribute adjustment excludes read and write operations.+++=====================+PAGE READ/ALLOC/WRITE+=====================++And the sixth step is to store and retrieve pages in the cache. There are+three functions that are used to do this.++Note:++ (1) A page should not be re-read or re-allocated without uncaching it first.++ (2) A read or allocated page must be uncached when the netfs page is released+ from the pagecache.++ (3) A page should only be written to the cache if previous read or allocated.++This permits the cache to maintain its page tracking in proper order.+++PAGE READ+---------++Firstly, the netfs should ask FS-Cache to examine the caches and read the+contents cached for a particular page of a particular file if present, or else+allocate space to store the contents if not:++ typedef+ void (*fscache_rw_complete_t)(struct page *page,+ void *context,+ int error);++ int fscache_read_or_alloc_page(struct fscache_cookie *cookie,+ struct page *page,+ fscache_rw_complete_t end_io_func,+ void *context,+ gfp_t gfp);++The cookie argument must specify a cookie for an object that isn't an index,+the page specified will have the data loaded into it (and is also used to+specify the page number), and the gfp argument is used to control how any+memory allocations made are satisfied.++If the cookie indicates the inode is not cached:++ (1) The function will return -ENOBUFS.++Else if there's a copy of the page resident in the cache:++ (1) The mark_pages_cached() cookie operation will be called on that page.++ (2) The function will submit a request to read the data from the cache's+ backing device directly into the page specified.++ (3) The function will return 0.++ (4) When the read is complete, end_io_func() will be invoked with:++ (*) The netfs data supplied when the cookie was created.++ (*) The page descriptor.++ (*) The context argument passed to the above function. This will be+ maintained with the get_context/put_context functions mentioned above.++ (*) An argument that's 0 on success or negative for an error code.++ If an error occurs, it should be assumed that the page contains no usable+ data.++ end_io_func() will be called in process context if the read is results in+ an error, but it might be called in interrupt context if the read is+ successful.++Otherwise, if there's not a copy available in cache, but the cache may be able+to store the page:++ (1) The mark_pages_cached() cookie operation will be called on that page.++ (2) A block may be reserved in the cache and attached to the object at the+ appropriate place.++ (3) The function will return -ENODATA.++This function may also return -ENOMEM or -EINTR, in which case it won't have+read any data from the cache.+++PAGE ALLOCATE+-------------++Alternatively, if there's not expected to be any data in the cache for a page+because the file has been extended, a block can simply be allocated instead:++ int fscache_alloc_page(struct fscache_cookie *cookie,+ struct page *page,+ gfp_t gfp);++This is similar to the fscache_read_or_alloc_page() function, except that it+never reads from the cache. It will return 0 if a block has been allocated,+rather than -ENODATA as the other would. One or the other must be performed+before writing to the cache.++The mark_pages_cached() cookie operation will be called on the page if+successful.+++PAGE WRITE+----------++Secondly, if the netfs changes the contents of the page (either due to an+initial download or if a user performs a write), then the page should be+written back to the cache:++ int fscache_write_page(struct fscache_cookie *cookie,+ struct page *page,+ gfp_t gfp);++The cookie argument must specify a data file cookie, the page specified should+contain the data to be written (and is also used to specify the page number),+and the gfp argument is used to control how any memory allocations made are+satisfied.++The page must have first been read or allocated successfully and must not have+been uncached before writing is performed.++If the cookie indicates the inode is not cached then:++ (1) The function will return -ENOBUFS.++Else if space can be allocated in the cache to hold this page:++ (1) PG_fscache_write will be set on the page.++ (2) The function will submit a request to write the data to cache's backing+ device directly from the page specified.++ (3) The function will return 0.++ (4) When the write is complete PG_fscache_write is cleared on the page and+ anyone waiting for that bit will be woken up.++Else if there's no space available in the cache, -ENOBUFS will be returned. It+is also possible for the PG_fscache_write bit to be cleared when no write took+place if unforeseen circumstances arose (such as a disk error).++Writing takes place asynchronously.+++MULTIPLE PAGE READ+------------------++A facility is provided to read several pages at once, as requested by the+readpages() address space operation:++ int fscache_read_or_alloc_pages(struct fscache_cookie *cookie,+ struct address_space *mapping,+ struct list_head *pages,+ int *nr_pages,+ fscache_rw_complete_t end_io_func,+ void *context,+ gfp_t gfp);++This works in a similar way to fscache_read_or_alloc_page(), except:++ (1) Any page it can retrieve data for is removed from pages and nr_pages and+ dispatched for reading to the disk. Reads of adjacent pages on disk may+ be merged for greater efficiency.++ (2) The mark_pages_cached() cookie operation will be called on several pages+ at once if they're being read or allocated.++ (3) If there was an general error, then that error will be returned.++ Else if some pages couldn't be allocated or read, then -ENOBUFS will be+ returned.++ Else if some pages couldn't be read but were allocated, then -ENODATA will+ be returned.++ Otherwise, if all pages had reads dispatched, then 0 will be returned, the+ list will be empty and *nr_pages will be 0.++ (4) end_io_func will be called once for each page being read as the reads+ complete. It will be called in process context if error != 0, but it may+ be called in interrupt context if there is no error.++Note that a return of -ENODATA, -ENOBUFS or any other error does not preclude+some of the pages being read and some being allocated. Those pages will have+been marked appropriately and will need uncaching.+++==============+PAGE UNCACHING+==============++To uncache a page, this function should be called:++ void fscache_uncache_page(struct fscache_cookie *cookie,+ struct page *page);++This function permits the cache to release any in-memory representation it+might be holding for this netfs page. This function must be called once for+each page on which the read or write page functions above have been called to+make sure the cache's in-memory tracking information gets torn down.++Note that pages can't be explicitly deleted from the a data file. The whole+data file must be retired (see the relinquish cookie function below).++Furthermore, note that this does not cancel the asynchronous read or write+operation started by the read/alloc and write functions.+++==========================+INDEX AND DATA FILE UPDATE+==========================++To request an update of the index data for an index or other object, the+following function should be called:++ void fscache_update_cookie(struct fscache_cookie *cookie);++This function will refer back to the netfs_data pointer stored in the cookie by+the acquisition function to obtain the data to write into each revised index+entry. The update method in the parent index definition will be called to+transfer the data.++Note that partial updates may happen automatically at other times, such as when+data blocks are added to a data file object.+++===============================+MISCELLANEOUS COOKIE OPERATIONS+===============================++There are a number of operations that can be used to control cookies:++ (*) Cookie pinning:++ int fscache_pin_cookie(struct fscache_cookie *cookie);+ void fscache_unpin_cookie(struct fscache_cookie *cookie);++ These operations permit data cookies to be pinned into the cache and to+ have the pinning removed. They are not permitted on index cookies.++ The pinning function will return 0 if successful, -ENOBUFS in the cookie+ isn't backed by a cache, -EOPNOTSUPP if the cache doesn't support pinning,+ -ENOSPC if there isn't enough space to honour the operation, -ENOMEM or+ -EIO if there's any other problem.++ (*) Data space reservation:++ int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size);++ This permits a netfs to request cache space be reserved to store up to the+ given amount of a file. It is permitted to ask for more than the current+ size of the file to allow for future file expansion.++ If size is given as zero then the reservation will be cancelled.++ The function will return 0 if successful, -ENOBUFS in the cookie isn't+ backed by a cache, -EOPNOTSUPP if the cache doesn't support reservations,+ -ENOSPC if there isn't enough space to honour the operation, -ENOMEM or+ -EIO if there's any other problem.++ Note that this doesn't pin an object in a cache; it can still be culled to+ make space if it's not in use.+++=====================+COOKIE UNREGISTRATION+=====================++To get rid of a cookie, this function should be called.++ void fscache_relinquish_cookie(struct fscache_cookie *cookie,+ int retire);++If retire is non-zero, then the object will be marked for recycling, and all+copies of it will be removed from all active caches in which it is present.+Not only that but all child objects will also be retired.++If retire is zero, then the object may be available again when next the+acquisition function is called. Retirement here will overrule the pinning on a+cookie.++One very important note - relinquish must NOT be called for a cookie unless all+the cookies for "child" indices, objects and pages have been relinquished+first.+++================================+INDEX AND DATA FILE INVALIDATION+================================++There is no direct way to invalidate an index subtree or a data file. To do+this, the caller should relinquish and retire the cookie they have, and then+acquire a new one.+++============================+FS-CACHE SPECIFIC PAGE FLAGS+============================++FS-Cache makes use of two page flags, PG_private_2 and PG_owner_priv_2, for+its own purpose. The first is given the alternative name PG_fscache and the+second PG_fscache_write.++FS-Cache uses these flags to keep track of two bits of information per cached+netfs page:++ (1) PG_fscache.++ This indicates that the page is known by the cache, and that the cache+ must be informed if the page is going to go away. It's an indication to+ the netfs that the cache has an interest in this page, where an interest+ may be a pointer to it, resources allocated or reserved for it, or I/O in+ progress upon it.++ The netfs can use this information in methods such as releasepage() to+ determine whether it needs to uncache a page or update it.++ Furthermore, if this bit is set, releasepage() and invalidatepage()+ operations will be called on a page to get rid of it, even if PG_private+ is not set. This allows caching to attempted on a page before+ read_cache_pages() to be called after fscache_read_or_alloc_pages() as+ the former will try and release pages it was given under certain+ circumstances.++ (2) PG_fscache_write.++ This indicates that the page is being written to disk by the cache, and+ that it cannot be released until completion. Ideally it shouldn't be+ changed until completion either so as to maintain the known state of the+ cache. This cannot be unified with PG_writeback as the page may be being+ written to both the server and the cache at the same time or at different+ times.++ This can be used by the netfs to wait for a page to be written out to the+ cache before, say, releasing or invalidating it, or before allowing+ someone to modify it in page_mkwrite(), say.++Neither of these two bits overlaps with such as PG_private. This means that+FS-Cache can be used with a filesystem that uses the block buffering code.++There are a number of operations defined on these two bits:++ int PageFsCache(struct page *page);+ void SetPageFsCache(struct page *page)+ void ClearPageFsCache(struct page *page)+ int TestSetPageFsCache(struct page *page)+ int TestClearPageFsCache(struct page *page)++ int PageFsCacheWrite(struct page *page)+ void SetPageFsCacheWrite(struct page *page)+ void ClearPageFsCacheWrite(struct page *page)+ int TestSetPageFsCacheWrite(struct page *page)+ int TestClearPageFsCacheWrite(struct page *page)++These functions are bit test, bit set, bit clear, bit test and set and bit+test and clear operations on PG_fscache and PG_fscache_write.++ void wait_on_page_fscache_write(struct page *page)+ void end_page_fscache_write(struct page *page)++The first of these two functions waits uninterruptibly for PG_fscache_write to+become clear, if it isn't already so. The second clears PG_fscache_write and+wakes up anyone waiting for it.diff --git a/fs/Kconfig b/fs/Kconfigindex d731282..80264c0 100644--- a/fs/Kconfig+++ b/fs/Kconfig@@ -618,6 +618,12 @@ config GENERIC_ACL bool select FS_POSIX_ACL