include/linux/fscache.h

   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
  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 */
  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
  46 enum fscache_want_state {
  47         FSCACHE_WANT_PARAMS,
  48         FSCACHE_WANT_WRITE,
  49         FSCACHE_WANT_READ,
  50 };
  51
  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 */
  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  */
  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         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  */
 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 */
 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  */
 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
 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);
 167 extern void __fscache_use_cookie(struct fscache_cookie *, bool);
 168 extern void __fscache_unuse_cookie(struct fscache_cookie *, const void *, const loff_t *);
 169 extern void __fscache_relinquish_cookie(struct fscache_cookie *, bool);
 170 extern void __fscache_resize_cookie(struct fscache_cookie *, loff_t);
 171 extern void __fscache_invalidate(struct fscache_cookie *, const void *, loff_t, unsigned int);
 172 extern int __fscache_begin_read_operation(struct netfs_cache_resources *, struct fscache_cookie *);
 173 extern int __fscache_begin_write_operation(struct netfs_cache_resources *, struct fscache_cookie *);
 174
 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
 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
 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
 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  */
 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
 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  */
 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
 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
 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
 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
 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  */
 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
 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
 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
 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
 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
 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
 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
 576 /**
 577  * fscache_clear_page_bits - Clear the PG_fscache bits from a set of pages
 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  */
 586 static inline void fscache_clear_page_bits(struct address_space *mapping,
 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
 632 #if __fscache_available
 633 bool fscache_dirty_folio(struct address_space *mapping, struct folio *folio,
 634                 struct fscache_cookie *cookie);
 635 #else
 636 #define fscache_dirty_folio(MAPPING, FOLIO, COOKIE) \
 637                 filemap_dirty_folio(MAPPING, FOLIO)
 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  *
 645  * Unpin the writeback resources pinned by fscache_dirty_folio().  This is
 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
 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 {
 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          */
 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
 695 #endif /* _LINUX_FSCACHE_H */