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 * Make sure there's space in the rolling queue. 13 */ 14 struct folio_queue *netfs_buffer_make_space(struct netfs_io_request *rreq) 15 { 16 struct folio_queue *tail = rreq->buffer_tail, *prev; 17 unsigned int prev_nr_slots = 0; 18 19 if (WARN_ON_ONCE(!rreq->buffer && tail) || 20 WARN_ON_ONCE(rreq->buffer && !tail)) 21 return ERR_PTR(-EIO); 22 23 prev = tail; 24 if (prev) { 25 if (!folioq_full(tail)) 26 return tail; 27 prev_nr_slots = folioq_nr_slots(tail); 28 } 29 30 tail = kmalloc(sizeof(*tail), GFP_NOFS); 31 if (!tail) 32 return ERR_PTR(-ENOMEM); 33 netfs_stat(&netfs_n_folioq); 34 folioq_init(tail); 35 tail->prev = prev; 36 if (prev) 37 /* [!] NOTE: After we set prev->next, the consumer is entirely 38 * at liberty to delete prev. 39 */ 40 WRITE_ONCE(prev->next, tail); 41 42 rreq->buffer_tail = tail; 43 if (!rreq->buffer) { 44 rreq->buffer = tail; 45 iov_iter_folio_queue(&rreq->io_iter, ITER_SOURCE, tail, 0, 0, 0); 46 } else { 47 /* Make sure we don't leave the master iterator pointing to a 48 * block that might get immediately consumed. 49 */ 50 if (rreq->io_iter.folioq == prev && 51 rreq->io_iter.folioq_slot == prev_nr_slots) { 52 rreq->io_iter.folioq = tail; 53 rreq->io_iter.folioq_slot = 0; 54 } 55 } 56 rreq->buffer_tail_slot = 0; 57 return tail; 58 } 59 60 /* 61 * Append a folio to the rolling queue. 62 */ 63 int netfs_buffer_append_folio(struct netfs_io_request *rreq, struct folio *folio, 64 bool needs_put) 65 { 66 struct folio_queue *tail; 67 unsigned int slot, order = folio_order(folio); 68 69 tail = netfs_buffer_make_space(rreq); 70 if (IS_ERR(tail)) 71 return PTR_ERR(tail); 72 73 rreq->io_iter.count += PAGE_SIZE << order; 74 75 slot = folioq_append(tail, folio); 76 /* Store the counter after setting the slot. */ 77 smp_store_release(&rreq->buffer_tail_slot, slot); 78 return 0; 79 } 80 81 /* 82 * Delete the head of a rolling queue. 83 */ 84 struct folio_queue *netfs_delete_buffer_head(struct netfs_io_request *wreq) 85 { 86 struct folio_queue *head = wreq->buffer, *next = head->next; 87 88 if (next) 89 next->prev = NULL; 90 netfs_stat_d(&netfs_n_folioq); 91 kfree(head); 92 wreq->buffer = next; 93 return next; 94 } 95 96 /* 97 * Clear out a rolling queue. 98 */ 99 void netfs_clear_buffer(struct netfs_io_request *rreq) 100 { 101 struct folio_queue *p; 102 103 while ((p = rreq->buffer)) { 104 rreq->buffer = p->next; 105 for (int slot = 0; slot < folioq_count(p); slot++) { 106 struct folio *folio = folioq_folio(p, slot); 107 if (!folio) 108 continue; 109 if (folioq_is_marked(p, slot)) { 110 trace_netfs_folio(folio, netfs_folio_trace_put); 111 folio_put(folio); 112 } 113 } 114 netfs_stat_d(&netfs_n_folioq); 115 kfree(p); 116 } 117 } 118 119 /* 120 * Reset the subrequest iterator to refer just to the region remaining to be 121 * read. The iterator may or may not have been advanced by socket ops or 122 * extraction ops to an extent that may or may not match the amount actually 123 * read. 124 */ 125 void netfs_reset_iter(struct netfs_io_subrequest *subreq) 126 { 127 struct iov_iter *io_iter = &subreq->io_iter; 128 size_t remain = subreq->len - subreq->transferred; 129 130 if (io_iter->count > remain) 131 iov_iter_advance(io_iter, io_iter->count - remain); 132 else if (io_iter->count < remain) 133 iov_iter_revert(io_iter, remain - io_iter->count); 134 iov_iter_truncate(&subreq->io_iter, remain); 135 } 136 137 /** 138 * netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback 139 * @mapping: The mapping the folio belongs to. 140 * @folio: The folio being dirtied. 141 * 142 * Set the dirty flag on a folio and pin an in-use cache object in memory so 143 * that writeback can later write to it. This is intended to be called from 144 * the filesystem's ->dirty_folio() method. 145 * 146 * Return: true if the dirty flag was set on the folio, false otherwise. 147 */ 148 bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio) 149 { 150 struct inode *inode = mapping->host; 151 struct netfs_inode *ictx = netfs_inode(inode); 152 struct fscache_cookie *cookie = netfs_i_cookie(ictx); 153 bool need_use = false; 154 155 _enter(""); 156 157 if (!filemap_dirty_folio(mapping, folio)) 158 return false; 159 if (!fscache_cookie_valid(cookie)) 160 return true; 161 162 if (!(inode->i_state & I_PINNING_NETFS_WB)) { 163 spin_lock(&inode->i_lock); 164 if (!(inode->i_state & I_PINNING_NETFS_WB)) { 165 inode->i_state |= I_PINNING_NETFS_WB; 166 need_use = true; 167 } 168 spin_unlock(&inode->i_lock); 169 170 if (need_use) 171 fscache_use_cookie(cookie, true); 172 } 173 return true; 174 } 175 EXPORT_SYMBOL(netfs_dirty_folio); 176 177 /** 178 * netfs_unpin_writeback - Unpin writeback resources 179 * @inode: The inode on which the cookie resides 180 * @wbc: The writeback control 181 * 182 * Unpin the writeback resources pinned by netfs_dirty_folio(). This is 183 * intended to be called as/by the netfs's ->write_inode() method. 184 */ 185 int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc) 186 { 187 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode)); 188 189 if (wbc->unpinned_netfs_wb) 190 fscache_unuse_cookie(cookie, NULL, NULL); 191 return 0; 192 } 193 EXPORT_SYMBOL(netfs_unpin_writeback); 194 195 /** 196 * netfs_clear_inode_writeback - Clear writeback resources pinned by an inode 197 * @inode: The inode to clean up 198 * @aux: Auxiliary data to apply to the inode 199 * 200 * Clear any writeback resources held by an inode when the inode is evicted. 201 * This must be called before clear_inode() is called. 202 */ 203 void netfs_clear_inode_writeback(struct inode *inode, const void *aux) 204 { 205 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode)); 206 207 if (inode->i_state & I_PINNING_NETFS_WB) { 208 loff_t i_size = i_size_read(inode); 209 fscache_unuse_cookie(cookie, aux, &i_size); 210 } 211 } 212 EXPORT_SYMBOL(netfs_clear_inode_writeback); 213 214 /** 215 * netfs_invalidate_folio - Invalidate or partially invalidate a folio 216 * @folio: Folio proposed for release 217 * @offset: Offset of the invalidated region 218 * @length: Length of the invalidated region 219 * 220 * Invalidate part or all of a folio for a network filesystem. The folio will 221 * be removed afterwards if the invalidated region covers the entire folio. 222 */ 223 void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length) 224 { 225 struct netfs_folio *finfo; 226 struct netfs_inode *ctx = netfs_inode(folio_inode(folio)); 227 size_t flen = folio_size(folio); 228 229 _enter("{%lx},%zx,%zx", folio->index, offset, length); 230 231 if (offset == 0 && length == flen) { 232 unsigned long long i_size = i_size_read(&ctx->inode); 233 unsigned long long fpos = folio_pos(folio), end; 234 235 end = umin(fpos + flen, i_size); 236 if (fpos < i_size && end > ctx->zero_point) 237 ctx->zero_point = end; 238 } 239 240 folio_wait_private_2(folio); /* [DEPRECATED] */ 241 242 if (!folio_test_private(folio)) 243 return; 244 245 finfo = netfs_folio_info(folio); 246 247 if (offset == 0 && length >= flen) 248 goto erase_completely; 249 250 if (finfo) { 251 /* We have a partially uptodate page from a streaming write. */ 252 unsigned int fstart = finfo->dirty_offset; 253 unsigned int fend = fstart + finfo->dirty_len; 254 unsigned int iend = offset + length; 255 256 if (offset >= fend) 257 return; 258 if (iend <= fstart) 259 return; 260 261 /* The invalidation region overlaps the data. If the region 262 * covers the start of the data, we either move along the start 263 * or just erase the data entirely. 264 */ 265 if (offset <= fstart) { 266 if (iend >= fend) 267 goto erase_completely; 268 /* Move the start of the data. */ 269 finfo->dirty_len = fend - iend; 270 finfo->dirty_offset = offset; 271 return; 272 } 273 274 /* Reduce the length of the data if the invalidation region 275 * covers the tail part. 276 */ 277 if (iend >= fend) { 278 finfo->dirty_len = offset - fstart; 279 return; 280 } 281 282 /* A partial write was split. The caller has already zeroed 283 * it, so just absorb the hole. 284 */ 285 } 286 return; 287 288 erase_completely: 289 netfs_put_group(netfs_folio_group(folio)); 290 folio_detach_private(folio); 291 folio_clear_uptodate(folio); 292 kfree(finfo); 293 return; 294 } 295 EXPORT_SYMBOL(netfs_invalidate_folio); 296 297 /** 298 * netfs_release_folio - Try to release a folio 299 * @folio: Folio proposed for release 300 * @gfp: Flags qualifying the release 301 * 302 * Request release of a folio and clean up its private state if it's not busy. 303 * Returns true if the folio can now be released, false if not 304 */ 305 bool netfs_release_folio(struct folio *folio, gfp_t gfp) 306 { 307 struct netfs_inode *ctx = netfs_inode(folio_inode(folio)); 308 unsigned long long end; 309 310 if (folio_test_dirty(folio)) 311 return false; 312 313 end = umin(folio_pos(folio) + folio_size(folio), i_size_read(&ctx->inode)); 314 if (end > ctx->zero_point) 315 ctx->zero_point = end; 316 317 if (folio_test_private(folio)) 318 return false; 319 if (unlikely(folio_test_private_2(folio))) { /* [DEPRECATED] */ 320 if (current_is_kswapd() || !(gfp & __GFP_FS)) 321 return false; 322 folio_wait_private_2(folio); 323 } 324 fscache_note_page_release(netfs_i_cookie(ctx)); 325 return true; 326 } 327 EXPORT_SYMBOL(netfs_release_folio); 328