fs/netfs/misc.c

   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  * Attach a folio to the buffer and maybe set marks on it to say that we need
  13  * to put the folio later and twiddle the pagecache flags.
  14  */
  15 int netfs_xa_store_and_mark(struct xarray *xa, unsigned long index,
  16                             struct folio *folio, unsigned int flags,
  17                             gfp_t gfp_mask)
  18 {
  19         XA_STATE_ORDER(xas, xa, index, folio_order(folio));
  20
  21 retry:
  22         xas_lock(&xas);
  23         for (;;) {
  24                 xas_store(&xas, folio);
  25                 if (!xas_error(&xas))
  26                         break;
  27                 xas_unlock(&xas);
  28                 if (!xas_nomem(&xas, gfp_mask))
  29                         return xas_error(&xas);
  30                 goto retry;
  31         }
  32
  33         if (flags & NETFS_FLAG_PUT_MARK)
  34                 xas_set_mark(&xas, NETFS_BUF_PUT_MARK);
  35         if (flags & NETFS_FLAG_PAGECACHE_MARK)
  36                 xas_set_mark(&xas, NETFS_BUF_PAGECACHE_MARK);
  37         xas_unlock(&xas);
  38         return xas_error(&xas);
  39 }
  40
  41 /*
  42  * Create the specified range of folios in the buffer attached to the read
  43  * request.  The folios are marked with NETFS_BUF_PUT_MARK so that we know that
  44  * these need freeing later.
  45  */
  46 int netfs_add_folios_to_buffer(struct xarray *buffer,
  47                                struct address_space *mapping,
  48                                pgoff_t index, pgoff_t to, gfp_t gfp_mask)
  49 {
  50         struct folio *folio;
  51         int ret;
  52
  53         if (to + 1 == index) /* Page range is inclusive */
  54                 return 0;
  55
  56         do {
  57                 /* TODO: Figure out what order folio can be allocated here */
  58                 folio = filemap_alloc_folio(readahead_gfp_mask(mapping), 0);
  59                 if (!folio)
  60                         return -ENOMEM;
  61                 folio->index = index;
  62                 ret = netfs_xa_store_and_mark(buffer, index, folio,
  63                                               NETFS_FLAG_PUT_MARK, gfp_mask);
  64                 if (ret < 0) {
  65                         folio_put(folio);
  66                         return ret;
  67                 }
  68
  69                 index += folio_nr_pages(folio);
  70         } while (index <= to && index != 0);
  71
  72         return 0;
  73 }
  74
  75 /*
  76  * Clear an xarray buffer, putting a ref on the folios that have
  77  * NETFS_BUF_PUT_MARK set.
  78  */
  79 void netfs_clear_buffer(struct xarray *buffer)
  80 {
  81         struct folio *folio;
  82         XA_STATE(xas, buffer, 0);
  83
  84         rcu_read_lock();
  85         xas_for_each_marked(&xas, folio, ULONG_MAX, NETFS_BUF_PUT_MARK) {
  86                 folio_put(folio);
  87         }
  88         rcu_read_unlock();
  89         xa_destroy(buffer);
  90 }
  91
  92 /**
  93  * netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback
  94  * @mapping: The mapping the folio belongs to.
  95  * @folio: The folio being dirtied.
  96  *
  97  * Set the dirty flag on a folio and pin an in-use cache object in memory so
  98  * that writeback can later write to it.  This is intended to be called from
  99  * the filesystem's ->dirty_folio() method.
 100  *
 101  * Return: true if the dirty flag was set on the folio, false otherwise.
 102  */
 103 bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio)
 104 {
 105         struct inode *inode = mapping->host;
 106         struct netfs_inode *ictx = netfs_inode(inode);
 107         struct fscache_cookie *cookie = netfs_i_cookie(ictx);
 108         bool need_use = false;
 109
 110         _enter("");
 111
 112         if (!filemap_dirty_folio(mapping, folio))
 113                 return false;
 114         if (!fscache_cookie_valid(cookie))
 115                 return true;
 116
 117         if (!(inode->i_state & I_PINNING_NETFS_WB)) {
 118                 spin_lock(&inode->i_lock);
 119                 if (!(inode->i_state & I_PINNING_NETFS_WB)) {
 120                         inode->i_state |= I_PINNING_NETFS_WB;
 121                         need_use = true;
 122                 }
 123                 spin_unlock(&inode->i_lock);
 124
 125                 if (need_use)
 126                         fscache_use_cookie(cookie, true);
 127         }
 128         return true;
 129 }
 130 EXPORT_SYMBOL(netfs_dirty_folio);
 131
 132 /**
 133  * netfs_unpin_writeback - Unpin writeback resources
 134  * @inode: The inode on which the cookie resides
 135  * @wbc: The writeback control
 136  *
 137  * Unpin the writeback resources pinned by netfs_dirty_folio().  This is
 138  * intended to be called as/by the netfs's ->write_inode() method.
 139  */
 140 int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc)
 141 {
 142         struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
 143
 144         if (wbc->unpinned_netfs_wb)
 145                 fscache_unuse_cookie(cookie, NULL, NULL);
 146         return 0;
 147 }
 148 EXPORT_SYMBOL(netfs_unpin_writeback);
 149
 150 /**
 151  * netfs_clear_inode_writeback - Clear writeback resources pinned by an inode
 152  * @inode: The inode to clean up
 153  * @aux: Auxiliary data to apply to the inode
 154  *
 155  * Clear any writeback resources held by an inode when the inode is evicted.
 156  * This must be called before clear_inode() is called.
 157  */
 158 void netfs_clear_inode_writeback(struct inode *inode, const void *aux)
 159 {
 160         struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
 161
 162         if (inode->i_state & I_PINNING_NETFS_WB) {
 163                 loff_t i_size = i_size_read(inode);
 164                 fscache_unuse_cookie(cookie, aux, &i_size);
 165         }
 166 }
 167 EXPORT_SYMBOL(netfs_clear_inode_writeback);
 168
 169 /**
 170  * netfs_invalidate_folio - Invalidate or partially invalidate a folio
 171  * @folio: Folio proposed for release
 172  * @offset: Offset of the invalidated region
 173  * @length: Length of the invalidated region
 174  *
 175  * Invalidate part or all of a folio for a network filesystem.  The folio will
 176  * be removed afterwards if the invalidated region covers the entire folio.
 177  */
 178 void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
 179 {
 180         struct netfs_folio *finfo = NULL;
 181         size_t flen = folio_size(folio);
 182
 183         _enter("{%lx},%zx,%zx", folio_index(folio), offset, length);
 184
 185         folio_wait_fscache(folio);
 186
 187         if (!folio_test_private(folio))
 188                 return;
 189
 190         finfo = netfs_folio_info(folio);
 191
 192         if (offset == 0 && length >= flen)
 193                 goto erase_completely;
 194
 195         if (finfo) {
 196                 /* We have a partially uptodate page from a streaming write. */
 197                 unsigned int fstart = finfo->dirty_offset;
 198                 unsigned int fend = fstart + finfo->dirty_len;
 199                 unsigned int end = offset + length;
 200
 201                 if (offset >= fend)
 202                         return;
 203                 if (end <= fstart)
 204                         return;
 205                 if (offset <= fstart && end >= fend)
 206                         goto erase_completely;
 207                 if (offset <= fstart && end > fstart)
 208                         goto reduce_len;
 209                 if (offset > fstart && end >= fend)
 210                         goto move_start;
 211                 /* A partial write was split.  The caller has already zeroed
 212                  * it, so just absorb the hole.
 213                  */
 214         }
 215         return;
 216
 217 erase_completely:
 218         netfs_put_group(netfs_folio_group(folio));
 219         folio_detach_private(folio);
 220         folio_clear_uptodate(folio);
 221         kfree(finfo);
 222         return;
 223 reduce_len:
 224         finfo->dirty_len = offset + length - finfo->dirty_offset;
 225         return;
 226 move_start:
 227         finfo->dirty_len -= offset - finfo->dirty_offset;
 228         finfo->dirty_offset = offset;
 229 }
 230 EXPORT_SYMBOL(netfs_invalidate_folio);
 231
 232 /**
 233  * netfs_release_folio - Try to release a folio
 234  * @folio: Folio proposed for release
 235  * @gfp: Flags qualifying the release
 236  *
 237  * Request release of a folio and clean up its private state if it's not busy.
 238  * Returns true if the folio can now be released, false if not
 239  */
 240 bool netfs_release_folio(struct folio *folio, gfp_t gfp)
 241 {
 242         struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
 243         unsigned long long end;
 244
 245         end = folio_pos(folio) + folio_size(folio);
 246         if (end > ctx->zero_point)
 247                 ctx->zero_point = end;
 248
 249         if (folio_test_private(folio))
 250                 return false;
 251         if (folio_test_fscache(folio)) {
 252                 if (current_is_kswapd() || !(gfp & __GFP_FS))
 253                         return false;
 254                 folio_wait_fscache(folio);
 255         }
 256
 257         fscache_note_page_release(netfs_i_cookie(ctx));
 258         return true;
 259 }
 260 EXPORT_SYMBOL(netfs_release_folio);