Commit | Line | Data |
---|---|---|
2874c5fd | 1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2d6fff63 DH |
2 | /* General filesystem caching interface |
3 | * | |
1e1236b8 | 4 | * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved. |
2d6fff63 DH |
5 | * Written by David Howells (dhowells@redhat.com) |
6 | * | |
2d6fff63 DH |
7 | * NOTE!!! See: |
8 | * | |
efc930fa | 9 | * Documentation/filesystems/caching/netfs-api.rst |
2d6fff63 DH |
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> | |
b533a83f | 18 | #include <linux/netfs.h> |
08276bda | 19 | #include <linux/writeback.h> |
2d6fff63 DH |
20 | |
21 | #if defined(CONFIG_FSCACHE) || defined(CONFIG_FSCACHE_MODULE) | |
1e1236b8 DH |
22 | #define __fscache_available (1) |
23 | #define fscache_available() (1) | |
62ab6335 | 24 | #define fscache_volume_valid(volume) (volume) |
2d6fff63 | 25 | #define fscache_cookie_valid(cookie) (cookie) |
12bb21a2 DH |
26 | #define fscache_resources_valid(cres) ((cres)->cache_priv) |
27 | #define fscache_cookie_enabled(cookie) (cookie && !test_bit(FSCACHE_COOKIE_DISABLED, &cookie->flags)) | |
2d6fff63 | 28 | #else |
1e1236b8 DH |
29 | #define __fscache_available (0) |
30 | #define fscache_available() (0) | |
62ab6335 | 31 | #define fscache_volume_valid(volume) (0) |
2d6fff63 | 32 | #define fscache_cookie_valid(cookie) (0) |
12bb21a2 | 33 | #define fscache_resources_valid(cres) (false) |
2cee6fbb | 34 | #define fscache_cookie_enabled(cookie) (0) |
2d6fff63 DH |
35 | #endif |
36 | ||
7f3283ab DH |
37 | struct 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 */ | |
c8383054 | 42 | #define FSCACHE_ADV_WANT_CACHE_SIZE 0x04 /* Retrieve cache size at runtime */ |
7f3283ab | 43 | |
d24af13e DH |
44 | #define FSCACHE_INVAL_DIO_WRITE 0x01 /* Invalidate due to DIO write */ |
45 | ||
d64f4554 DH |
46 | enum fscache_want_state { |
47 | FSCACHE_WANT_PARAMS, | |
48 | FSCACHE_WANT_WRITE, | |
49 | FSCACHE_WANT_READ, | |
50 | }; | |
51 | ||
7f3283ab DH |
52 | /* |
53 | * Data object state. | |
54 | */ | |
55 | enum 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 */ | |
d24af13e | 60 | FSCACHE_COOKIE_STATE_INVALIDATING, /* The cache is being invalidated */ |
7f3283ab | 61 | FSCACHE_COOKIE_STATE_FAILED, /* The cache failed, withdraw to clear */ |
12bb21a2 | 62 | FSCACHE_COOKIE_STATE_LRU_DISCARDING, /* The cookie is being discarded by the LRU */ |
7f3283ab DH |
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 | ||
62ab6335 DH |
69 | /* |
70 | * Volume representation cookie. | |
71 | */ | |
72 | struct 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 | char *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 */ | |
32e15003 DH |
91 | u8 coherency_len; /* Length of the coherency data */ |
92 | u8 coherency[]; /* Coherency data */ | |
62ab6335 DH |
93 | }; |
94 | ||
7f3283ab DH |
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 | */ | |
102 | struct 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 */ | |
85e4ea10 | 133 | #define FSCACHE_COOKIE_DO_INVALIDATE 15 /* T if cookie needs invalidation */ |
7f3283ab DH |
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 | ||
62ab6335 DH |
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 | */ | |
157 | extern struct fscache_volume *__fscache_acquire_volume(const char *, const char *, | |
158 | const void *, size_t); | |
159 | extern void __fscache_relinquish_volume(struct fscache_volume *, const void *, bool); | |
160 | ||
7f3283ab DH |
161 | extern 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); | |
12bb21a2 DH |
167 | extern void __fscache_use_cookie(struct fscache_cookie *, bool); |
168 | extern void __fscache_unuse_cookie(struct fscache_cookie *, const void *, const loff_t *); | |
7f3283ab | 169 | extern void __fscache_relinquish_cookie(struct fscache_cookie *, bool); |
16a96bdf | 170 | extern void __fscache_resize_cookie(struct fscache_cookie *, loff_t); |
d24af13e | 171 | extern void __fscache_invalidate(struct fscache_cookie *, const void *, loff_t, unsigned int); |
d64f4554 | 172 | extern int __fscache_begin_read_operation(struct netfs_cache_resources *, struct fscache_cookie *); |
16f2f4e6 | 173 | extern int __fscache_begin_write_operation(struct netfs_cache_resources *, struct fscache_cookie *); |
7f3283ab | 174 | |
b6e16652 DH |
175 | extern 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); | |
178 | extern void __fscache_clear_page_bits(struct address_space *, loff_t, size_t); | |
179 | ||
62ab6335 DH |
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 | */ | |
196 | static inline | |
197 | struct 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 | */ | |
218 | static inline | |
219 | void 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 | ||
7f3283ab DH |
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 | */ | |
242 | static inline | |
243 | struct 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 | ||
12bb21a2 DH |
259 | /** |
260 | * fscache_use_cookie - Request usage of cookie attached to an object | |
ec1bd371 | 261 | * @cookie: The cookie representing the cache object |
12bb21a2 DH |
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 | */ | |
268 | static 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 | |
ec1bd371 | 277 | * @cookie: The cookie representing the cache object |
12bb21a2 DH |
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 | */ | |
284 | static 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 | ||
7f3283ab DH |
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 | */ | |
304 | static inline | |
305 | void fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire) | |
306 | { | |
307 | if (fscache_cookie_valid(cookie)) | |
308 | __fscache_relinquish_cookie(cookie, retire); | |
309 | } | |
310 | ||
12bb21a2 DH |
311 | /* |
312 | * Find the auxiliary data on a cookie. | |
313 | */ | |
314 | static 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 | */ | |
325 | static inline | |
326 | void 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 | |
338 | extern atomic_t fscache_n_updates; | |
339 | #endif | |
340 | ||
341 | static inline | |
342 | void __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(&fscache_n_updates); | |
347 | #endif | |
348 | fscache_update_aux(cookie, aux_data, object_size); | |
349 | smp_wmb(); | |
350 | set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags); | |
351 | } | |
352 | ||
ed1235eb DH |
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 | */ | |
367 | static inline | |
368 | void 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 | ||
16a96bdf DH |
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 | * | |
752f5963 | 382 | * See Documentation/filesystems/caching/netfs-api.rst for a complete |
16a96bdf DH |
383 | * description. |
384 | */ | |
385 | static inline | |
386 | void 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 | ||
d24af13e DH |
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 | */ | |
411 | static inline | |
412 | void 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 | ||
d64f4554 DH |
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 | */ | |
425 | static inline | |
426 | const 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 | * This is intended to be called from the ->begin_cache_operation() netfs lib | |
441 | * operation as implemented by the network filesystem. | |
442 | * | |
443 | * @cres->inval_counter is set from @cookie->inval_counter for comparison at | |
444 | * the end of the operation. This allows invalidation during the operation to | |
445 | * be detected by the caller. | |
446 | * | |
447 | * Returns: | |
448 | * * 0 - Success | |
449 | * * -ENOBUFS - No caching available | |
450 | * * Other error code from the cache, such as -ENOMEM. | |
451 | */ | |
452 | static inline | |
453 | int fscache_begin_read_operation(struct netfs_cache_resources *cres, | |
454 | struct fscache_cookie *cookie) | |
455 | { | |
456 | if (fscache_cookie_enabled(cookie)) | |
457 | return __fscache_begin_read_operation(cres, cookie); | |
458 | return -ENOBUFS; | |
459 | } | |
460 | ||
e9b57aaa JX |
461 | /** |
462 | * fscache_end_operation - End the read operation for the netfs lib | |
463 | * @cres: The cache resources for the read operation | |
464 | * | |
465 | * Clean up the resources at the end of the read request. | |
466 | */ | |
467 | static inline void fscache_end_operation(struct netfs_cache_resources *cres) | |
468 | { | |
469 | const struct netfs_cache_ops *ops = fscache_operation_valid(cres); | |
470 | ||
471 | if (ops) | |
472 | ops->end_operation(cres); | |
473 | } | |
474 | ||
9af1c6c3 DH |
475 | /** |
476 | * fscache_read - Start a read from the cache. | |
477 | * @cres: The cache resources to use | |
478 | * @start_pos: The beginning file offset in the cache file | |
479 | * @iter: The buffer to fill - and also the length | |
480 | * @read_hole: How to handle a hole in the data. | |
481 | * @term_func: The function to call upon completion | |
482 | * @term_func_priv: The private data for @term_func | |
483 | * | |
484 | * Start a read from the cache. @cres indicates the cache object to read from | |
485 | * and must be obtained by a call to fscache_begin_operation() beforehand. | |
486 | * | |
487 | * The data is read into the iterator, @iter, and that also indicates the size | |
488 | * of the operation. @start_pos is the start position in the file, though if | |
489 | * @seek_data is set appropriately, the cache can use SEEK_DATA to find the | |
490 | * next piece of data, writing zeros for the hole into the iterator. | |
491 | * | |
492 | * Upon termination of the operation, @term_func will be called and supplied | |
493 | * with @term_func_priv plus the amount of data written, if successful, or the | |
494 | * error code otherwise. | |
495 | * | |
496 | * @read_hole indicates how a partially populated region in the cache should be | |
497 | * handled. It can be one of a number of settings: | |
498 | * | |
499 | * NETFS_READ_HOLE_IGNORE - Just try to read (may return a short read). | |
500 | * | |
501 | * NETFS_READ_HOLE_CLEAR - Seek for data, clearing the part of the buffer | |
502 | * skipped over, then do as for IGNORE. | |
503 | * | |
504 | * NETFS_READ_HOLE_FAIL - Give ENODATA if we encounter a hole. | |
505 | */ | |
506 | static inline | |
507 | int fscache_read(struct netfs_cache_resources *cres, | |
508 | loff_t start_pos, | |
509 | struct iov_iter *iter, | |
510 | enum netfs_read_from_hole read_hole, | |
511 | netfs_io_terminated_t term_func, | |
512 | void *term_func_priv) | |
513 | { | |
514 | const struct netfs_cache_ops *ops = fscache_operation_valid(cres); | |
515 | return ops->read(cres, start_pos, iter, read_hole, | |
516 | term_func, term_func_priv); | |
517 | } | |
518 | ||
16f2f4e6 DH |
519 | /** |
520 | * fscache_begin_write_operation - Begin a write operation for the netfs lib | |
521 | * @cres: The cache resources for the write being performed | |
522 | * @cookie: The cookie representing the cache object | |
523 | * | |
524 | * Begin a write operation on behalf of the netfs helper library. @cres | |
525 | * indicates the cache resources to which the operation state should be | |
526 | * attached; @cookie indicates the cache object that will be accessed. | |
527 | * | |
528 | * @cres->inval_counter is set from @cookie->inval_counter for comparison at | |
529 | * the end of the operation. This allows invalidation during the operation to | |
530 | * be detected by the caller. | |
531 | * | |
532 | * Returns: | |
533 | * * 0 - Success | |
534 | * * -ENOBUFS - No caching available | |
535 | * * Other error code from the cache, such as -ENOMEM. | |
536 | */ | |
537 | static inline | |
538 | int fscache_begin_write_operation(struct netfs_cache_resources *cres, | |
539 | struct fscache_cookie *cookie) | |
540 | { | |
541 | if (fscache_cookie_enabled(cookie)) | |
542 | return __fscache_begin_write_operation(cres, cookie); | |
543 | return -ENOBUFS; | |
544 | } | |
545 | ||
9af1c6c3 DH |
546 | /** |
547 | * fscache_write - Start a write to the cache. | |
548 | * @cres: The cache resources to use | |
549 | * @start_pos: The beginning file offset in the cache file | |
550 | * @iter: The data to write - and also the length | |
551 | * @term_func: The function to call upon completion | |
552 | * @term_func_priv: The private data for @term_func | |
553 | * | |
554 | * Start a write to the cache. @cres indicates the cache object to write to and | |
555 | * must be obtained by a call to fscache_begin_operation() beforehand. | |
556 | * | |
557 | * The data to be written is obtained from the iterator, @iter, and that also | |
558 | * indicates the size of the operation. @start_pos is the start position in | |
559 | * the file. | |
560 | * | |
561 | * Upon termination of the operation, @term_func will be called and supplied | |
562 | * with @term_func_priv plus the amount of data written, if successful, or the | |
563 | * error code otherwise. | |
564 | */ | |
565 | static inline | |
566 | int fscache_write(struct netfs_cache_resources *cres, | |
567 | loff_t start_pos, | |
568 | struct iov_iter *iter, | |
569 | netfs_io_terminated_t term_func, | |
570 | void *term_func_priv) | |
571 | { | |
572 | const struct netfs_cache_ops *ops = fscache_operation_valid(cres); | |
573 | return ops->write(cres, start_pos, iter, term_func, term_func_priv); | |
574 | } | |
575 | ||
b6e16652 DH |
576 | /** |
577 | * fscache_clear_page_bits - Clear the PG_fscache bits from a set of pages | |
b6e16652 DH |
578 | * @mapping: The netfs inode to use as the source |
579 | * @start: The start position in @mapping | |
580 | * @len: The amount of data to unlock | |
581 | * @caching: If PG_fscache has been set | |
582 | * | |
583 | * Clear the PG_fscache flag from a sequence of pages and wake up anyone who's | |
584 | * waiting. | |
585 | */ | |
2c547f29 | 586 | static inline void fscache_clear_page_bits(struct address_space *mapping, |
b6e16652 DH |
587 | loff_t start, size_t len, |
588 | bool caching) | |
589 | { | |
590 | if (caching) | |
591 | __fscache_clear_page_bits(mapping, start, len); | |
592 | } | |
593 | ||
594 | /** | |
595 | * fscache_write_to_cache - Save a write to the cache and clear PG_fscache | |
596 | * @cookie: The cookie representing the cache object | |
597 | * @mapping: The netfs inode to use as the source | |
598 | * @start: The start position in @mapping | |
599 | * @len: The amount of data to write back | |
600 | * @i_size: The new size of the inode | |
601 | * @term_func: The function to call upon completion | |
602 | * @term_func_priv: The private data for @term_func | |
603 | * @caching: If PG_fscache has been set | |
604 | * | |
605 | * Helper function for a netfs to write dirty data from an inode into the cache | |
606 | * object that's backing it. | |
607 | * | |
608 | * @start and @len describe the range of the data. This does not need to be | |
609 | * page-aligned, but to satisfy DIO requirements, the cache may expand it up to | |
610 | * the page boundaries on either end. All the pages covering the range must be | |
611 | * marked with PG_fscache. | |
612 | * | |
613 | * If given, @term_func will be called upon completion and supplied with | |
614 | * @term_func_priv. Note that the PG_fscache flags will have been cleared by | |
615 | * this point, so the netfs must retain its own pin on the mapping. | |
616 | */ | |
617 | static inline void fscache_write_to_cache(struct fscache_cookie *cookie, | |
618 | struct address_space *mapping, | |
619 | loff_t start, size_t len, loff_t i_size, | |
620 | netfs_io_terminated_t term_func, | |
621 | void *term_func_priv, | |
622 | bool caching) | |
623 | { | |
624 | if (caching) | |
625 | __fscache_write_to_cache(cookie, mapping, start, len, i_size, | |
626 | term_func, term_func_priv, caching); | |
627 | else if (term_func) | |
628 | term_func(term_func_priv, -ENOBUFS, false); | |
629 | ||
630 | } | |
631 | ||
08276bda | 632 | #if __fscache_available |
8fb72b4a MWO |
633 | bool fscache_dirty_folio(struct address_space *mapping, struct folio *folio, |
634 | struct fscache_cookie *cookie); | |
08276bda | 635 | #else |
8fb72b4a MWO |
636 | #define fscache_dirty_folio(MAPPING, FOLIO, COOKIE) \ |
637 | filemap_dirty_folio(MAPPING, FOLIO) | |
08276bda DH |
638 | #endif |
639 | ||
640 | /** | |
641 | * fscache_unpin_writeback - Unpin writeback resources | |
642 | * @wbc: The writeback control | |
643 | * @cookie: The cookie referring to the cache object | |
644 | * | |
8fb72b4a | 645 | * Unpin the writeback resources pinned by fscache_dirty_folio(). This is |
08276bda DH |
646 | * intended to be called by the netfs's ->write_inode() method. |
647 | */ | |
648 | static inline void fscache_unpin_writeback(struct writeback_control *wbc, | |
649 | struct fscache_cookie *cookie) | |
650 | { | |
651 | if (wbc->unpinned_fscache_wb) | |
652 | fscache_unuse_cookie(cookie, NULL, NULL); | |
653 | } | |
654 | ||
655 | /** | |
656 | * fscache_clear_inode_writeback - Clear writeback resources pinned by an inode | |
657 | * @cookie: The cookie referring to the cache object | |
658 | * @inode: The inode to clean up | |
659 | * @aux: Auxiliary data to apply to the inode | |
660 | * | |
661 | * Clear any writeback resources held by an inode when the inode is evicted. | |
662 | * This must be called before clear_inode() is called. | |
663 | */ | |
664 | static inline void fscache_clear_inode_writeback(struct fscache_cookie *cookie, | |
665 | struct inode *inode, | |
666 | const void *aux) | |
667 | { | |
668 | if (inode->i_state & I_PINNING_FSCACHE_WB) { | |
669 | loff_t i_size = i_size_read(inode); | |
670 | fscache_unuse_cookie(cookie, aux, &i_size); | |
671 | } | |
672 | } | |
673 | ||
1f67e6d0 DH |
674 | /** |
675 | * fscache_note_page_release - Note that a netfs page got released | |
676 | * @cookie: The cookie corresponding to the file | |
677 | * | |
678 | * Note that a page that has been copied to the cache has been released. This | |
679 | * means that future reads will need to look in the cache to see if it's there. | |
680 | */ | |
681 | static inline | |
682 | void fscache_note_page_release(struct fscache_cookie *cookie) | |
683 | { | |
c522e3ad DH |
684 | /* If we've written data to the cache (HAVE_DATA) and there wasn't any |
685 | * data in the cache when we started (NO_DATA_TO_READ), it may no | |
686 | * longer be true that we can skip reading from the cache - so clear | |
687 | * the flag that causes reads to be skipped. | |
688 | */ | |
1f67e6d0 DH |
689 | if (cookie && |
690 | test_bit(FSCACHE_COOKIE_HAVE_DATA, &cookie->flags) && | |
691 | test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) | |
692 | clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags); | |
693 | } | |
694 | ||
2d6fff63 | 695 | #endif /* _LINUX_FSCACHE_H */ |