From nobody Fri Dec 19 12:13:17 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AE7EE303A2D for ; Fri, 10 Oct 2025 21:42:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132551; cv=none; b=tNUuyB0/F8dq2Y26zU3gk+7jRf1oMiHTqHRyfi1cSnzv6zwrwl/6wutlr2iFJSucc05JBSyDNHbP2zRz9Jj4YQr+64O0ZXAiaWupdic9s0mlHP8D0UPy/nLVnwYuX1aQ7qGTZPUPC78YdfBH7qA3vjealy7waL6pVmmpbqVPD2k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132551; c=relaxed/simple; bh=iq2e/sv+Zi9ciUHjCrlUp5Jvva2s5vbwXLIaUxZ7+K8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=eGvJjAshRoTIhFytkd2nlbMGs09MqAaLvEkPilbaDz/zaWJHrQ/9oIrpROXlgGW0ihU1dNioGbHu4ztHf0GihdR1iooDJk1x3uqCeo1YbpURG7Q7CudnmU9CBE8RYjowk+9+tARHpot5dKrSAvHTnE6xy34XKE7vsYXJt90QfMk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=Kx4kS1kd; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="Kx4kS1kd" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1760132548; 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=kQTrdZe6qZc3CMSCwVfDCC92bOCqOE6gyRvkJ7nko6k=; b=Kx4kS1kds/9BoOA5CSz/4UmA8r9Klh2wClozbfB/lDWiNGugEzoHUkqcWPBgUIuJxjDyIT K6dhw7G0kuiNepVG0FN23x+RDMrtCLaDSV15gwMNlRd8s7ODxUCeuoxoWqXY1/GVSQyTAf h1Hr6z8JLD+JYqQzjluIVQ90xFZsayo= Received: from mail-il1-f199.google.com (mail-il1-f199.google.com [209.85.166.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-453-tVkVHYKRMcGTiFnB7nNDKA-1; Fri, 10 Oct 2025 17:42:27 -0400 X-MC-Unique: tVkVHYKRMcGTiFnB7nNDKA-1 X-Mimecast-MFC-AGG-ID: tVkVHYKRMcGTiFnB7nNDKA_1760132547 Received: by mail-il1-f199.google.com with SMTP id e9e14a558f8ab-42f86e96381so89902895ab.1 for ; Fri, 10 Oct 2025 14:42:27 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760132547; x=1760737347; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=kQTrdZe6qZc3CMSCwVfDCC92bOCqOE6gyRvkJ7nko6k=; b=rfrbj+PFFNtSmUfZjF0E6ElPCocmsQDaVAlZM19y5F64WqvsOCHfPtVUp9iM1us9M6 9O3jgdss95zAmmUlHv2C+ghAe3G3e+w7LaFun7twq/fdBGnuMwYyUXZ1EQAPx7Rw0opL cCF+3TQsjAPYwyWDMAsphKLcMR8m5DHNgqaPBtRdmnab7dPAtQmXpmkCq3kSUxOj2E5t chdtDSQGjPl5JCW2yKHsvOAkgdtMpWyU5QuVIVNS2huQ+acLmann2BATGfov1sa41zNG MkwJivSColHYOF4xr2OtSfDvXQr0UYmws3mjVoRu2mWZi/F15TWP1ASRZzTMAaTIUWqf T+bA== X-Forwarded-Encrypted: i=1; AJvYcCUTtoZrX83jOUAxvSNxX6mfcVnjf24/JDApPYmfKNn4RmajbdYhfI1K1j/8hhTXQ5Fugvo1eqFEKhl1Vzw=@vger.kernel.org X-Gm-Message-State: AOJu0YyU3jU/4+jQZy43fBQn70oGL5lFeqOlLPn8Kt+EZjzfb9AqJ0Qg U085YcPJfIy1Djj4KY8woLQhuL1BwWzUB759tD1uE5Upbx159HpTb0Xn6OT3btRfC7QkPJDUp2b SS8DmCVQIHZ8kz9vQLojN3A61ZWhzW2oIe3dUssqkGSbJc5YhhYDAezJfYGcmxn6JoUgYEInnpA == X-Gm-Gg: ASbGncv3lLQheFTvQeK/HNssjxG6XNpHLlfXtAa8uBmOveaP9+c+nygYzA0uWKo+8XO 5EHLzqUQ96+LDTktSGUEEVKLJJJjHQQ/+hUJFseaoSAfQ7BKAbx5ZbT+676cBKlzWECNwA32Mn6 sIyTLXlPcfSSFDqkVBopFp3y/sso48ZgwNtNr+9YNwgAHsYi6sm9yBvTBalVdIHBCRkUvCXL1jL sXioC/IQLS4DmvvG1FKuRLqbuPb3hGF6d5DQE5B05+ggbN3WEVclQrnDZdYP0vc80ZltH1SWjSc vrmo8pBvdCxOTwOHLEfq5ijwOYEov/wkGHyRsFGFTZ/J7XP5lZcwxog= X-Received: by 2002:a05:6e02:1849:b0:429:6c5a:61f3 with SMTP id e9e14a558f8ab-42f87373153mr127614405ab.8.1760132546321; Fri, 10 Oct 2025 14:42:26 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG8wowT6uDx6IYvItIFqvayc0HgxnQWRhznxzbTVphFWlfOlNrKFLBVqyZESk0W8ghcY0ggsQ== X-Received: by 2002:a05:6e02:1849:b0:429:6c5a:61f3 with SMTP id e9e14a558f8ab-42f87373153mr127613725ab.8.1760132545634; Fri, 10 Oct 2025 14:42:25 -0700 (PDT) Received: from big24.xxmyappdomainxx.com ([79.127.136.56]) by smtp.gmail.com with ESMTPSA id e9e14a558f8ab-42f9027855bsm24382895ab.11.2025.10.10.14.42.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Oct 2025 14:42:25 -0700 (PDT) From: Eric Sandeen To: v9fs@lists.linux.dev Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, ericvh@kernel.org, lucho@ionkov.net, asmadeus@codewreck.org, linux_oss@crudebyte.com, eadavis@qq.com, Eric Sandeen Subject: [PATCH V3 1/4] fs/fs_parse: add back fsparam_u32hex Date: Fri, 10 Oct 2025 16:36:16 -0500 Message-ID: <20251010214222.1347785-2-sandeen@redhat.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251010214222.1347785-1-sandeen@redhat.com> References: <20251010214222.1347785-1-sandeen@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" 296b67059 removed fsparam_u32hex because there were no callers (yet) and it didn't build due to using the nonexistent symbol fs_param_is_u32_hex. fs/9p will need this parser, so add it back with the appropriate fix (use fs_param_is_u32). Signed-off-by: Eric Sandeen --- include/linux/fs_parser.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/linux/fs_parser.h b/include/linux/fs_parser.h index 5a0e897cae80..5e8a3b546033 100644 --- a/include/linux/fs_parser.h +++ b/include/linux/fs_parser.h @@ -120,6 +120,8 @@ static inline bool fs_validate_description(const char *= name, #define fsparam_u32(NAME, OPT) __fsparam(fs_param_is_u32, NAME, OPT, 0, NU= LL) #define fsparam_u32oct(NAME, OPT) \ __fsparam(fs_param_is_u32, NAME, OPT, 0, (void *)8) +#define fsparam_u32hex(NAME, OPT) \ + __fsparam(fs_param_is_u32, NAME, OPT, 0, (void *)16) #define fsparam_s32(NAME, OPT) __fsparam(fs_param_is_s32, NAME, OPT, 0, NU= LL) #define fsparam_u64(NAME, OPT) __fsparam(fs_param_is_u64, NAME, OPT, 0, NU= LL) #define fsparam_enum(NAME, OPT, array) __fsparam(fs_param_is_enum, NAME, O= PT, 0, array) --=20 2.51.0 From nobody Fri Dec 19 12:13:17 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CF99D303C83 for ; Fri, 10 Oct 2025 21:42:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132552; cv=none; b=VjxqOlWud7YpJXMUbgzsbWmbURAI/O5/H+YkMwfMLvHPVMTg06Piy65OReYU9NKPQCVpNGWoNbwHLmfvbp4UMhiIALoz183R0WKSCgbunl8e/3cB4lOKNsnU/mj2qD42Q6+LyGvYhGhUChQIyF6VdJkZgSOHsyzlns/VcI3FJxc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132552; c=relaxed/simple; bh=GJryDFOsOloQjP7siK0zC0G7J45WHi1AB6btkM6QkBw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rlG+4Hhl7oQ+0huMObSMUlwrq/ZZYiidYorZ5yPT7TmWKIDI0cqaVLjX2OArwuOsbx74k0OypGuU4YPt1vmoNINnt7YCiFZj3gnanyVZwQ9LMaOfimQ0i++epwrG4fN2Lcz1To5Bw+yP/2ZZslwfD+1dnZ1oHXt3QHIuAQJPNns= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=KkYypHNC; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="KkYypHNC" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1760132549; 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=HR7ws2UKD9+oIwfuUNn9Tl9ltcybskbjqnKMPXQbKgk=; b=KkYypHNCQU+vtaNsDCwFRslg0rChnbYtikLHvGNNz0FMB077ZJ+e+pJxdueEemzZj5+/Pl 5oMxZviUJ0mSKO14KLpJEAF3Vc/zBs+2dA0PEWq4SUnbmyPeP5M387QwFX51tXngCEkuj6 AemIo+OxK77d7Zrgs6e50ejAEZ7FQhE= Received: from mail-il1-f199.google.com (mail-il1-f199.google.com [209.85.166.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-66-vaObHPDvOO-5kdtbaJG7Qw-1; Fri, 10 Oct 2025 17:42:28 -0400 X-MC-Unique: vaObHPDvOO-5kdtbaJG7Qw-1 X-Mimecast-MFC-AGG-ID: vaObHPDvOO-5kdtbaJG7Qw_1760132548 Received: by mail-il1-f199.google.com with SMTP id e9e14a558f8ab-42f6639fb22so99521045ab.0 for ; Fri, 10 Oct 2025 14:42:28 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760132548; x=1760737348; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=HR7ws2UKD9+oIwfuUNn9Tl9ltcybskbjqnKMPXQbKgk=; b=w1oGIlKfIAthbsujBsUjxfeMPztKGetQCs5RxjVoBWOuu9RmXNzD20nPEIszQpqytZ niAlUcUfHWEcsiIhzw1PyTHVMLixhOJj0Oo9l3AmOPcrx0ylCnPBRY3cpepOC6iod+mS 4/Q/liBJnvfIZFQRnQt52yBM54tEckwG3CT2eOo79eXM3A/mic2ROLzwBMUU70zXlGCB gae+rWhatrGERt0WqWVtpFqANGdJc5ZpTsG/Z9SQBRpxZ4fhCLXthdxQpUMK5eN/2klO hIjkj0YU6pyUG3R3EG5hIqykGVzzGRIh/yxreEgUXMMHa2AcA2rlOVL0p8SBYLdLCU+q Nj7Q== X-Forwarded-Encrypted: i=1; AJvYcCU540BiUuBqlV7zr0HipOMXKXP3JWv4L4Kcs2XpMTh/5cPw9E7ndlGR0q916p4x60zoPa4KVgaaC0DTZtg=@vger.kernel.org X-Gm-Message-State: AOJu0YwihLIvFylqIDWxVQIkPJNd2X92B3L3TJ0DPPwDHZHzOB0dE5kf ipAtF+SkhUpomtrb9FT+z8sEavRGNJfJTcrZWgfPTm+SvXrv2YTsp9iPGgEDmnCLs6ZGL7pq3xO TOSXe9nsajfsB51F6fbinqUprTL7VBWC7QCNrQl9QAPUyaWeJuH2ckLZZF7MJsXsU5g== X-Gm-Gg: ASbGncsTrZwux12Lu4EWBdvG/pxbT4040mUfdOKglTsyYeX0jbsp0kw6ZQRtLqNmD5l s4OntCt+Q6GyGdCQGRHca/UD9O8NvsvP0OgTE6XrZZPTfagxYrzb1dwRoVVRUSq1VIZ2IBZOMhw ZXG0bj73kM3qdsE4Ndh1Ft1nKUQyuQeJcqlcj0V0aO1KV+lwPy/yx0ZQlo9dnWrhQ6/jM9mEXkR ZgIxMbQIWWvKjH5iC5BLW8zbKu1/c8bZnKiQR3ZflBXZvnycBGj4F6DU44fwe3AXxizmrKV14xt lxV2IReUWb6xIgq2WSBls3o= X-Received: by 2002:a05:6e02:3c85:b0:42f:9ba7:e47e with SMTP id e9e14a558f8ab-42f9ba7e72dmr70052785ab.14.1760132547649; Fri, 10 Oct 2025 14:42:27 -0700 (PDT) X-Google-Smtp-Source: AGHT+IH44cVXJKsWaECfwgaloao72H4DmNC0TIRKAyNGZ6LB3b/aUsmISlSFdph6ZLlnpFd+FZr3Mg== X-Received: by 2002:a05:6e02:3c85:b0:42f:9ba7:e47e with SMTP id e9e14a558f8ab-42f9ba7e72dmr70051355ab.14.1760132546767; Fri, 10 Oct 2025 14:42:26 -0700 (PDT) Received: from big24.xxmyappdomainxx.com ([79.127.136.56]) by smtp.gmail.com with ESMTPSA id e9e14a558f8ab-42f9027855bsm24382895ab.11.2025.10.10.14.42.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Oct 2025 14:42:26 -0700 (PDT) From: Eric Sandeen To: v9fs@lists.linux.dev Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, ericvh@kernel.org, lucho@ionkov.net, asmadeus@codewreck.org, linux_oss@crudebyte.com, eadavis@qq.com, Eric Sandeen Subject: [PATCH V3 2/4] net/9p: move structures and macros to header files Date: Fri, 10 Oct 2025 16:36:17 -0500 Message-ID: <20251010214222.1347785-3-sandeen@redhat.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251010214222.1347785-1-sandeen@redhat.com> References: <20251010214222.1347785-1-sandeen@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" With the new mount API all option parsing will need to happen in fs/v9fs.c, so move some existing data structures and macros to header files to facilitate this. Rename some to reflect the transport they are used for (rdma, fd, etc), for clarity. Signed-off-by: Eric Sandeen --- include/net/9p/client.h | 6 ++++++ include/net/9p/transport.h | 39 ++++++++++++++++++++++++++++++++++++++ net/9p/client.c | 6 ------ net/9p/trans_fd.c | 20 ++----------------- net/9p/trans_rdma.c | 25 ++---------------------- 5 files changed, 49 insertions(+), 47 deletions(-) diff --git a/include/net/9p/client.h b/include/net/9p/client.h index 4f785098c67a..2d46f8017bd5 100644 --- a/include/net/9p/client.h +++ b/include/net/9p/client.h @@ -16,6 +16,12 @@ /* Number of requests per row */ #define P9_ROW_MAXTAG 255 =20 +/* DEFAULT MSIZE =3D 32 pages worth of payload + P9_HDRSZ + + * room for write (16 extra) or read (11 extra) operands. + */ + +#define DEFAULT_MSIZE ((128 * 1024) + P9_IOHDRSZ) + /** enum p9_proto_versions - 9P protocol versions * @p9_proto_legacy: 9P Legacy mode, pre-9P2000.u * @p9_proto_2000u: 9P2000.u extension diff --git a/include/net/9p/transport.h b/include/net/9p/transport.h index 766ec07c9599..88702953b1ef 100644 --- a/include/net/9p/transport.h +++ b/include/net/9p/transport.h @@ -14,6 +14,45 @@ #define P9_DEF_MIN_RESVPORT (665U) #define P9_DEF_MAX_RESVPORT (1023U) =20 +#define P9_FD_PORT 564 + +#define P9_RDMA_PORT 5640 +#define P9_RDMA_SQ_DEPTH 32 +#define P9_RDMA_RQ_DEPTH 32 +#define P9_RDMA_TIMEOUT 30000 /* 30 seconds */ + +/** + * struct p9_fd_opts - per-transport options for fd transport + * @rfd: file descriptor for reading (trans=3Dfd) + * @wfd: file descriptor for writing (trans=3Dfd) + * @port: port to connect to (trans=3Dtcp) + * @privport: port is privileged + */ + +struct p9_fd_opts { + int rfd; + int wfd; + u16 port; + bool privport; +}; + +/** + * struct p9_rdma_opts - Collection of mount options for rdma transport + * @port: port of connection + * @privport: Whether a privileged port may be used + * @sq_depth: The requested depth of the SQ. This really doesn't need + * to be any deeper than the number of threads used in the client + * @rq_depth: The depth of the RQ. Should be greater than or equal to SQ d= epth + * @timeout: Time to wait in msecs for CM events + */ +struct p9_rdma_opts { + short port; + bool privport; + int sq_depth; + int rq_depth; + long timeout; +}; + /** * struct p9_trans_module - transport module interface * @list: used to maintain a list of currently available transports diff --git a/net/9p/client.c b/net/9p/client.c index 5c1ca57ccd28..5e3230b1bfab 100644 --- a/net/9p/client.c +++ b/net/9p/client.c @@ -29,12 +29,6 @@ #define CREATE_TRACE_POINTS #include =20 -/* DEFAULT MSIZE =3D 32 pages worth of payload + P9_HDRSZ + - * room for write (16 extra) or read (11 extra) operands. - */ - -#define DEFAULT_MSIZE ((128 * 1024) + P9_IOHDRSZ) - /* Client Option Parsing (code inspired by NFS code) * - a little lazy - parse all client options */ diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c index 339ec4e54778..9ef4f2e0db3c 100644 --- a/net/9p/trans_fd.c +++ b/net/9p/trans_fd.c @@ -31,28 +31,12 @@ =20 #include /* killme */ =20 -#define P9_PORT 564 #define MAX_SOCK_BUF (1024*1024) #define MAXPOLLWADDR 2 =20 static struct p9_trans_module p9_tcp_trans; static struct p9_trans_module p9_fd_trans; =20 -/** - * struct p9_fd_opts - per-transport options - * @rfd: file descriptor for reading (trans=3Dfd) - * @wfd: file descriptor for writing (trans=3Dfd) - * @port: port to connect to (trans=3Dtcp) - * @privport: port is privileged - */ - -struct p9_fd_opts { - int rfd; - int wfd; - u16 port; - bool privport; -}; - /* * Option Parsing (code inspired by NFS code) * - a little lazy - parse all fd-transport options @@ -749,7 +733,7 @@ static int p9_fd_cancelled(struct p9_client *client, st= ruct p9_req_t *req) static int p9_fd_show_options(struct seq_file *m, struct p9_client *clnt) { if (clnt->trans_mod =3D=3D &p9_tcp_trans) { - if (clnt->trans_opts.tcp.port !=3D P9_PORT) + if (clnt->trans_opts.tcp.port !=3D P9_FD_PORT) seq_printf(m, ",port=3D%u", clnt->trans_opts.tcp.port); } else if (clnt->trans_mod =3D=3D &p9_fd_trans) { if (clnt->trans_opts.fd.rfd !=3D ~0) @@ -775,7 +759,7 @@ static int parse_opts(char *params, struct p9_fd_opts *= opts) int option; char *options, *tmp_options; =20 - opts->port =3D P9_PORT; + opts->port =3D P9_FD_PORT; opts->rfd =3D ~0; opts->wfd =3D ~0; opts->privport =3D false; diff --git a/net/9p/trans_rdma.c b/net/9p/trans_rdma.c index b84748baf9cb..46ee37061faf 100644 --- a/net/9p/trans_rdma.c +++ b/net/9p/trans_rdma.c @@ -32,14 +32,10 @@ #include #include =20 -#define P9_PORT 5640 -#define P9_RDMA_SQ_DEPTH 32 -#define P9_RDMA_RQ_DEPTH 32 #define P9_RDMA_SEND_SGE 4 #define P9_RDMA_RECV_SGE 4 #define P9_RDMA_IRD 0 #define P9_RDMA_ORD 0 -#define P9_RDMA_TIMEOUT 30000 /* 30 seconds */ #define P9_RDMA_MAXSIZE (1024*1024) /* 1MB */ =20 /** @@ -110,23 +106,6 @@ struct p9_rdma_context { }; }; =20 -/** - * struct p9_rdma_opts - Collection of mount options - * @port: port of connection - * @privport: Whether a privileged port may be used - * @sq_depth: The requested depth of the SQ. This really doesn't need - * to be any deeper than the number of threads used in the client - * @rq_depth: The depth of the RQ. Should be greater than or equal to SQ d= epth - * @timeout: Time to wait in msecs for CM events - */ -struct p9_rdma_opts { - short port; - bool privport; - int sq_depth; - int rq_depth; - long timeout; -}; - /* * Option Parsing (code inspired by NFS code) */ @@ -151,7 +130,7 @@ static int p9_rdma_show_options(struct seq_file *m, str= uct p9_client *clnt) { struct p9_trans_rdma *rdma =3D clnt->trans; =20 - if (rdma->port !=3D P9_PORT) + if (rdma->port !=3D P9_RDMA_PORT) seq_printf(m, ",port=3D%u", rdma->port); if (rdma->sq_depth !=3D P9_RDMA_SQ_DEPTH) seq_printf(m, ",sq=3D%u", rdma->sq_depth); @@ -178,7 +157,7 @@ static int parse_opts(char *params, struct p9_rdma_opts= *opts) int option; char *options, *tmp_options; =20 - opts->port =3D P9_PORT; + opts->port =3D P9_RDMA_PORT; opts->sq_depth =3D P9_RDMA_SQ_DEPTH; opts->rq_depth =3D P9_RDMA_RQ_DEPTH; opts->timeout =3D P9_RDMA_TIMEOUT; --=20 2.51.0 From nobody Fri Dec 19 12:13:17 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 045AF303CA4 for ; Fri, 10 Oct 2025 21:42:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132553; cv=none; b=Ce5AzteW+Hhcip+NI9250CgWU43Z6ExlJKq+ruW2AZg9yiUc+m/OptByUKdkz9qNcZMeLLF4RoN6dGyF90MHEbzwW3m6h8Ur/OtY6ZYAZpKdMiwqdKhqgjSNJfhJxj5USDnJCQHSumegBNNxwg57rUDynXn4qyaUUU5R9ZHV0m4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132553; c=relaxed/simple; bh=50iMg4cjhPiTK7ZC9StdXLuoYu4mQzjFec4yy2wlFUk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rKIUcNsuD64ELJph+KdCnHzAwwWOLL1/c9kaFpWnd+afh8Du4vETvVvtaTawt4Pr3KUfcf9ODbyLBk6PzJtVOKi+g8wz0+nQIi3hwi6u1ZfkoEhY4qBrrju5To7CxqQgPTC3qnKi5Y/vxkC3rijjDk4oHW7c6I4RqJsroivxO2I= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=KLTQY8zG; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="KLTQY8zG" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1760132550; 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=ZPCYbFFACQ3Rv/ZhYJDcxm0pSUm0LvajwjZxksg70Jk=; b=KLTQY8zGOT+e/iEGb0hmSD6U5BU9N/Dw6WWx99GPYcPT8DugznuAZAKRwUqs2xJPbhZlDN 9GPphEof1iYH9UGRv3HDM3eULBUX4BoXaTyE0mjfb7AMS0aU+9T2k8GcJaekyrxpQN/TmQ ox8Uf/ytXB416zrnvRDsf6ih1kBprLo= Received: from mail-il1-f200.google.com (mail-il1-f200.google.com [209.85.166.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-664-dORtbMjmMLS6hom4tnqGKQ-1; Fri, 10 Oct 2025 17:42:29 -0400 X-MC-Unique: dORtbMjmMLS6hom4tnqGKQ-1 X-Mimecast-MFC-AGG-ID: dORtbMjmMLS6hom4tnqGKQ_1760132548 Received: by mail-il1-f200.google.com with SMTP id e9e14a558f8ab-42f9eb73b34so56646995ab.3 for ; Fri, 10 Oct 2025 14:42:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760132548; x=1760737348; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ZPCYbFFACQ3Rv/ZhYJDcxm0pSUm0LvajwjZxksg70Jk=; b=l9gEBYvDxKg7BqaRAmGUTTv0p+A1QQvvtZs73PRKC6HmQgSt2hiSLGY7Rj/LperDtK YO526ejgGLXsqo5YACOTIYZa2PHcOjezExVT6pUiJNTgUFX1HiDvi97UyIr1fSCsWeIQ JnRo06fmMyjEaLYTDEuoN+RL07p2pEc8Jhj897whwU4uqpcOY4yDeq+Y/5SqKIzeNce1 w2hd4U6J9ZGlynxQnBZZ/+5ZOk2N1p+pnACjCxSAuc8ewre8XEhf7KSx/SNinYx68TWV dGOCLUpVjLfP9xDIvtOF++N3CXq3aEdz2VQw6Ae1QwQuceM6OfvKRMdNsl96JWaGDAB7 xctw== X-Forwarded-Encrypted: i=1; AJvYcCX9u9iQ/D1XcXSAZ0NCyUkqAvxbpIr5Y+2LFexC0kczNjsLkruUmOGGtSCa2c3GJ3nXlkMSvN5you2skIs=@vger.kernel.org X-Gm-Message-State: AOJu0YxrGLyEunyWzpqe76YrBRnHwTj2CItUCNheXLfzq60BYC9LrmHL ISc2vuHI2lpuTOW0FrI4D/YzeXgC6LXUyeigApptokJ4yQdqELO0knLSg8qbWwTSsmXdj3CipHm HjeodY6vfSZ29yS83oyknikmUIkgyPB4K2nYbLcHB3w6eEfDoSrjcDyVTVgbQJMREnQ== X-Gm-Gg: ASbGncveJmS+NOUS+jYIBnGXg/Mm24E9V1qIibeBrFsESlL/7EjfNmygyejVozr1Ccy XipH/u53dXVjQ4dEFFmyO0SqwMZ6tQcxwO0XnzsbGaTBNfuxRrtZnFc/F61lKgjWDLVmZcfGp0Q PumxqC5j07XrYK/Al5ww2lQDS4I6Zm5yC8LDEud5q2bO5ChXwBIIldSp7VavJ7/M8bFa3pyOgQN VPNLJWPqHAL1xZDQQWwJju1ZPs/WdF/CnTqQzuCmOc+ARqRy0osBGBzQHLs6VwEdtpCfEd0pUBy HlVKUfUL8KBh4CRBs3FuDSKS3p5z9qLz+DsPTgckEdq1qDQZ4EsGGNo= X-Received: by 2002:a05:6e02:178b:b0:425:744b:52d3 with SMTP id e9e14a558f8ab-42f87380d9dmr144056055ab.11.1760132547961; Fri, 10 Oct 2025 14:42:27 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGN9W2IC/SA0+yMXYj+bexcHnyhvZRXEQnWhjpte5lw9OnE4asaSu6KQ3Uaia/qiH+7I5ocnw== X-Received: by 2002:a05:6e02:178b:b0:425:744b:52d3 with SMTP id e9e14a558f8ab-42f87380d9dmr144055155ab.11.1760132547477; Fri, 10 Oct 2025 14:42:27 -0700 (PDT) Received: from big24.xxmyappdomainxx.com ([79.127.136.56]) by smtp.gmail.com with ESMTPSA id e9e14a558f8ab-42f9027855bsm24382895ab.11.2025.10.10.14.42.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Oct 2025 14:42:27 -0700 (PDT) From: Eric Sandeen To: v9fs@lists.linux.dev Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, ericvh@kernel.org, lucho@ionkov.net, asmadeus@codewreck.org, linux_oss@crudebyte.com, eadavis@qq.com, Eric Sandeen Subject: [PATCH V3 3/4] 9p: create a v9fs_context structure to hold parsed options Date: Fri, 10 Oct 2025 16:36:18 -0500 Message-ID: <20251010214222.1347785-4-sandeen@redhat.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251010214222.1347785-1-sandeen@redhat.com> References: <20251010214222.1347785-1-sandeen@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This patch creates a new v9fs_context structure which includes new p9_session_opts and p9_client_opts structures, as well as re-using the existing p9_fd_opts and p9_rdma_opts to store options during parsing. The new structure will be used in the next commit to pass all parsed options to the appropriate transports. Signed-off-by: Eric Sandeen --- include/net/9p/client.h | 90 ++++++++++++++++++++++++++++++++++++++ include/net/9p/transport.h | 32 -------------- 2 files changed, 90 insertions(+), 32 deletions(-) diff --git a/include/net/9p/client.h b/include/net/9p/client.h index 2d46f8017bd5..cc18443f7d51 100644 --- a/include/net/9p/client.h +++ b/include/net/9p/client.h @@ -132,6 +132,96 @@ struct p9_client { char name[__NEW_UTS_LEN + 1]; }; =20 +/** + * struct p9_fd_opts - holds client options during parsing + * @msize: maximum data size negotiated by protocol + * @prot-Oversion: 9P protocol version to use + * @trans_mod: module API instantiated with this client + * + * These parsed options get transferred into client in + * apply_client_options() + */ +struct p9_client_opts { + unsigned int msize; + unsigned char proto_version; + struct p9_trans_module *trans_mod; +}; + +/** + * struct p9_fd_opts - per-transport options for fd transport + * @rfd: file descriptor for reading (trans=3Dfd) + * @wfd: file descriptor for writing (trans=3Dfd) + * @port: port to connect to (trans=3Dtcp) + * @privport: port is privileged + */ +struct p9_fd_opts { + int rfd; + int wfd; + u16 port; + bool privport; +}; + +/** + * struct p9_rdma_opts - Collection of mount options for rdma transport + * @port: port of connection + * @privport: Whether a privileged port may be used + * @sq_depth: The requested depth of the SQ. This really doesn't need + * to be any deeper than the number of threads used in the client + * @rq_depth: The depth of the RQ. Should be greater than or equal to SQ d= epth + * @timeout: Time to wait in msecs for CM events + */ +struct p9_rdma_opts { + short port; + bool privport; + int sq_depth; + int rq_depth; + long timeout; +}; + +/** + * struct p9_session_opts - holds parsed options for v9fs_session_info + * @flags: session options of type &p9_session_flags + * @nodev: set to 1 to disable device mapping + * @debug: debug level + * @afid: authentication handle + * @cache: cache mode of type &p9_cache_bits + * @cachetag: the tag of the cache associated with this session + * @uname: string user name to mount hierarchy as + * @aname: mount specifier for remote hierarchy + * @dfltuid: default numeric userid to mount hierarchy as + * @dfltgid: default numeric groupid to mount hierarchy as + * @uid: if %V9FS_ACCESS_SINGLE, the numeric uid which mounted the hierarc= hy + * @session_lock_timeout: retry interval for blocking locks + * + * This strucure holds options which are parsed and will be transferred + * to the v9fs_session_info structure when mounted, and therefore largely + * duplicates struct v9fs_session_info. + */ +struct p9_session_opts { + unsigned int flags; + unsigned char nodev; + unsigned short debug; + unsigned int afid; + unsigned int cache; +#ifdef CONFIG_9P_FSCACHE + char *cachetag; +#endif + char *uname; + char *aname; + kuid_t dfltuid; + kgid_t dfltgid; + kuid_t uid; + long session_lock_timeout; +}; + +/* Used by mount API to store parsed mount options */ +struct v9fs_context { + struct p9_client_opts client_opts; + struct p9_fd_opts fd_opts; + struct p9_rdma_opts rdma_opts; + struct p9_session_opts session_opts; +}; + /** * struct p9_fid - file system entity handle * @clnt: back pointer to instantiating &p9_client diff --git a/include/net/9p/transport.h b/include/net/9p/transport.h index 88702953b1ef..ebbb4b50ee20 100644 --- a/include/net/9p/transport.h +++ b/include/net/9p/transport.h @@ -21,38 +21,6 @@ #define P9_RDMA_RQ_DEPTH 32 #define P9_RDMA_TIMEOUT 30000 /* 30 seconds */ =20 -/** - * struct p9_fd_opts - per-transport options for fd transport - * @rfd: file descriptor for reading (trans=3Dfd) - * @wfd: file descriptor for writing (trans=3Dfd) - * @port: port to connect to (trans=3Dtcp) - * @privport: port is privileged - */ - -struct p9_fd_opts { - int rfd; - int wfd; - u16 port; - bool privport; -}; - -/** - * struct p9_rdma_opts - Collection of mount options for rdma transport - * @port: port of connection - * @privport: Whether a privileged port may be used - * @sq_depth: The requested depth of the SQ. This really doesn't need - * to be any deeper than the number of threads used in the client - * @rq_depth: The depth of the RQ. Should be greater than or equal to SQ d= epth - * @timeout: Time to wait in msecs for CM events - */ -struct p9_rdma_opts { - short port; - bool privport; - int sq_depth; - int rq_depth; - long timeout; -}; - /** * struct p9_trans_module - transport module interface * @list: used to maintain a list of currently available transports --=20 2.51.0 From nobody Fri Dec 19 12:13:17 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 588F93043C0 for ; Fri, 10 Oct 2025 21:42:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132557; cv=none; b=swDbopgOz9oCPX3mPIVzrQUWHEtiuhUltCpHjAMxJk/lj4f8k3hHxs1gV4TwWZyK8LjrSUpJUV03dVC01zJVa6RkKSEDLpEKovlg1+OVqHbjVcl/IUPRK6tE60ov+j57FQrQ529U+BoH/zecUcOQlLJY+iRVxq2z4MXX70dmITM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760132557; c=relaxed/simple; bh=mnFRGKWiCU/Y0bSZZZtd3RfpnEkP2aMwME88vWhneF4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=fHDPhfmvYiKUJNe79yuFoBthoTkl4oJTPke7rpJFsk7XZ9fQ8iivYwrk4S7/oHAl4BiHw0yWkyNK/FgzZX/iKTZBjdhWTg4Istj2BufXsdwc6Qexwx3Z8SDTttxQCPZAmJzYP9yNQenNvqXk4iTA/7d5UOfiEopIXDuy7uTE5l0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=cQSRbwST; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="cQSRbwST" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1760132552; 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=8sfkdq85h44HFcZmUBA7XKUXRGbpoM+BKPyNcgI4PI0=; b=cQSRbwSTYGMtPj0ejsCfmKeNZElVu/Yc5/6Q+KLc2IqJHW+aLgua0+czpOl0YJtrSUetSX mpyfU90PvQRKtY94s1vTv+3ZMNpHNejaTq6FfFnojSLCQ38JkAatPjEeWVtCM4Ohdtepwf kCJ4ZfVsmCb33+P4mFv6zmJcyX1vy7Y= Received: from mail-il1-f200.google.com (mail-il1-f200.google.com [209.85.166.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-3-QksPPSndNvKYPr1_SU0fmQ-1; Fri, 10 Oct 2025 17:42:31 -0400 X-MC-Unique: QksPPSndNvKYPr1_SU0fmQ-1 X-Mimecast-MFC-AGG-ID: QksPPSndNvKYPr1_SU0fmQ_1760132550 Received: by mail-il1-f200.google.com with SMTP id e9e14a558f8ab-42f911a1984so159938435ab.0 for ; Fri, 10 Oct 2025 14:42:30 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760132550; x=1760737350; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8sfkdq85h44HFcZmUBA7XKUXRGbpoM+BKPyNcgI4PI0=; b=T8qFVv69eHiAhGyJcCBNH8Z3klKMPwFxFsb2AhpAAUk7PHUipqVTss8T4caw6YvCxU VDw5KxrjV4vT3TPG6zXuTKXTKOsjJNnmvwFitUHztwgvxRqT5TxtS9VqemHJbT8x9oXd xdL/FA/p2KIb9BTpGvxHzTcLOrhPq1Q4kDpAqkwVPMIqREMhqO9Ahgq/tiBTKGXVi7aa 7hfNQJfnuKQ4pLBKylbIGuJGusubjqmUvJqme5WbGsdf4h5L7ejes4fKdBE8SjV/hD3s RY+FgarT2zSdzXisEqlmbhD60o9M5X0ed9W6mETPcR/GRbcH/qJEYMAf8HQJ1jF48O/m Xw7g== X-Forwarded-Encrypted: i=1; AJvYcCUsdapCIkJWam5fLroBNfLwmOHnNY/94i4hsR2mQuQyb/mGnwtEhLL6vpKe0YT0yzlOOPsPeYrXy++4OfU=@vger.kernel.org X-Gm-Message-State: AOJu0YzpzoHVasSot9FTO2ZULYkO2IVaSkU4iKsTCMllRd6jBhlJB2nk uIoaHizB4Jw+r6OhKrAQJPgQvdg5NhJ1MT+Od9Le2pMN5NUja54lUXsBzBrjp1AGUaX5NUNrbQb zAKDm9bgknsCww9TKvPpqbsmWs23EL27hetaY0JVwlplzB+eTBuqW21Dx0A93ESRjIA== X-Gm-Gg: ASbGncv3BPo/qg9+ixmXvnf14wDMhzD1q32ri208ZrF+bFr/wjW7iZPeYSAEGfAndY3 usRWfR8qJOO/6qxJ3HnbO35ZsHGhkOufSlTC+lLJoUMILF3ijgh/yCdTKh2k4I9TtCSTPqnaMzK aeoC1mD9/gwxM7Tz8arBOaYTS8OVssxoQS3RiY8f4AJgDfsLhWgGhi52A5LDSL98pjzNNQ70uyK /+QHJZjqOpmA/i7u2JaGlVQkQYXburn4rS5MpFbv3DDadKwHjmuL+O2psrjn8Zov+yxVS2mAgEN 815lIlOwU51EVZK+HxMVCHHVTgPC+OSr2aFp/8PJjO4p17PGvkcm9yg= X-Received: by 2002:a05:6e02:23c3:b0:42f:8afa:326f with SMTP id e9e14a558f8ab-42f8afa34damr141170825ab.19.1760132549630; Fri, 10 Oct 2025 14:42:29 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGrY+hGXobn1ewxHQXDJ3/LtKFA8P9+G4dWvdRYK2yRdKIyf0wrOGJ3XuNy5C3ZGsCPTMqXeQ== X-Received: by 2002:a05:6e02:23c3:b0:42f:8afa:326f with SMTP id e9e14a558f8ab-42f8afa34damr141169795ab.19.1760132548892; Fri, 10 Oct 2025 14:42:28 -0700 (PDT) Received: from big24.xxmyappdomainxx.com ([79.127.136.56]) by smtp.gmail.com with ESMTPSA id e9e14a558f8ab-42f9027855bsm24382895ab.11.2025.10.10.14.42.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Oct 2025 14:42:28 -0700 (PDT) From: Eric Sandeen To: v9fs@lists.linux.dev Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, ericvh@kernel.org, lucho@ionkov.net, asmadeus@codewreck.org, linux_oss@crudebyte.com, eadavis@qq.com, Eric Sandeen Subject: [PATCH V3 4/4] 9p: convert to the new mount API Date: Fri, 10 Oct 2025 16:36:19 -0500 Message-ID: <20251010214222.1347785-5-sandeen@redhat.com> X-Mailer: git-send-email 2.51.0 In-Reply-To: <20251010214222.1347785-1-sandeen@redhat.com> References: <20251010214222.1347785-1-sandeen@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Convert 9p to the new mount API. This patch consolidates all parsing into fs/9p/v9fs.c, which stores all results into a filesystem context which can be passed to the various transports as needed. Some of the parsing helper functions such as get_cache_mode() have been eliminated in favor of using the new mount API's enum param type, for simplicity. Signed-off-by: Eric Sandeen --- fs/9p/v9fs.c | 539 +++++++++++++++++++------------------ fs/9p/v9fs.h | 7 +- fs/9p/vfs_super.c | 130 ++++++--- include/net/9p/client.h | 2 +- include/net/9p/transport.h | 2 +- net/9p/client.c | 148 +--------- net/9p/mod.c | 2 +- net/9p/trans_fd.c | 109 +------- net/9p/trans_rdma.c | 108 +------- net/9p/trans_usbg.c | 4 +- net/9p/trans_virtio.c | 8 +- net/9p/trans_xen.c | 4 +- 12 files changed, 411 insertions(+), 652 deletions(-) diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c index 77e9c4387c1d..07be64e73711 100644 --- a/fs/9p/v9fs.c +++ b/fs/9p/v9fs.c @@ -13,7 +13,8 @@ #include #include #include -#include +#include +#include #include #include #include @@ -43,55 +44,80 @@ enum { Opt_access, Opt_posixacl, /* Lock timeout option */ Opt_locktimeout, - /* Error token */ - Opt_err + + /* Client options */ + Opt_msize, Opt_trans, Opt_legacy, Opt_version, + + /* fd transport options */ + /* Options that take integer arguments */ + Opt_rfdno, Opt_wfdno, + /* Options that take no arguments */ + + /* rdma transport options */ + /* Options that take integer arguments */ + Opt_rq_depth, Opt_sq_depth, Opt_timeout, + + /* Options for both fd and rdma transports */ + Opt_port, Opt_privport, }; =20 -static const match_table_t tokens =3D { - {Opt_debug, "debug=3D%x"}, - {Opt_dfltuid, "dfltuid=3D%u"}, - {Opt_dfltgid, "dfltgid=3D%u"}, - {Opt_afid, "afid=3D%u"}, - {Opt_uname, "uname=3D%s"}, - {Opt_remotename, "aname=3D%s"}, - {Opt_nodevmap, "nodevmap"}, - {Opt_noxattr, "noxattr"}, - {Opt_directio, "directio"}, - {Opt_ignoreqv, "ignoreqv"}, - {Opt_cache, "cache=3D%s"}, - {Opt_cachetag, "cachetag=3D%s"}, - {Opt_access, "access=3D%s"}, - {Opt_posixacl, "posixacl"}, - {Opt_locktimeout, "locktimeout=3D%u"}, - {Opt_err, NULL} +static const struct constant_table p9_versions[] =3D { + { "9p2000", p9_proto_legacy }, + { "9p2000.u", p9_proto_2000u }, + { "9p2000.L", p9_proto_2000L }, + {} }; =20 -/* Interpret mount options for cache mode */ -static int get_cache_mode(char *s) -{ - int version =3D -EINVAL; - - if (!strcmp(s, "loose")) { - version =3D CACHE_SC_LOOSE; - p9_debug(P9_DEBUG_9P, "Cache mode: loose\n"); - } else if (!strcmp(s, "fscache")) { - version =3D CACHE_SC_FSCACHE; - p9_debug(P9_DEBUG_9P, "Cache mode: fscache\n"); - } else if (!strcmp(s, "mmap")) { - version =3D CACHE_SC_MMAP; - p9_debug(P9_DEBUG_9P, "Cache mode: mmap\n"); - } else if (!strcmp(s, "readahead")) { - version =3D CACHE_SC_READAHEAD; - p9_debug(P9_DEBUG_9P, "Cache mode: readahead\n"); - } else if (!strcmp(s, "none")) { - version =3D CACHE_SC_NONE; - p9_debug(P9_DEBUG_9P, "Cache mode: none\n"); - } else if (kstrtoint(s, 0, &version) !=3D 0) { - version =3D -EINVAL; - pr_info("Unknown Cache mode or invalid value %s\n", s); - } - return version; -} +static const struct constant_table p9_cache_mode[] =3D { + { "loose", CACHE_SC_LOOSE }, + { "fscache", CACHE_SC_FSCACHE }, + { "mmap", CACHE_SC_MMAP }, + { "readahead", CACHE_SC_READAHEAD }, + { "none", CACHE_SC_NONE }, + {} +}; + +/* + * This structure contains all parameters used for the core code, + * the client, and all the transports. + */ +const struct fs_parameter_spec v9fs_param_spec[] =3D { + fsparam_u32hex ("debug", Opt_debug), + fsparam_uid ("dfltuid", Opt_dfltuid), + fsparam_gid ("dfltgid", Opt_dfltgid), + fsparam_u32 ("afid", Opt_afid), + fsparam_string ("uname", Opt_uname), + fsparam_string ("aname", Opt_remotename), + fsparam_flag ("nodevmap", Opt_nodevmap), + fsparam_flag ("noxattr", Opt_noxattr), + fsparam_flag ("directio", Opt_directio), + fsparam_flag ("ignoreqv", Opt_ignoreqv), + fsparam_enum ("cache", Opt_cache, p9_cache_mode), + fsparam_string ("cachetag", Opt_cachetag), + fsparam_string ("access", Opt_access), + fsparam_flag ("posixacl", Opt_posixacl), + fsparam_u32 ("locktimeout", Opt_locktimeout), + + /* client options */ + fsparam_u32 ("msize", Opt_msize), + fsparam_flag ("noextend", Opt_legacy), + fsparam_string ("trans", Opt_trans), + fsparam_enum ("version", Opt_version, p9_versions), + + /* fd transport options */ + fsparam_u32 ("rfdno", Opt_rfdno), + fsparam_u32 ("wfdno", Opt_wfdno), + + /* rdma transport options */ + fsparam_u32 ("sq", Opt_sq_depth), + fsparam_u32 ("rq", Opt_rq_depth), + fsparam_u32 ("timeout", Opt_timeout), + + /* fd and rdma transprt options */ + fsparam_u32 ("port", Opt_port), + fsparam_flag ("privport", Opt_privport), + {} +}; =20 /* * Display the mount options in /proc/mounts. @@ -153,267 +179,244 @@ int v9fs_show_options(struct seq_file *m, struct de= ntry *root) } =20 /** - * v9fs_parse_options - parse mount options into session structure - * @v9ses: existing v9fs session information - * @opts: The mount option string + * v9fs_parse_param - parse a mount option into the filesystem context + * @fc: the filesystem context + * @param: the parameter to parse * * Return 0 upon success, -ERRNO upon failure. */ - -static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) +int v9fs_parse_param(struct fs_context *fc, struct fs_parameter *param) { - char *options, *tmp_options; - substring_t args[MAX_OPT_ARGS]; - char *p; - int option =3D 0; + struct v9fs_context *ctx =3D fc->fs_private; + struct fs_parse_result result; char *s; - int ret =3D 0; - - /* setup defaults */ - v9ses->afid =3D ~0; - v9ses->debug =3D 0; - v9ses->cache =3D CACHE_NONE; -#ifdef CONFIG_9P_FSCACHE - v9ses->cachetag =3D NULL; -#endif - v9ses->session_lock_timeout =3D P9_LOCK_TIMEOUT; - - if (!opts) - return 0; + int r; + int opt; + struct p9_client_opts *clnt =3D &ctx->client_opts; + struct p9_fd_opts *fd_opts =3D &ctx->fd_opts; + struct p9_rdma_opts *rdma_opts =3D &ctx->rdma_opts; + struct p9_session_opts *session_opts =3D &ctx->session_opts; + + opt =3D fs_parse(fc, v9fs_param_spec, param, &result); + if (opt < 0) { + /* + * We might like to report bad mount options here, but + * traditionally 9p has ignored unknown mount options + */ + if (opt =3D=3D -ENOPARAM) + return 0; =20 - tmp_options =3D kstrdup(opts, GFP_KERNEL); - if (!tmp_options) { - ret =3D -ENOMEM; - goto fail_option_alloc; + return opt; } - options =3D tmp_options; - - while ((p =3D strsep(&options, ",")) !=3D NULL) { - int token, r; - - if (!*p) - continue; - - token =3D match_token(p, tokens, args); - switch (token) { - case Opt_debug: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - } else { - v9ses->debug =3D option; + + switch (opt) { + case Opt_debug: + session_opts->debug =3D result.uint_32; #ifdef CONFIG_NET_9P_DEBUG - p9_debug_level =3D option; + p9_debug_level =3D result.uint_32; #endif - } - break; - - case Opt_dfltuid: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - continue; - } - v9ses->dfltuid =3D make_kuid(current_user_ns(), option); - if (!uid_valid(v9ses->dfltuid)) { - p9_debug(P9_DEBUG_ERROR, - "uid field, but not a uid?\n"); - ret =3D -EINVAL; - } - break; - case Opt_dfltgid: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - continue; - } - v9ses->dfltgid =3D make_kgid(current_user_ns(), option); - if (!gid_valid(v9ses->dfltgid)) { - p9_debug(P9_DEBUG_ERROR, - "gid field, but not a gid?\n"); - ret =3D -EINVAL; - } - break; - case Opt_afid: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - } else { - v9ses->afid =3D option; - } - break; - case Opt_uname: - kfree(v9ses->uname); - v9ses->uname =3D match_strdup(&args[0]); - if (!v9ses->uname) { - ret =3D -ENOMEM; - goto free_and_return; - } - break; - case Opt_remotename: - kfree(v9ses->aname); - v9ses->aname =3D match_strdup(&args[0]); - if (!v9ses->aname) { - ret =3D -ENOMEM; - goto free_and_return; - } - break; - case Opt_nodevmap: - v9ses->nodev =3D 1; - break; - case Opt_noxattr: - v9ses->flags |=3D V9FS_NO_XATTR; - break; - case Opt_directio: - v9ses->flags |=3D V9FS_DIRECT_IO; - break; - case Opt_ignoreqv: - v9ses->flags |=3D V9FS_IGNORE_QV; - break; - case Opt_cachetag: + break; + + case Opt_dfltuid: + session_opts->dfltuid =3D result.uid; + break; + case Opt_dfltgid: + session_opts->dfltgid =3D result.gid; + break; + case Opt_afid: + session_opts->afid =3D result.uint_32; + break; + case Opt_uname: + kfree(session_opts->uname); + session_opts->uname =3D param->string; + param->string =3D NULL; + break; + case Opt_remotename: + kfree(session_opts->aname); + session_opts->aname =3D param->string; + param->string =3D NULL; + break; + case Opt_nodevmap: + session_opts->nodev =3D 1; + break; + case Opt_noxattr: + session_opts->flags |=3D V9FS_NO_XATTR; + break; + case Opt_directio: + session_opts->flags |=3D V9FS_DIRECT_IO; + break; + case Opt_ignoreqv: + session_opts->flags |=3D V9FS_IGNORE_QV; + break; + case Opt_cachetag: #ifdef CONFIG_9P_FSCACHE - kfree(v9ses->cachetag); - v9ses->cachetag =3D match_strdup(&args[0]); - if (!v9ses->cachetag) { - ret =3D -ENOMEM; - goto free_and_return; - } + kfree(session_opts->cachetag); + session_opts->cachetag =3D param->string; + param->string =3D NULL; #endif - break; - case Opt_cache: - s =3D match_strdup(&args[0]); - if (!s) { - ret =3D -ENOMEM; - p9_debug(P9_DEBUG_ERROR, - "problem allocating copy of cache arg\n"); - goto free_and_return; - } - r =3D get_cache_mode(s); - if (r < 0) - ret =3D r; - else - v9ses->cache =3D r; - - kfree(s); - break; - - case Opt_access: - s =3D match_strdup(&args[0]); - if (!s) { - ret =3D -ENOMEM; - p9_debug(P9_DEBUG_ERROR, - "problem allocating copy of access arg\n"); - goto free_and_return; + break; + case Opt_cache: + session_opts->cache =3D result.uint_32; + p9_debug(P9_DEBUG_9P, "Cache mode: %s\n", param->string); + break; + case Opt_access: + s =3D param->string; + session_opts->flags &=3D ~V9FS_ACCESS_MASK; + if (strcmp(s, "user") =3D=3D 0) { + session_opts->flags |=3D V9FS_ACCESS_USER; + } else if (strcmp(s, "any") =3D=3D 0) { + session_opts->flags |=3D V9FS_ACCESS_ANY; + } else if (strcmp(s, "client") =3D=3D 0) { + session_opts->flags |=3D V9FS_ACCESS_CLIENT; + } else { + uid_t uid; + + session_opts->flags |=3D V9FS_ACCESS_SINGLE; + r =3D kstrtouint(s, 10, &uid); + if (r) { + pr_info("Unknown access argument %s: %d\n", + param->string, r); + return r; } - - v9ses->flags &=3D ~V9FS_ACCESS_MASK; - if (strcmp(s, "user") =3D=3D 0) - v9ses->flags |=3D V9FS_ACCESS_USER; - else if (strcmp(s, "any") =3D=3D 0) - v9ses->flags |=3D V9FS_ACCESS_ANY; - else if (strcmp(s, "client") =3D=3D 0) { - v9ses->flags |=3D V9FS_ACCESS_CLIENT; - } else { - uid_t uid; - - v9ses->flags |=3D V9FS_ACCESS_SINGLE; - r =3D kstrtouint(s, 10, &uid); - if (r) { - ret =3D r; - pr_info("Unknown access argument %s: %d\n", - s, r); - kfree(s); - continue; - } - v9ses->uid =3D make_kuid(current_user_ns(), uid); - if (!uid_valid(v9ses->uid)) { - ret =3D -EINVAL; - pr_info("Unknown uid %s\n", s); - } + session_opts->uid =3D make_kuid(current_user_ns(), uid); + if (!uid_valid(session_opts->uid)) { + pr_info("Unknown uid %s\n", s); + return -EINVAL; } + } + break; =20 - kfree(s); - break; - - case Opt_posixacl: + case Opt_posixacl: #ifdef CONFIG_9P_FS_POSIX_ACL - v9ses->flags |=3D V9FS_POSIX_ACL; + session_opts->flags |=3D V9FS_POSIX_ACL; #else - p9_debug(P9_DEBUG_ERROR, - "Not defined CONFIG_9P_FS_POSIX_ACL. Ignoring posixacl option\n"); + p9_debug(P9_DEBUG_ERROR, + "Not defined CONFIG_9P_FS_POSIX_ACL. Ignoring posixacl option\n"); #endif - break; - - case Opt_locktimeout: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - continue; - } - if (option < 1) { - p9_debug(P9_DEBUG_ERROR, - "locktimeout must be a greater than zero integer.\n"); - ret =3D -EINVAL; - continue; - } - v9ses->session_lock_timeout =3D (long)option * HZ; - break; + break; =20 - default: - continue; + case Opt_locktimeout: + if (result.uint_32 < 1) { + p9_debug(P9_DEBUG_ERROR, + "locktimeout must be a greater than zero integer.\n"); + return -EINVAL; + } + session_opts->session_lock_timeout =3D (long)result.uint_32 * HZ; + break; + + /* Options for client */ + case Opt_msize: + if (result.uint_32 < 4096) { + p9_debug(P9_DEBUG_ERROR, "msize should be at least 4k\n"); + return -EINVAL; + } + if (result.uint_32 > INT_MAX) { + p9_debug(P9_DEBUG_ERROR, "msize too big\n"); + return -EINVAL; } + clnt->msize =3D result.uint_32; + break; + case Opt_trans: + v9fs_put_trans(clnt->trans_mod); + clnt->trans_mod =3D v9fs_get_trans_by_name(param->string); + if (!clnt->trans_mod) { + pr_info("Could not find request transport: %s\n", + param->string); + return -EINVAL; + } + break; + case Opt_legacy: + clnt->proto_version =3D p9_proto_legacy; + break; + case Opt_version: + clnt->proto_version =3D result.uint_32; + p9_debug(P9_DEBUG_9P, "Protocol version: %s\n", param->string); + break; + /* Options for fd transport */ + case Opt_rfdno: + fd_opts->rfd =3D result.uint_32; + break; + case Opt_wfdno: + fd_opts->wfd =3D result.uint_32; + break; + /* Options for rdma transport */ + case Opt_sq_depth: + rdma_opts->sq_depth =3D result.uint_32; + break; + case Opt_rq_depth: + rdma_opts->rq_depth =3D result.uint_32; + break; + case Opt_timeout: + rdma_opts->timeout =3D result.uint_32; + break; + /* Options for both fd and rdma transports */ + case Opt_port: + fd_opts->port =3D result.uint_32; + rdma_opts->port =3D result.uint_32; + break; + case Opt_privport: + fd_opts->privport =3D true; + rdma_opts->port =3D true; + break; } =20 -free_and_return: - kfree(tmp_options); -fail_option_alloc: - return ret; + return 0; +} + +static void v9fs_apply_options(struct v9fs_session_info *v9ses, + struct fs_context *fc) +{ + struct v9fs_context *ctx =3D fc->fs_private; + + v9ses->debug =3D ctx->session_opts.debug; + v9ses->dfltuid =3D ctx->session_opts.dfltuid; + v9ses->dfltgid =3D ctx->session_opts.dfltgid; + v9ses->afid =3D ctx->session_opts.afid; + v9ses->uname =3D ctx->session_opts.uname; + ctx->session_opts.uname =3D NULL; + v9ses->aname =3D ctx->session_opts.aname; + ctx->session_opts.aname =3D NULL; + v9ses->nodev =3D ctx->session_opts.nodev; + /* + * Note that we must |=3D flags here as session_init already + * set basic flags. This adds in flags from parsed options. + */ + v9ses->flags |=3D ctx->session_opts.flags; +#ifdef CONFIG_9P_FSCACHE + v9ses->cachetag =3D ctx->session_opts.cachetag; + ctx->session_opts.cachetag =3D NULL; +#endif + v9ses->cache =3D ctx->session_opts.cache; + v9ses->uid =3D ctx->session_opts.uid; + v9ses->session_lock_timeout =3D ctx->session_opts.session_lock_timeout; } =20 /** * v9fs_session_init - initialize session * @v9ses: session information structure - * @dev_name: device being mounted - * @data: options + * @fc: the filesystem mount context * */ =20 struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, - const char *dev_name, char *data) + struct fs_context *fc) { struct p9_fid *fid; int rc =3D -ENOMEM; =20 - v9ses->uname =3D kstrdup(V9FS_DEFUSER, GFP_KERNEL); - if (!v9ses->uname) - goto err_names; - - v9ses->aname =3D kstrdup(V9FS_DEFANAME, GFP_KERNEL); - if (!v9ses->aname) - goto err_names; init_rwsem(&v9ses->rename_sem); =20 - v9ses->uid =3D INVALID_UID; - v9ses->dfltuid =3D V9FS_DEFUID; - v9ses->dfltgid =3D V9FS_DEFGID; - - v9ses->clnt =3D p9_client_create(dev_name, data); + v9ses->clnt =3D p9_client_create(fc); if (IS_ERR(v9ses->clnt)) { rc =3D PTR_ERR(v9ses->clnt); p9_debug(P9_DEBUG_ERROR, "problem initializing 9p client\n"); goto err_names; } =20 + /* + * Initialize flags on the real v9ses. v9fs_apply_options below + * will |=3D the additional flags from parsed options. + */ v9ses->flags =3D V9FS_ACCESS_USER; =20 if (p9_is_proto_dotl(v9ses->clnt)) { @@ -423,9 +426,7 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_in= fo *v9ses, v9ses->flags |=3D V9FS_PROTO_2000U; } =20 - rc =3D v9fs_parse_options(v9ses, data); - if (rc < 0) - goto err_clnt; + v9fs_apply_options(v9ses, fc); =20 v9ses->maxdata =3D v9ses->clnt->msize - P9_IOHDRSZ; =20 @@ -472,7 +473,7 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_in= fo *v9ses, #ifdef CONFIG_9P_FSCACHE /* register the session for caching */ if (v9ses->cache & CACHE_FSCACHE) { - rc =3D v9fs_cache_session_get_cookie(v9ses, dev_name); + rc =3D v9fs_cache_session_get_cookie(v9ses, fc->source); if (rc < 0) goto err_clnt; } diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h index f28bc763847a..6a12445d3858 100644 --- a/fs/9p/v9fs.h +++ b/fs/9p/v9fs.h @@ -10,6 +10,9 @@ =20 #include #include +#include +#include +#include =20 /** * enum p9_session_flags - option flags for each 9P session @@ -163,11 +166,13 @@ static inline struct fscache_volume *v9fs_session_cac= he(struct v9fs_session_info #endif } =20 +extern const struct fs_parameter_spec v9fs_param_spec[]; =20 +extern int v9fs_parse_param(struct fs_context *fc, struct fs_parameter *pa= ram); extern int v9fs_show_options(struct seq_file *m, struct dentry *root); =20 struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, - const char *dev_name, char *data); + struct fs_context *fc); extern void v9fs_session_close(struct v9fs_session_info *v9ses); extern void v9fs_session_cancel(struct v9fs_session_info *v9ses); extern void v9fs_session_begin_cancel(struct v9fs_session_info *v9ses); diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c index 1581ebac5bb4..315336de6f02 100644 --- a/fs/9p/vfs_super.c +++ b/fs/9p/vfs_super.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include =20 @@ -30,32 +31,10 @@ =20 static const struct super_operations v9fs_super_ops, v9fs_super_ops_dotl; =20 -/** - * v9fs_set_super - set the superblock - * @s: super block - * @data: file system specific data - * - */ - -static int v9fs_set_super(struct super_block *s, void *data) -{ - s->s_fs_info =3D data; - return set_anon_super(s, data); -} - -/** - * v9fs_fill_super - populate superblock with info - * @sb: superblock - * @v9ses: session information - * @flags: flags propagated from v9fs_mount() - * - */ - -static int -v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses, - int flags) +static int v9fs_fill_super(struct super_block *sb) { int ret; + struct v9fs_session_info *v9ses =3D v9ses =3D sb->s_fs_info; =20 sb->s_maxbytes =3D MAX_LFS_FILESIZE; sb->s_blocksize_bits =3D fls(v9ses->maxdata - 1); @@ -95,16 +74,12 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_ses= sion_info *v9ses, } =20 /** - * v9fs_mount - mount a superblock - * @fs_type: file system type - * @flags: mount flags - * @dev_name: device name that was mounted - * @data: mount options + * v9fs_get_tree - create the mountable root and superblock + * @fc: the filesystem context * */ =20 -static struct dentry *v9fs_mount(struct file_system_type *fs_type, int fla= gs, - const char *dev_name, void *data) +static int v9fs_get_tree(struct fs_context *fc) { struct super_block *sb =3D NULL; struct inode *inode =3D NULL; @@ -117,20 +92,21 @@ static struct dentry *v9fs_mount(struct file_system_ty= pe *fs_type, int flags, =20 v9ses =3D kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL); if (!v9ses) - return ERR_PTR(-ENOMEM); + return -ENOMEM; =20 - fid =3D v9fs_session_init(v9ses, dev_name, data); + fid =3D v9fs_session_init(v9ses, fc); if (IS_ERR(fid)) { retval =3D PTR_ERR(fid); goto free_session; } =20 - sb =3D sget(fs_type, NULL, v9fs_set_super, flags, v9ses); + fc->s_fs_info =3D v9ses; + sb =3D sget_fc(fc, NULL, set_anon_super_fc); if (IS_ERR(sb)) { retval =3D PTR_ERR(sb); goto clunk_fid; } - retval =3D v9fs_fill_super(sb, v9ses, flags); + retval =3D v9fs_fill_super(sb); if (retval) goto release_sb; =20 @@ -159,14 +135,15 @@ static struct dentry *v9fs_mount(struct file_system_t= ype *fs_type, int flags, v9fs_fid_add(root, &fid); =20 p9_debug(P9_DEBUG_VFS, " simple set mount, return 0\n"); - return dget(sb->s_root); + fc->root =3D dget(sb->s_root); + return 0; =20 clunk_fid: p9_fid_put(fid); v9fs_session_close(v9ses); free_session: kfree(v9ses); - return ERR_PTR(retval); + return retval; =20 release_sb: /* @@ -177,7 +154,7 @@ static struct dentry *v9fs_mount(struct file_system_typ= e *fs_type, int flags, */ p9_fid_put(fid); deactivate_locked_super(sb); - return ERR_PTR(retval); + return retval; } =20 /** @@ -303,11 +280,86 @@ static const struct super_operations v9fs_super_ops_d= otl =3D { .write_inode =3D v9fs_write_inode_dotl, }; =20 +static void v9fs_free_fc(struct fs_context *fc) +{ + struct v9fs_context *ctx =3D fc->fs_private; + + if (!ctx) + return; + + /* These should be NULL by now but guard against leaks */ + kfree(ctx->session_opts.uname); + kfree(ctx->session_opts.aname); +#ifdef CONFIG_9P_FSCACHE + kfree(ctx->session_opts.cachetag); +#endif + if (ctx->client_opts.trans_mod) + v9fs_put_trans(ctx->client_opts.trans_mod); + kfree(ctx); +} + +static const struct fs_context_operations v9fs_context_ops =3D { + .parse_param =3D v9fs_parse_param, + .get_tree =3D v9fs_get_tree, + .free =3D v9fs_free_fc, +}; + +static int v9fs_init_fs_context(struct fs_context *fc) +{ + struct v9fs_context *ctx; + + ctx =3D kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + /* initialize core options */ + ctx->session_opts.afid =3D ~0; + ctx->session_opts.cache =3D CACHE_NONE; + ctx->session_opts.session_lock_timeout =3D P9_LOCK_TIMEOUT; + ctx->session_opts.uname =3D kstrdup(V9FS_DEFUSER, GFP_KERNEL); + if (!ctx->session_opts.uname) + goto error; + + ctx->session_opts.aname =3D kstrdup(V9FS_DEFANAME, GFP_KERNEL); + if (!ctx->session_opts.aname) + goto error; + + ctx->session_opts.uid =3D INVALID_UID; + ctx->session_opts.dfltuid =3D V9FS_DEFUID; + ctx->session_opts.dfltgid =3D V9FS_DEFGID; + + /* initialize client options */ + ctx->client_opts.proto_version =3D p9_proto_2000L; + ctx->client_opts.msize =3D DEFAULT_MSIZE; + + /* initialize fd transport options */ + ctx->fd_opts.port =3D P9_FD_PORT; + ctx->fd_opts.rfd =3D ~0; + ctx->fd_opts.wfd =3D ~0; + ctx->fd_opts.privport =3D false; + + /* initialize rdma transport options */ + ctx->rdma_opts.port =3D P9_RDMA_PORT; + ctx->rdma_opts.sq_depth =3D P9_RDMA_SQ_DEPTH; + ctx->rdma_opts.rq_depth =3D P9_RDMA_RQ_DEPTH; + ctx->rdma_opts.timeout =3D P9_RDMA_TIMEOUT; + ctx->rdma_opts.privport =3D false; + + fc->ops =3D &v9fs_context_ops; + fc->fs_private =3D ctx; + + return 0; +error: + fc->need_free =3D 1; + return -ENOMEM; +} + struct file_system_type v9fs_fs_type =3D { .name =3D "9p", - .mount =3D v9fs_mount, .kill_sb =3D v9fs_kill_super, .owner =3D THIS_MODULE, .fs_flags =3D FS_RENAME_DOES_D_MOVE, + .init_fs_context =3D v9fs_init_fs_context, + .parameters =3D v9fs_param_spec, }; MODULE_ALIAS_FS("9p"); diff --git a/include/net/9p/client.h b/include/net/9p/client.h index cc18443f7d51..838a94218b59 100644 --- a/include/net/9p/client.h +++ b/include/net/9p/client.h @@ -279,7 +279,7 @@ int p9_client_rename(struct p9_fid *fid, struct p9_fid = *newdirfid, const char *name); int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name, struct p9_fid *newdirfid, const char *new_name); -struct p9_client *p9_client_create(const char *dev_name, char *options); +struct p9_client *p9_client_create(struct fs_context *fc); void p9_client_destroy(struct p9_client *clnt); void p9_client_disconnect(struct p9_client *clnt); void p9_client_begin_disconnect(struct p9_client *clnt); diff --git a/include/net/9p/transport.h b/include/net/9p/transport.h index ebbb4b50ee20..e53f312191b6 100644 --- a/include/net/9p/transport.h +++ b/include/net/9p/transport.h @@ -53,7 +53,7 @@ struct p9_trans_module { int def; /* this transport should be default */ struct module *owner; int (*create)(struct p9_client *client, - const char *devname, char *args); + struct fs_context *fc); void (*close)(struct p9_client *client); int (*request)(struct p9_client *client, struct p9_req_t *req); int (*cancel)(struct p9_client *client, struct p9_req_t *req); diff --git a/net/9p/client.c b/net/9p/client.c index 5e3230b1bfab..22b88596e2fe 100644 --- a/net/9p/client.c +++ b/net/9p/client.c @@ -20,8 +20,8 @@ #include #include #include -#include #include +#include #include #include #include "protocol.h" @@ -33,22 +33,6 @@ * - a little lazy - parse all client options */ =20 -enum { - Opt_msize, - Opt_trans, - Opt_legacy, - Opt_version, - Opt_err, -}; - -static const match_table_t tokens =3D { - {Opt_msize, "msize=3D%u"}, - {Opt_legacy, "noextend"}, - {Opt_trans, "trans=3D%s"}, - {Opt_version, "version=3D%s"}, - {Opt_err, NULL}, -}; - inline int p9_is_proto_dotl(struct p9_client *clnt) { return clnt->proto_version =3D=3D p9_proto_2000L; @@ -97,124 +81,16 @@ static int safe_errno(int err) return err; } =20 -/* Interpret mount option for protocol version */ -static int get_protocol_version(char *s) +static int apply_client_options(struct p9_client *clnt, struct fs_context = *fc) { - int version =3D -EINVAL; - - if (!strcmp(s, "9p2000")) { - version =3D p9_proto_legacy; - p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n"); - } else if (!strcmp(s, "9p2000.u")) { - version =3D p9_proto_2000u; - p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n"); - } else if (!strcmp(s, "9p2000.L")) { - version =3D p9_proto_2000L; - p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n"); - } else { - pr_info("Unknown protocol version %s\n", s); - } + struct v9fs_context *ctx =3D fc->fs_private; =20 - return version; -} - -/** - * parse_opts - parse mount options into client structure - * @opts: options string passed from mount - * @clnt: existing v9fs client information - * - * Return 0 upon success, -ERRNO upon failure - */ - -static int parse_opts(char *opts, struct p9_client *clnt) -{ - char *options, *tmp_options; - char *p; - substring_t args[MAX_OPT_ARGS]; - int option; - char *s; - int ret =3D 0; - - clnt->proto_version =3D p9_proto_2000L; - clnt->msize =3D DEFAULT_MSIZE; - - if (!opts) - return 0; + clnt->msize =3D ctx->client_opts.msize; + clnt->trans_mod =3D ctx->client_opts.trans_mod; + ctx->client_opts.trans_mod =3D NULL; + clnt->proto_version =3D ctx->client_opts.proto_version; =20 - tmp_options =3D kstrdup(opts, GFP_KERNEL); - if (!tmp_options) - return -ENOMEM; - options =3D tmp_options; - - while ((p =3D strsep(&options, ",")) !=3D NULL) { - int token, r; - - if (!*p) - continue; - token =3D match_token(p, tokens, args); - switch (token) { - case Opt_msize: - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - ret =3D r; - continue; - } - if (option < 4096) { - p9_debug(P9_DEBUG_ERROR, - "msize should be at least 4k\n"); - ret =3D -EINVAL; - continue; - } - clnt->msize =3D option; - break; - case Opt_trans: - s =3D match_strdup(&args[0]); - if (!s) { - ret =3D -ENOMEM; - p9_debug(P9_DEBUG_ERROR, - "problem allocating copy of trans arg\n"); - goto free_and_return; - } - - v9fs_put_trans(clnt->trans_mod); - clnt->trans_mod =3D v9fs_get_trans_by_name(s); - if (!clnt->trans_mod) { - pr_info("Could not find request transport: %s\n", - s); - ret =3D -EINVAL; - } - kfree(s); - break; - case Opt_legacy: - clnt->proto_version =3D p9_proto_legacy; - break; - case Opt_version: - s =3D match_strdup(&args[0]); - if (!s) { - ret =3D -ENOMEM; - p9_debug(P9_DEBUG_ERROR, - "problem allocating copy of version arg\n"); - goto free_and_return; - } - r =3D get_protocol_version(s); - if (r < 0) - ret =3D r; - else - clnt->proto_version =3D r; - kfree(s); - break; - default: - continue; - } - } - -free_and_return: - if (ret) - v9fs_put_trans(clnt->trans_mod); - kfree(tmp_options); - return ret; + return 0; } =20 static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc, @@ -968,7 +844,7 @@ static int p9_client_version(struct p9_client *c) return err; } =20 -struct p9_client *p9_client_create(const char *dev_name, char *options) +struct p9_client *p9_client_create(struct fs_context *fc) { int err; static atomic_t seqno =3D ATOMIC_INIT(0); @@ -991,8 +867,8 @@ struct p9_client *p9_client_create(const char *dev_name= , char *options) idr_init(&clnt->fids); idr_init(&clnt->reqs); =20 - err =3D parse_opts(options, clnt); - if (err < 0) + err =3D apply_client_options(clnt, fc); + if (err) goto free_client; =20 if (!clnt->trans_mod) @@ -1008,7 +884,7 @@ struct p9_client *p9_client_create(const char *dev_nam= e, char *options) p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n", clnt, clnt->trans_mod, clnt->msize, clnt->proto_version); =20 - err =3D clnt->trans_mod->create(clnt, dev_name, options); + err =3D clnt->trans_mod->create(clnt, fc); if (err) goto put_trans; =20 diff --git a/net/9p/mod.c b/net/9p/mod.c index 55576c1866fa..85160b52da55 100644 --- a/net/9p/mod.c +++ b/net/9p/mod.c @@ -16,7 +16,6 @@ #include #include #include -#include #include #include #include @@ -171,6 +170,7 @@ void v9fs_put_trans(struct p9_trans_module *m) if (m) module_put(m->owner); } +EXPORT_SYMBOL(v9fs_put_trans); =20 /** * init_p9 - Initialize module diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c index 9ef4f2e0db3c..cb4398d79b0a 100644 --- a/net/9p/trans_fd.c +++ b/net/9p/trans_fd.c @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include #include #include @@ -37,26 +37,6 @@ static struct p9_trans_module p9_tcp_trans; static struct p9_trans_module p9_fd_trans; =20 -/* - * Option Parsing (code inspired by NFS code) - * - a little lazy - parse all fd-transport options - */ - -enum { - /* Options that take integer arguments */ - Opt_port, Opt_rfdno, Opt_wfdno, Opt_err, - /* Options that take no arguments */ - Opt_privport, -}; - -static const match_table_t tokens =3D { - {Opt_port, "port=3D%u"}, - {Opt_rfdno, "rfdno=3D%u"}, - {Opt_wfdno, "wfdno=3D%u"}, - {Opt_privport, "privport"}, - {Opt_err, NULL}, -}; - enum { Rworksched =3D 1, /* read work scheduled or running */ Rpending =3D 2, /* can read */ @@ -744,73 +724,6 @@ static int p9_fd_show_options(struct seq_file *m, stru= ct p9_client *clnt) return 0; } =20 -/** - * parse_opts - parse mount options into p9_fd_opts structure - * @params: options string passed from mount - * @opts: fd transport-specific structure to parse options into - * - * Returns 0 upon success, -ERRNO upon failure - */ - -static int parse_opts(char *params, struct p9_fd_opts *opts) -{ - char *p; - substring_t args[MAX_OPT_ARGS]; - int option; - char *options, *tmp_options; - - opts->port =3D P9_FD_PORT; - opts->rfd =3D ~0; - opts->wfd =3D ~0; - opts->privport =3D false; - - if (!params) - return 0; - - tmp_options =3D kstrdup(params, GFP_KERNEL); - if (!tmp_options) { - p9_debug(P9_DEBUG_ERROR, - "failed to allocate copy of option string\n"); - return -ENOMEM; - } - options =3D tmp_options; - - while ((p =3D strsep(&options, ",")) !=3D NULL) { - int token; - int r; - if (!*p) - continue; - token =3D match_token(p, tokens, args); - if ((token !=3D Opt_err) && (token !=3D Opt_privport)) { - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - continue; - } - } - switch (token) { - case Opt_port: - opts->port =3D option; - break; - case Opt_rfdno: - opts->rfd =3D option; - break; - case Opt_wfdno: - opts->wfd =3D option; - break; - case Opt_privport: - opts->privport =3D true; - break; - default: - continue; - } - } - - kfree(tmp_options); - return 0; -} - static int p9_fd_open(struct p9_client *client, int rfd, int wfd) { struct p9_trans_fd *ts =3D kzalloc(sizeof(struct p9_trans_fd), @@ -965,17 +878,18 @@ static int p9_bind_privport(struct socket *sock) } =20 static int -p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args) +p9_fd_create_tcp(struct p9_client *client, struct fs_context *fc) { + const char *addr =3D fc->source; + struct v9fs_context *ctx =3D fc->fs_private; int err; char port_str[6]; struct socket *csocket; struct sockaddr_storage stor =3D { 0 }; struct p9_fd_opts opts; =20 - err =3D parse_opts(args, &opts); - if (err < 0) - return err; + /* opts are already parsed in context */ + opts =3D ctx->fd_opts; =20 if (!addr) return -EINVAL; @@ -1022,8 +936,9 @@ p9_fd_create_tcp(struct p9_client *client, const char = *addr, char *args) } =20 static int -p9_fd_create_unix(struct p9_client *client, const char *addr, char *args) +p9_fd_create_unix(struct p9_client *client, struct fs_context *fc) { + const char *addr =3D fc->source; int err; struct socket *csocket; struct sockaddr_un sun_server; @@ -1062,14 +977,12 @@ p9_fd_create_unix(struct p9_client *client, const ch= ar *addr, char *args) } =20 static int -p9_fd_create(struct p9_client *client, const char *addr, char *args) +p9_fd_create(struct p9_client *client, struct fs_context *fc) { + struct v9fs_context *ctx =3D fc->fs_private; + struct p9_fd_opts opts =3D ctx->fd_opts; int err; - struct p9_fd_opts opts; =20 - err =3D parse_opts(args, &opts); - if (err < 0) - return err; client->trans_opts.fd.rfd =3D opts.rfd; client->trans_opts.fd.wfd =3D opts.wfd; =20 diff --git a/net/9p/trans_rdma.c b/net/9p/trans_rdma.c index 46ee37061faf..fa3365990fdf 100644 --- a/net/9p/trans_rdma.c +++ b/net/9p/trans_rdma.c @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include #include #include @@ -106,26 +106,6 @@ struct p9_rdma_context { }; }; =20 -/* - * Option Parsing (code inspired by NFS code) - */ -enum { - /* Options that take integer arguments */ - Opt_port, Opt_rq_depth, Opt_sq_depth, Opt_timeout, - /* Options that take no argument */ - Opt_privport, - Opt_err, -}; - -static match_table_t tokens =3D { - {Opt_port, "port=3D%u"}, - {Opt_sq_depth, "sq=3D%u"}, - {Opt_rq_depth, "rq=3D%u"}, - {Opt_timeout, "timeout=3D%u"}, - {Opt_privport, "privport"}, - {Opt_err, NULL}, -}; - static int p9_rdma_show_options(struct seq_file *m, struct p9_client *clnt) { struct p9_trans_rdma *rdma =3D clnt->trans; @@ -143,77 +123,6 @@ static int p9_rdma_show_options(struct seq_file *m, st= ruct p9_client *clnt) return 0; } =20 -/** - * parse_opts - parse mount options into rdma options structure - * @params: options string passed from mount - * @opts: rdma transport-specific structure to parse options into - * - * Returns 0 upon success, -ERRNO upon failure - */ -static int parse_opts(char *params, struct p9_rdma_opts *opts) -{ - char *p; - substring_t args[MAX_OPT_ARGS]; - int option; - char *options, *tmp_options; - - opts->port =3D P9_RDMA_PORT; - opts->sq_depth =3D P9_RDMA_SQ_DEPTH; - opts->rq_depth =3D P9_RDMA_RQ_DEPTH; - opts->timeout =3D P9_RDMA_TIMEOUT; - opts->privport =3D false; - - if (!params) - return 0; - - tmp_options =3D kstrdup(params, GFP_KERNEL); - if (!tmp_options) { - p9_debug(P9_DEBUG_ERROR, - "failed to allocate copy of option string\n"); - return -ENOMEM; - } - options =3D tmp_options; - - while ((p =3D strsep(&options, ",")) !=3D NULL) { - int token; - int r; - if (!*p) - continue; - token =3D match_token(p, tokens, args); - if ((token !=3D Opt_err) && (token !=3D Opt_privport)) { - r =3D match_int(&args[0], &option); - if (r < 0) { - p9_debug(P9_DEBUG_ERROR, - "integer field, but no integer?\n"); - continue; - } - } - switch (token) { - case Opt_port: - opts->port =3D option; - break; - case Opt_sq_depth: - opts->sq_depth =3D option; - break; - case Opt_rq_depth: - opts->rq_depth =3D option; - break; - case Opt_timeout: - opts->timeout =3D option; - break; - case Opt_privport: - opts->privport =3D true; - break; - default: - continue; - } - } - /* RQ must be at least as large as the SQ */ - opts->rq_depth =3D max(opts->rq_depth, opts->sq_depth); - kfree(tmp_options); - return 0; -} - static int p9_cm_event_handler(struct rdma_cm_id *id, struct rdma_cm_event *event) { @@ -607,14 +516,15 @@ static int p9_rdma_bind_privport(struct p9_trans_rdma= *rdma) /** * rdma_create_trans - Transport method for creating a transport instance * @client: client instance - * @addr: IP address string - * @args: Mount options string + * @fc: The filesystem context */ static int -rdma_create_trans(struct p9_client *client, const char *addr, char *args) +rdma_create_trans(struct p9_client *client, struct fs_context *fc) { + const char *addr =3D fc->source; + struct v9fs_context *ctx =3D fc->fs_private; + struct p9_rdma_opts opts =3D ctx->rdma_opts; int err; - struct p9_rdma_opts opts; struct p9_trans_rdma *rdma; struct rdma_conn_param conn_param; struct ib_qp_init_attr qp_attr; @@ -622,10 +532,8 @@ rdma_create_trans(struct p9_client *client, const char= *addr, char *args) if (addr =3D=3D NULL) return -EINVAL; =20 - /* Parse the transport specific mount options */ - err =3D parse_opts(args, &opts); - if (err < 0) - return err; + /* options are already parsed, in the fs context */ + opts =3D ctx->rdma_opts; =20 /* Create and initialize the RDMA transport structure */ rdma =3D alloc_rdma(&opts); diff --git a/net/9p/trans_usbg.c b/net/9p/trans_usbg.c index 6b694f117aef..61197dae52cb 100644 --- a/net/9p/trans_usbg.c +++ b/net/9p/trans_usbg.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include =20 @@ -366,8 +367,9 @@ enable_usb9pfs(struct usb_composite_dev *cdev, struct f= _usb9pfs *usb9pfs) return ret; } =20 -static int p9_usbg_create(struct p9_client *client, const char *devname, c= har *args) +static int p9_usbg_create(struct p9_client *client, struct fs_context *fc) { + const char *devname =3D fc->source; struct f_usb9pfs_dev *dev; struct f_usb9pfs *usb9pfs; int ret =3D -ENOENT; diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c index 0b8086f58ad5..580d74ca92b0 100644 --- a/net/9p/trans_virtio.c +++ b/net/9p/trans_virtio.c @@ -26,7 +26,7 @@ #include #include #include -#include +#include #include #include #include @@ -679,8 +679,7 @@ static int p9_virtio_probe(struct virtio_device *vdev) /** * p9_virtio_create - allocate a new virtio channel * @client: client instance invoking this transport - * @devname: string identifying the channel to connect to (unused) - * @args: args passed from sys_mount() for per-transport options (unused) + * @fc: the filesystem context * * This sets up a transport channel for 9p communication. Right now * we only match the first available channel, but eventually we could look= up @@ -691,8 +690,9 @@ static int p9_virtio_probe(struct virtio_device *vdev) */ =20 static int -p9_virtio_create(struct p9_client *client, const char *devname, char *args) +p9_virtio_create(struct p9_client *client, struct fs_context *fc) { + const char *devname =3D fc->source; struct virtio_chan *chan; int ret =3D -ENOENT; int found =3D 0; diff --git a/net/9p/trans_xen.c b/net/9p/trans_xen.c index b9ff69c7522a..091a99eb51f4 100644 --- a/net/9p/trans_xen.c +++ b/net/9p/trans_xen.c @@ -15,6 +15,7 @@ =20 #include #include +#include #include #include #include @@ -66,8 +67,9 @@ static int p9_xen_cancel(struct p9_client *client, struct= p9_req_t *req) return 1; } =20 -static int p9_xen_create(struct p9_client *client, const char *addr, char = *args) +static int p9_xen_create(struct p9_client *client, struct fs_context *fc) { + const char *addr =3D fc->source; struct xen_9pfs_front_priv *priv; =20 if (addr =3D=3D NULL) --=20 2.51.0