1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/* General filesystem caching interface
3 *
4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 *
7 * NOTE!!! See:
8 *
9 * Documentation/filesystems/caching/netfs-api.rst
10 *
11 * for a description of the network filesystem interface declared here.
12 */
13
14#ifndef _LINUX_FSCACHE_H
15#define _LINUX_FSCACHE_H
16
17#include <linux/fs.h>
18#include <linux/netfs.h>
19#include <linux/writeback.h>
20
21#if defined(CONFIG_FSCACHE) || defined(CONFIG_FSCACHE_MODULE)
22#define __fscache_available (1)
23#define fscache_available() (1)
24#define fscache_volume_valid(volume) (volume)
25#define fscache_cookie_valid(cookie) (cookie)
26#define fscache_resources_valid(cres) ((cres)->cache_priv)
27#define fscache_cookie_enabled(cookie) (cookie && !test_bit(FSCACHE_COOKIE_DISABLED, &cookie->flags))
28#else
29#define __fscache_available (0)
30#define fscache_available() (0)
31#define fscache_volume_valid(volume) (0)
32#define fscache_cookie_valid(cookie) (0)
33#define fscache_resources_valid(cres) (false)
34#define fscache_cookie_enabled(cookie) (0)
35#endif
36
37struct fscache_cookie;
38
39#define FSCACHE_ADV_SINGLE_CHUNK 0x01 /* The object is a single chunk of data */
40#define FSCACHE_ADV_WRITE_CACHE 0x00 /* Do cache if written to locally */
41#define FSCACHE_ADV_WRITE_NOCACHE 0x02 /* Don't cache if written to locally */
42#define FSCACHE_ADV_WANT_CACHE_SIZE 0x04 /* Retrieve cache size at runtime */
43
44#define FSCACHE_INVAL_DIO_WRITE 0x01 /* Invalidate due to DIO write */
45
46enum fscache_want_state {
47 FSCACHE_WANT_PARAMS,
48 FSCACHE_WANT_WRITE,
49 FSCACHE_WANT_READ,
50};
51
52/*
53 * Data object state.
54 */
55enum fscache_cookie_state {
56 FSCACHE_COOKIE_STATE_QUIESCENT, /* The cookie is uncached */
57 FSCACHE_COOKIE_STATE_LOOKING_UP, /* The cache object is being looked up */
58 FSCACHE_COOKIE_STATE_CREATING, /* The cache object is being created */
59 FSCACHE_COOKIE_STATE_ACTIVE, /* The cache is active, readable and writable */
60 FSCACHE_COOKIE_STATE_INVALIDATING, /* The cache is being invalidated */
61 FSCACHE_COOKIE_STATE_FAILED, /* The cache failed, withdraw to clear */
62 FSCACHE_COOKIE_STATE_LRU_DISCARDING, /* The cookie is being discarded by the LRU */
63 FSCACHE_COOKIE_STATE_WITHDRAWING, /* The cookie is being withdrawn */
64 FSCACHE_COOKIE_STATE_RELINQUISHING, /* The cookie is being relinquished */
65 FSCACHE_COOKIE_STATE_DROPPED, /* The cookie has been dropped */
66#define FSCACHE_COOKIE_STATE__NR (FSCACHE_COOKIE_STATE_DROPPED + 1)
67} __attribute__((mode(byte)));
68
69/*
70 * Volume representation cookie.
71 */
72struct fscache_volume {
73 refcount_t ref;
74 atomic_t n_cookies; /* Number of data cookies in volume */
75 atomic_t n_accesses; /* Number of cache accesses in progress */
76 unsigned int debug_id;
77 unsigned int key_hash; /* Hash of key string */
78 u8 *key; /* Volume ID, eg. "afs@example.com@1234" */
79 struct list_head proc_link; /* Link in /proc/fs/fscache/volumes */
80 struct hlist_bl_node hash_link; /* Link in hash table */
81 struct work_struct work;
82 struct fscache_cache *cache; /* The cache in which this resides */
83 void *cache_priv; /* Cache private data */
84 spinlock_t lock;
85 unsigned long flags;
86#define FSCACHE_VOLUME_RELINQUISHED 0 /* Volume is being cleaned up */
87#define FSCACHE_VOLUME_INVALIDATE 1 /* Volume was invalidated */
88#define FSCACHE_VOLUME_COLLIDED_WITH 2 /* Volume was collided with */
89#define FSCACHE_VOLUME_ACQUIRE_PENDING 3 /* Volume is waiting to complete acquisition */
90#define FSCACHE_VOLUME_CREATING 4 /* Volume is being created on disk */
91 u8 coherency_len; /* Length of the coherency data */
92 u8 coherency[]; /* Coherency data */
93};
94
95/*
96 * Data file representation cookie.
97 * - a file will only appear in one cache
98 * - a request to cache a file may or may not be honoured, subject to
99 * constraints such as disk space
100 * - indices are created on disk just-in-time
101 */
102struct fscache_cookie {
103 refcount_t ref;
104 atomic_t n_active; /* number of active users of cookie */
105 atomic_t n_accesses; /* Number of cache accesses in progress */
106 unsigned int debug_id;
107 unsigned int inval_counter; /* Number of invalidations made */
108 spinlock_t lock;
109 struct fscache_volume *volume; /* Parent volume of this file. */
110 void *cache_priv; /* Cache-side representation */
111 struct hlist_bl_node hash_link; /* Link in hash table */
112 struct list_head proc_link; /* Link in proc list */
113 struct list_head commit_link; /* Link in commit queue */
114 struct work_struct work; /* Commit/relinq/withdraw work */
115 loff_t object_size; /* Size of the netfs object */
116 unsigned long unused_at; /* Time at which unused (jiffies) */
117 unsigned long flags;
118#define FSCACHE_COOKIE_RELINQUISHED 0 /* T if cookie has been relinquished */
119#define FSCACHE_COOKIE_RETIRED 1 /* T if this cookie has retired on relinq */
120#define FSCACHE_COOKIE_IS_CACHING 2 /* T if this cookie is cached */
121#define FSCACHE_COOKIE_NO_DATA_TO_READ 3 /* T if this cookie has nothing to read */
122#define FSCACHE_COOKIE_NEEDS_UPDATE 4 /* T if attrs have been updated */
123#define FSCACHE_COOKIE_HAS_BEEN_CACHED 5 /* T if cookie needs withdraw-on-relinq */
124#define FSCACHE_COOKIE_DISABLED 6 /* T if cookie has been disabled */
125#define FSCACHE_COOKIE_LOCAL_WRITE 7 /* T if cookie has been modified locally */
126#define FSCACHE_COOKIE_NO_ACCESS_WAKE 8 /* T if no wake when n_accesses goes 0 */
127#define FSCACHE_COOKIE_DO_RELINQUISH 9 /* T if this cookie needs relinquishment */
128#define FSCACHE_COOKIE_DO_WITHDRAW 10 /* T if this cookie needs withdrawing */
129#define FSCACHE_COOKIE_DO_LRU_DISCARD 11 /* T if this cookie needs LRU discard */
130#define FSCACHE_COOKIE_DO_PREP_TO_WRITE 12 /* T if cookie needs write preparation */
131#define FSCACHE_COOKIE_HAVE_DATA 13 /* T if this cookie has data stored */
132#define FSCACHE_COOKIE_IS_HASHED 14 /* T if this cookie is hashed */
133#define FSCACHE_COOKIE_DO_INVALIDATE 15 /* T if cookie needs invalidation */
134
135 enum fscache_cookie_state state;
136 u8 advice; /* FSCACHE_ADV_* */
137 u8 key_len; /* Length of index key */
138 u8 aux_len; /* Length of auxiliary data */
139 u32 key_hash; /* Hash of volume, key, len */
140 union {
141 void *key; /* Index key */
142 u8 inline_key[16]; /* - If the key is short enough */
143 };
144 union {
145 void *aux; /* Auxiliary data */
146 u8 inline_aux[8]; /* - If the aux data is short enough */
147 };
148};
149
150/*
151 * slow-path functions for when there is actually caching available, and the
152 * netfs does actually have a valid token
153 * - these are not to be called directly
154 * - these are undefined symbols when FS-Cache is not configured and the
155 * optimiser takes care of not using them
156 */
157extern struct fscache_volume *__fscache_acquire_volume(const char *, const char *,
158 const void *, size_t);
159extern void __fscache_relinquish_volume(struct fscache_volume *, const void *, bool);
160
161extern struct fscache_cookie *__fscache_acquire_cookie(
162 struct fscache_volume *,
163 u8,
164 const void *, size_t,
165 const void *, size_t,
166 loff_t);
167extern void __fscache_use_cookie(struct fscache_cookie *, bool);
168extern void __fscache_unuse_cookie(struct fscache_cookie *, const void *, const loff_t *);
169extern void __fscache_relinquish_cookie(struct fscache_cookie *, bool);
170extern void __fscache_resize_cookie(struct fscache_cookie *, loff_t);
171extern void __fscache_invalidate(struct fscache_cookie *, const void *, loff_t, unsigned int);
172extern int __fscache_begin_read_operation(struct netfs_cache_resources *, struct fscache_cookie *);
173extern int __fscache_begin_write_operation(struct netfs_cache_resources *, struct fscache_cookie *);
174
175extern void __fscache_write_to_cache(struct fscache_cookie *, struct address_space *,
176 loff_t, size_t, loff_t, netfs_io_terminated_t, void *,
177 bool);
178extern void __fscache_clear_page_bits(struct address_space *, loff_t, size_t);
179
180/**
181 * fscache_acquire_volume - Register a volume as desiring caching services
182 * @volume_key: An identification string for the volume
183 * @cache_name: The name of the cache to use (or NULL for the default)
184 * @coherency_data: Piece of arbitrary coherency data to check (or NULL)
185 * @coherency_len: The size of the coherency data
186 *
187 * Register a volume as desiring caching services if they're available. The
188 * caller must provide an identifier for the volume and may also indicate which
189 * cache it should be in. If a preexisting volume entry is found in the cache,
190 * the coherency data must match otherwise the entry will be invalidated.
191 *
192 * Returns a cookie pointer on success, -ENOMEM if out of memory or -EBUSY if a
193 * cache volume of that name is already acquired. Note that "NULL" is a valid
194 * cookie pointer and can be returned if caching is refused.
195 */
196static inline
197struct fscache_volume *fscache_acquire_volume(const char *volume_key,
198 const char *cache_name,
199 const void *coherency_data,
200 size_t coherency_len)
201{
202 if (!fscache_available())
203 return NULL;
204 return __fscache_acquire_volume(volume_key, cache_name,
205 coherency_data, coherency_len);
206}
207
208/**
209 * fscache_relinquish_volume - Cease caching a volume
210 * @volume: The volume cookie
211 * @coherency_data: Piece of arbitrary coherency data to set (or NULL)
212 * @invalidate: True if the volume should be invalidated
213 *
214 * Indicate that a filesystem no longer desires caching services for a volume.
215 * The caller must have relinquished all file cookies prior to calling this.
216 * The stored coherency data is updated.
217 */
218static inline
219void fscache_relinquish_volume(struct fscache_volume *volume,
220 const void *coherency_data,
221 bool invalidate)
222{
223 if (fscache_volume_valid(volume))
224 __fscache_relinquish_volume(volume, coherency_data, invalidate);
225}
226
227/**
228 * fscache_acquire_cookie - Acquire a cookie to represent a cache object
229 * @volume: The volume in which to locate/create this cookie
230 * @advice: Advice flags (FSCACHE_COOKIE_ADV_*)
231 * @index_key: The index key for this cookie
232 * @index_key_len: Size of the index key
233 * @aux_data: The auxiliary data for the cookie (may be NULL)
234 * @aux_data_len: Size of the auxiliary data buffer
235 * @object_size: The initial size of object
236 *
237 * Acquire a cookie to represent a data file within the given cache volume.
238 *
239 * See Documentation/filesystems/caching/netfs-api.rst for a complete
240 * description.
241 */
242static inline
243struct fscache_cookie *fscache_acquire_cookie(struct fscache_volume *volume,
244 u8 advice,
245 const void *index_key,
246 size_t index_key_len,
247 const void *aux_data,
248 size_t aux_data_len,
249 loff_t object_size)
250{
251 if (!fscache_volume_valid(volume))
252 return NULL;
253 return __fscache_acquire_cookie(volume, advice,
254 index_key, index_key_len,
255 aux_data, aux_data_len,
256 object_size);
257}
258
259/**
260 * fscache_use_cookie - Request usage of cookie attached to an object
261 * @cookie: The cookie representing the cache object
262 * @will_modify: If cache is expected to be modified locally
263 *
264 * Request usage of the cookie attached to an object. The caller should tell
265 * the cache if the object's contents are about to be modified locally and then
266 * the cache can apply the policy that has been set to handle this case.
267 */
268static inline void fscache_use_cookie(struct fscache_cookie *cookie,
269 bool will_modify)
270{
271 if (fscache_cookie_valid(cookie))
272 __fscache_use_cookie(cookie, will_modify);
273}
274
275/**
276 * fscache_unuse_cookie - Cease usage of cookie attached to an object
277 * @cookie: The cookie representing the cache object
278 * @aux_data: Updated auxiliary data (or NULL)
279 * @object_size: Revised size of the object (or NULL)
280 *
281 * Cease usage of the cookie attached to an object. When the users count
282 * reaches zero then the cookie relinquishment will be permitted to proceed.
283 */
284static inline void fscache_unuse_cookie(struct fscache_cookie *cookie,
285 const void *aux_data,
286 const loff_t *object_size)
287{
288 if (fscache_cookie_valid(cookie))
289 __fscache_unuse_cookie(cookie, aux_data, object_size);
290}
291
292/**
293 * fscache_relinquish_cookie - Return the cookie to the cache, maybe discarding
294 * it
295 * @cookie: The cookie being returned
296 * @retire: True if the cache object the cookie represents is to be discarded
297 *
298 * This function returns a cookie to the cache, forcibly discarding the
299 * associated cache object if retire is set to true.
300 *
301 * See Documentation/filesystems/caching/netfs-api.rst for a complete
302 * description.
303 */
304static inline
305void fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire)
306{
307 if (fscache_cookie_valid(cookie))
308 __fscache_relinquish_cookie(cookie, retire);
309}
310
311/*
312 * Find the auxiliary data on a cookie.
313 */
314static inline void *fscache_get_aux(struct fscache_cookie *cookie)
315{
316 if (cookie->aux_len <= sizeof(cookie->inline_aux))
317 return cookie->inline_aux;
318 else
319 return cookie->aux;
320}
321
322/*
323 * Update the auxiliary data on a cookie.
324 */
325static inline
326void fscache_update_aux(struct fscache_cookie *cookie,
327 const void *aux_data, const loff_t *object_size)
328{
329 void *p = fscache_get_aux(cookie);
330
331 if (aux_data && p)
332 memcpy(p, aux_data, cookie->aux_len);
333 if (object_size)
334 cookie->object_size = *object_size;
335}
336
337#ifdef CONFIG_FSCACHE_STATS
338extern atomic_t fscache_n_updates;
339#endif
340
341static inline
342void __fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data,
343 const loff_t *object_size)
344{
345#ifdef CONFIG_FSCACHE_STATS
346 atomic_inc(v: &fscache_n_updates);
347#endif
348 fscache_update_aux(cookie, aux_data, object_size);
349 smp_wmb();
350 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, addr: &cookie->flags);
351}
352
353/**
354 * fscache_update_cookie - Request that a cache object be updated
355 * @cookie: The cookie representing the cache object
356 * @aux_data: The updated auxiliary data for the cookie (may be NULL)
357 * @object_size: The current size of the object (may be NULL)
358 *
359 * Request an update of the index data for the cache object associated with the
360 * cookie. The auxiliary data on the cookie will be updated first if @aux_data
361 * is set and the object size will be updated and the object possibly trimmed
362 * if @object_size is set.
363 *
364 * See Documentation/filesystems/caching/netfs-api.rst for a complete
365 * description.
366 */
367static inline
368void fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data,
369 const loff_t *object_size)
370{
371 if (fscache_cookie_enabled(cookie))
372 __fscache_update_cookie(cookie, aux_data, object_size);
373}
374
375/**
376 * fscache_resize_cookie - Request that a cache object be resized
377 * @cookie: The cookie representing the cache object
378 * @new_size: The new size of the object (may be NULL)
379 *
380 * Request that the size of an object be changed.
381 *
382 * See Documentation/filesystems/caching/netfs-api.rst for a complete
383 * description.
384 */
385static inline
386void fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
387{
388 if (fscache_cookie_enabled(cookie))
389 __fscache_resize_cookie(cookie, new_size);
390}
391
392/**
393 * fscache_invalidate - Notify cache that an object needs invalidation
394 * @cookie: The cookie representing the cache object
395 * @aux_data: The updated auxiliary data for the cookie (may be NULL)
396 * @size: The revised size of the object.
397 * @flags: Invalidation flags (FSCACHE_INVAL_*)
398 *
399 * Notify the cache that an object is needs to be invalidated and that it
400 * should abort any retrievals or stores it is doing on the cache. This
401 * increments inval_counter on the cookie which can be used by the caller to
402 * reconsider I/O requests as they complete.
403 *
404 * If @flags has FSCACHE_INVAL_DIO_WRITE set, this indicates that this is due
405 * to a direct I/O write and will cause caching to be disabled on this cookie
406 * until it is completely unused.
407 *
408 * See Documentation/filesystems/caching/netfs-api.rst for a complete
409 * description.
410 */
411static inline
412void fscache_invalidate(struct fscache_cookie *cookie,
413 const void *aux_data, loff_t size, unsigned int flags)
414{
415 if (fscache_cookie_enabled(cookie))
416 __fscache_invalidate(cookie, aux_data, size, flags);
417}
418
419/**
420 * fscache_operation_valid - Return true if operations resources are usable
421 * @cres: The resources to check.
422 *
423 * Returns a pointer to the operations table if usable or NULL if not.
424 */
425static inline
426const struct netfs_cache_ops *fscache_operation_valid(const struct netfs_cache_resources *cres)
427{
428 return fscache_resources_valid(cres) ? cres->ops : NULL;
429}
430
431/**
432 * fscache_begin_read_operation - Begin a read operation for the netfs lib
433 * @cres: The cache resources for the read being performed
434 * @cookie: The cookie representing the cache object
435 *
436 * Begin a read operation on behalf of the netfs helper library. @cres
437 * indicates the cache resources to which the operation state should be
438 * attached; @cookie indicates the cache object that will be accessed.
439 *
440 * @cres->inval_counter is set from @cookie->inval_counter for comparison at
441 * the end of the operation. This allows invalidation during the operation to
442 * be detected by the caller.
443 *
444 * Returns:
445 * * 0 - Success
446 * * -ENOBUFS - No caching available
447 * * Other error code from the cache, such as -ENOMEM.
448 */
449static inline
450int fscache_begin_read_operation(struct netfs_cache_resources *cres,
451 struct fscache_cookie *cookie)
452{
453 if (fscache_cookie_enabled(cookie))
454 return __fscache_begin_read_operation(cres, cookie);
455 return -ENOBUFS;
456}
457
458/**
459 * fscache_end_operation - End the read operation for the netfs lib
460 * @cres: The cache resources for the read operation
461 *
462 * Clean up the resources at the end of the read request.
463 */
464static inline void fscache_end_operation(struct netfs_cache_resources *cres)
465{
466 const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
467
468 if (ops)
469 ops->end_operation(cres);
470}
471
472/**
473 * fscache_read - Start a read from the cache.
474 * @cres: The cache resources to use
475 * @start_pos: The beginning file offset in the cache file
476 * @iter: The buffer to fill - and also the length
477 * @read_hole: How to handle a hole in the data.
478 * @term_func: The function to call upon completion
479 * @term_func_priv: The private data for @term_func
480 *
481 * Start a read from the cache. @cres indicates the cache object to read from
482 * and must be obtained by a call to fscache_begin_operation() beforehand.
483 *
484 * The data is read into the iterator, @iter, and that also indicates the size
485 * of the operation. @start_pos is the start position in the file, though if
486 * @seek_data is set appropriately, the cache can use SEEK_DATA to find the
487 * next piece of data, writing zeros for the hole into the iterator.
488 *
489 * Upon termination of the operation, @term_func will be called and supplied
490 * with @term_func_priv plus the amount of data written, if successful, or the
491 * error code otherwise.
492 *
493 * @read_hole indicates how a partially populated region in the cache should be
494 * handled. It can be one of a number of settings:
495 *
496 * NETFS_READ_HOLE_IGNORE - Just try to read (may return a short read).
497 *
498 * NETFS_READ_HOLE_CLEAR - Seek for data, clearing the part of the buffer
499 * skipped over, then do as for IGNORE.
500 *
501 * NETFS_READ_HOLE_FAIL - Give ENODATA if we encounter a hole.
502 */
503static inline
504int fscache_read(struct netfs_cache_resources *cres,
505 loff_t start_pos,
506 struct iov_iter *iter,
507 enum netfs_read_from_hole read_hole,
508 netfs_io_terminated_t term_func,
509 void *term_func_priv)
510{
511 const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
512 return ops->read(cres, start_pos, iter, read_hole,
513 term_func, term_func_priv);
514}
515
516/**
517 * fscache_begin_write_operation - Begin a write operation for the netfs lib
518 * @cres: The cache resources for the write being performed
519 * @cookie: The cookie representing the cache object
520 *
521 * Begin a write operation on behalf of the netfs helper library. @cres
522 * indicates the cache resources to which the operation state should be
523 * attached; @cookie indicates the cache object that will be accessed.
524 *
525 * @cres->inval_counter is set from @cookie->inval_counter for comparison at
526 * the end of the operation. This allows invalidation during the operation to
527 * be detected by the caller.
528 *
529 * Returns:
530 * * 0 - Success
531 * * -ENOBUFS - No caching available
532 * * Other error code from the cache, such as -ENOMEM.
533 */
534static inline
535int fscache_begin_write_operation(struct netfs_cache_resources *cres,
536 struct fscache_cookie *cookie)
537{
538 if (fscache_cookie_enabled(cookie))
539 return __fscache_begin_write_operation(cres, cookie);
540 return -ENOBUFS;
541}
542
543/**
544 * fscache_write - Start a write to the cache.
545 * @cres: The cache resources to use
546 * @start_pos: The beginning file offset in the cache file
547 * @iter: The data to write - and also the length
548 * @term_func: The function to call upon completion
549 * @term_func_priv: The private data for @term_func
550 *
551 * Start a write to the cache. @cres indicates the cache object to write to and
552 * must be obtained by a call to fscache_begin_operation() beforehand.
553 *
554 * The data to be written is obtained from the iterator, @iter, and that also
555 * indicates the size of the operation. @start_pos is the start position in
556 * the file.
557 *
558 * Upon termination of the operation, @term_func will be called and supplied
559 * with @term_func_priv plus the amount of data written, if successful, or the
560 * error code otherwise.
561 */
562static inline
563int fscache_write(struct netfs_cache_resources *cres,
564 loff_t start_pos,
565 struct iov_iter *iter,
566 netfs_io_terminated_t term_func,
567 void *term_func_priv)
568{
569 const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
570 return ops->write(cres, start_pos, iter, term_func, term_func_priv);
571}
572
573/**
574 * fscache_clear_page_bits - Clear the PG_fscache bits from a set of pages
575 * @mapping: The netfs inode to use as the source
576 * @start: The start position in @mapping
577 * @len: The amount of data to unlock
578 * @caching: If PG_fscache has been set
579 *
580 * Clear the PG_fscache flag from a sequence of pages and wake up anyone who's
581 * waiting.
582 */
583static inline void fscache_clear_page_bits(struct address_space *mapping,
584 loff_t start, size_t len,
585 bool caching)
586{
587 if (caching)
588 __fscache_clear_page_bits(mapping, start, len);
589}
590
591/**
592 * fscache_write_to_cache - Save a write to the cache and clear PG_fscache
593 * @cookie: The cookie representing the cache object
594 * @mapping: The netfs inode to use as the source
595 * @start: The start position in @mapping
596 * @len: The amount of data to write back
597 * @i_size: The new size of the inode
598 * @term_func: The function to call upon completion
599 * @term_func_priv: The private data for @term_func
600 * @caching: If PG_fscache has been set
601 *
602 * Helper function for a netfs to write dirty data from an inode into the cache
603 * object that's backing it.
604 *
605 * @start and @len describe the range of the data. This does not need to be
606 * page-aligned, but to satisfy DIO requirements, the cache may expand it up to
607 * the page boundaries on either end. All the pages covering the range must be
608 * marked with PG_fscache.
609 *
610 * If given, @term_func will be called upon completion and supplied with
611 * @term_func_priv. Note that the PG_fscache flags will have been cleared by
612 * this point, so the netfs must retain its own pin on the mapping.
613 */
614static inline void fscache_write_to_cache(struct fscache_cookie *cookie,
615 struct address_space *mapping,
616 loff_t start, size_t len, loff_t i_size,
617 netfs_io_terminated_t term_func,
618 void *term_func_priv,
619 bool caching)
620{
621 if (caching)
622 __fscache_write_to_cache(cookie, mapping, start, len, i_size,
623 term_func, term_func_priv, caching);
624 else if (term_func)
625 term_func(term_func_priv, -ENOBUFS, false);
626
627}
628
629/**
630 * fscache_note_page_release - Note that a netfs page got released
631 * @cookie: The cookie corresponding to the file
632 *
633 * Note that a page that has been copied to the cache has been released. This
634 * means that future reads will need to look in the cache to see if it's there.
635 */
636static inline
637void fscache_note_page_release(struct fscache_cookie *cookie)
638{
639 /* If we've written data to the cache (HAVE_DATA) and there wasn't any
640 * data in the cache when we started (NO_DATA_TO_READ), it may no
641 * longer be true that we can skip reading from the cache - so clear
642 * the flag that causes reads to be skipped.
643 */
644 if (cookie &&
645 test_bit(FSCACHE_COOKIE_HAVE_DATA, &cookie->flags) &&
646 test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags))
647 clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, addr: &cookie->flags);
648}
649
650#endif /* _LINUX_FSCACHE_H */
651

source code of linux/include/linux/fscache.h