Unverified Commit 5e1e6ec2 authored by David Howells's avatar David Howells Committed by Christian Brauner
Browse files

netfs: Merge i_size update functions 



Netfslib has two functions for updating the i_size after a write: one for
buffered writes into the pagecache and one for direct/unbuffered writes.
However, what needs to be done is much the same in both cases, so merge
them together.

This does raise one question, though: should updating the i_size after a
direct write do the same estimated update of i_blocks as is done for
buffered writes.

Also get rid of the cleanup function pointer from netfs_io_request as it's
only used for direct write to update i_size; instead do the i_size setting
directly from write collection.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Link: https://lore.kernel.org/20250701163852.2171681-12-dhowells@redhat.com


cc: Steve French <sfrench@samba.org>
cc: Paulo Alcantara <pc@manguebit.org>
cc: linux-cifs@vger.kernel.org
cc: netfs@lists.linux.dev
cc: linux-fsdevel@vger.kernel.org
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 2e065894

fs/netfs/buffered_write.c

+21 −15
Original line number Diff line number Diff line
@@ -53,21 +53,28 @@ static struct folio *netfs_grab_folio_for_write(struct address_space *mapping, 
 * data written into the pagecache until we can find out from the server what

 * the values actually are.

 */

static void netfs_update_i_size(struct netfs_inode *ctx, struct inode *inode,

				loff_t i_size, loff_t pos, size_t copied)

void netfs_update_i_size(struct netfs_inode *ctx, struct inode *inode,

			 loff_t pos, size_t copied)

{

	loff_t i_size, end = pos + copied;

	blkcnt_t add;

	size_t gap;



	if (end <= i_size_read(inode))

		return;



	if (ctx->ops->update_i_size) {

		ctx->ops->update_i_size(inode, pos);

		ctx->ops->update_i_size(inode, end);

		return;

	}



	spin_lock(&inode->i_lock);

	i_size_write(inode, pos);



	i_size = i_size_read(inode);

	if (end > i_size) {

		i_size_write(inode, end);

#if IS_ENABLED(CONFIG_FSCACHE)

	fscache_update_cookie(ctx->cache, NULL, &pos);

		fscache_update_cookie(ctx->cache, NULL, &end);

#endif



		gap = SECTOR_SIZE - (i_size & (SECTOR_SIZE - 1));
@@ -75,9 +82,10 @@ static void netfs_update_i_size(struct netfs_inode *ctx, struct inode *inode, 
			add = DIV_ROUND_UP(copied - gap, SECTOR_SIZE);



			inode->i_blocks = min_t(blkcnt_t,

					DIV_ROUND_UP(pos, SECTOR_SIZE),

						DIV_ROUND_UP(end, SECTOR_SIZE),

						inode->i_blocks + add);

		}

	}

	spin_unlock(&inode->i_lock);

}
@@ -113,7 +121,7 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, 
	struct folio *folio = NULL, *writethrough = NULL;

	unsigned int bdp_flags = (iocb->ki_flags & IOCB_NOWAIT) ? BDP_ASYNC : 0;

	ssize_t written = 0, ret, ret2;

	loff_t i_size, pos = iocb->ki_pos;

	loff_t pos = iocb->ki_pos;

	size_t max_chunk = mapping_max_folio_size(mapping);

	bool maybe_trouble = false;
@@ -346,10 +354,8 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, 
		flush_dcache_folio(folio);



		/* Update the inode size if we moved the EOF marker */

		netfs_update_i_size(ctx, inode, pos, copied);

		pos += copied;

		i_size = i_size_read(inode);

		if (pos > i_size)

			netfs_update_i_size(ctx, inode, i_size, pos, copied);

		written += copied;



		if (likely(!wreq)) {

fs/netfs/direct_write.c

+0 −19
Original line number Diff line number Diff line
@@ -9,24 +9,6 @@ 
#include <linux/uio.h>

#include "internal.h"



static void netfs_cleanup_dio_write(struct netfs_io_request *wreq)

{

	struct inode *inode = wreq->inode;

	unsigned long long end = wreq->start + wreq->transferred;



	if (wreq->error || end <= i_size_read(inode))

		return;



	spin_lock(&inode->i_lock);

	if (end > i_size_read(inode)) {

		if (wreq->netfs_ops->update_i_size)

			wreq->netfs_ops->update_i_size(inode, end);

		else

			i_size_write(inode, end);

	}

	spin_unlock(&inode->i_lock);

}



/*

 * Perform an unbuffered write where we may have to do an RMW operation on an

 * encrypted file.  This can also be used for direct I/O writes.
@@ -102,7 +84,6 @@ ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov_iter * 
	if (async)

		wreq->iocb = iocb;

	wreq->len = iov_iter_count(&wreq->buffer.iter);

	wreq->cleanup = netfs_cleanup_dio_write;

	ret = netfs_unbuffered_write(wreq, is_sync_kiocb(iocb), wreq->len);

	if (ret < 0) {

		_debug("begin = %zd", ret);

fs/netfs/internal.h

+6 −0
Original line number Diff line number Diff line
@@ -27,6 +27,12 @@ void netfs_cache_read_terminated(void *priv, ssize_t transferred_or_error); 
int netfs_prefetch_for_write(struct file *file, struct folio *folio,

			     size_t offset, size_t len);



/*

 * buffered_write.c

 */

void netfs_update_i_size(struct netfs_inode *ctx, struct inode *inode,

			 loff_t pos, size_t copied);



/*

 * main.c

 */

fs/netfs/write_collect.c

+4 −2
Original line number Diff line number Diff line
@@ -393,8 +393,10 @@ bool netfs_write_collection(struct netfs_io_request *wreq) 
		ictx->ops->invalidate_cache(wreq);

	}



	if (wreq->cleanup)

		wreq->cleanup(wreq);

	if ((wreq->origin == NETFS_UNBUFFERED_WRITE ||

	     wreq->origin == NETFS_DIO_WRITE) &&

	    !wreq->error)

		netfs_update_i_size(ictx, &ictx->inode, wreq->start, wreq->transferred);



	if (wreq->origin == NETFS_DIO_WRITE &&

	    wreq->mapping->nrpages) {

include/linux/netfs.h

+0 −1
Original line number Diff line number Diff line
@@ -279,7 +279,6 @@ struct netfs_io_request { 
#define NETFS_RREQ_USE_PGPRIV2		31	/* [DEPRECATED] Use PG_private_2 to mark

						 * write to cache on read */

	const struct netfs_request_ops *netfs_ops;

	void (*cleanup)(struct netfs_io_request *req);

};



/*