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  * 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);