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_dirty_folio - Mark folio dirty and pin a cache object for writeback 13 * @mapping: The mapping the folio belongs to. 14 * @folio: The folio being dirtied. 15 * 16 * Set the dirty flag on a folio and pin an in-use cache object in memory so 17 * that writeback can later write to it. This is intended to be called from 18 * the filesystem's ->dirty_folio() method. 19 * 20 * Return: true if the dirty flag was set on the folio, false otherwise. 21 */ 22 bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio) 23 { 24 struct inode *inode = mapping->host; 25 struct netfs_inode *ictx = netfs_inode(inode); 26 struct fscache_cookie *cookie = netfs_i_cookie(ictx); 27 bool need_use = false; 28 29 _enter(""); 30 31 if (!filemap_dirty_folio(mapping, folio)) 32 return false; 33 if (!fscache_cookie_valid(cookie)) 34 return true; 35 36 if (!(inode->i_state & I_PINNING_NETFS_WB)) { 37 spin_lock(&inode->i_lock); 38 if (!(inode->i_state & I_PINNING_NETFS_WB)) { 39 inode->i_state |= I_PINNING_NETFS_WB; 40 need_use = true; 41 } 42 spin_unlock(&inode->i_lock); 43 44 if (need_use) 45 fscache_use_cookie(cookie, true); 46 } 47 return true; 48 } 49 EXPORT_SYMBOL(netfs_dirty_folio); 50 51 /** 52 * netfs_unpin_writeback - Unpin writeback resources 53 * @inode: The inode on which the cookie resides 54 * @wbc: The writeback control 55 * 56 * Unpin the writeback resources pinned by netfs_dirty_folio(). This is 57 * intended to be called as/by the netfs's ->write_inode() method. 58 */ 59 int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc) 60 { 61 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode)); 62 63 if (wbc->unpinned_netfs_wb) 64 fscache_unuse_cookie(cookie, NULL, NULL); 65 return 0; 66 } 67 EXPORT_SYMBOL(netfs_unpin_writeback); 68 69 /** 70 * netfs_clear_inode_writeback - Clear writeback resources pinned by an inode 71 * @inode: The inode to clean up 72 * @aux: Auxiliary data to apply to the inode 73 * 74 * Clear any writeback resources held by an inode when the inode is evicted. 75 * This must be called before clear_inode() is called. 76 */ 77 void netfs_clear_inode_writeback(struct inode *inode, const void *aux) 78 { 79 struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode)); 80 81 if (inode->i_state & I_PINNING_NETFS_WB) { 82 loff_t i_size = i_size_read(inode); 83 fscache_unuse_cookie(cookie, aux, &i_size); 84 } 85 } 86 EXPORT_SYMBOL(netfs_clear_inode_writeback); 87 88 /** 89 * netfs_invalidate_folio - Invalidate or partially invalidate a folio 90 * @folio: Folio proposed for release 91 * @offset: Offset of the invalidated region 92 * @length: Length of the invalidated region 93 * 94 * Invalidate part or all of a folio for a network filesystem. The folio will 95 * be removed afterwards if the invalidated region covers the entire folio. 96 */ 97 void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length) 98 { 99 struct netfs_folio *finfo; 100 struct netfs_inode *ctx = netfs_inode(folio_inode(folio)); 101 size_t flen = folio_size(folio); 102 103 _enter("{%lx},%zx,%zx", folio->index, offset, length); 104 105 if (offset == 0 && length == flen) { 106 unsigned long long i_size = i_size_read(&ctx->inode); 107 unsigned long long fpos = folio_pos(folio), end; 108 109 end = umin(fpos + flen, i_size); 110 if (fpos < i_size && end > ctx->zero_point) 111 ctx->zero_point = end; 112 } 113 114 folio_wait_private_2(folio); /* [DEPRECATED] */ 115 116 if (!folio_test_private(folio)) 117 return; 118 119 finfo = netfs_folio_info(folio); 120 121 if (offset == 0 && length >= flen) 122 goto erase_completely; 123 124 if (finfo) { 125 /* We have a partially uptodate page from a streaming write. */ 126 unsigned int fstart = finfo->dirty_offset; 127 unsigned int fend = fstart + finfo->dirty_len; 128 unsigned int iend = offset + length; 129 130 if (offset >= fend) 131 return; 132 if (iend <= fstart) 133 return; 134 135 /* The invalidation region overlaps the data. If the region 136 * covers the start of the data, we either move along the start 137 * or just erase the data entirely. 138 */ 139 if (offset <= fstart) { 140 if (iend >= fend) 141 goto erase_completely; 142 /* Move the start of the data. */ 143 finfo->dirty_len = fend - iend; 144 finfo->dirty_offset = offset; 145 return; 146 } 147 148 /* Reduce the length of the data if the invalidation region 149 * covers the tail part. 150 */ 151 if (iend >= fend) { 152 finfo->dirty_len = offset - fstart; 153 return; 154 } 155 156 /* A partial write was split. The caller has already zeroed 157 * it, so just absorb the hole. 158 */ 159 } 160 return; 161 162 erase_completely: 163 netfs_put_group(netfs_folio_group(folio)); 164 folio_detach_private(folio); 165 folio_clear_uptodate(folio); 166 kfree(finfo); 167 return; 168 } 169 EXPORT_SYMBOL(netfs_invalidate_folio); 170 171 /** 172 * netfs_release_folio - Try to release a folio 173 * @folio: Folio proposed for release 174 * @gfp: Flags qualifying the release 175 * 176 * Request release of a folio and clean up its private state if it's not busy. 177 * Returns true if the folio can now be released, false if not 178 */ 179 bool netfs_release_folio(struct folio *folio, gfp_t gfp) 180 { 181 struct netfs_inode *ctx = netfs_inode(folio_inode(folio)); 182 unsigned long long end; 183 184 if (folio_test_dirty(folio)) 185 return false; 186 187 end = umin(folio_pos(folio) + folio_size(folio), i_size_read(&ctx->inode)); 188 if (end > ctx->zero_point) 189 ctx->zero_point = end; 190 191 if (folio_test_private(folio)) 192 return false; 193 if (unlikely(folio_test_private_2(folio))) { /* [DEPRECATED] */ 194 if (current_is_kswapd() || !(gfp & __GFP_FS)) 195 return false; 196 folio_wait_private_2(folio); 197 } 198 fscache_note_page_release(netfs_i_cookie(ctx)); 199 return true; 200 } 201 EXPORT_SYMBOL(netfs_release_folio); 202