fs/fscache/io.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Cache data I/O routines
   3  *
   4  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7 #define FSCACHE_DEBUG_LEVEL OPERATION
   8 #include <linux/fscache-cache.h>
   9 #include <linux/uio.h>
  10 #include <linux/bvec.h>
  11 #include <linux/slab.h>
  12 #include <linux/uio.h>
  13 #include "internal.h"
  14
  15 /**
  16  * fscache_wait_for_operation - Wait for an object become accessible
  17  * @cres: The cache resources for the operation being performed
  18  * @want_state: The minimum state the object must be at
  19  *
  20  * See if the target cache object is at the specified minimum state of
  21  * accessibility yet, and if not, wait for it.
  22  */
  23 bool fscache_wait_for_operation(struct netfs_cache_resources *cres,
  24                                 enum fscache_want_state want_state)
  25 {
  26         struct fscache_cookie *cookie = fscache_cres_cookie(cres);
  27         enum fscache_cookie_state state;
  28
  29 again:
  30         if (!fscache_cache_is_live(cookie->volume->cache)) {
  31                 _leave(" [broken]");
  32                 return false;
  33         }
  34
  35         state = fscache_cookie_state(cookie);
  36         _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
  37
  38         switch (state) {
  39         case FSCACHE_COOKIE_STATE_CREATING:
  40         case FSCACHE_COOKIE_STATE_INVALIDATING:
  41                 if (want_state == FSCACHE_WANT_PARAMS)
  42                         goto ready; /* There can be no content */
  43                 fallthrough;
  44         case FSCACHE_COOKIE_STATE_LOOKING_UP:
  45         case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
  46                 wait_var_event(&cookie->state,
  47                                fscache_cookie_state(cookie) != state);
  48                 goto again;
  49
  50         case FSCACHE_COOKIE_STATE_ACTIVE:
  51                 goto ready;
  52         case FSCACHE_COOKIE_STATE_DROPPED:
  53         case FSCACHE_COOKIE_STATE_RELINQUISHING:
  54         default:
  55                 _leave(" [not live]");
  56                 return false;
  57         }
  58
  59 ready:
  60         if (!cres->cache_priv2)
  61                 return cookie->volume->cache->ops->begin_operation(cres, want_state);
  62         return true;
  63 }
  64 EXPORT_SYMBOL(fscache_wait_for_operation);
  65
  66 /*
  67  * Begin an I/O operation on the cache, waiting till we reach the right state.
  68  *
  69  * Attaches the resources required to the operation resources record.
  70  */
  71 static int fscache_begin_operation(struct netfs_cache_resources *cres,
  72                                    struct fscache_cookie *cookie,
  73                                    enum fscache_want_state want_state,
  74                                    enum fscache_access_trace why)
  75 {
  76         enum fscache_cookie_state state;
  77         long timeo;
  78         bool once_only = false;
  79
  80         cres->ops               = NULL;
  81         cres->cache_priv        = cookie;
  82         cres->cache_priv2       = NULL;
  83         cres->debug_id          = cookie->debug_id;
  84         cres->inval_counter     = cookie->inval_counter;
  85
  86         if (!fscache_begin_cookie_access(cookie, why))
  87                 return -ENOBUFS;
  88
  89 again:
  90         spin_lock(&cookie->lock);
  91
  92         state = fscache_cookie_state(cookie);
  93         _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
  94
  95         switch (state) {
  96         case FSCACHE_COOKIE_STATE_LOOKING_UP:
  97         case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
  98         case FSCACHE_COOKIE_STATE_INVALIDATING:
  99                 goto wait_for_file_wrangling;
 100         case FSCACHE_COOKIE_STATE_CREATING:
 101                 if (want_state == FSCACHE_WANT_PARAMS)
 102                         goto ready; /* There can be no content */
 103                 goto wait_for_file_wrangling;
 104         case FSCACHE_COOKIE_STATE_ACTIVE:
 105                 goto ready;
 106         case FSCACHE_COOKIE_STATE_DROPPED:
 107         case FSCACHE_COOKIE_STATE_RELINQUISHING:
 108                 WARN(1, "Can't use cookie in state %u\n", cookie->state);
 109                 goto not_live;
 110         default:
 111                 goto not_live;
 112         }
 113
 114 ready:
 115         spin_unlock(&cookie->lock);
 116         if (!cookie->volume->cache->ops->begin_operation(cres, want_state))
 117                 goto failed;
 118         return 0;
 119
 120 wait_for_file_wrangling:
 121         spin_unlock(&cookie->lock);
 122         trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
 123                              atomic_read(&cookie->n_accesses),
 124                              fscache_access_io_wait);
 125         timeo = wait_var_event_timeout(&cookie->state,
 126                                        fscache_cookie_state(cookie) != state, 20 * HZ);
 127         if (timeo <= 1 && !once_only) {
 128                 pr_warn("%s: cookie state change wait timed out: cookie->state=%u state=%u",
 129                         __func__, fscache_cookie_state(cookie), state);
 130                 fscache_print_cookie(cookie, 'O');
 131                 once_only = true;
 132         }
 133         goto again;
 134
 135 not_live:
 136         spin_unlock(&cookie->lock);
 137 failed:
 138         cres->cache_priv = NULL;
 139         cres->ops = NULL;
 140         fscache_end_cookie_access(cookie, fscache_access_io_not_live);
 141         _leave(" = -ENOBUFS");
 142         return -ENOBUFS;
 143 }
 144
 145 int __fscache_begin_read_operation(struct netfs_cache_resources *cres,
 146                                    struct fscache_cookie *cookie)
 147 {
 148         return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
 149                                        fscache_access_io_read);
 150 }
 151 EXPORT_SYMBOL(__fscache_begin_read_operation);
 152
 153 int __fscache_begin_write_operation(struct netfs_cache_resources *cres,
 154                                     struct fscache_cookie *cookie)
 155 {
 156         return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
 157                                        fscache_access_io_write);
 158 }
 159 EXPORT_SYMBOL(__fscache_begin_write_operation);
 160
 161 /**
 162  * fscache_dirty_folio - Mark folio dirty and pin a cache object for writeback
 163  * @mapping: The mapping the folio belongs to.
 164  * @folio: The folio being dirtied.
 165  * @cookie: The cookie referring to the cache object
 166  *
 167  * Set the dirty flag on a folio and pin an in-use cache object in memory
 168  * so that writeback can later write to it.  This is intended
 169  * to be called from the filesystem's ->dirty_folio() method.
 170  *
 171  * Return: true if the dirty flag was set on the folio, false otherwise.
 172  */
 173 bool fscache_dirty_folio(struct address_space *mapping, struct folio *folio,
 174                                 struct fscache_cookie *cookie)
 175 {
 176         struct inode *inode = mapping->host;
 177         bool need_use = false;
 178
 179         _enter("");
 180
 181         if (!filemap_dirty_folio(mapping, folio))
 182                 return false;
 183         if (!fscache_cookie_valid(cookie))
 184                 return true;
 185
 186         if (!(inode->i_state & I_PINNING_FSCACHE_WB)) {
 187                 spin_lock(&inode->i_lock);
 188                 if (!(inode->i_state & I_PINNING_FSCACHE_WB)) {
 189                         inode->i_state |= I_PINNING_FSCACHE_WB;
 190                         need_use = true;
 191                 }
 192                 spin_unlock(&inode->i_lock);
 193
 194                 if (need_use)
 195                         fscache_use_cookie(cookie, true);
 196         }
 197         return true;
 198 }
 199 EXPORT_SYMBOL(fscache_dirty_folio);
 200
 201 struct fscache_write_request {
 202         struct netfs_cache_resources cache_resources;
 203         struct address_space    *mapping;
 204         loff_t                  start;
 205         size_t                  len;
 206         bool                    set_bits;
 207         netfs_io_terminated_t   term_func;
 208         void                    *term_func_priv;
 209 };
 210
 211 void __fscache_clear_page_bits(struct address_space *mapping,
 212                                loff_t start, size_t len)
 213 {
 214         pgoff_t first = start / PAGE_SIZE;
 215         pgoff_t last = (start + len - 1) / PAGE_SIZE;
 216         struct page *page;
 217
 218         if (len) {
 219                 XA_STATE(xas, &mapping->i_pages, first);
 220
 221                 rcu_read_lock();
 222                 xas_for_each(&xas, page, last) {
 223                         end_page_fscache(page);
 224                 }
 225                 rcu_read_unlock();
 226         }
 227 }
 228 EXPORT_SYMBOL(__fscache_clear_page_bits);
 229
 230 /*
 231  * Deal with the completion of writing the data to the cache.
 232  */
 233 static void fscache_wreq_done(void *priv, ssize_t transferred_or_error,
 234                               bool was_async)
 235 {
 236         struct fscache_write_request *wreq = priv;
 237
 238         fscache_clear_page_bits(wreq->mapping, wreq->start, wreq->len,
 239                                 wreq->set_bits);
 240
 241         if (wreq->term_func)
 242                 wreq->term_func(wreq->term_func_priv, transferred_or_error,
 243                                 was_async);
 244         fscache_end_operation(&wreq->cache_resources);
 245         kfree(wreq);
 246 }
 247
 248 void __fscache_write_to_cache(struct fscache_cookie *cookie,
 249                               struct address_space *mapping,
 250                               loff_t start, size_t len, loff_t i_size,
 251                               netfs_io_terminated_t term_func,
 252                               void *term_func_priv,
 253                               bool cond)
 254 {
 255         struct fscache_write_request *wreq;
 256         struct netfs_cache_resources *cres;
 257         struct iov_iter iter;
 258         int ret = -ENOBUFS;
 259
 260         if (len == 0)
 261                 goto abandon;
 262
 263         _enter("%llx,%zx", start, len);
 264
 265         wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS);
 266         if (!wreq)
 267                 goto abandon;
 268         wreq->mapping           = mapping;
 269         wreq->start             = start;
 270         wreq->len               = len;
 271         wreq->set_bits          = cond;
 272         wreq->term_func         = term_func;
 273         wreq->term_func_priv    = term_func_priv;
 274
 275         cres = &wreq->cache_resources;
 276         if (fscache_begin_operation(cres, cookie, FSCACHE_WANT_WRITE,
 277                                     fscache_access_io_write) < 0)
 278                 goto abandon_free;
 279
 280         ret = cres->ops->prepare_write(cres, &start, &len, i_size, false);
 281         if (ret < 0)
 282                 goto abandon_end;
 283
 284         /* TODO: Consider clearing page bits now for space the write isn't
 285          * covering.  This is more complicated than it appears when THPs are
 286          * taken into account.
 287          */
 288
 289         iov_iter_xarray(&iter, WRITE, &mapping->i_pages, start, len);
 290         fscache_write(cres, start, &iter, fscache_wreq_done, wreq);
 291         return;
 292
 293 abandon_end:
 294         return fscache_wreq_done(wreq, ret, false);
 295 abandon_free:
 296         kfree(wreq);
 297 abandon:
 298         fscache_clear_page_bits(mapping, start, len, cond);
 299         if (term_func)
 300                 term_func(term_func_priv, ret, false);
 301 }
 302 EXPORT_SYMBOL(__fscache_write_to_cache);
 303
 304 /*
 305  * Change the size of a backing object.
 306  */
 307 void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
 308 {
 309         struct netfs_cache_resources cres;
 310
 311         trace_fscache_resize(cookie, new_size);
 312         if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
 313                                     fscache_access_io_resize) == 0) {
 314                 fscache_stat(&fscache_n_resizes);
 315                 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
 316
 317                 /* We cannot defer a resize as we need to do it inside the
 318                  * netfs's inode lock so that we're serialised with respect to
 319                  * writes.
 320                  */
 321                 cookie->volume->cache->ops->resize_cookie(&cres, new_size);
 322                 fscache_end_operation(&cres);
 323         } else {
 324                 fscache_stat(&fscache_n_resizes_null);
 325         }
 326 }
 327 EXPORT_SYMBOL(__fscache_resize_cookie);