fs/netfs/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 struct fscache_write_request {
 162         struct netfs_cache_resources cache_resources;
 163         struct address_space    *mapping;
 164         loff_t                  start;
 165         size_t                  len;
 166         bool                    set_bits;
 167         netfs_io_terminated_t   term_func;
 168         void                    *term_func_priv;
 169 };
 170
 171 void __fscache_clear_page_bits(struct address_space *mapping,
 172                                loff_t start, size_t len)
 173 {
 174         pgoff_t first = start / PAGE_SIZE;
 175         pgoff_t last = (start + len - 1) / PAGE_SIZE;
 176         struct page *page;
 177
 178         if (len) {
 179                 XA_STATE(xas, &mapping->i_pages, first);
 180
 181                 rcu_read_lock();
 182                 xas_for_each(&xas, page, last) {
 183                         end_page_fscache(page);
 184                 }
 185                 rcu_read_unlock();
 186         }
 187 }
 188 EXPORT_SYMBOL(__fscache_clear_page_bits);
 189
 190 /*
 191  * Deal with the completion of writing the data to the cache.
 192  */
 193 static void fscache_wreq_done(void *priv, ssize_t transferred_or_error,
 194                               bool was_async)
 195 {
 196         struct fscache_write_request *wreq = priv;
 197
 198         fscache_clear_page_bits(wreq->mapping, wreq->start, wreq->len,
 199                                 wreq->set_bits);
 200
 201         if (wreq->term_func)
 202                 wreq->term_func(wreq->term_func_priv, transferred_or_error,
 203                                 was_async);
 204         fscache_end_operation(&wreq->cache_resources);
 205         kfree(wreq);
 206 }
 207
 208 void __fscache_write_to_cache(struct fscache_cookie *cookie,
 209                               struct address_space *mapping,
 210                               loff_t start, size_t len, loff_t i_size,
 211                               netfs_io_terminated_t term_func,
 212                               void *term_func_priv,
 213                               bool cond)
 214 {
 215         struct fscache_write_request *wreq;
 216         struct netfs_cache_resources *cres;
 217         struct iov_iter iter;
 218         int ret = -ENOBUFS;
 219
 220         if (len == 0)
 221                 goto abandon;
 222
 223         _enter("%llx,%zx", start, len);
 224
 225         wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS);
 226         if (!wreq)
 227                 goto abandon;
 228         wreq->mapping           = mapping;
 229         wreq->start             = start;
 230         wreq->len               = len;
 231         wreq->set_bits          = cond;
 232         wreq->term_func         = term_func;
 233         wreq->term_func_priv    = term_func_priv;
 234
 235         cres = &wreq->cache_resources;
 236         if (fscache_begin_operation(cres, cookie, FSCACHE_WANT_WRITE,
 237                                     fscache_access_io_write) < 0)
 238                 goto abandon_free;
 239
 240         ret = cres->ops->prepare_write(cres, &start, &len, len, i_size, false);
 241         if (ret < 0)
 242                 goto abandon_end;
 243
 244         /* TODO: Consider clearing page bits now for space the write isn't
 245          * covering.  This is more complicated than it appears when THPs are
 246          * taken into account.
 247          */
 248
 249         iov_iter_xarray(&iter, ITER_SOURCE, &mapping->i_pages, start, len);
 250         fscache_write(cres, start, &iter, fscache_wreq_done, wreq);
 251         return;
 252
 253 abandon_end:
 254         return fscache_wreq_done(wreq, ret, false);
 255 abandon_free:
 256         kfree(wreq);
 257 abandon:
 258         fscache_clear_page_bits(mapping, start, len, cond);
 259         if (term_func)
 260                 term_func(term_func_priv, ret, false);
 261 }
 262 EXPORT_SYMBOL(__fscache_write_to_cache);
 263
 264 /*
 265  * Change the size of a backing object.
 266  */
 267 void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
 268 {
 269         struct netfs_cache_resources cres;
 270
 271         trace_fscache_resize(cookie, new_size);
 272         if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
 273                                     fscache_access_io_resize) == 0) {
 274                 fscache_stat(&fscache_n_resizes);
 275                 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
 276
 277                 /* We cannot defer a resize as we need to do it inside the
 278                  * netfs's inode lock so that we're serialised with respect to
 279                  * writes.
 280                  */
 281                 cookie->volume->cache->ops->resize_cookie(&cres, new_size);
 282                 fscache_end_operation(&cres);
 283         } else {
 284                 fscache_stat(&fscache_n_resizes_null);
 285         }
 286 }
 287 EXPORT_SYMBOL(__fscache_resize_cookie);