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(&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 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, &cookie->flags); 648} 649 650#endif /* _LINUX_FSCACHE_H */ 651