From patchwork Thu Mar 28 16:34:13 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 13609090 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5B93CCD1283 for ; Thu, 28 Mar 2024 16:38:40 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id E3E216B00C1; Thu, 28 Mar 2024 12:38:39 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id DC6516B00C3; Thu, 28 Mar 2024 12:38:39 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id C3FD06B00C4; Thu, 28 Mar 2024 12:38:39 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id A2B2B6B00C1 for ; Thu, 28 Mar 2024 12:38:39 -0400 (EDT) Received: from smtpin12.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 645A3C0AD1 for ; Thu, 28 Mar 2024 16:38:39 +0000 (UTC) X-FDA: 81947006358.12.52948C0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by imf27.hostedemail.com (Postfix) with ESMTP id AA4EC4001D for ; Thu, 28 Mar 2024 16:38:37 +0000 (UTC) Authentication-Results: imf27.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b=iSLl8rIK; dmarc=pass (policy=none) header.from=redhat.com; spf=pass (imf27.hostedemail.com: domain of dhowells@redhat.com designates 170.10.129.124 as permitted sender) smtp.mailfrom=dhowells@redhat.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1711643917; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=08BQVB5a47a8ZK8FFbOaylpdSd6N4VkCmtEx277bjMw=; b=E1ofEIXnBoq9k89vG+Dh2yMWaWksirZb2/a75MlKxpV0s7HX4GYgAmh19C2ClrfewNL8SW ma97DFgt5huFVdbwroJUweGNw9vMoSbm5gKzuCaa8zSVUdBe9G3CvjYu3Egv1FY5Sm+ALO jqxeNYnNo5+MjobI4dVhrd83nx4lXtc= ARC-Authentication-Results: i=1; imf27.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b=iSLl8rIK; dmarc=pass (policy=none) header.from=redhat.com; spf=pass (imf27.hostedemail.com: domain of dhowells@redhat.com designates 170.10.129.124 as permitted sender) smtp.mailfrom=dhowells@redhat.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1711643917; a=rsa-sha256; cv=none; b=XmQ73ZZvHPSMd556jxuYs4hFMS2OFOosTvkbxnJuNNPyBAefANGSdJXDXl8HjtDkXsF8k0 Uv50Nj3HXFHGdd47B3SJqTKUtMJpZJIjZZGTPR5k9m8o7bIgcygWBgiXg0+/LTynxr1DNl Y6rOYKjI8uYhqbTEWTg97N4S+8P194M= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1711643917; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=08BQVB5a47a8ZK8FFbOaylpdSd6N4VkCmtEx277bjMw=; b=iSLl8rIKdkCrvTAif7HoZFYvift5i7UdTdGlKt2Uo3Lk75jewP+8LYa1GgPhDXmhzJn6IL 90rGXGUOUEDvUgp+/mRBr9HUUorBqFux71HNh4MKXXs5XuceSmsd5lhi6EYmMt7I9OXr1A wttlxw7QIxvKdqaqw7OGW11rfZlwH4Q= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-187-ESNBE_2_P8S2T8AJ9Ud0UA-1; Thu, 28 Mar 2024 12:38:34 -0400 X-MC-Unique: ESNBE_2_P8S2T8AJ9Ud0UA-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id CC456857E7C; Thu, 28 Mar 2024 16:38:31 +0000 (UTC) Received: from warthog.procyon.org.com (unknown [10.42.28.146]) by smtp.corp.redhat.com (Postfix) with ESMTP id 9D693200A384; Thu, 28 Mar 2024 16:38:28 +0000 (UTC) From: David Howells To: Christian Brauner , Jeff Layton , Gao Xiang , Dominique Martinet Cc: David Howells , Matthew Wilcox , Steve French , Marc Dionne , Paulo Alcantara , Shyam Prasad N , Tom Talpey , Eric Van Hensbergen , Ilya Dryomov , netfs@lists.linux.dev, linux-cachefs@redhat.com, linux-afs@lists.infradead.org, linux-cifs@vger.kernel.org, linux-nfs@vger.kernel.org, ceph-devel@vger.kernel.org, v9fs@lists.linux.dev, linux-erofs@lists.ozlabs.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, Latchesar Ionkov , Christian Schoenebeck Subject: [PATCH 21/26] netfs, 9p: Implement helpers for new write code Date: Thu, 28 Mar 2024 16:34:13 +0000 Message-ID: <20240328163424.2781320-22-dhowells@redhat.com> In-Reply-To: <20240328163424.2781320-1-dhowells@redhat.com> References: <20240328163424.2781320-1-dhowells@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.4 X-Rspam-User: X-Stat-Signature: c9ssm9e5k7kcdwwiu14y8dzqu73tm4zn X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: AA4EC4001D X-HE-Tag: 1711643917-777430 X-HE-Meta: U2FsdGVkX18X7r1y1vaGwTZVt5BCzEl2ZEvJvKUu+EJaitqqAw24iWS5FMOXmKx11qicTLv7uGKqlzO7nd4qLMb7FkqhK6R2/Lv5q0RLNjH7Dw/lRNycnuSCzWiwLNX8gc3Ii5G7h7JxjgLllbetcezMGUAvCn9MBn7U/NkAvhT/Vu56SD1ECROV/iJxpkLTQSXgxofVgqJBukULr1wdA/yc7EbvHtE2rdKxofR8dc7IFJRa1jx885GVxG3zPTJEFdW+hJ1bF+uifu+m17/BXHXryLDFFpWWxNTwapRc4D/Nr/4fTzG2Bcv9Hk+tF6246uxnZkZyqp347Q6HP17sX/DwzCPN0P82LTyrPga4czAM6jHKX/SX8KrtxnLK3CnAWxLaVI3FjiUewonr4w2Q9OGjwISwqzF1s2jtNo4Wa0aJ7eLUyCMJcXBwI4EeWetz0lifNCcAKNmCBGO3b3ZAhfi6OWrIfig872sUY3Kjx1cENswtcU+FGiO9FDamCICRQKG8VdYmqjVoFcIM/5mJY2WysEXllmDpuz4cYrPCe0sfq39KqG2A3pP6y66a6xncUfE7fYdiuRSNLsfak5+bSoaKkIXlbky54UBP4XmrXcfJ2xZeu4yOYDfJik5vEtna+RZa1uyOc6q5Z6BvE/Z7qWneufXZYOrUhu7PGO//p0YBQLPa3Fi+19lBbXeTu6n1UI+x3mNMBYL+FNGKD9VG7UEywzt2bMkSvS6Jrq9d5YBkei35Kzm6N4hWEpTfJIAm9suD16jUzyz7klvIvboCbR1HVMsVLTkq5s9cptPGdgxC5hR+2WupU3RZudmk/jgB5mUiRTGeNfB06RR3mDB5TLOtkj0T6OZ47Tz+esr0tIA5YXdtnIY/M6GHod7Fzk1qJsCpDEWPEZEZtB5txO2s59BTeB7OAAWcWIb8WZd0dwSguaA+76BB5Nn6XCWzoCiwqmrSnJ8ga8FypFVy8cT lCRPfimQ fV8Ge5IMzx9IyZfqCYUi+gqbIpdG5RJ5ZzR0HsuZxpkN6JEQWO51selxemh4uEjH54jqCO0/sl728g+ryrOVSNtdp0ftLwTztDHydGb7/rPFdXvFkpfTAEOupiUVKikN1lZ9fFDVHg1neIxDq861iKR63+F64s7txgavqweR3On5Zda0tR+f7z9EVIq0/hkTgJvg/SfmyrkUGqUf0274pNTqKe3EPZsmEFKXfInJF6cC2J2X7UuJFxUXGMblttDns6fU2CXNXjWn/MRDieP3zmX+T1l/P7lGi+EyC8m2RvN7Rb+8UR980O9au6kjLncil1G7bilc5bpdKDZKbdiK9oo0eR+ED8Uy+3HxLArQLU+xVmfT74A7q8Vo8DPU5VkxnjBFsuPDrNvFdInbX1zY0+Sfn3J8UXLt4j8PUfe6XPdAS6BaDj5Frcm5UZw== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Implement the helpers for the new write code in 9p. There's now an optional ->prepare_write() that allows the filesystem to set the parameters for the next write, such as maximum size and maximum segment count, and an ->issue_write() that is called to initiate an (asynchronous) write operation. Signed-off-by: David Howells cc: Eric Van Hensbergen cc: Latchesar Ionkov cc: Dominique Martinet cc: Christian Schoenebeck cc: Jeff Layton cc: v9fs@lists.linux.dev cc: netfs@lists.linux.dev cc: linux-fsdevel@vger.kernel.org --- fs/9p/vfs_addr.c | 48 ++++++++++++++++++++++++++++++++++++++++ include/net/9p/client.h | 2 ++ net/9p/Kconfig | 1 + net/9p/client.c | 49 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 100 insertions(+) diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c index 5a943c122d83..07d03efdd594 100644 --- a/fs/9p/vfs_addr.c +++ b/fs/9p/vfs_addr.c @@ -26,6 +26,40 @@ #include "cache.h" #include "fid.h" +/* + * Writeback calls this when it finds a folio that needs uploading. This isn't + * called if writeback only has copy-to-cache to deal with. + */ +static void v9fs_begin_writeback(struct netfs_io_request *wreq) +{ + struct p9_fid *fid; + + fid = v9fs_fid_find_inode(wreq->inode, true, INVALID_UID, true); + if (!fid) { + WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n", + wreq->inode->i_ino); + return; + } + + wreq->wsize = fid->clnt->msize - P9_IOHDRSZ; + if (fid->iounit) + wreq->wsize = min(wreq->wsize, fid->iounit); + wreq->netfs_priv = fid; + wreq->io_streams[0].avail = true; +} + +/* + * Issue a subrequest to write to the server. + */ +static void v9fs_issue_write(struct netfs_io_subrequest *subreq) +{ + struct p9_fid *fid = subreq->rreq->netfs_priv; + int err, len; + + len = p9_client_write(fid, subreq->start, &subreq->io_iter, &err); + netfs_write_subrequest_terminated(subreq, len ?: err, false); +} + static void v9fs_upload_to_server(struct netfs_io_subrequest *subreq) { struct p9_fid *fid = subreq->rreq->netfs_priv; @@ -92,6 +126,14 @@ static int v9fs_init_request(struct netfs_io_request *rreq, struct file *file) rreq->origin == NETFS_UNBUFFERED_WRITE || rreq->origin == NETFS_DIO_WRITE); +#if 0 // TODO: Cut over + if (rreq->origin == NETFS_WRITEBACK) + return 0; /* We don't get the write handle until we find we + * have actually dirty data and not just + * copy-to-cache data. + */ +#endif + if (file) { fid = file->private_data; if (!fid) @@ -103,6 +145,10 @@ static int v9fs_init_request(struct netfs_io_request *rreq, struct file *file) goto no_fid; } + rreq->wsize = fid->clnt->msize - P9_IOHDRSZ; + if (fid->iounit) + rreq->wsize = min(rreq->wsize, fid->iounit); + /* we might need to read from a fid that was opened write-only * for read-modify-write of page cache, use the writeback fid * for that */ @@ -131,6 +177,8 @@ const struct netfs_request_ops v9fs_req_ops = { .init_request = v9fs_init_request, .free_request = v9fs_free_request, .issue_read = v9fs_issue_read, + .begin_writeback = v9fs_begin_writeback, + .issue_write = v9fs_issue_write, .create_write_requests = v9fs_create_write_requests, }; diff --git a/include/net/9p/client.h b/include/net/9p/client.h index 78ebcf782ce5..4f785098c67a 100644 --- a/include/net/9p/client.h +++ b/include/net/9p/client.h @@ -207,6 +207,8 @@ int p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err int p9_client_read_once(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err); int p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err); +struct netfs_io_subrequest; +void p9_client_write_subreq(struct netfs_io_subrequest *subreq); int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset); int p9dirent_read(struct p9_client *clnt, char *buf, int len, struct p9_dirent *dirent); diff --git a/net/9p/Kconfig b/net/9p/Kconfig index 00ebce9e5a65..bcdab9c23b40 100644 --- a/net/9p/Kconfig +++ b/net/9p/Kconfig @@ -5,6 +5,7 @@ menuconfig NET_9P tristate "Plan 9 Resource Sharing Support (9P2000)" + select NETFS_SUPPORT help If you say Y here, you will get experimental support for Plan 9 resource sharing via the 9P2000 protocol. diff --git a/net/9p/client.c b/net/9p/client.c index e265a0ca6bdd..844aca4fe4d8 100644 --- a/net/9p/client.c +++ b/net/9p/client.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -1661,6 +1662,54 @@ p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err) } EXPORT_SYMBOL(p9_client_write); +void +p9_client_write_subreq(struct netfs_io_subrequest *subreq) +{ + struct netfs_io_request *wreq = subreq->rreq; + struct p9_fid *fid = wreq->netfs_priv; + struct p9_client *clnt = fid->clnt; + struct p9_req_t *req; + unsigned long long start = subreq->start + subreq->transferred; + size_t len = subreq->len - subreq->transferred; + int written, err; + + p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu len %zd\n", + fid->fid, start, len); + + /* Don't bother zerocopy for small IO (< 1024) */ + if (clnt->trans_mod->zc_request && len > 1024) { + req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, &subreq->io_iter, + 0, wreq->len, P9_ZC_HDR_SZ, "dqd", + fid->fid, start, len); + } else { + req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid, + start, len, &subreq->io_iter); + } + if (IS_ERR(req)) { + netfs_write_subrequest_terminated(subreq, PTR_ERR(req), false); + return; + } + + err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &written); + if (err) { + trace_9p_protocol_dump(clnt, &req->rc); + p9_req_put(clnt, req); + netfs_write_subrequest_terminated(subreq, err, false); + return; + } + + if (written > len) { + pr_err("bogus RWRITE count (%d > %lu)\n", written, len); + written = len; + } + + p9_debug(P9_DEBUG_9P, "<<< RWRITE count %zd\n", len); + + p9_req_put(clnt, req); + netfs_write_subrequest_terminated(subreq, written, false); +} +EXPORT_SYMBOL(p9_client_write_subreq); + struct p9_wstat *p9_client_stat(struct p9_fid *fid) { int err;