]> Git Repo - J-linux.git/blob - fs/netfs/fscache_io.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / 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 ([email protected])
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 "internal.h"
13
14 /**
15  * fscache_wait_for_operation - Wait for an object become accessible
16  * @cres: The cache resources for the operation being performed
17  * @want_state: The minimum state the object must be at
18  *
19  * See if the target cache object is at the specified minimum state of
20  * accessibility yet, and if not, wait for it.
21  */
22 bool fscache_wait_for_operation(struct netfs_cache_resources *cres,
23                                 enum fscache_want_state want_state)
24 {
25         struct fscache_cookie *cookie = fscache_cres_cookie(cres);
26         enum fscache_cookie_state state;
27
28 again:
29         if (!fscache_cache_is_live(cookie->volume->cache)) {
30                 _leave(" [broken]");
31                 return false;
32         }
33
34         state = fscache_cookie_state(cookie);
35         _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
36
37         switch (state) {
38         case FSCACHE_COOKIE_STATE_CREATING:
39         case FSCACHE_COOKIE_STATE_INVALIDATING:
40                 if (want_state == FSCACHE_WANT_PARAMS)
41                         goto ready; /* There can be no content */
42                 fallthrough;
43         case FSCACHE_COOKIE_STATE_LOOKING_UP:
44         case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
45                 wait_var_event(&cookie->state,
46                                fscache_cookie_state(cookie) != state);
47                 goto again;
48
49         case FSCACHE_COOKIE_STATE_ACTIVE:
50                 goto ready;
51         case FSCACHE_COOKIE_STATE_DROPPED:
52         case FSCACHE_COOKIE_STATE_RELINQUISHING:
53         default:
54                 _leave(" [not live]");
55                 return false;
56         }
57
58 ready:
59         if (!cres->cache_priv2)
60                 return cookie->volume->cache->ops->begin_operation(cres, want_state);
61         return true;
62 }
63 EXPORT_SYMBOL(fscache_wait_for_operation);
64
65 /*
66  * Begin an I/O operation on the cache, waiting till we reach the right state.
67  *
68  * Attaches the resources required to the operation resources record.
69  */
70 static int fscache_begin_operation(struct netfs_cache_resources *cres,
71                                    struct fscache_cookie *cookie,
72                                    enum fscache_want_state want_state,
73                                    enum fscache_access_trace why)
74 {
75         enum fscache_cookie_state state;
76         long timeo;
77         bool once_only = false;
78
79         cres->ops               = NULL;
80         cres->cache_priv        = cookie;
81         cres->cache_priv2       = NULL;
82         cres->debug_id          = cookie->debug_id;
83         cres->inval_counter     = cookie->inval_counter;
84
85         if (!fscache_begin_cookie_access(cookie, why)) {
86                 cres->cache_priv = NULL;
87                 return -ENOBUFS;
88         }
89
90 again:
91         spin_lock(&cookie->lock);
92
93         state = fscache_cookie_state(cookie);
94         _enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
95
96         switch (state) {
97         case FSCACHE_COOKIE_STATE_LOOKING_UP:
98         case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
99         case FSCACHE_COOKIE_STATE_INVALIDATING:
100                 goto wait_for_file_wrangling;
101         case FSCACHE_COOKIE_STATE_CREATING:
102                 if (want_state == FSCACHE_WANT_PARAMS)
103                         goto ready; /* There can be no content */
104                 goto wait_for_file_wrangling;
105         case FSCACHE_COOKIE_STATE_ACTIVE:
106                 goto ready;
107         case FSCACHE_COOKIE_STATE_DROPPED:
108         case FSCACHE_COOKIE_STATE_RELINQUISHING:
109                 WARN(1, "Can't use cookie in state %u\n", cookie->state);
110                 goto not_live;
111         default:
112                 goto not_live;
113         }
114
115 ready:
116         spin_unlock(&cookie->lock);
117         if (!cookie->volume->cache->ops->begin_operation(cres, want_state))
118                 goto failed;
119         return 0;
120
121 wait_for_file_wrangling:
122         spin_unlock(&cookie->lock);
123         trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
124                              atomic_read(&cookie->n_accesses),
125                              fscache_access_io_wait);
126         timeo = wait_var_event_timeout(&cookie->state,
127                                        fscache_cookie_state(cookie) != state, 20 * HZ);
128         if (timeo <= 1 && !once_only) {
129                 pr_warn("%s: cookie state change wait timed out: cookie->state=%u state=%u",
130                         __func__, fscache_cookie_state(cookie), state);
131                 fscache_print_cookie(cookie, 'O');
132                 once_only = true;
133         }
134         goto again;
135
136 not_live:
137         spin_unlock(&cookie->lock);
138 failed:
139         cres->cache_priv = NULL;
140         cres->ops = NULL;
141         fscache_end_cookie_access(cookie, fscache_access_io_not_live);
142         _leave(" = -ENOBUFS");
143         return -ENOBUFS;
144 }
145
146 int __fscache_begin_read_operation(struct netfs_cache_resources *cres,
147                                    struct fscache_cookie *cookie)
148 {
149         return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
150                                        fscache_access_io_read);
151 }
152 EXPORT_SYMBOL(__fscache_begin_read_operation);
153
154 int __fscache_begin_write_operation(struct netfs_cache_resources *cres,
155                                     struct fscache_cookie *cookie)
156 {
157         return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
158                                        fscache_access_io_write);
159 }
160 EXPORT_SYMBOL(__fscache_begin_write_operation);
161
162 struct fscache_write_request {
163         struct netfs_cache_resources cache_resources;
164         struct address_space    *mapping;
165         loff_t                  start;
166         size_t                  len;
167         bool                    set_bits;
168         bool                    using_pgpriv2;
169         netfs_io_terminated_t   term_func;
170         void                    *term_func_priv;
171 };
172
173 void __fscache_clear_page_bits(struct address_space *mapping,
174                                loff_t start, size_t len)
175 {
176         pgoff_t first = start / PAGE_SIZE;
177         pgoff_t last = (start + len - 1) / PAGE_SIZE;
178         struct page *page;
179
180         if (len) {
181                 XA_STATE(xas, &mapping->i_pages, first);
182
183                 rcu_read_lock();
184                 xas_for_each(&xas, page, last) {
185                         folio_end_private_2(page_folio(page));
186                 }
187                 rcu_read_unlock();
188         }
189 }
190 EXPORT_SYMBOL(__fscache_clear_page_bits);
191
192 /*
193  * Deal with the completion of writing the data to the cache.
194  */
195 static void fscache_wreq_done(void *priv, ssize_t transferred_or_error,
196                               bool was_async)
197 {
198         struct fscache_write_request *wreq = priv;
199
200         if (wreq->using_pgpriv2)
201                 fscache_clear_page_bits(wreq->mapping, wreq->start, wreq->len,
202                                         wreq->set_bits);
203
204         if (wreq->term_func)
205                 wreq->term_func(wreq->term_func_priv, transferred_or_error,
206                                 was_async);
207         fscache_end_operation(&wreq->cache_resources);
208         kfree(wreq);
209 }
210
211 void __fscache_write_to_cache(struct fscache_cookie *cookie,
212                               struct address_space *mapping,
213                               loff_t start, size_t len, loff_t i_size,
214                               netfs_io_terminated_t term_func,
215                               void *term_func_priv,
216                               bool using_pgpriv2, bool cond)
217 {
218         struct fscache_write_request *wreq;
219         struct netfs_cache_resources *cres;
220         struct iov_iter iter;
221         int ret = -ENOBUFS;
222
223         if (len == 0)
224                 goto abandon;
225
226         _enter("%llx,%zx", start, len);
227
228         wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS);
229         if (!wreq)
230                 goto abandon;
231         wreq->mapping           = mapping;
232         wreq->start             = start;
233         wreq->len               = len;
234         wreq->using_pgpriv2     = using_pgpriv2;
235         wreq->set_bits          = cond;
236         wreq->term_func         = term_func;
237         wreq->term_func_priv    = term_func_priv;
238
239         cres = &wreq->cache_resources;
240         if (fscache_begin_operation(cres, cookie, FSCACHE_WANT_WRITE,
241                                     fscache_access_io_write) < 0)
242                 goto abandon_free;
243
244         ret = cres->ops->prepare_write(cres, &start, &len, len, i_size, false);
245         if (ret < 0)
246                 goto abandon_end;
247
248         /* TODO: Consider clearing page bits now for space the write isn't
249          * covering.  This is more complicated than it appears when THPs are
250          * taken into account.
251          */
252
253         iov_iter_xarray(&iter, ITER_SOURCE, &mapping->i_pages, start, len);
254         fscache_write(cres, start, &iter, fscache_wreq_done, wreq);
255         return;
256
257 abandon_end:
258         return fscache_wreq_done(wreq, ret, false);
259 abandon_free:
260         kfree(wreq);
261 abandon:
262         if (using_pgpriv2)
263                 fscache_clear_page_bits(mapping, start, len, cond);
264         if (term_func)
265                 term_func(term_func_priv, ret, false);
266 }
267 EXPORT_SYMBOL(__fscache_write_to_cache);
268
269 /*
270  * Change the size of a backing object.
271  */
272 void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
273 {
274         struct netfs_cache_resources cres;
275
276         trace_fscache_resize(cookie, new_size);
277         if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
278                                     fscache_access_io_resize) == 0) {
279                 fscache_stat(&fscache_n_resizes);
280                 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
281
282                 /* We cannot defer a resize as we need to do it inside the
283                  * netfs's inode lock so that we're serialised with respect to
284                  * writes.
285                  */
286                 cookie->volume->cache->ops->resize_cookie(&cres, new_size);
287                 fscache_end_operation(&cres);
288         } else {
289                 fscache_stat(&fscache_n_resizes_null);
290         }
291 }
292 EXPORT_SYMBOL(__fscache_resize_cookie);
This page took 0.042598 seconds and 4 git commands to generate.