Merge branch 'vfs-6.15.iomap' of...

   * **IOMAP_F_PRIVATE**: Starting with this value, the upper bits can

     be set by the filesystem for its own purposes.

   * **IOMAP_F_ANON_WRITE**: Indicates that (write) I/O does not have a target

     block assigned to it yet and the file system will do that in the bio

     submission handler, splitting the I/O as needed.

   These flags can be set by iomap itself during file operations.

   The filesystem should supply an ``->iomap_end`` function if it needs

   to observe these flags:

   ``IOMAP_NOWAIT`` is often set on behalf of ``IOCB_NOWAIT`` or

   ``RWF_NOWAIT``.

 * ``IOMAP_DONTCACHE`` is set when the caller wishes to perform a

   buffered file I/O and would like the kernel to drop the pagecache

   after the I/O completes, if it isn't already being used by another

   thread.

If it is necessary to read existing file contents from a `different

<https://lore.kernel.org/all/20191008071527.29304-9-hch@lst.de/>`_

device or address range on a device, the filesystem should return that

 * ``IOCB_NOWAIT``: Turns on ``IOMAP_NOWAIT``.

 * ``IOCB_DONTCACHE``: Turns on ``IOMAP_DONTCACHE``.

Internal per-Folio State

------------------------

 struct iomap_writeback_ops {

     int (*map_blocks)(struct iomap_writepage_ctx *wpc, struct inode *inode,

                       loff_t offset, unsigned len);

     int (*prepare_ioend)(struct iomap_ioend *ioend, int status);

     int (*submit_ioend)(struct iomap_writepage_ctx *wpc, int status);

     void (*discard_folio)(struct folio *folio, loff_t pos);

 };

    purpose.

    This function must be supplied by the filesystem.

  - ``prepare_ioend``: Enables filesystems to transform the writeback

    ioend or perform any other preparatory work before the writeback I/O

    is submitted.

  - ``submit_ioend``: Allows the file systems to hook into writeback bio

    submission.

    This might include pre-write space accounting updates, or installing

    a custom ``->bi_end_io`` function for internal purposes, such as

    deferring the ioend completion to a workqueue to run metadata update

    transactions from process context.

    transactions from process context before submitting the bio.

    This function is optional.

  - ``discard_folio``: iomap calls this function after ``->map_blocks``

storage device.

Filesystems that need to update internal bookkeeping (e.g. unwritten

extent conversions) should provide a ``->prepare_ioend`` function to

extent conversions) should provide a ``->submit_ioend`` function to

set ``struct iomap_end::bio::bi_end_io`` to its own function.

This function should call ``iomap_finish_ioends`` after finishing its

own work (e.g. unwritten extent conversion).

}

#endif /* CONFIG_FS_DAX_PMD */

static s64 dax_unshare_iter(struct iomap_iter *iter)

static int dax_unshare_iter(struct iomap_iter *iter)

{

	struct iomap *iomap = &iter->iomap;

	const struct iomap *srcmap = iomap_iter_srcmap(iter);

	u64 copy_len = iomap_length(iter);

	u32 mod;

	int id = 0;

	s64 ret = 0;

	s64 ret;

	void *daddr = NULL, *saddr = NULL;

	if (!iomap_want_unshare_iter(iter))

		return iomap_length(iter);

		return iomap_iter_advance_full(iter);

	/*

	 * Extend the file range to be aligned to fsblock/pagesize, because

	if (ret < 0)

		goto out_unlock;

	if (copy_mc_to_kernel(daddr, saddr, copy_len) == 0)

		ret = iomap_length(iter);

	else

	if (copy_mc_to_kernel(daddr, saddr, copy_len) != 0)

		ret = -EIO;

out_unlock:

	dax_read_unlock(id);

	if (ret < 0)

		return dax_mem2blk_err(ret);

	return iomap_iter_advance_full(iter);

}

int dax_file_unshare(struct inode *inode, loff_t pos, loff_t len,

	iter.len = min(len, size - pos);

	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = dax_unshare_iter(&iter);

		iter.status = dax_unshare_iter(&iter);

	return ret;

}

EXPORT_SYMBOL_GPL(dax_file_unshare);

	return ret;

}

static s64 dax_zero_iter(struct iomap_iter *iter, bool *did_zero)

static int dax_zero_iter(struct iomap_iter *iter, bool *did_zero)

{

	const struct iomap *iomap = &iter->iomap;

	const struct iomap *srcmap = iomap_iter_srcmap(iter);

	loff_t pos = iter->pos;

	u64 length = iomap_length(iter);

	s64 written = 0;

	int ret;

	/* already zeroed?  we're done. */

	if (srcmap->type == IOMAP_HOLE || srcmap->type == IOMAP_UNWRITTEN)

		return length;

		return iomap_iter_advance(iter, &length);

	/*

	 * invalidate the pages whose sharing state is to be changed

	 */

	if (iomap->flags & IOMAP_F_SHARED)

		invalidate_inode_pages2_range(iter->inode->i_mapping,

					      pos >> PAGE_SHIFT,

					      (pos + length - 1) >> PAGE_SHIFT);

				iter->pos >> PAGE_SHIFT,

				(iter->pos + length - 1) >> PAGE_SHIFT);

	do {

		loff_t pos = iter->pos;

		unsigned offset = offset_in_page(pos);

		unsigned size = min_t(u64, PAGE_SIZE - offset, length);

		pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);

		long rc;

		int id;

		length = min_t(u64, PAGE_SIZE - offset, length);

		id = dax_read_lock();

		if (IS_ALIGNED(pos, PAGE_SIZE) && size == PAGE_SIZE)

			rc = dax_zero_page_range(iomap->dax_dev, pgoff, 1);

		if (IS_ALIGNED(pos, PAGE_SIZE) && length == PAGE_SIZE)

			ret = dax_zero_page_range(iomap->dax_dev, pgoff, 1);

		else

			rc = dax_memzero(iter, pos, size);

			ret = dax_memzero(iter, pos, length);

		dax_read_unlock(id);

		if (rc < 0)

			return rc;

		pos += size;

		length -= size;

		written += size;

		if (ret < 0)

			return ret;

		ret = iomap_iter_advance(iter, &length);

		if (ret)

			return ret;

	} while (length > 0);

	if (did_zero)

		*did_zero = true;

	return written;

	return ret;

}

int dax_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero,

	int ret;

	while ((ret = iomap_iter(&iter, ops)) > 0)

		iter.processed = dax_zero_iter(&iter, did_zero);

		iter.status = dax_zero_iter(&iter, did_zero);

	return ret;

}

EXPORT_SYMBOL_GPL(dax_zero_range);

}

EXPORT_SYMBOL_GPL(dax_truncate_page);

static loff_t dax_iomap_iter(const struct iomap_iter *iomi,

		struct iov_iter *iter)

static int dax_iomap_iter(struct iomap_iter *iomi, struct iov_iter *iter)

{

	const struct iomap *iomap = &iomi->iomap;

	const struct iomap *srcmap = iomap_iter_srcmap(iomi);

		if (pos >= end)

			return 0;

		if (iomap->type == IOMAP_HOLE || iomap->type == IOMAP_UNWRITTEN)

			return iov_iter_zero(min(length, end - pos), iter);

		if (iomap->type == IOMAP_HOLE || iomap->type == IOMAP_UNWRITTEN) {

			done = iov_iter_zero(min(length, end - pos), iter);

			return iomap_iter_advance(iomi, &done);

		}

	}

	/*

	}

	id = dax_read_lock();

	while (pos < end) {

	while ((pos = iomi->pos) < end) {

		unsigned offset = pos & (PAGE_SIZE - 1);

		const size_t size = ALIGN(length + offset, PAGE_SIZE);

		pgoff_t pgoff = dax_iomap_pgoff(iomap, pos);

			xfer = dax_copy_to_iter(dax_dev, pgoff, kaddr,

					map_len, iter);

		pos += xfer;

		length -= xfer;

		done += xfer;

		if (xfer == 0)

		length = xfer;

		ret = iomap_iter_advance(iomi, &length);

		if (!ret && xfer == 0)

			ret = -EFAULT;

		if (xfer < map_len)

			break;

	}

	dax_read_unlock(id);

	return done ? done : ret;

	return ret;

}

/**

		iomi.flags |= IOMAP_NOWAIT;

	while ((ret = iomap_iter(&iomi, ops)) > 0)

		iomi.processed = dax_iomap_iter(&iomi, iter);

		iomi.status = dax_iomap_iter(&iomi, iter);

	done = iomi.pos - iocb->ki_pos;

	iocb->ki_pos = iomi.pos;

	while ((error = iomap_iter(&iter, ops)) > 0) {

		if (WARN_ON_ONCE(iomap_length(&iter) < PAGE_SIZE)) {

			iter.processed = -EIO;	/* fs corruption? */

			iter.status = -EIO;	/* fs corruption? */

			continue;

		}

			ret |= VM_FAULT_MAJOR;

		}

		if (!(ret & VM_FAULT_ERROR))

			iter.processed = PAGE_SIZE;

		if (!(ret & VM_FAULT_ERROR)) {

			u64 length = PAGE_SIZE;

			iter.status = iomap_iter_advance(&iter, &length);

		}

	}

	if (iomap_errp)

			continue; /* actually breaks out of the loop */

		ret = dax_fault_iter(vmf, &iter, pfnp, &xas, &entry, true);

		if (ret != VM_FAULT_FALLBACK)

			iter.processed = PMD_SIZE;

		if (ret != VM_FAULT_FALLBACK) {

			u64 length = PMD_SIZE;

			iter.status = iomap_iter_advance(&iter, &length);

		}

	}

unlock_entry:

}

EXPORT_SYMBOL_GPL(dax_finish_sync_fault);

static loff_t dax_range_compare_iter(struct iomap_iter *it_src,

static int dax_range_compare_iter(struct iomap_iter *it_src,

		struct iomap_iter *it_dest, u64 len, bool *same)

{

	const struct iomap *smap = &it_src->iomap;

	const struct iomap *dmap = &it_dest->iomap;

	loff_t pos1 = it_src->pos, pos2 = it_dest->pos;

	u64 dest_len;

	void *saddr, *daddr;

	int id, ret;

	if (smap->type == IOMAP_HOLE && dmap->type == IOMAP_HOLE) {

		*same = true;

		return len;

		goto advance;

	}

	if (smap->type == IOMAP_HOLE || dmap->type == IOMAP_HOLE) {

	if (!*same)

		len = 0;

	dax_read_unlock(id);

	return len;

advance:

	dest_len = len;

	ret = iomap_iter_advance(it_src, &len);

	if (!ret)

		ret = iomap_iter_advance(it_dest, &dest_len);

	return ret;

out_unlock:

	dax_read_unlock(id);

		.len		= len,

		.flags		= IOMAP_DAX,

	};

	int ret, compared = 0;

	int ret, status;

	while ((ret = iomap_iter(&src_iter, ops)) > 0 &&

	       (ret = iomap_iter(&dst_iter, ops)) > 0) {

		compared = dax_range_compare_iter(&src_iter, &dst_iter,

		status = dax_range_compare_iter(&src_iter, &dst_iter,

				min(src_iter.len, dst_iter.len), same);

		if (compared < 0)

		if (status < 0)

			return ret;

		src_iter.processed = dst_iter.processed = compared;

		src_iter.status = dst_iter.status = status;

	}

	return ret;

}

				 unsigned int length)

{

	BUG_ON(current->journal_info);

	return iomap_zero_range(inode, from, length, NULL, &gfs2_iomap_ops);

	return iomap_zero_range(inode, from, length, NULL, &gfs2_iomap_ops,

			NULL);

}

#define GFS2_JTRUNC_REVOKES 8192

				   iter.o

iomap-$(CONFIG_BLOCK)		+= buffered-io.o \

				   direct-io.o \

				   ioend.o \

				   fiemap.o \

				   seek.o

iomap-$(CONFIG_SWAP)		+= swapfile.o