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 ([email protected])
   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  */
  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  */
  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  */
 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  */
 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  */
 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  */
 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  */
 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  */
 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);