WIP FPC-III support
[linux/fpc-iii.git] / Documentation / filesystems / caching / netfs-api.rst
blobd9f14b8610badaef96b552bb6a2d850feef07641
1 .. SPDX-License-Identifier: GPL-2.0
3 ===============================
4 FS-Cache Network Filesystem API
5 ===============================
7 There's an API by which a network filesystem can make use of the FS-Cache
8 facilities.  This is based around a number of principles:
10  (1) Caches can store a number of different object types.  There are two main
11      object types: indices and files.  The first is a special type used by
12      FS-Cache to make finding objects faster and to make retiring of groups of
13      objects easier.
15  (2) Every index, file or other object is represented by a cookie.  This cookie
16      may or may not have anything associated with it, but the netfs doesn't
17      need to care.
19  (3) Barring the top-level index (one entry per cached netfs), the index
20      hierarchy for each netfs is structured according the whim of the netfs.
22 This API is declared in <linux/fscache.h>.
24 .. This document contains the following sections:
26          (1) Network filesystem definition
27          (2) Index definition
28          (3) Object definition
29          (4) Network filesystem (un)registration
30          (5) Cache tag lookup
31          (6) Index registration
32          (7) Data file registration
33          (8) Miscellaneous object registration
34          (9) Setting the data file size
35         (10) Page alloc/read/write
36         (11) Page uncaching
37         (12) Index and data file consistency
38         (13) Cookie enablement
39         (14) Miscellaneous cookie operations
40         (15) Cookie unregistration
41         (16) Index invalidation
42         (17) Data file invalidation
43         (18) FS-Cache specific page flags.
46 Network Filesystem Definition
47 =============================
49 FS-Cache needs a description of the network filesystem.  This is specified
50 using a record of the following structure::
52         struct fscache_netfs {
53                 uint32_t                        version;
54                 const char                      *name;
55                 struct fscache_cookie           *primary_index;
56                 ...
57         };
59 This first two fields should be filled in before registration, and the third
60 will be filled in by the registration function; any other fields should just be
61 ignored and are for internal use only.
63 The fields are:
65  (1) The name of the netfs (used as the key in the toplevel index).
67  (2) The version of the netfs (if the name matches but the version doesn't, the
68      entire in-cache hierarchy for this netfs will be scrapped and begun
69      afresh).
71  (3) The cookie representing the primary index will be allocated according to
72      another parameter passed into the registration function.
74 For example, kAFS (linux/fs/afs/) uses the following definitions to describe
75 itself::
77         struct fscache_netfs afs_cache_netfs = {
78                 .version        = 0,
79                 .name           = "afs",
80         };
83 Index Definition
84 ================
86 Indices are used for two purposes:
88  (1) To aid the finding of a file based on a series of keys (such as AFS's
89      "cell", "volume ID", "vnode ID").
91  (2) To make it easier to discard a subset of all the files cached based around
92      a particular key - for instance to mirror the removal of an AFS volume.
94 However, since it's unlikely that any two netfs's are going to want to define
95 their index hierarchies in quite the same way, FS-Cache tries to impose as few
96 restraints as possible on how an index is structured and where it is placed in
97 the tree.  The netfs can even mix indices and data files at the same level, but
98 it's not recommended.
100 Each index entry consists of a key of indeterminate length plus some auxiliary
101 data, also of indeterminate length.
103 There are some limits on indices:
105  (1) Any index containing non-index objects should be restricted to a single
106      cache.  Any such objects created within an index will be created in the
107      first cache only.  The cache in which an index is created can be
108      controlled by cache tags (see below).
110  (2) The entry data must be atomically journallable, so it is limited to about
111      400 bytes at present.  At least 400 bytes will be available.
113  (3) The depth of the index tree should be judged with care as the search
114      function is recursive.  Too many layers will run the kernel out of stack.
117 Object Definition
118 =================
120 To define an object, a structure of the following type should be filled out::
122         struct fscache_cookie_def
123         {
124                 uint8_t name[16];
125                 uint8_t type;
127                 struct fscache_cache_tag *(*select_cache)(
128                         const void *parent_netfs_data,
129                         const void *cookie_netfs_data);
131                 enum fscache_checkaux (*check_aux)(void *cookie_netfs_data,
132                                                    const void *data,
133                                                    uint16_t datalen,
134                                                    loff_t object_size);
136                 void (*get_context)(void *cookie_netfs_data, void *context);
138                 void (*put_context)(void *cookie_netfs_data, void *context);
140                 void (*mark_pages_cached)(void *cookie_netfs_data,
141                                           struct address_space *mapping,
142                                           struct pagevec *cached_pvec);
143         };
145 This has the following fields:
147  (1) The type of the object [mandatory].
149      This is one of the following values:
151         FSCACHE_COOKIE_TYPE_INDEX
152             This defines an index, which is a special FS-Cache type.
154         FSCACHE_COOKIE_TYPE_DATAFILE
155             This defines an ordinary data file.
157         Any other value between 2 and 255
158             This defines an extraordinary object such as an XATTR.
160  (2) The name of the object type (NUL terminated unless all 16 chars are used)
161      [optional].
163  (3) A function to select the cache in which to store an index [optional].
165      This function is invoked when an index needs to be instantiated in a cache
166      during the instantiation of a non-index object.  Only the immediate index
167      parent for the non-index object will be queried.  Any indices above that
168      in the hierarchy may be stored in multiple caches.  This function does not
169      need to be supplied for any non-index object or any index that will only
170      have index children.
172      If this function is not supplied or if it returns NULL then the first
173      cache in the parent's list will be chosen, or failing that, the first
174      cache in the master list.
176  (4) A function to check the auxiliary data [optional].
178      This function will be called to check that a match found in the cache for
179      this object is valid.  For instance with AFS it could check the auxiliary
180      data against the data version number returned by the server to determine
181      whether the index entry in a cache is still valid.
183      If this function is absent, it will be assumed that matching objects in a
184      cache are always valid.
186      The function is also passed the cache's idea of the object size and may
187      use this to manage coherency also.
189      If present, the function should return one of the following values:
191         FSCACHE_CHECKAUX_OKAY
192             - the entry is okay as is
194         FSCACHE_CHECKAUX_NEEDS_UPDATE
195             - the entry requires update
197         FSCACHE_CHECKAUX_OBSOLETE
198             - the entry should be deleted
200      This function can also be used to extract data from the auxiliary data in
201      the cache and copy it into the netfs's structures.
203  (5) A pair of functions to manage contexts for the completion callback
204      [optional].
206      The cache read/write functions are passed a context which is then passed
207      to the I/O completion callback function.  To ensure this context remains
208      valid until after the I/O completion is called, two functions may be
209      provided: one to get an extra reference on the context, and one to drop a
210      reference to it.
212      If the context is not used or is a type of object that won't go out of
213      scope, then these functions are not required.  These functions are not
214      required for indices as indices may not contain data.  These functions may
215      be called in interrupt context and so may not sleep.
217  (6) A function to mark a page as retaining cache metadata [optional].
219      This is called by the cache to indicate that it is retaining in-memory
220      information for this page and that the netfs should uncache the page when
221      it has finished.  This does not indicate whether there's data on the disk
222      or not.  Note that several pages at once may be presented for marking.
224      The PG_fscache bit is set on the pages before this function would be
225      called, so the function need not be provided if this is sufficient.
227      This function is not required for indices as they're not permitted data.
229  (7) A function to unmark all the pages retaining cache metadata [mandatory].
231      This is called by FS-Cache to indicate that a backing store is being
232      unbound from a cookie and that all the marks on the pages should be
233      cleared to prevent confusion.  Note that the cache will have torn down all
234      its tracking information so that the pages don't need to be explicitly
235      uncached.
237      This function is not required for indices as they're not permitted data.
240 Network Filesystem (Un)registration
241 ===================================
243 The first step is to declare the network filesystem to the cache.  This also
244 involves specifying the layout of the primary index (for AFS, this would be the
245 "cell" level).
247 The registration function is::
249         int fscache_register_netfs(struct fscache_netfs *netfs);
251 It just takes a pointer to the netfs definition.  It returns 0 or an error as
252 appropriate.
254 For kAFS, registration is done as follows::
256         ret = fscache_register_netfs(&afs_cache_netfs);
258 The last step is, of course, unregistration::
260         void fscache_unregister_netfs(struct fscache_netfs *netfs);
263 Cache Tag Lookup
264 ================
266 FS-Cache permits the use of more than one cache.  To permit particular index
267 subtrees to be bound to particular caches, the second step is to look up cache
268 representation tags.  This step is optional; it can be left entirely up to
269 FS-Cache as to which cache should be used.  The problem with doing that is that
270 FS-Cache will always pick the first cache that was registered.
272 To get the representation for a named tag::
274         struct fscache_cache_tag *fscache_lookup_cache_tag(const char *name);
276 This takes a text string as the name and returns a representation of a tag.  It
277 will never return an error.  It may return a dummy tag, however, if it runs out
278 of memory; this will inhibit caching with this tag.
280 Any representation so obtained must be released by passing it to this function::
282         void fscache_release_cache_tag(struct fscache_cache_tag *tag);
284 The tag will be retrieved by FS-Cache when it calls the object definition
285 operation select_cache().
288 Index Registration
289 ==================
291 The third step is to inform FS-Cache about part of an index hierarchy that can
292 be used to locate files.  This is done by requesting a cookie for each index in
293 the path to the file::
295         struct fscache_cookie *
296         fscache_acquire_cookie(struct fscache_cookie *parent,
297                                const struct fscache_object_def *def,
298                                const void *index_key,
299                                size_t index_key_len,
300                                const void *aux_data,
301                                size_t aux_data_len,
302                                void *netfs_data,
303                                loff_t object_size,
304                                bool enable);
306 This function creates an index entry in the index represented by parent,
307 filling in the index entry by calling the operations pointed to by def.
309 A unique key that represents the object within the parent must be pointed to by
310 index_key and is of length index_key_len.
312 An optional blob of auxiliary data that is to be stored within the cache can be
313 pointed to with aux_data and should be of length aux_data_len.  This would
314 typically be used for storing coherency data.
316 The netfs may pass an arbitrary value in netfs_data and this will be presented
317 to it in the event of any calling back.  This may also be used in tracing or
318 logging of messages.
320 The cache tracks the size of the data attached to an object and this set to be
321 object_size.  For indices, this should be 0.  This value will be passed to the
322 ->check_aux() callback.
324 Note that this function never returns an error - all errors are handled
325 internally.  It may, however, return NULL to indicate no cookie.  It is quite
326 acceptable to pass this token back to this function as the parent to another
327 acquisition (or even to the relinquish cookie, read page and write page
328 functions - see below).
330 Note also that no indices are actually created in a cache until a non-index
331 object needs to be created somewhere down the hierarchy.  Furthermore, an index
332 may be created in several different caches independently at different times.
333 This is all handled transparently, and the netfs doesn't see any of it.
335 A cookie will be created in the disabled state if enabled is false.  A cookie
336 must be enabled to do anything with it.  A disabled cookie can be enabled by
337 calling fscache_enable_cookie() (see below).
339 For example, with AFS, a cell would be added to the primary index.  This index
340 entry would have a dependent inode containing volume mappings within this cell::
342         cell->cache =
343                 fscache_acquire_cookie(afs_cache_netfs.primary_index,
344                                        &afs_cell_cache_index_def,
345                                        cell->name, strlen(cell->name),
346                                        NULL, 0,
347                                        cell, 0, true);
349 And then a particular volume could be added to that index by ID, creating
350 another index for vnodes (AFS inode equivalents)::
352         volume->cache =
353                 fscache_acquire_cookie(volume->cell->cache,
354                                        &afs_volume_cache_index_def,
355                                        &volume->vid, sizeof(volume->vid),
356                                        NULL, 0,
357                                        volume, 0, true);
360 Data File Registration
361 ======================
363 The fourth step is to request a data file be created in the cache.  This is
364 identical to index cookie acquisition.  The only difference is that the type in
365 the object definition should be something other than index type::
367         vnode->cache =
368                 fscache_acquire_cookie(volume->cache,
369                                        &afs_vnode_cache_object_def,
370                                        &key, sizeof(key),
371                                        &aux, sizeof(aux),
372                                        vnode, vnode->status.size, true);
375 Miscellaneous Object Registration
376 =================================
378 An optional step is to request an object of miscellaneous type be created in
379 the cache.  This is almost identical to index cookie acquisition.  The only
380 difference is that the type in the object definition should be something other
381 than index type.  While the parent object could be an index, it's more likely
382 it would be some other type of object such as a data file::
384         xattr->cache =
385                 fscache_acquire_cookie(vnode->cache,
386                                        &afs_xattr_cache_object_def,
387                                        &xattr->name, strlen(xattr->name),
388                                        NULL, 0,
389                                        xattr, strlen(xattr->val), true);
391 Miscellaneous objects might be used to store extended attributes or directory
392 entries for example.
395 Setting the Data File Size
396 ==========================
398 The fifth step is to set the physical attributes of the file, such as its size.
399 This doesn't automatically reserve any space in the cache, but permits the
400 cache to adjust its metadata for data tracking appropriately::
402         int fscache_attr_changed(struct fscache_cookie *cookie);
404 The cache will return -ENOBUFS if there is no backing cache or if there is no
405 space to allocate any extra metadata required in the cache.
407 Note that attempts to read or write data pages in the cache over this size may
408 be rebuffed with -ENOBUFS.
410 This operation schedules an attribute adjustment to happen asynchronously at
411 some point in the future, and as such, it may happen after the function returns
412 to the caller.  The attribute adjustment excludes read and write operations.
415 Page alloc/read/write
416 =====================
418 And the sixth step is to store and retrieve pages in the cache.  There are
419 three functions that are used to do this.
421 Note:
423  (1) A page should not be re-read or re-allocated without uncaching it first.
425  (2) A read or allocated page must be uncached when the netfs page is released
426      from the pagecache.
428  (3) A page should only be written to the cache if previous read or allocated.
430 This permits the cache to maintain its page tracking in proper order.
433 PAGE READ
434 ---------
436 Firstly, the netfs should ask FS-Cache to examine the caches and read the
437 contents cached for a particular page of a particular file if present, or else
438 allocate space to store the contents if not::
440         typedef
441         void (*fscache_rw_complete_t)(struct page *page,
442                                       void *context,
443                                       int error);
445         int fscache_read_or_alloc_page(struct fscache_cookie *cookie,
446                                        struct page *page,
447                                        fscache_rw_complete_t end_io_func,
448                                        void *context,
449                                        gfp_t gfp);
451 The cookie argument must specify a cookie for an object that isn't an index,
452 the page specified will have the data loaded into it (and is also used to
453 specify the page number), and the gfp argument is used to control how any
454 memory allocations made are satisfied.
456 If the cookie indicates the inode is not cached:
458  (1) The function will return -ENOBUFS.
460 Else if there's a copy of the page resident in the cache:
462  (1) The mark_pages_cached() cookie operation will be called on that page.
464  (2) The function will submit a request to read the data from the cache's
465      backing device directly into the page specified.
467  (3) The function will return 0.
469  (4) When the read is complete, end_io_func() will be invoked with:
471        * The netfs data supplied when the cookie was created.
473        * The page descriptor.
475        * The context argument passed to the above function.  This will be
476          maintained with the get_context/put_context functions mentioned above.
478        * An argument that's 0 on success or negative for an error code.
480      If an error occurs, it should be assumed that the page contains no usable
481      data.  fscache_readpages_cancel() may need to be called.
483      end_io_func() will be called in process context if the read is results in
484      an error, but it might be called in interrupt context if the read is
485      successful.
487 Otherwise, if there's not a copy available in cache, but the cache may be able
488 to store the page:
490  (1) The mark_pages_cached() cookie operation will be called on that page.
492  (2) A block may be reserved in the cache and attached to the object at the
493      appropriate place.
495  (3) The function will return -ENODATA.
497 This function may also return -ENOMEM or -EINTR, in which case it won't have
498 read any data from the cache.
501 Page Allocate
502 -------------
504 Alternatively, if there's not expected to be any data in the cache for a page
505 because the file has been extended, a block can simply be allocated instead::
507         int fscache_alloc_page(struct fscache_cookie *cookie,
508                                struct page *page,
509                                gfp_t gfp);
511 This is similar to the fscache_read_or_alloc_page() function, except that it
512 never reads from the cache.  It will return 0 if a block has been allocated,
513 rather than -ENODATA as the other would.  One or the other must be performed
514 before writing to the cache.
516 The mark_pages_cached() cookie operation will be called on the page if
517 successful.
520 Page Write
521 ----------
523 Secondly, if the netfs changes the contents of the page (either due to an
524 initial download or if a user performs a write), then the page should be
525 written back to the cache::
527         int fscache_write_page(struct fscache_cookie *cookie,
528                                struct page *page,
529                                loff_t object_size,
530                                gfp_t gfp);
532 The cookie argument must specify a data file cookie, the page specified should
533 contain the data to be written (and is also used to specify the page number),
534 object_size is the revised size of the object and the gfp argument is used to
535 control how any memory allocations made are satisfied.
537 The page must have first been read or allocated successfully and must not have
538 been uncached before writing is performed.
540 If the cookie indicates the inode is not cached then:
542  (1) The function will return -ENOBUFS.
544 Else if space can be allocated in the cache to hold this page:
546  (1) PG_fscache_write will be set on the page.
548  (2) The function will submit a request to write the data to cache's backing
549      device directly from the page specified.
551  (3) The function will return 0.
553  (4) When the write is complete PG_fscache_write is cleared on the page and
554      anyone waiting for that bit will be woken up.
556 Else if there's no space available in the cache, -ENOBUFS will be returned.  It
557 is also possible for the PG_fscache_write bit to be cleared when no write took
558 place if unforeseen circumstances arose (such as a disk error).
560 Writing takes place asynchronously.
563 Multiple Page Read
564 ------------------
566 A facility is provided to read several pages at once, as requested by the
567 readpages() address space operation::
569         int fscache_read_or_alloc_pages(struct fscache_cookie *cookie,
570                                         struct address_space *mapping,
571                                         struct list_head *pages,
572                                         int *nr_pages,
573                                         fscache_rw_complete_t end_io_func,
574                                         void *context,
575                                         gfp_t gfp);
577 This works in a similar way to fscache_read_or_alloc_page(), except:
579  (1) Any page it can retrieve data for is removed from pages and nr_pages and
580      dispatched for reading to the disk.  Reads of adjacent pages on disk may
581      be merged for greater efficiency.
583  (2) The mark_pages_cached() cookie operation will be called on several pages
584      at once if they're being read or allocated.
586  (3) If there was an general error, then that error will be returned.
588      Else if some pages couldn't be allocated or read, then -ENOBUFS will be
589      returned.
591      Else if some pages couldn't be read but were allocated, then -ENODATA will
592      be returned.
594      Otherwise, if all pages had reads dispatched, then 0 will be returned, the
595      list will be empty and ``*nr_pages`` will be 0.
597  (4) end_io_func will be called once for each page being read as the reads
598      complete.  It will be called in process context if error != 0, but it may
599      be called in interrupt context if there is no error.
601 Note that a return of -ENODATA, -ENOBUFS or any other error does not preclude
602 some of the pages being read and some being allocated.  Those pages will have
603 been marked appropriately and will need uncaching.
606 Cancellation of Unread Pages
607 ----------------------------
609 If one or more pages are passed to fscache_read_or_alloc_pages() but not then
610 read from the cache and also not read from the underlying filesystem then
611 those pages will need to have any marks and reservations removed.  This can be
612 done by calling::
614         void fscache_readpages_cancel(struct fscache_cookie *cookie,
615                                       struct list_head *pages);
617 prior to returning to the caller.  The cookie argument should be as passed to
618 fscache_read_or_alloc_pages().  Every page in the pages list will be examined
619 and any that have PG_fscache set will be uncached.
622 Page Uncaching
623 ==============
625 To uncache a page, this function should be called::
627         void fscache_uncache_page(struct fscache_cookie *cookie,
628                                   struct page *page);
630 This function permits the cache to release any in-memory representation it
631 might be holding for this netfs page.  This function must be called once for
632 each page on which the read or write page functions above have been called to
633 make sure the cache's in-memory tracking information gets torn down.
635 Note that pages can't be explicitly deleted from the a data file.  The whole
636 data file must be retired (see the relinquish cookie function below).
638 Furthermore, note that this does not cancel the asynchronous read or write
639 operation started by the read/alloc and write functions, so the page
640 invalidation functions must use::
642         bool fscache_check_page_write(struct fscache_cookie *cookie,
643                                       struct page *page);
645 to see if a page is being written to the cache, and::
647         void fscache_wait_on_page_write(struct fscache_cookie *cookie,
648                                         struct page *page);
650 to wait for it to finish if it is.
653 When releasepage() is being implemented, a special FS-Cache function exists to
654 manage the heuristics of coping with vmscan trying to eject pages, which may
655 conflict with the cache trying to write pages to the cache (which may itself
656 need to allocate memory)::
658         bool fscache_maybe_release_page(struct fscache_cookie *cookie,
659                                         struct page *page,
660                                         gfp_t gfp);
662 This takes the netfs cookie, and the page and gfp arguments as supplied to
663 releasepage().  It will return false if the page cannot be released yet for
664 some reason and if it returns true, the page has been uncached and can now be
665 released.
667 To make a page available for release, this function may wait for an outstanding
668 storage request to complete, or it may attempt to cancel the storage request -
669 in which case the page will not be stored in the cache this time.
672 Bulk Image Page Uncache
673 -----------------------
675 A convenience routine is provided to perform an uncache on all the pages
676 attached to an inode.  This assumes that the pages on the inode correspond on a
677 1:1 basis with the pages in the cache::
679         void fscache_uncache_all_inode_pages(struct fscache_cookie *cookie,
680                                              struct inode *inode);
682 This takes the netfs cookie that the pages were cached with and the inode that
683 the pages are attached to.  This function will wait for pages to finish being
684 written to the cache and for the cache to finish with the page generally.  No
685 error is returned.
688 Index and Data File consistency
689 ===============================
691 To find out whether auxiliary data for an object is up to data within the
692 cache, the following function can be called::
694         int fscache_check_consistency(struct fscache_cookie *cookie,
695                                       const void *aux_data);
697 This will call back to the netfs to check whether the auxiliary data associated
698 with a cookie is correct; if aux_data is non-NULL, it will update the auxiliary
699 data buffer first.  It returns 0 if it is and -ESTALE if it isn't; it may also
700 return -ENOMEM and -ERESTARTSYS.
702 To request an update of the index data for an index or other object, the
703 following function should be called::
705         void fscache_update_cookie(struct fscache_cookie *cookie,
706                                    const void *aux_data);
708 This function will update the cookie's auxiliary data buffer from aux_data if
709 that is non-NULL and then schedule this to be stored on disk.  The update
710 method in the parent index definition will be called to transfer the data.
712 Note that partial updates may happen automatically at other times, such as when
713 data blocks are added to a data file object.
716 Cookie Enablement
717 =================
719 Cookies exist in one of two states: enabled and disabled.  If a cookie is
720 disabled, it ignores all attempts to acquire child cookies; check, update or
721 invalidate its state; allocate, read or write backing pages - though it is
722 still possible to uncache pages and relinquish the cookie.
724 The initial enablement state is set by fscache_acquire_cookie(), but the cookie
725 can be enabled or disabled later.  To disable a cookie, call::
727         void fscache_disable_cookie(struct fscache_cookie *cookie,
728                                     const void *aux_data,
729                                     bool invalidate);
731 If the cookie is not already disabled, this locks the cookie against other
732 enable and disable ops, marks the cookie as being disabled, discards or
733 invalidates any backing objects and waits for cessation of activity on any
734 associated object before unlocking the cookie.
736 All possible failures are handled internally.  The caller should consider
737 calling fscache_uncache_all_inode_pages() afterwards to make sure all page
738 markings are cleared up.
740 Cookies can be enabled or reenabled with::
742         void fscache_enable_cookie(struct fscache_cookie *cookie,
743                                    const void *aux_data,
744                                    loff_t object_size,
745                                    bool (*can_enable)(void *data),
746                                    void *data)
748 If the cookie is not already enabled, this locks the cookie against other
749 enable and disable ops, invokes can_enable() and, if the cookie is not an index
750 cookie, will begin the procedure of acquiring backing objects.
752 The optional can_enable() function is passed the data argument and returns a
753 ruling as to whether or not enablement should actually be permitted to begin.
755 All possible failures are handled internally.  The cookie will only be marked
756 as enabled if provisional backing objects are allocated.
758 The object's data size is updated from object_size and is passed to the
759 ->check_aux() function.
761 In both cases, the cookie's auxiliary data buffer is updated from aux_data if
762 that is non-NULL inside the enablement lock before proceeding.
765 Miscellaneous Cookie operations
766 ===============================
768 There are a number of operations that can be used to control cookies:
770      * Cookie pinning::
772         int fscache_pin_cookie(struct fscache_cookie *cookie);
773         void fscache_unpin_cookie(struct fscache_cookie *cookie);
775      These operations permit data cookies to be pinned into the cache and to
776      have the pinning removed.  They are not permitted on index cookies.
778      The pinning function will return 0 if successful, -ENOBUFS in the cookie
779      isn't backed by a cache, -EOPNOTSUPP if the cache doesn't support pinning,
780      -ENOSPC if there isn't enough space to honour the operation, -ENOMEM or
781      -EIO if there's any other problem.
783    * Data space reservation::
785         int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size);
787      This permits a netfs to request cache space be reserved to store up to the
788      given amount of a file.  It is permitted to ask for more than the current
789      size of the file to allow for future file expansion.
791      If size is given as zero then the reservation will be cancelled.
793      The function will return 0 if successful, -ENOBUFS in the cookie isn't
794      backed by a cache, -EOPNOTSUPP if the cache doesn't support reservations,
795      -ENOSPC if there isn't enough space to honour the operation, -ENOMEM or
796      -EIO if there's any other problem.
798      Note that this doesn't pin an object in a cache; it can still be culled to
799      make space if it's not in use.
802 Cookie Unregistration
803 =====================
805 To get rid of a cookie, this function should be called::
807         void fscache_relinquish_cookie(struct fscache_cookie *cookie,
808                                        const void *aux_data,
809                                        bool retire);
811 If retire is non-zero, then the object will be marked for recycling, and all
812 copies of it will be removed from all active caches in which it is present.
813 Not only that but all child objects will also be retired.
815 If retire is zero, then the object may be available again when next the
816 acquisition function is called.  Retirement here will overrule the pinning on a
817 cookie.
819 The cookie's auxiliary data will be updated from aux_data if that is non-NULL
820 so that the cache can lazily update it on disk.
822 One very important note - relinquish must NOT be called for a cookie unless all
823 the cookies for "child" indices, objects and pages have been relinquished
824 first.
827 Index Invalidation
828 ==================
830 There is no direct way to invalidate an index subtree.  To do this, the caller
831 should relinquish and retire the cookie they have, and then acquire a new one.
834 Data File Invalidation
835 ======================
837 Sometimes it will be necessary to invalidate an object that contains data.
838 Typically this will be necessary when the server tells the netfs of a foreign
839 change - at which point the netfs has to throw away all the state it had for an
840 inode and reload from the server.
842 To indicate that a cache object should be invalidated, the following function
843 can be called::
845         void fscache_invalidate(struct fscache_cookie *cookie);
847 This can be called with spinlocks held as it defers the work to a thread pool.
848 All extant storage, retrieval and attribute change ops at this point are
849 cancelled and discarded.  Some future operations will be rejected until the
850 cache has had a chance to insert a barrier in the operations queue.  After
851 that, operations will be queued again behind the invalidation operation.
853 The invalidation operation will perform an attribute change operation and an
854 auxiliary data update operation as it is very likely these will have changed.
856 Using the following function, the netfs can wait for the invalidation operation
857 to have reached a point at which it can start submitting ordinary operations
858 once again::
860         void fscache_wait_on_invalidate(struct fscache_cookie *cookie);
863 FS-cache Specific Page Flag
864 ===========================
866 FS-Cache makes use of a page flag, PG_private_2, for its own purpose.  This is
867 given the alternative name PG_fscache.
869 PG_fscache is used to indicate that the page is known by the cache, and that
870 the cache must be informed if the page is going to go away.  It's an indication
871 to the netfs that the cache has an interest in this page, where an interest may
872 be a pointer to it, resources allocated or reserved for it, or I/O in progress
873 upon it.
875 The netfs can use this information in methods such as releasepage() to
876 determine whether it needs to uncache a page or update it.
878 Furthermore, if this bit is set, releasepage() and invalidatepage() operations
879 will be called on a page to get rid of it, even if PG_private is not set.  This
880 allows caching to attempted on a page before read_cache_pages() to be called
881 after fscache_read_or_alloc_pages() as the former will try and release pages it
882 was given under certain circumstances.
884 This bit does not overlap with such as PG_private.  This means that FS-Cache
885 can be used with a filesystem that uses the block buffering code.
887 There are a number of operations defined on this flag::
889         int PageFsCache(struct page *page);
890         void SetPageFsCache(struct page *page)
891         void ClearPageFsCache(struct page *page)
892         int TestSetPageFsCache(struct page *page)
893         int TestClearPageFsCache(struct page *page)
895 These functions are bit test, bit set, bit clear, bit test and set and bit
896 test and clear operations on PG_fscache.