Blame view
include/linux/fscache.h
28.7 KB
2874c5fd2 treewide: Replace... |
1 |
/* SPDX-License-Identifier: GPL-2.0-or-later */ |
2d6fff637 FS-Cache: Add the... |
2 3 4 5 6 |
/* General filesystem caching interface * * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * |
2d6fff637 FS-Cache: Add the... |
7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
* NOTE!!! See: * * Documentation/filesystems/caching/netfs-api.txt * * for a description of the network filesystem interface declared here. */ #ifndef _LINUX_FSCACHE_H #define _LINUX_FSCACHE_H #include <linux/fs.h> #include <linux/list.h> #include <linux/pagemap.h> #include <linux/pagevec.h> |
ec0328e46 fscache: Maintain... |
21 |
#include <linux/list_bl.h> |
2d6fff637 FS-Cache: Add the... |
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
#if defined(CONFIG_FSCACHE) || defined(CONFIG_FSCACHE_MODULE) #define fscache_available() (1) #define fscache_cookie_valid(cookie) (cookie) #else #define fscache_available() (0) #define fscache_cookie_valid(cookie) (0) #endif /* * overload PG_private_2 to give us PG_fscache - this is used to indicate that * a page is currently backed by a local disk cache */ #define PageFsCache(page) PagePrivate2((page)) #define SetPageFsCache(page) SetPagePrivate2((page)) #define ClearPageFsCache(page) ClearPagePrivate2((page)) #define TestSetPageFsCache(page) TestSetPagePrivate2((page)) #define TestClearPageFsCache(page) TestClearPagePrivate2((page)) /* pattern used to fill dead space in an index entry */ #define FSCACHE_INDEX_DEADFILL_PATTERN 0x79 struct pagevec; struct fscache_cache_tag; struct fscache_cookie; struct fscache_netfs; typedef void (*fscache_rw_complete_t)(struct page *page, void *context, int error); /* result of index entry consultation */ enum fscache_checkaux { FSCACHE_CHECKAUX_OKAY, /* entry okay as is */ FSCACHE_CHECKAUX_NEEDS_UPDATE, /* entry requires update */ FSCACHE_CHECKAUX_OBSOLETE, /* entry requires deletion */ }; /* * fscache cookie definition */ struct fscache_cookie_def { /* name of cookie type */ char name[16]; /* cookie type */ uint8_t type; #define FSCACHE_COOKIE_TYPE_INDEX 0 #define FSCACHE_COOKIE_TYPE_DATAFILE 1 /* select the cache into which to insert an entry in this index * - optional * - should return a cache identifier or NULL to cause the cache to be * inherited from the parent if possible or the first cache picked * for a non-index file if not */ struct fscache_cache_tag *(*select_cache)( const void *parent_netfs_data, const void *cookie_netfs_data); |
2d6fff637 FS-Cache: Add the... |
82 83 84 |
/* consult the netfs about the state of an object * - this function can be absent if the index carries no state data * - the netfs data from the cookie being used as the target is |
ee1235a9a fscache: Pass obj... |
85 |
* presented, as is the auxiliary data and the object size |
2d6fff637 FS-Cache: Add the... |
86 87 88 |
*/ enum fscache_checkaux (*check_aux)(void *cookie_netfs_data, const void *data, |
ee1235a9a fscache: Pass obj... |
89 90 |
uint16_t datalen, loff_t object_size); |
2d6fff637 FS-Cache: Add the... |
91 92 93 94 95 96 97 98 99 100 101 102 |
/* get an extra reference on a read context * - this function can be absent if the completion function doesn't * require a context */ void (*get_context)(void *cookie_netfs_data, void *context); /* release an extra reference on a read context * - this function can be absent if the completion function doesn't * require a context */ void (*put_context)(void *cookie_netfs_data, void *context); |
c4d6d8dbf CacheFiles: Fix t... |
103 104 105 |
/* indicate page that now have cache metadata retained * - this function should mark the specified page as now being cached * - the page will have been marked with PG_fscache before this is |
2d6fff637 FS-Cache: Add the... |
106 107 |
* called, so this is optional */ |
c4d6d8dbf CacheFiles: Fix t... |
108 109 110 |
void (*mark_page_cached)(void *cookie_netfs_data, struct address_space *mapping, struct page *page); |
2d6fff637 FS-Cache: Add the... |
111 112 113 114 115 116 117 118 119 120 121 |
}; /* * fscache cached network filesystem type * - name, version and ops must be filled in before registration * - all other fields will be set during registration */ struct fscache_netfs { uint32_t version; /* indexing version */ const char *name; /* filesystem name */ struct fscache_cookie *primary_index; |
2d6fff637 FS-Cache: Add the... |
122 123 124 |
}; /* |
94d30ae90 FS-Cache: Provide... |
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
* data file or index object cookie * - a file will only appear in one cache * - a request to cache a file may or may not be honoured, subject to * constraints such as disk space * - indices are created on disk just-in-time */ struct fscache_cookie { atomic_t usage; /* number of users of this cookie */ atomic_t n_children; /* number of children of this cookie */ atomic_t n_active; /* number of active users of netfs ptrs */ spinlock_t lock; spinlock_t stores_lock; /* lock on page store tree */ struct hlist_head backing_objects; /* object(s) backing this file/index */ const struct fscache_cookie_def *def; /* definition */ struct fscache_cookie *parent; /* parent of this entry */ |
ec0328e46 fscache: Maintain... |
140 |
struct hlist_bl_node hash_link; /* Link in hash table */ |
94d30ae90 FS-Cache: Provide... |
141 142 143 144 145 146 147 148 149 150 151 152 153 |
void *netfs_data; /* back pointer to netfs */ struct radix_tree_root stores; /* pages to be stored on this cookie */ #define FSCACHE_COOKIE_PENDING_TAG 0 /* pages tag: pending write to cache */ #define FSCACHE_COOKIE_STORING_TAG 1 /* pages tag: writing to cache */ unsigned long flags; #define FSCACHE_COOKIE_LOOKING_UP 0 /* T if non-index cookie being looked up still */ #define FSCACHE_COOKIE_NO_DATA_YET 1 /* T if new object with no cached data yet */ #define FSCACHE_COOKIE_UNAVAILABLE 2 /* T if cookie is unavailable (error, etc) */ #define FSCACHE_COOKIE_INVALIDATING 3 /* T if cookie is being invalidated */ #define FSCACHE_COOKIE_RELINQUISHED 4 /* T if cookie has been relinquished */ #define FSCACHE_COOKIE_ENABLED 5 /* T if cookie is enabled */ #define FSCACHE_COOKIE_ENABLEMENT_LOCK 6 /* T if cookie is being en/disabled */ |
ec0328e46 fscache: Maintain... |
154 155 156 |
#define FSCACHE_COOKIE_AUX_UPDATED 8 /* T if the auxiliary data was updated */ #define FSCACHE_COOKIE_ACQUIRED 9 /* T if cookie is in use */ #define FSCACHE_COOKIE_RELINQUISHING 10 /* T if cookie is being relinquished */ |
402cb8dda fscache: Attach t... |
157 158 159 160 |
u8 type; /* Type of object */ u8 key_len; /* Length of index key */ u8 aux_len; /* Length of auxiliary data */ |
ec0328e46 fscache: Maintain... |
161 |
u32 key_hash; /* Hash of parent, type, key, len */ |
402cb8dda fscache: Attach t... |
162 163 164 165 166 167 168 169 |
union { void *key; /* Index key */ u8 inline_key[16]; /* - If the key is short enough */ }; union { void *aux; /* Auxiliary data */ u8 inline_aux[8]; /* - If the aux data is short enough */ }; |
94d30ae90 FS-Cache: Provide... |
170 171 172 173 174 175 176 177 |
}; static inline bool fscache_cookie_enabled(struct fscache_cookie *cookie) { return test_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags); } /* |
2d6fff637 FS-Cache: Add the... |
178 179 180 181 182 183 |
* slow-path functions for when there is actually caching available, and the * netfs does actually have a valid token * - these are not to be called directly * - these are undefined symbols when FS-Cache is not configured and the * optimiser takes care of not using them */ |
726dd7ff1 FS-Cache: Add net... |
184 185 |
extern int __fscache_register_netfs(struct fscache_netfs *); extern void __fscache_unregister_netfs(struct fscache_netfs *); |
0e04d4cef FS-Cache: Add cac... |
186 187 |
extern struct fscache_cache_tag *__fscache_lookup_cache_tag(const char *); extern void __fscache_release_cache_tag(struct fscache_cache_tag *); |
2d6fff637 FS-Cache: Add the... |
188 |
|
ccc4fc3d1 FS-Cache: Impleme... |
189 190 191 |
extern struct fscache_cookie *__fscache_acquire_cookie( struct fscache_cookie *, const struct fscache_cookie_def *, |
402cb8dda fscache: Attach t... |
192 193 |
const void *, size_t, const void *, size_t, |
ee1235a9a fscache: Pass obj... |
194 |
void *, loff_t, bool); |
402cb8dda fscache: Attach t... |
195 196 197 |
extern void __fscache_relinquish_cookie(struct fscache_cookie *, const void *, bool); extern int __fscache_check_consistency(struct fscache_cookie *, const void *); extern void __fscache_update_cookie(struct fscache_cookie *, const void *); |
b51088228 FS-Cache: Impleme... |
198 |
extern int __fscache_attr_changed(struct fscache_cookie *); |
ef778e7ae FS-Cache: Provide... |
199 200 |
extern void __fscache_invalidate(struct fscache_cookie *); extern void __fscache_wait_on_invalidate(struct fscache_cookie *); |
b51088228 FS-Cache: Impleme... |
201 202 203 204 205 206 207 208 209 210 211 212 213 |
extern int __fscache_read_or_alloc_page(struct fscache_cookie *, struct page *, fscache_rw_complete_t, void *, gfp_t); extern int __fscache_read_or_alloc_pages(struct fscache_cookie *, struct address_space *, struct list_head *, unsigned *, fscache_rw_complete_t, void *, gfp_t); extern int __fscache_alloc_page(struct fscache_cookie *, struct page *, gfp_t); |
ee1235a9a fscache: Pass obj... |
214 |
extern int __fscache_write_page(struct fscache_cookie *, struct page *, loff_t, gfp_t); |
b51088228 FS-Cache: Impleme... |
215 216 217 |
extern void __fscache_uncache_page(struct fscache_cookie *, struct page *); extern bool __fscache_check_page_write(struct fscache_cookie *, struct page *); extern void __fscache_wait_on_page_write(struct fscache_cookie *, struct page *); |
201a15428 FS-Cache: Handle ... |
218 219 |
extern bool __fscache_maybe_release_page(struct fscache_cookie *, struct page *, gfp_t); |
c902ce1bf FS-Cache: Add a h... |
220 221 |
extern void __fscache_uncache_all_inode_pages(struct fscache_cookie *, struct inode *); |
5a6f282a2 fscache: Netfs fu... |
222 223 |
extern void __fscache_readpages_cancel(struct fscache_cookie *cookie, struct list_head *pages); |
402cb8dda fscache: Attach t... |
224 |
extern void __fscache_disable_cookie(struct fscache_cookie *, const void *, bool); |
ee1235a9a fscache: Pass obj... |
225 |
extern void __fscache_enable_cookie(struct fscache_cookie *, const void *, loff_t, |
94d30ae90 FS-Cache: Provide... |
226 |
bool (*)(void *), void *); |
ccc4fc3d1 FS-Cache: Impleme... |
227 |
|
2d6fff637 FS-Cache: Add the... |
228 229 230 231 232 233 234 235 236 237 238 239 |
/** * fscache_register_netfs - Register a filesystem as desiring caching services * @netfs: The description of the filesystem * * Register a filesystem as desiring caching services if they're available. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_register_netfs(struct fscache_netfs *netfs) { |
726dd7ff1 FS-Cache: Add net... |
240 241 242 243 |
if (fscache_available()) return __fscache_register_netfs(netfs); else return 0; |
2d6fff637 FS-Cache: Add the... |
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 |
} /** * fscache_unregister_netfs - Indicate that a filesystem no longer desires * caching services * @netfs: The description of the filesystem * * Indicate that a filesystem no longer desires caching services for the * moment. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_unregister_netfs(struct fscache_netfs *netfs) { |
726dd7ff1 FS-Cache: Add net... |
260 261 |
if (fscache_available()) __fscache_unregister_netfs(netfs); |
2d6fff637 FS-Cache: Add the... |
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 |
} /** * fscache_lookup_cache_tag - Look up a cache tag * @name: The name of the tag to search for * * Acquire a specific cache referral tag that can be used to select a specific * cache in which to cache an index. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline struct fscache_cache_tag *fscache_lookup_cache_tag(const char *name) { |
0e04d4cef FS-Cache: Add cac... |
277 278 279 280 |
if (fscache_available()) return __fscache_lookup_cache_tag(name); else return NULL; |
2d6fff637 FS-Cache: Add the... |
281 282 283 284 285 286 287 288 289 290 291 292 293 294 |
} /** * fscache_release_cache_tag - Release a cache tag * @tag: The tag to release * * Release a reference to a cache referral tag previously looked up. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_release_cache_tag(struct fscache_cache_tag *tag) { |
0e04d4cef FS-Cache: Add cac... |
295 296 |
if (fscache_available()) __fscache_release_cache_tag(tag); |
2d6fff637 FS-Cache: Add the... |
297 298 299 300 301 302 |
} /** * fscache_acquire_cookie - Acquire a cookie to represent a cache object * @parent: The cookie that's to be the parent of this one * @def: A description of the cache object, including callback operations |
402cb8dda fscache: Attach t... |
303 304 305 306 |
* @index_key: The index key for this cookie * @index_key_len: Size of the index key * @aux_data: The auxiliary data for the cookie (may be NULL) * @aux_data_len: Size of the auxiliary data buffer |
2d6fff637 FS-Cache: Add the... |
307 308 |
* @netfs_data: An arbitrary piece of data to be kept in the cookie to * represent the cache object to the netfs |
ee1235a9a fscache: Pass obj... |
309 |
* @object_size: The initial size of object |
94d30ae90 FS-Cache: Provide... |
310 |
* @enable: Whether or not to enable a data cookie immediately |
2d6fff637 FS-Cache: Add the... |
311 312 313 314 315 316 317 318 319 320 321 322 |
* * This function is used to inform FS-Cache about part of an index hierarchy * that can be used to locate files. This is done by requesting a cookie for * each index in the path to the file. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline struct fscache_cookie *fscache_acquire_cookie( struct fscache_cookie *parent, const struct fscache_cookie_def *def, |
402cb8dda fscache: Attach t... |
323 324 325 326 |
const void *index_key, size_t index_key_len, const void *aux_data, size_t aux_data_len, |
94d30ae90 FS-Cache: Provide... |
327 |
void *netfs_data, |
ee1235a9a fscache: Pass obj... |
328 |
loff_t object_size, |
94d30ae90 FS-Cache: Provide... |
329 |
bool enable) |
2d6fff637 FS-Cache: Add the... |
330 |
{ |
94d30ae90 FS-Cache: Provide... |
331 |
if (fscache_cookie_valid(parent) && fscache_cookie_enabled(parent)) |
402cb8dda fscache: Attach t... |
332 333 334 |
return __fscache_acquire_cookie(parent, def, index_key, index_key_len, aux_data, aux_data_len, |
ee1235a9a fscache: Pass obj... |
335 |
netfs_data, object_size, enable); |
ccc4fc3d1 FS-Cache: Impleme... |
336 337 |
else return NULL; |
2d6fff637 FS-Cache: Add the... |
338 339 340 341 342 343 |
} /** * fscache_relinquish_cookie - Return the cookie to the cache, maybe discarding * it * @cookie: The cookie being returned |
402cb8dda fscache: Attach t... |
344 |
* @aux_data: The updated auxiliary data for the cookie (may be NULL) |
2d6fff637 FS-Cache: Add the... |
345 346 347 |
* @retire: True if the cache object the cookie represents is to be discarded * * This function returns a cookie to the cache, forcibly discarding the |
402cb8dda fscache: Attach t... |
348 349 350 |
* associated cache object if retire is set to true. The opportunity is * provided to update the auxiliary data in the cache before the object is * disconnected. |
2d6fff637 FS-Cache: Add the... |
351 352 353 354 355 |
* * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline |
402cb8dda fscache: Attach t... |
356 357 358 |
void fscache_relinquish_cookie(struct fscache_cookie *cookie, const void *aux_data, bool retire) |
2d6fff637 FS-Cache: Add the... |
359 |
{ |
ccc4fc3d1 FS-Cache: Impleme... |
360 |
if (fscache_cookie_valid(cookie)) |
402cb8dda fscache: Attach t... |
361 |
__fscache_relinquish_cookie(cookie, aux_data, retire); |
2d6fff637 FS-Cache: Add the... |
362 363 364 |
} /** |
402cb8dda fscache: Attach t... |
365 |
* fscache_check_consistency - Request validation of a cache's auxiliary data |
da9803bc8 FS-Cache: Add int... |
366 |
* @cookie: The cookie representing the cache object |
402cb8dda fscache: Attach t... |
367 |
* @aux_data: The updated auxiliary data for the cookie (may be NULL) |
da9803bc8 FS-Cache: Add int... |
368 |
* |
402cb8dda fscache: Attach t... |
369 370 371 |
* Request an consistency check from fscache, which passes the request to the * backing cache. The auxiliary data on the cookie will be updated first if * @aux_data is set. |
da9803bc8 FS-Cache: Add int... |
372 373 374 375 376 |
* * Returns 0 if consistent and -ESTALE if inconsistent. May also * return -ENOMEM and -ERESTARTSYS. */ static inline |
402cb8dda fscache: Attach t... |
377 378 |
int fscache_check_consistency(struct fscache_cookie *cookie, const void *aux_data) |
da9803bc8 FS-Cache: Add int... |
379 |
{ |
94d30ae90 FS-Cache: Provide... |
380 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
402cb8dda fscache: Attach t... |
381 |
return __fscache_check_consistency(cookie, aux_data); |
da9803bc8 FS-Cache: Add int... |
382 383 384 385 386 |
else return 0; } /** |
2d6fff637 FS-Cache: Add the... |
387 388 |
* fscache_update_cookie - Request that a cache object be updated * @cookie: The cookie representing the cache object |
402cb8dda fscache: Attach t... |
389 |
* @aux_data: The updated auxiliary data for the cookie (may be NULL) |
2d6fff637 FS-Cache: Add the... |
390 391 |
* * Request an update of the index data for the cache object associated with the |
402cb8dda fscache: Attach t... |
392 393 |
* cookie. The auxiliary data on the cookie will be updated first if @aux_data * is set. |
2d6fff637 FS-Cache: Add the... |
394 395 396 397 398 |
* * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline |
402cb8dda fscache: Attach t... |
399 |
void fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data) |
2d6fff637 FS-Cache: Add the... |
400 |
{ |
94d30ae90 FS-Cache: Provide... |
401 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
402cb8dda fscache: Attach t... |
402 |
__fscache_update_cookie(cookie, aux_data); |
2d6fff637 FS-Cache: Add the... |
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 |
} /** * fscache_pin_cookie - Pin a data-storage cache object in its cache * @cookie: The cookie representing the cache object * * Permit data-storage cache objects to be pinned in the cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_pin_cookie(struct fscache_cookie *cookie) { return -ENOBUFS; } /** * fscache_pin_cookie - Unpin a data-storage cache object in its cache * @cookie: The cookie representing the cache object * * Permit data-storage cache objects to be unpinned from the cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_unpin_cookie(struct fscache_cookie *cookie) { } /** * fscache_attr_changed - Notify cache that an object's attributes changed * @cookie: The cookie representing the cache object * * Send a notification to the cache indicating that an object's attributes have * changed. This includes the data size. These attributes will be obtained * through the get_attr() cookie definition op. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_attr_changed(struct fscache_cookie *cookie) { |
94d30ae90 FS-Cache: Provide... |
448 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
b51088228 FS-Cache: Impleme... |
449 450 451 |
return __fscache_attr_changed(cookie); else return -ENOBUFS; |
2d6fff637 FS-Cache: Add the... |
452 453 454 |
} /** |
ef778e7ae FS-Cache: Provide... |
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 |
* fscache_invalidate - Notify cache that an object needs invalidation * @cookie: The cookie representing the cache object * * Notify the cache that an object is needs to be invalidated and that it * should abort any retrievals or stores it is doing on the cache. The object * is then marked non-caching until such time as the invalidation is complete. * * This can be called with spinlocks held. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_invalidate(struct fscache_cookie *cookie) { |
94d30ae90 FS-Cache: Provide... |
470 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
ef778e7ae FS-Cache: Provide... |
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 |
__fscache_invalidate(cookie); } /** * fscache_wait_on_invalidate - Wait for invalidation to complete * @cookie: The cookie representing the cache object * * Wait for the invalidation of an object to complete. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_wait_on_invalidate(struct fscache_cookie *cookie) { if (fscache_cookie_valid(cookie)) __fscache_wait_on_invalidate(cookie); } /** |
2d6fff637 FS-Cache: Add the... |
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 |
* fscache_reserve_space - Reserve data space for a cached object * @cookie: The cookie representing the cache object * @i_size: The amount of space to be reserved * * Reserve an amount of space in the cache for the cache object attached to a * cookie so that a write to that object within the space can always be * honoured. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size) { return -ENOBUFS; } /** * fscache_read_or_alloc_page - Read a page from the cache or allocate a block * in which to store it * @cookie: The cookie representing the cache object * @page: The netfs page to fill if possible * @end_io_func: The callback to invoke when and if the page is filled * @context: An arbitrary piece of data to pass on to end_io_func() * @gfp: The conditions under which memory allocation should be made * * Read a page from the cache, or if that's not possible make a potential * one-block reservation in the cache into which the page may be stored once * fetched from the server. * * If the page is not backed by the cache object, or if it there's some reason * it can't be, -ENOBUFS will be returned and nothing more will be done for * that page. * * Else, if that page is backed by the cache, a read will be initiated directly * to the netfs's page and 0 will be returned by this function. The * end_io_func() callback will be invoked when the operation terminates on a * completion or failure. Note that the callback may be invoked before the * return. * * Else, if the page is unbacked, -ENODATA is returned and a block may have * been allocated in the cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_read_or_alloc_page(struct fscache_cookie *cookie, struct page *page, fscache_rw_complete_t end_io_func, void *context, gfp_t gfp) { |
94d30ae90 FS-Cache: Provide... |
544 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
b51088228 FS-Cache: Impleme... |
545 546 547 548 |
return __fscache_read_or_alloc_page(cookie, page, end_io_func, context, gfp); else return -ENOBUFS; |
2d6fff637 FS-Cache: Add the... |
549 550 551 552 553 554 555 556 |
} /** * fscache_read_or_alloc_pages - Read pages from the cache and/or allocate * blocks in which to store them * @cookie: The cookie representing the cache object * @mapping: The netfs inode mapping to which the pages will be attached * @pages: A list of potential netfs pages to be filled |
49a3df804 fscache: fix miss... |
557 |
* @nr_pages: Number of pages to be read and/or allocated |
2d6fff637 FS-Cache: Add the... |
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 |
* @end_io_func: The callback to invoke when and if each page is filled * @context: An arbitrary piece of data to pass on to end_io_func() * @gfp: The conditions under which memory allocation should be made * * Read a set of pages from the cache, or if that's not possible, attempt to * make a potential one-block reservation for each page in the cache into which * that page may be stored once fetched from the server. * * If some pages are not backed by the cache object, or if it there's some * reason they can't be, -ENOBUFS will be returned and nothing more will be * done for that pages. * * Else, if some of the pages are backed by the cache, a read will be initiated * directly to the netfs's page and 0 will be returned by this function. The * end_io_func() callback will be invoked when the operation terminates on a * completion or failure. Note that the callback may be invoked before the * return. * * Else, if a page is unbacked, -ENODATA is returned and a block may have * been allocated in the cache. * * Because the function may want to return all of -ENOBUFS, -ENODATA and 0 in * regard to different pages, the return values are prioritised in that order. * Any pages submitted for reading are removed from the pages list. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_read_or_alloc_pages(struct fscache_cookie *cookie, struct address_space *mapping, struct list_head *pages, unsigned *nr_pages, fscache_rw_complete_t end_io_func, void *context, gfp_t gfp) { |
94d30ae90 FS-Cache: Provide... |
595 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
b51088228 FS-Cache: Impleme... |
596 597 598 599 600 |
return __fscache_read_or_alloc_pages(cookie, mapping, pages, nr_pages, end_io_func, context, gfp); else return -ENOBUFS; |
2d6fff637 FS-Cache: Add the... |
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 |
} /** * fscache_alloc_page - Allocate a block in which to store a page * @cookie: The cookie representing the cache object * @page: The netfs page to allocate a page for * @gfp: The conditions under which memory allocation should be made * * Request Allocation a block in the cache in which to store a netfs page * without retrieving any contents from the cache. * * If the page is not backed by a file then -ENOBUFS will be returned and * nothing more will be done, and no reservation will be made. * * Else, a block will be allocated if one wasn't already, and 0 will be * returned * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_alloc_page(struct fscache_cookie *cookie, struct page *page, gfp_t gfp) { |
94d30ae90 FS-Cache: Provide... |
626 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
b51088228 FS-Cache: Impleme... |
627 628 629 |
return __fscache_alloc_page(cookie, page, gfp); else return -ENOBUFS; |
2d6fff637 FS-Cache: Add the... |
630 631 632 |
} /** |
5a6f282a2 fscache: Netfs fu... |
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 |
* fscache_readpages_cancel - Cancel read/alloc on pages * @cookie: The cookie representing the inode's cache object. * @pages: The netfs pages that we canceled write on in readpages() * * Uncache/unreserve the pages reserved earlier in readpages() via * fscache_readpages_or_alloc() and similar. In most successful caches in * readpages() this doesn't do anything. In cases when the underlying netfs's * readahead failed we need to clean up the pagelist (unmark and uncache). * * This function may sleep as it may have to clean up disk state. */ static inline void fscache_readpages_cancel(struct fscache_cookie *cookie, struct list_head *pages) { if (fscache_cookie_valid(cookie)) __fscache_readpages_cancel(cookie, pages); } /** |
2d6fff637 FS-Cache: Add the... |
653 654 655 |
* fscache_write_page - Request storage of a page in the cache * @cookie: The cookie representing the cache object * @page: The netfs page to store |
ee1235a9a fscache: Pass obj... |
656 |
* @object_size: Updated size of object |
2d6fff637 FS-Cache: Add the... |
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 |
* @gfp: The conditions under which memory allocation should be made * * Request the contents of the netfs page be written into the cache. This * request may be ignored if no cache block is currently allocated, in which * case it will return -ENOBUFS. * * If a cache block was already allocated, a write will be initiated and 0 will * be returned. The PG_fscache_write page bit is set immediately and will then * be cleared at the completion of the write to indicate the success or failure * of the operation. Note that the completion may happen before the return. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_write_page(struct fscache_cookie *cookie, struct page *page, |
ee1235a9a fscache: Pass obj... |
674 |
loff_t object_size, |
2d6fff637 FS-Cache: Add the... |
675 676 |
gfp_t gfp) { |
94d30ae90 FS-Cache: Provide... |
677 |
if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
ee1235a9a fscache: Pass obj... |
678 |
return __fscache_write_page(cookie, page, object_size, gfp); |
b51088228 FS-Cache: Impleme... |
679 680 |
else return -ENOBUFS; |
2d6fff637 FS-Cache: Add the... |
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 |
} /** * fscache_uncache_page - Indicate that caching is no longer required on a page * @cookie: The cookie representing the cache object * @page: The netfs page that was being cached. * * Tell the cache that we no longer want a page to be cached and that it should * remove any knowledge of the netfs page it may have. * * Note that this cannot cancel any outstanding I/O operations between this * page and the cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_uncache_page(struct fscache_cookie *cookie, struct page *page) { |
b51088228 FS-Cache: Impleme... |
701 702 |
if (fscache_cookie_valid(cookie)) __fscache_uncache_page(cookie, page); |
2d6fff637 FS-Cache: Add the... |
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 |
} /** * fscache_check_page_write - Ask if a page is being writing to the cache * @cookie: The cookie representing the cache object * @page: The netfs page that is being cached. * * Ask the cache if a page is being written to the cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline bool fscache_check_page_write(struct fscache_cookie *cookie, struct page *page) { |
b51088228 FS-Cache: Impleme... |
719 720 |
if (fscache_cookie_valid(cookie)) return __fscache_check_page_write(cookie, page); |
2d6fff637 FS-Cache: Add the... |
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 |
return false; } /** * fscache_wait_on_page_write - Wait for a page to complete writing to the cache * @cookie: The cookie representing the cache object * @page: The netfs page that is being cached. * * Ask the cache to wake us up when a page is no longer being written to the * cache. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_wait_on_page_write(struct fscache_cookie *cookie, struct page *page) { |
b51088228 FS-Cache: Impleme... |
739 740 |
if (fscache_cookie_valid(cookie)) __fscache_wait_on_page_write(cookie, page); |
2d6fff637 FS-Cache: Add the... |
741 |
} |
201a15428 FS-Cache: Handle ... |
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 |
/** * fscache_maybe_release_page - Consider releasing a page, cancelling a store * @cookie: The cookie representing the cache object * @page: The netfs page that is being cached. * @gfp: The gfp flags passed to releasepage() * * Consider releasing a page for the vmscan algorithm, on behalf of the netfs's * releasepage() call. A storage request on the page may cancelled if it is * not currently being processed. * * The function returns true if the page no longer has a storage request on it, * and false if a storage request is left in place. If true is returned, the * page will have been passed to fscache_uncache_page(). If false is returned * the page cannot be freed yet. */ static inline bool fscache_maybe_release_page(struct fscache_cookie *cookie, struct page *page, gfp_t gfp) { if (fscache_cookie_valid(cookie) && PageFsCache(page)) return __fscache_maybe_release_page(cookie, page, gfp); |
988015065 fscache: Fix the ... |
764 |
return true; |
201a15428 FS-Cache: Handle ... |
765 |
} |
c902ce1bf FS-Cache: Add a h... |
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 |
/** * fscache_uncache_all_inode_pages - Uncache all an inode's pages * @cookie: The cookie representing the inode's cache object. * @inode: The inode to uncache pages from. * * Uncache all the pages in an inode that are marked PG_fscache, assuming them * to be associated with the given cookie. * * This function may sleep. It will wait for pages that are being written out * and will wait whilst the PG_fscache mark is removed by the cache. */ static inline void fscache_uncache_all_inode_pages(struct fscache_cookie *cookie, struct inode *inode) { if (fscache_cookie_valid(cookie)) __fscache_uncache_all_inode_pages(cookie, inode); } |
94d30ae90 FS-Cache: Provide... |
784 785 786 |
/** * fscache_disable_cookie - Disable a cookie * @cookie: The cookie representing the cache object |
402cb8dda fscache: Attach t... |
787 |
* @aux_data: The updated auxiliary data for the cookie (may be NULL) |
94d30ae90 FS-Cache: Provide... |
788 789 790 791 792 793 794 795 796 797 |
* @invalidate: Invalidate the backing object * * Disable a cookie from accepting further alloc, read, write, invalidate, * update or acquire operations. Outstanding operations can still be waited * upon and pages can still be uncached and the cookie relinquished. * * This will not return until all outstanding operations have completed. * * If @invalidate is set, then the backing object will be invalidated and * detached, otherwise it will just be detached. |
402cb8dda fscache: Attach t... |
798 799 |
* * If @aux_data is set, then auxiliary data will be updated from that. |
94d30ae90 FS-Cache: Provide... |
800 801 |
*/ static inline |
402cb8dda fscache: Attach t... |
802 803 804 |
void fscache_disable_cookie(struct fscache_cookie *cookie, const void *aux_data, bool invalidate) |
94d30ae90 FS-Cache: Provide... |
805 806 |
{ if (fscache_cookie_valid(cookie) && fscache_cookie_enabled(cookie)) |
402cb8dda fscache: Attach t... |
807 |
__fscache_disable_cookie(cookie, aux_data, invalidate); |
94d30ae90 FS-Cache: Provide... |
808 809 810 811 812 |
} /** * fscache_enable_cookie - Reenable a cookie * @cookie: The cookie representing the cache object |
402cb8dda fscache: Attach t... |
813 |
* @aux_data: The updated auxiliary data for the cookie (may be NULL) |
ee1235a9a fscache: Pass obj... |
814 |
* @object_size: Current size of object |
94d30ae90 FS-Cache: Provide... |
815 816 817 818 819 |
* @can_enable: A function to permit enablement once lock is held * @data: Data for can_enable() * * Reenable a previously disabled cookie, allowing it to accept further alloc, * read, write, invalidate, update or acquire operations. An attempt will be |
402cb8dda fscache: Attach t... |
820 821 |
* made to immediately reattach the cookie to a backing object. If @aux_data * is set, the auxiliary data attached to the cookie will be updated. |
94d30ae90 FS-Cache: Provide... |
822 823 824 825 826 827 |
* * The can_enable() function is called (if not NULL) once the enablement lock * is held to rule on whether enablement is still permitted to go ahead. */ static inline void fscache_enable_cookie(struct fscache_cookie *cookie, |
402cb8dda fscache: Attach t... |
828 |
const void *aux_data, |
ee1235a9a fscache: Pass obj... |
829 |
loff_t object_size, |
94d30ae90 FS-Cache: Provide... |
830 831 832 833 |
bool (*can_enable)(void *data), void *data) { if (fscache_cookie_valid(cookie) && !fscache_cookie_enabled(cookie)) |
ee1235a9a fscache: Pass obj... |
834 835 |
__fscache_enable_cookie(cookie, aux_data, object_size, can_enable, data); |
94d30ae90 FS-Cache: Provide... |
836 |
} |
2d6fff637 FS-Cache: Add the... |
837 |
#endif /* _LINUX_FSCACHE_H */ |