1 .. SPDX-License-Identifier: GPL-2.0
3 ==========================
4 FS-Cache Cache backend API
5 ==========================
7 The FS-Cache system provides an API by which actual caches can be supplied to
8 FS-Cache for it to then serve out to network filesystems and other interested
11 This API is declared in <linux/fscache-cache.h>.
14 Initialising and Registering a Cache
15 ====================================
17 To start off, a cache definition must be initialised and registered for each
18 cache the backend wants to make available. For instance, CacheFS does this in
19 the fill_super() operation on mounting.
21 The cache definition (struct fscache_cache) should be initialised by calling::
23 void fscache_init_cache(struct fscache_cache *cache,
24 struct fscache_cache_ops *ops,
30 * "cache" is a pointer to the cache definition;
32 * "ops" is a pointer to the table of operations that the backend supports on
35 * "idfmt" is a format and printf-style arguments for constructing a label
39 The cache should then be registered with FS-Cache by passing a pointer to the
40 previously initialised cache definition to::
42 int fscache_add_cache(struct fscache_cache *cache,
43 struct fscache_object *fsdef,
46 Two extra arguments should also be supplied:
48 * "fsdef" which should point to the object representation for the FS-Cache
49 master index in this cache. Netfs primary index entries will be created
50 here. FS-Cache keeps the caller's reference to the index object if
51 successful and will release it upon withdrawal of the cache.
53 * "tagname" which, if given, should be a text string naming this cache. If
54 this is NULL, the identifier will be used instead. For CacheFS, the
55 identifier is set to name the underlying block device and the tag can be
58 This function may return -ENOMEM if it ran out of memory or -EEXIST if the tag
59 is already in use. 0 will be returned on success.
65 A cache can be withdrawn from the system by calling this function with a
66 pointer to the cache definition::
68 void fscache_withdraw_cache(struct fscache_cache *cache);
70 In CacheFS's case, this is called by put_super().
76 The cache methods are executed one of two contexts:
78 (1) that of the userspace process that issued the netfs operation that caused
79 the cache method to be invoked, or
81 (2) that of one of the processes in the FS-Cache thread pool.
83 In either case, this may not be an appropriate context in which to access the
86 The calling process's fsuid, fsgid and SELinux security identities may need to
87 be masqueraded for the duration of the cache driver's access to the cache.
88 This is left to the cache to handle; FS-Cache makes no effort in this regard.
91 Control and Statistics Presentation
92 ===================================
94 The cache may present data to the outside world through FS-Cache's interfaces
95 in sysfs and procfs - the former for control and the latter for statistics.
97 A sysfs directory called /sys/fs/fscache/<cachetag>/ is created if CONFIG_SYSFS
98 is enabled. This is accessible through the kobject struct fscache_cache::kobj
99 and is for use by the cache as it sees fit.
102 Relevant Data Structures
103 ========================
105 * Index/Data file FS-Cache representation cookie::
107 struct fscache_cookie {
108 struct fscache_object_def *def;
109 struct fscache_netfs *netfs;
114 The fields that might be of use to the backend describe the object
115 definition, the netfs definition and the netfs's data for this cookie.
116 The object definition contain functions supplied by the netfs for loading
117 and matching index entries; these are required to provide some of the
121 * In-cache object representation::
123 struct fscache_object {
126 FSCACHE_OBJECT_RECYCLING,
130 struct fscache_cache *cache;
131 struct fscache_cookie *cookie;
135 Structures of this type should be allocated by the cache backend and
136 passed to FS-Cache when requested by the appropriate cache operation. In
137 the case of CacheFS, they're embedded in CacheFS's internal object
140 The debug_id is a simple integer that can be used in debugging messages
141 that refer to a particular object. In such a case it should be printed
142 using "OBJ%x" to be consistent with FS-Cache.
144 Each object contains a pointer to the cookie that represents the object it
145 is backing. An object should retired when put_object() is called if it is
146 in state FSCACHE_OBJECT_RECYCLING. The fscache_object struct should be
147 initialised by calling fscache_object_init(object).
150 * FS-Cache operation record::
152 struct fscache_operation {
154 struct fscache_object *object;
156 #define FSCACHE_OP_EXCLUSIVE
157 void (*processor)(struct fscache_operation *op);
158 void (*release)(struct fscache_operation *op);
162 FS-Cache has a pool of threads that it uses to give CPU time to the
163 various asynchronous operations that need to be done as part of driving
164 the cache. These are represented by the above structure. The processor
165 method is called to give the op CPU time, and the release method to get
166 rid of it when its usage count reaches 0.
168 An operation can be made exclusive upon an object by setting the
169 appropriate flag before enqueuing it with fscache_enqueue_operation(). If
170 an operation needs more processing time, it should be enqueued again.
173 * FS-Cache retrieval operation record::
175 struct fscache_retrieval {
176 struct fscache_operation op;
177 struct address_space *mapping;
178 struct list_head *to_do;
182 A structure of this type is allocated by FS-Cache to record retrieval and
183 allocation requests made by the netfs. This struct is then passed to the
184 backend to do the operation. The backend may get extra refs to it by
185 calling fscache_get_retrieval() and refs may be discarded by calling
186 fscache_put_retrieval().
188 A retrieval operation can be used by the backend to do retrieval work. To
189 do this, the retrieval->op.processor method pointer should be set
190 appropriately by the backend and fscache_enqueue_retrieval() called to
191 submit it to the thread pool. CacheFiles, for example, uses this to queue
192 page examination when it detects PG_lock being cleared.
194 The to_do field is an empty list available for the cache backend to use as
198 * FS-Cache storage operation record::
200 struct fscache_storage {
201 struct fscache_operation op;
206 A structure of this type is allocated by FS-Cache to record outstanding
207 writes to be made. FS-Cache itself enqueues this operation and invokes
208 the write_page() method on the object at appropriate times to effect
215 The cache backend provides FS-Cache with a table of operations that can be
216 performed on the denizens of the cache. These are held in a structure of type:
220 struct fscache_cache_ops
222 * Name of cache provider [mandatory]::
226 This isn't strictly an operation, but should be pointed at a string naming
230 * Allocate a new object [mandatory]::
232 struct fscache_object *(*alloc_object)(struct fscache_cache *cache,
233 struct fscache_cookie *cookie)
235 This method is used to allocate a cache object representation to back a
236 cookie in a particular cache. fscache_object_init() should be called on
237 the object to initialise it prior to returning.
239 This function may also be used to parse the index key to be used for
240 multiple lookup calls to turn it into a more convenient form. FS-Cache
241 will call the lookup_complete() method to allow the cache to release the
242 form once lookup is complete or aborted.
245 * Look up and create object [mandatory]::
247 void (*lookup_object)(struct fscache_object *object)
249 This method is used to look up an object, given that the object is already
250 allocated and attached to the cookie. This should instantiate that object
251 in the cache if it can.
253 The method should call fscache_object_lookup_negative() as soon as
254 possible if it determines the object doesn't exist in the cache. If the
255 object is found to exist and the netfs indicates that it is valid then
256 fscache_obtained_object() should be called once the object is in a
257 position to have data stored in it. Similarly, fscache_obtained_object()
258 should also be called once a non-present object has been created.
260 If a lookup error occurs, fscache_object_lookup_error() should be called
261 to abort the lookup of that object.
264 * Release lookup data [mandatory]::
266 void (*lookup_complete)(struct fscache_object *object)
268 This method is called to ask the cache to release any resources it was
269 using to perform a lookup.
272 * Increment object refcount [mandatory]::
274 struct fscache_object *(*grab_object)(struct fscache_object *object)
276 This method is called to increment the reference count on an object. It
277 may fail (for instance if the cache is being withdrawn) by returning NULL.
278 It should return the object pointer if successful.
281 * Lock/Unlock object [mandatory]::
283 void (*lock_object)(struct fscache_object *object)
284 void (*unlock_object)(struct fscache_object *object)
286 These methods are used to exclusively lock an object. It must be possible
287 to schedule with the lock held, so a spinlock isn't sufficient.
290 * Pin/Unpin object [optional]::
292 int (*pin_object)(struct fscache_object *object)
293 void (*unpin_object)(struct fscache_object *object)
295 These methods are used to pin an object into the cache. Once pinned an
296 object cannot be reclaimed to make space. Return -ENOSPC if there's not
297 enough space in the cache to permit this.
300 * Check coherency state of an object [mandatory]::
302 int (*check_consistency)(struct fscache_object *object)
304 This method is called to have the cache check the saved auxiliary data of
305 the object against the netfs's idea of the state. 0 should be returned
306 if they're consistent and -ESTALE otherwise. -ENOMEM and -ERESTARTSYS
307 may also be returned.
309 * Update object [mandatory]::
311 int (*update_object)(struct fscache_object *object)
313 This is called to update the index entry for the specified object. The
314 new information should be in object->cookie->netfs_data. This can be
315 obtained by calling object->cookie->def->get_aux()/get_attr().
318 * Invalidate data object [mandatory]::
320 int (*invalidate_object)(struct fscache_operation *op)
322 This is called to invalidate a data object (as pointed to by op->object).
323 All the data stored for this object should be discarded and an
324 attr_changed operation should be performed. The caller will follow up
325 with an object update operation.
327 fscache_op_complete() must be called on op before returning.
330 * Discard object [mandatory]::
332 void (*drop_object)(struct fscache_object *object)
334 This method is called to indicate that an object has been unbound from its
335 cookie, and that the cache should release the object's resources and
336 retire it if it's in state FSCACHE_OBJECT_RECYCLING.
338 This method should not attempt to release any references held by the
339 caller. The caller will invoke the put_object() method as appropriate.
342 * Release object reference [mandatory]::
344 void (*put_object)(struct fscache_object *object)
346 This method is used to discard a reference to an object. The object may
347 be freed when all the references to it are released.
350 * Synchronise a cache [mandatory]::
352 void (*sync)(struct fscache_cache *cache)
354 This is called to ask the backend to synchronise a cache with its backing
358 * Dissociate a cache [mandatory]::
360 void (*dissociate_pages)(struct fscache_cache *cache)
362 This is called to ask a cache to perform any page dissociations as part of
366 * Notification that the attributes on a netfs file changed [mandatory]::
368 int (*attr_changed)(struct fscache_object *object);
370 This is called to indicate to the cache that certain attributes on a netfs
371 file have changed (for example the maximum size a file may reach). The
372 cache can read these from the netfs by calling the cookie's get_attr()
375 The cache may use the file size information to reserve space on the cache.
376 It should also call fscache_set_store_limit() to indicate to FS-Cache the
377 highest byte it's willing to store for an object.
379 This method may return -ve if an error occurred or the cache object cannot
380 be expanded. In such a case, the object will be withdrawn from service.
382 This operation is run asynchronously from FS-Cache's thread pool, and
383 storage and retrieval operations from the netfs are excluded during the
384 execution of this operation.
387 * Reserve cache space for an object's data [optional]::
389 int (*reserve_space)(struct fscache_object *object, loff_t size);
391 This is called to request that cache space be reserved to hold the data
392 for an object and the metadata used to track it. Zero size should be
393 taken as request to cancel a reservation.
395 This should return 0 if successful, -ENOSPC if there isn't enough space
396 available, or -ENOMEM or -EIO on other errors.
398 The reservation may exceed the current size of the object, thus permitting
399 future expansion. If the amount of space consumed by an object would
400 exceed the reservation, it's permitted to refuse requests to allocate
401 pages, but not required. An object may be pruned down to its reservation
402 size if larger than that already.
405 * Request page be read from cache [mandatory]::
407 int (*read_or_alloc_page)(struct fscache_retrieval *op,
411 This is called to attempt to read a netfs page from the cache, or to
412 reserve a backing block if not. FS-Cache will have done as much checking
413 as it can before calling, but most of the work belongs to the backend.
415 If there's no page in the cache, then -ENODATA should be returned if the
416 backend managed to reserve a backing block; -ENOBUFS or -ENOMEM if it
419 If there is suitable data in the cache, then a read operation should be
420 queued and 0 returned. When the read finishes, fscache_end_io() should be
423 The fscache_mark_pages_cached() should be called for the page if any cache
424 metadata is retained. This will indicate to the netfs that the page needs
425 explicit uncaching. This operation takes a pagevec, thus allowing several
426 pages to be marked at once.
428 The retrieval record pointed to by op should be retained for each page
429 queued and released when I/O on the page has been formally ended.
430 fscache_get/put_retrieval() are available for this purpose.
432 The retrieval record may be used to get CPU time via the FS-Cache thread
433 pool. If this is desired, the op->op.processor should be set to point to
434 the appropriate processing routine, and fscache_enqueue_retrieval() should
435 be called at an appropriate point to request CPU time. For instance, the
436 retrieval routine could be enqueued upon the completion of a disk read.
437 The to_do field in the retrieval record is provided to aid in this.
439 If an I/O error occurs, fscache_io_error() should be called and -ENOBUFS
440 returned if possible or fscache_end_io() called with a suitable error
443 fscache_put_retrieval() should be called after a page or pages are dealt
444 with. This will complete the operation when all pages are dealt with.
447 * Request pages be read from cache [mandatory]::
449 int (*read_or_alloc_pages)(struct fscache_retrieval *op,
450 struct list_head *pages,
454 This is like the read_or_alloc_page() method, except it is handed a list
455 of pages instead of one page. Any pages on which a read operation is
456 started must be added to the page cache for the specified mapping and also
457 to the LRU. Such pages must also be removed from the pages list and
458 ``*nr_pages`` decremented per page.
460 If there was an error such as -ENOMEM, then that should be returned; else
461 if one or more pages couldn't be read or allocated, then -ENOBUFS should
462 be returned; else if one or more pages couldn't be read, then -ENODATA
463 should be returned. If all the pages are dispatched then 0 should be
467 * Request page be allocated in the cache [mandatory]::
469 int (*allocate_page)(struct fscache_retrieval *op,
473 This is like the read_or_alloc_page() method, except that it shouldn't
474 read from the cache, even if there's data there that could be retrieved.
475 It should, however, set up any internal metadata required such that
476 the write_page() method can write to the cache.
478 If there's no backing block available, then -ENOBUFS should be returned
479 (or -ENOMEM if there were other problems). If a block is successfully
480 allocated, then the netfs page should be marked and 0 returned.
483 * Request pages be allocated in the cache [mandatory]::
485 int (*allocate_pages)(struct fscache_retrieval *op,
486 struct list_head *pages,
490 This is an multiple page version of the allocate_page() method. pages and
491 nr_pages should be treated as for the read_or_alloc_pages() method.
494 * Request page be written to cache [mandatory]::
496 int (*write_page)(struct fscache_storage *op,
499 This is called to write from a page on which there was a previously
500 successful read_or_alloc_page() call or similar. FS-Cache filters out
501 pages that don't have mappings.
503 This method is called asynchronously from the FS-Cache thread pool. It is
504 not required to actually store anything, provided -ENODATA is then
505 returned to the next read of this page.
507 If an error occurred, then a negative error code should be returned,
508 otherwise zero should be returned. FS-Cache will take appropriate action
509 in response to an error, such as withdrawing this object.
511 If this method returns success then FS-Cache will inform the netfs
515 * Discard retained per-page metadata [mandatory]::
517 void (*uncache_page)(struct fscache_object *object, struct page *page)
519 This is called when a netfs page is being evicted from the pagecache. The
520 cache backend should tear down any internal representation or tracking it
521 maintains for this page.
527 FS-Cache provides some utilities that a cache backend may make use of:
529 * Note occurrence of an I/O error in a cache::
531 void fscache_io_error(struct fscache_cache *cache)
533 This tells FS-Cache that an I/O error occurred in the cache. After this
534 has been called, only resource dissociation operations (object and page
535 release) will be passed from the netfs to the cache backend for the
538 This does not actually withdraw the cache. That must be done separately.
541 * Invoke the retrieval I/O completion function::
543 void fscache_end_io(struct fscache_retrieval *op, struct page *page,
546 This is called to note the end of an attempt to retrieve a page. The
547 error value should be 0 if successful and an error otherwise.
550 * Record that one or more pages being retrieved or allocated have been dealt
553 void fscache_retrieval_complete(struct fscache_retrieval *op,
556 This is called to record the fact that one or more pages have been dealt
557 with and are no longer the concern of this operation. When the number of
558 pages remaining in the operation reaches 0, the operation will be
562 * Record operation completion::
564 void fscache_op_complete(struct fscache_operation *op);
566 This is called to record the completion of an operation. This deducts
567 this operation from the parent object's run state, potentially permitting
568 one or more pending operations to start running.
571 * Set highest store limit::
573 void fscache_set_store_limit(struct fscache_object *object,
576 This sets the limit FS-Cache imposes on the highest byte it's willing to
577 try and store for a netfs. Any page over this limit is automatically
578 rejected by fscache_read_alloc_page() and co with -ENOBUFS.
581 * Mark pages as being cached::
583 void fscache_mark_pages_cached(struct fscache_retrieval *op,
584 struct pagevec *pagevec);
586 This marks a set of pages as being cached. After this has been called,
587 the netfs must call fscache_uncache_page() to unmark the pages.
590 * Perform coherency check on an object::
592 enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
596 This asks the netfs to perform a coherency check on an object that has
597 just been looked up. The cookie attached to the object will determine the
598 netfs to use. data and datalen should specify where the auxiliary data
599 retrieved from the cache can be found.
601 One of three values will be returned:
603 FSCACHE_CHECKAUX_OKAY
604 The coherency data indicates the object is valid as is.
606 FSCACHE_CHECKAUX_NEEDS_UPDATE
607 The coherency data needs updating, but otherwise the object is
610 FSCACHE_CHECKAUX_OBSOLETE
611 The coherency data indicates that the object is obsolete and should
615 * Initialise a freshly allocated object::
617 void fscache_object_init(struct fscache_object *object);
619 This initialises all the fields in an object representation.
622 * Indicate the destruction of an object::
624 void fscache_object_destroyed(struct fscache_cache *cache);
626 This must be called to inform FS-Cache that an object that belonged to a
627 cache has been destroyed and deallocated. This will allow continuation
628 of the cache withdrawal process when it is stopped pending destruction of
632 * Indicate negative lookup on an object::
634 void fscache_object_lookup_negative(struct fscache_object *object);
636 This is called to indicate to FS-Cache that a lookup process for an object
637 found a negative result.
639 This changes the state of an object to permit reads pending on lookup
640 completion to go off and start fetching data from the netfs server as it's
641 known at this point that there can't be any data in the cache.
643 This may be called multiple times on an object. Only the first call is
644 significant - all subsequent calls are ignored.
647 * Indicate an object has been obtained::
649 void fscache_obtained_object(struct fscache_object *object);
651 This is called to indicate to FS-Cache that a lookup process for an object
652 produced a positive result, or that an object was created. This should
653 only be called once for any particular object.
655 This changes the state of an object to indicate:
657 (1) if no call to fscache_object_lookup_negative() has been made on
658 this object, that there may be data available, and that reads can
659 now go and look for it; and
661 (2) that writes may now proceed against this object.
664 * Indicate that object lookup failed::
666 void fscache_object_lookup_error(struct fscache_object *object);
668 This marks an object as having encountered a fatal error (usually EIO)
669 and causes it to move into a state whereby it will be withdrawn as soon
673 * Indicate that a stale object was found and discarded::
675 void fscache_object_retrying_stale(struct fscache_object *object);
677 This is called to indicate that the lookup procedure found an object in
678 the cache that the netfs decided was stale. The object has been
679 discarded from the cache and the lookup will be performed again.
682 * Indicate that the caching backend killed an object::
684 void fscache_object_mark_killed(struct fscache_object *object,
685 enum fscache_why_object_killed why);
687 This is called to indicate that the cache backend preemptively killed an
688 object. The why parameter should be set to indicate the reason:
690 FSCACHE_OBJECT_IS_STALE
691 - the object was stale and needs discarding.
693 FSCACHE_OBJECT_NO_SPACE
694 - there was insufficient cache space
696 FSCACHE_OBJECT_WAS_RETIRED
697 - the object was retired when relinquished.
699 FSCACHE_OBJECT_WAS_CULLED
700 - the object was culled to make space.
703 * Get and release references on a retrieval record::
705 void fscache_get_retrieval(struct fscache_retrieval *op);
706 void fscache_put_retrieval(struct fscache_retrieval *op);
708 These two functions are used to retain a retrieval record while doing
709 asynchronous data retrieval and block allocation.
712 * Enqueue a retrieval record for processing::
714 void fscache_enqueue_retrieval(struct fscache_retrieval *op);
716 This enqueues a retrieval record for processing by the FS-Cache thread
717 pool. One of the threads in the pool will invoke the retrieval record's
718 op->op.processor callback function. This function may be called from
719 within the callback function.
722 * List of object state names::
724 const char *fscache_object_states[];
726 For debugging purposes, this may be used to turn the state that an object
727 is in into a text string for display purposes.