1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Miscellaneous routines.
3 *
4 * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/swap.h>
9 #include "internal.h"
10
11 /**
12 * netfs_alloc_folioq_buffer - Allocate buffer space into a folio queue
13 * @mapping: Address space to set on the folio (or NULL).
14 * @_buffer: Pointer to the folio queue to add to (may point to a NULL; updated).
15 * @_cur_size: Current size of the buffer (updated).
16 * @size: Target size of the buffer.
17 * @gfp: The allocation constraints.
18 */
netfs_alloc_folioq_buffer(struct address_space * mapping,struct folio_queue ** _buffer,size_t * _cur_size,ssize_t size,gfp_t gfp)19 int netfs_alloc_folioq_buffer(struct address_space *mapping,
20 struct folio_queue **_buffer,
21 size_t *_cur_size, ssize_t size, gfp_t gfp)
22 {
23 struct folio_queue *tail = *_buffer, *p;
24
25 size = round_up(size, PAGE_SIZE);
26 if (*_cur_size >= size)
27 return 0;
28
29 if (tail)
30 while (tail->next)
31 tail = tail->next;
32
33 do {
34 struct folio *folio;
35 int order = 0, slot;
36
37 if (!tail || folioq_full(tail)) {
38 p = netfs_folioq_alloc(0, GFP_NOFS, netfs_trace_folioq_alloc_buffer);
39 if (!p)
40 return -ENOMEM;
41 if (tail) {
42 tail->next = p;
43 p->prev = tail;
44 } else {
45 *_buffer = p;
46 }
47 tail = p;
48 }
49
50 if (size - *_cur_size > PAGE_SIZE)
51 order = umin(ilog2(size - *_cur_size) - PAGE_SHIFT,
52 MAX_PAGECACHE_ORDER);
53
54 folio = folio_alloc(gfp, order);
55 if (!folio && order > 0)
56 folio = folio_alloc(gfp, 0);
57 if (!folio)
58 return -ENOMEM;
59
60 folio->mapping = mapping;
61 folio->index = *_cur_size / PAGE_SIZE;
62 trace_netfs_folio(folio, netfs_folio_trace_alloc_buffer);
63 slot = folioq_append_mark(tail, folio);
64 *_cur_size += folioq_folio_size(tail, slot);
65 } while (*_cur_size < size);
66
67 return 0;
68 }
69 EXPORT_SYMBOL(netfs_alloc_folioq_buffer);
70
71 /**
72 * netfs_free_folioq_buffer - Free a folio queue.
73 * @fq: The start of the folio queue to free
74 *
75 * Free up a chain of folio_queues and, if marked, the marked folios they point
76 * to.
77 */
netfs_free_folioq_buffer(struct folio_queue * fq)78 void netfs_free_folioq_buffer(struct folio_queue *fq)
79 {
80 struct folio_queue *next;
81 struct folio_batch fbatch;
82
83 folio_batch_init(&fbatch);
84
85 for (; fq; fq = next) {
86 for (int slot = 0; slot < folioq_count(fq); slot++) {
87 struct folio *folio = folioq_folio(fq, slot);
88
89 if (!folio ||
90 !folioq_is_marked(fq, slot))
91 continue;
92
93 trace_netfs_folio(folio, netfs_folio_trace_put);
94 if (folio_batch_add(&fbatch, folio))
95 folio_batch_release(&fbatch);
96 }
97
98 netfs_stat_d(&netfs_n_folioq);
99 next = fq->next;
100 kfree(fq);
101 }
102
103 folio_batch_release(&fbatch);
104 }
105 EXPORT_SYMBOL(netfs_free_folioq_buffer);
106
107 /*
108 * Reset the subrequest iterator to refer just to the region remaining to be
109 * read. The iterator may or may not have been advanced by socket ops or
110 * extraction ops to an extent that may or may not match the amount actually
111 * read.
112 */
netfs_reset_iter(struct netfs_io_subrequest * subreq)113 void netfs_reset_iter(struct netfs_io_subrequest *subreq)
114 {
115 struct iov_iter *io_iter = &subreq->io_iter;
116 size_t remain = subreq->len - subreq->transferred;
117
118 if (io_iter->count > remain)
119 iov_iter_advance(io_iter, io_iter->count - remain);
120 else if (io_iter->count < remain)
121 iov_iter_revert(io_iter, remain - io_iter->count);
122 iov_iter_truncate(&subreq->io_iter, remain);
123 }
124
125 /**
126 * netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback
127 * @mapping: The mapping the folio belongs to.
128 * @folio: The folio being dirtied.
129 *
130 * Set the dirty flag on a folio and pin an in-use cache object in memory so
131 * that writeback can later write to it. This is intended to be called from
132 * the filesystem's ->dirty_folio() method.
133 *
134 * Return: true if the dirty flag was set on the folio, false otherwise.
135 */
netfs_dirty_folio(struct address_space * mapping,struct folio * folio)136 bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio)
137 {
138 struct inode *inode = mapping->host;
139 struct netfs_inode *ictx = netfs_inode(inode);
140 struct fscache_cookie *cookie = netfs_i_cookie(ictx);
141 bool need_use = false;
142
143 _enter("");
144
145 if (!filemap_dirty_folio(mapping, folio))
146 return false;
147 if (!fscache_cookie_valid(cookie))
148 return true;
149
150 if (!(inode->i_state & I_PINNING_NETFS_WB)) {
151 spin_lock(&inode->i_lock);
152 if (!(inode->i_state & I_PINNING_NETFS_WB)) {
153 inode->i_state |= I_PINNING_NETFS_WB;
154 need_use = true;
155 }
156 spin_unlock(&inode->i_lock);
157
158 if (need_use)
159 fscache_use_cookie(cookie, true);
160 }
161 return true;
162 }
163 EXPORT_SYMBOL(netfs_dirty_folio);
164
165 /**
166 * netfs_unpin_writeback - Unpin writeback resources
167 * @inode: The inode on which the cookie resides
168 * @wbc: The writeback control
169 *
170 * Unpin the writeback resources pinned by netfs_dirty_folio(). This is
171 * intended to be called as/by the netfs's ->write_inode() method.
172 */
netfs_unpin_writeback(struct inode * inode,struct writeback_control * wbc)173 int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc)
174 {
175 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
176
177 if (wbc->unpinned_netfs_wb)
178 fscache_unuse_cookie(cookie, NULL, NULL);
179 return 0;
180 }
181 EXPORT_SYMBOL(netfs_unpin_writeback);
182
183 /**
184 * netfs_clear_inode_writeback - Clear writeback resources pinned by an inode
185 * @inode: The inode to clean up
186 * @aux: Auxiliary data to apply to the inode
187 *
188 * Clear any writeback resources held by an inode when the inode is evicted.
189 * This must be called before clear_inode() is called.
190 */
netfs_clear_inode_writeback(struct inode * inode,const void * aux)191 void netfs_clear_inode_writeback(struct inode *inode, const void *aux)
192 {
193 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
194
195 if (inode->i_state & I_PINNING_NETFS_WB) {
196 loff_t i_size = i_size_read(inode);
197 fscache_unuse_cookie(cookie, aux, &i_size);
198 }
199 }
200 EXPORT_SYMBOL(netfs_clear_inode_writeback);
201
202 /**
203 * netfs_invalidate_folio - Invalidate or partially invalidate a folio
204 * @folio: Folio proposed for release
205 * @offset: Offset of the invalidated region
206 * @length: Length of the invalidated region
207 *
208 * Invalidate part or all of a folio for a network filesystem. The folio will
209 * be removed afterwards if the invalidated region covers the entire folio.
210 */
netfs_invalidate_folio(struct folio * folio,size_t offset,size_t length)211 void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
212 {
213 struct netfs_folio *finfo;
214 struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
215 size_t flen = folio_size(folio);
216
217 _enter("{%lx},%zx,%zx", folio->index, offset, length);
218
219 if (offset == 0 && length == flen) {
220 unsigned long long i_size = i_size_read(&ctx->inode);
221 unsigned long long fpos = folio_pos(folio), end;
222
223 end = umin(fpos + flen, i_size);
224 if (fpos < i_size && end > ctx->zero_point)
225 ctx->zero_point = end;
226 }
227
228 folio_wait_private_2(folio); /* [DEPRECATED] */
229
230 if (!folio_test_private(folio))
231 return;
232
233 finfo = netfs_folio_info(folio);
234
235 if (offset == 0 && length >= flen)
236 goto erase_completely;
237
238 if (finfo) {
239 /* We have a partially uptodate page from a streaming write. */
240 unsigned int fstart = finfo->dirty_offset;
241 unsigned int fend = fstart + finfo->dirty_len;
242 unsigned int iend = offset + length;
243
244 if (offset >= fend)
245 return;
246 if (iend <= fstart)
247 return;
248
249 /* The invalidation region overlaps the data. If the region
250 * covers the start of the data, we either move along the start
251 * or just erase the data entirely.
252 */
253 if (offset <= fstart) {
254 if (iend >= fend)
255 goto erase_completely;
256 /* Move the start of the data. */
257 finfo->dirty_len = fend - iend;
258 finfo->dirty_offset = offset;
259 return;
260 }
261
262 /* Reduce the length of the data if the invalidation region
263 * covers the tail part.
264 */
265 if (iend >= fend) {
266 finfo->dirty_len = offset - fstart;
267 return;
268 }
269
270 /* A partial write was split. The caller has already zeroed
271 * it, so just absorb the hole.
272 */
273 }
274 return;
275
276 erase_completely:
277 netfs_put_group(netfs_folio_group(folio));
278 folio_detach_private(folio);
279 folio_clear_uptodate(folio);
280 kfree(finfo);
281 return;
282 }
283 EXPORT_SYMBOL(netfs_invalidate_folio);
284
285 /**
286 * netfs_release_folio - Try to release a folio
287 * @folio: Folio proposed for release
288 * @gfp: Flags qualifying the release
289 *
290 * Request release of a folio and clean up its private state if it's not busy.
291 * Returns true if the folio can now be released, false if not
292 */
netfs_release_folio(struct folio * folio,gfp_t gfp)293 bool netfs_release_folio(struct folio *folio, gfp_t gfp)
294 {
295 struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
296 unsigned long long end;
297
298 if (folio_test_dirty(folio))
299 return false;
300
301 end = umin(folio_pos(folio) + folio_size(folio), i_size_read(&ctx->inode));
302 if (end > ctx->zero_point)
303 ctx->zero_point = end;
304
305 if (folio_test_private(folio))
306 return false;
307 if (unlikely(folio_test_private_2(folio))) { /* [DEPRECATED] */
308 if (current_is_kswapd() || !(gfp & __GFP_FS))
309 return false;
310 folio_wait_private_2(folio);
311 }
312 fscache_note_page_release(netfs_i_cookie(ctx));
313 return true;
314 }
315 EXPORT_SYMBOL(netfs_release_folio);
316