// SPDX-License-Identifier: GPL-2.0-only
/* Read with PG_private_2 [DEPRECATED].
 *
 * Copyright (C) 2024 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/export.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/task_io_accounting_ops.h>
#include "internal.h"

/*
 * [DEPRECATED] Copy a folio to the cache with PG_private_2 set.
 */
static void netfs_pgpriv2_copy_folio(struct netfs_io_request *creq, struct folio *folio)
{
 struct netfs_io_stream *cache = &creq->io_streams[1];
 size_t fsize = folio_size(folio), flen = fsize;
 loff_t fpos = folio_pos(folio), i_size;
 bool to_eof = false;

 _enter("");

 /* netfs_perform_write() may shift i_size around the page or from out
  * of the page to beyond it, but cannot move i_size into or through the
  * page since we have it locked.
 */
 i_size = i_size_read(creq->inode);

 if (fpos >= i_size) {
  /* mmap beyond eof. */
  _debug("beyond eof");
  folio_end_private_2(folio);
  return;
 }

 if (fpos + fsize > creq->i_size)
  creq->i_size = i_size;

 if (flen > i_size - fpos) {
  flen = i_size - fpos;
  to_eof = true;
 } else if (flen == i_size - fpos) {
  to_eof = true;
 }

 _debug("folio %zx %zx", flen, fsize);

 trace_netfs_folio(folio, netfs_folio_trace_store_copy);

 /* Attach the folio to the rolling buffer. */
 if (rolling_buffer_append(&creq->buffer, folio, 0) < 0) {
  clear_bit(NETFS_RREQ_FOLIO_COPY_TO_CACHE, &creq->flags);
  return;
 }

 cache->submit_extendable_to = fsize;
 cache->submit_off = 0;
 cache->submit_len = flen;

 /* Attach the folio to one or more subrequests.  For a big folio, we
  * could end up with thousands of subrequests if the wsize is small -
  * but we might need to wait during the creation of subrequests for
  * network resources (eg. SMB credits).
 */
 do {
  ssize_t part;

  creq->buffer.iter.iov_offset = cache->submit_off;

  atomic64_set(&creq->issued_to, fpos + cache->submit_off);
  cache->submit_extendable_to = fsize - cache->submit_off;
  part = netfs_advance_write(creq, cache, fpos + cache->submit_off,
        cache->submit_len, to_eof);
  cache->submit_off += part;
  if (part > cache->submit_len)
   cache->submit_len = 0;
  else
   cache->submit_len -= part;
 } while (cache->submit_len > 0);

 creq->buffer.iter.iov_offset = 0;
 rolling_buffer_advance(&creq->buffer, fsize);
 atomic64_set(&creq->issued_to, fpos + fsize);

 if (flen < fsize)
  netfs_issue_write(creq, cache);
}

/*
 * [DEPRECATED] Set up copying to the cache.
 */
static struct netfs_io_request *netfs_pgpriv2_begin_copy_to_cache(
 struct netfs_io_request *rreq, struct folio *folio)
{
 struct netfs_io_request *creq;

 if (!fscache_resources_valid(&rreq->cache_resources))
  goto cancel;

 creq = netfs_create_write_req(rreq->mapping, NULL, folio_pos(folio),
          NETFS_PGPRIV2_COPY_TO_CACHE);
 if (IS_ERR(creq))
  goto cancel;

 if (!creq->io_streams[1].avail)
  goto cancel_put;

 __set_bit(NETFS_RREQ_OFFLOAD_COLLECTION, &creq->flags);
 trace_netfs_copy2cache(rreq, creq);
 trace_netfs_write(creq, netfs_write_trace_copy_to_cache);
 netfs_stat(&netfs_n_wh_copy_to_cache);
 rreq->copy_to_cache = creq;
 return creq;

cancel_put:
 netfs_put_failed_request(creq);
cancel:
 rreq->copy_to_cache = ERR_PTR(-ENOBUFS);
 clear_bit(NETFS_RREQ_FOLIO_COPY_TO_CACHE, &rreq->flags);
 return ERR_PTR(-ENOBUFS);
}

/*
 * [DEPRECATED] Mark page as requiring copy-to-cache using PG_private_2 and add
 * it to the copy write request.
 */
void netfs_pgpriv2_copy_to_cache(struct netfs_io_request *rreq, struct folio *folio)
{
 struct netfs_io_request *creq = rreq->copy_to_cache;

 if (!creq)
  creq = netfs_pgpriv2_begin_copy_to_cache(rreq, folio);
 if (IS_ERR(creq))
  return;

 trace_netfs_folio(folio, netfs_folio_trace_copy_to_cache);
 folio_start_private_2(folio);
 netfs_pgpriv2_copy_folio(creq, folio);
}

/*
 * [DEPRECATED] End writing to the cache, flushing out any outstanding writes.
 */
void netfs_pgpriv2_end_copy_to_cache(struct netfs_io_request *rreq)
{
 struct netfs_io_request *creq = rreq->copy_to_cache;

 if (IS_ERR_OR_NULL(creq))
  return;

 netfs_issue_write(creq, &creq->io_streams[1]);
 smp_wmb(); /* Write lists before ALL_QUEUED. */
 set_bit(NETFS_RREQ_ALL_QUEUED, &creq->flags);
 trace_netfs_rreq(rreq, netfs_rreq_trace_end_copy_to_cache);
 if (list_empty_careful(&creq->io_streams[1].subrequests))
  netfs_wake_collector(creq);

 netfs_put_request(creq, netfs_rreq_trace_put_return);
 creq->copy_to_cache = NULL;
}

/*
 * [DEPRECATED] Remove the PG_private_2 mark from any folios we've finished
 * copying.
 */
bool netfs_pgpriv2_unlock_copied_folios(struct netfs_io_request *creq)
{
 struct folio_queue *folioq = creq->buffer.tail;
 unsigned long long collected_to = creq->collected_to;
 unsigned int slot = creq->buffer.first_tail_slot;
 bool made_progress = false;

 if (slot >= folioq_nr_slots(folioq)) {
  folioq = rolling_buffer_delete_spent(&creq->buffer);
  slot = 0;
 }

 for (;;) {
  struct folio *folio;
  unsigned long long fpos, fend;
  size_t fsize, flen;

  folio = folioq_folio(folioq, slot);
  if (WARN_ONCE(!folio_test_private_2(folio),
         "R=%08x: folio %lx is not marked private_2\n",
         creq->debug_id, folio->index))
   trace_netfs_folio(folio, netfs_folio_trace_not_under_wback);

  fpos = folio_pos(folio);
  fsize = folio_size(folio);
  flen = fsize;

  fend = min_t(unsigned long long, fpos + flen, creq->i_size);

  trace_netfs_collect_folio(creq, folio, fend, collected_to);

  /* Unlock any folio we've transferred all of. */
  if (collected_to < fend)
   break;

  trace_netfs_folio(folio, netfs_folio_trace_end_copy);
  folio_end_private_2(folio);
  creq->cleaned_to = fpos + fsize;
  made_progress = true;

  /* Clean up the head folioq.  If we clear an entire folioq, then
   * we can get rid of it provided it's not also the tail folioq
   * being filled by the issuer.
 */
  folioq_clear(folioq, slot);
  slot++;
  if (slot >= folioq_nr_slots(folioq)) {
   folioq = rolling_buffer_delete_spent(&creq->buffer);
   if (!folioq)
    goto done;
   slot = 0;
  }

  if (fpos + fsize >= collected_to)
   break;
 }

 creq->buffer.tail = folioq;
done:
 creq->buffer.first_tail_slot = slot;
 return made_progress;
}