nfs/nfsd: add support for localio
Subsystems (5)
v7 cover nfs/nfsd: add support for localio
Hi,
IANA has assigned the RPC program number 400122 for localio!
Tested with xfstests, all is passing agsint NFS v3 and v4.2 (localio ontop of XFS) except generic/355 (which tests if suid bit gets cleared with directio).
My git tree is here:
https://git.kernel.org/pub/scm/linux/kernel/git/snitzer/linux.git/
This v7 is both branch nfs-localio-for-6.11 (always tracks latest) and nfs-localio-for-6.11.v7
Quite a bit has changed since v6:
- Updated to use IANA assigned RPC program number 400122.
- Thanks to Neil the localio protocol stands on its own and is simplified, all of Neil's changes were included. But a patch is needed to sunrpc to remove the BUG_ON if p_arglen is 0 (otherwise the NULL rpc used during connection triggers the BUG_ON.
- Reduced Kconfig knobs down to NFS_LOCALIO and NFSD_LOCALIO. Left them piece-wise for reason detailed in the last patch.
- Added MODULE_DESCRIPTION to nfs_localio module.
- Removed all the AIO directio code from fs/nfs/localio.c because it wasn't used (since nothing ever set NFS_IOHDR_ODIRECT). But even if enabled the async kiocb completion wasn't ever used in practice.
TODO:
- For directio, fix kiocb so that it conveys IOCB_DIRECT to underlying filesystem.
- Must fix xfstests generic/355.
- Look closer at implementing standlone SRCU to avoid bloating nfsd_net -- idea of shared SRCU is very unintuitive to me...
FYI:
- Really rather not play games with 'localio_enabled' to get all of localio code to build but be disabled by default.. just too fiddley.
All review and comments are welcome!
Thanks,
Mike
Mike Snitzer (11):
nfs_common: add NFS LOCALIO auxiliary protocol enablement nfsd/localio: manage netns reference in nfsd_open_local_fh nfs/nfsd: factor out {encode,decode}_opaque_fixed to nfs_xdr.h
SUNRPC: remove call_allocate() BUG_ON if p_arglen=0 to allow RPC with void arg
nfs: implement client support for NFS_LOCALIO_PROGRAM
nfsd: implement server support for NFS_LOCALIO_PROGRAM
nfsd: prepare to use SRCU to dereference nn->nfsd_serv
nfsd: use SRCU to dereference nn->nfsd_serv
nfsd/localio: use SRCU to dereference nn->nfsd_serv in nfsd_open_local_fh
nfs: add Documentation/filesystems/nfs/localio.rst
nfs/nfsd: add Kconfig options to allow localio to be enabled
NeilBrown (1):
SUNRPC: replace program list with program array
Trond Myklebust (3):
NFS: Enable localio for non-pNFS I/O
pnfs/flexfiles: Enable localio for flexfiles I/O nfs/localio: use dedicated workqueues for filesystem read and write
Weston Andros Adamson (5):
nfs: pass nfs_client to nfs_initiate_pgio
nfs: pass descriptor thru nfs_initiate_pgio path
nfs: pass struct file to nfs_init_pgio and nfs_init_commit
sunrpc: add rpcauth_map_to_svc_cred_local nfs/nfsd: add "localio" support
Documentation/filesystems/nfs/localio.rst | 134 ++++ fs/Kconfig | 3 + fs/nfs/Kconfig | 14 + fs/nfs/Makefile | 1 + fs/nfs/blocklayout/blocklayout.c | 6 +- fs/nfs/client.c | 15 +- fs/nfs/filelayout/filelayout.c | 16 +- fs/nfs/flexfilelayout/flexfilelayout.c | 131 +++- fs/nfs/flexfilelayout/flexfilelayout.h | 2 + fs/nfs/flexfilelayout/flexfilelayoutdev.c | 6 + fs/nfs/inode.c | 61 +- fs/nfs/internal.h | 61 +- fs/nfs/localio.c | 851 ++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 13 - fs/nfs/nfstrace.h | 61 ++ fs/nfs/pagelist.c | 32 +- fs/nfs/pnfs.c | 24 +- fs/nfs/pnfs.h | 6 +- fs/nfs/pnfs_nfs.c | 2 +- fs/nfs/write.c | 13 +- fs/nfs_common/Makefile | 3 + fs/nfs_common/nfslocalio.c | 72 ++ fs/nfsd/Kconfig | 14 + fs/nfsd/Makefile | 1 + fs/nfsd/filecache.c | 15 +- fs/nfsd/localio.c | 327 +++++++++ fs/nfsd/netns.h | 18 +- fs/nfsd/nfs4state.c | 25 +- fs/nfsd/nfsctl.c | 30 +- fs/nfsd/nfsd.h | 2 +- fs/nfsd/nfssvc.c | 165 +++-- fs/nfsd/trace.h | 3 +- fs/nfsd/vfs.h | 9 + include/linux/nfs.h | 9 + include/linux/nfs_fs.h | 2 + include/linux/nfs_fs_sb.h | 10 + include/linux/nfs_xdr.h | 20 +- include/linux/nfslocalio.h | 41 ++ include/linux/sunrpc/auth.h | 4 + include/linux/sunrpc/svc.h | 7 +- net/sunrpc/auth.c | 15 + net/sunrpc/clnt.c | 1 - net/sunrpc/svc.c | 68 +- net/sunrpc/svc_xprt.c | 2 +- net/sunrpc/svcauth_unix.c | 3 +- 45 files changed, 2116 insertions(+), 202 deletions(-) create mode 100644 Documentation/filesystems/nfs/localio.rst create mode 100644 fs/nfs/localio.c create mode 100644 fs/nfs_common/nfslocalio.c create mode 100644 fs/nfsd/localio.c create mode 100644 include/linux/nfslocalio.h
Signature · 1 line
2.44.0
PATCH v7 1/20 nfs: pass nfs_client to nfs_initiate_pgio
From: Weston Andros Adamson <[email protected]>
The nfs_client is needed for localio support. Otherwise it won't be possible to disable localio if it is attempted but fails.
--- fs/nfs/filelayout/filelayout.c | 4 ++-- fs/nfs/flexfilelayout/flexfilelayout.c | 6 ++++-- fs/nfs/internal.h | 5 +++-- fs/nfs/pagelist.c | 10 ++++++---- 4 files changed, 15 insertions(+), 10 deletions(-)
fs/nfs/filelayout/filelayout.c +2 -2
@@ -486,7 +486,7 @@ filelayout_read_pagelist(struct nfs_pgio_header *hdr) hdr->mds_offset = offset;/* Perform an asynchronous read to ds */ -nfs_initiate_pgio (ds_clnt, hdr, hdr->cred, +nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_read_call_ops,0 ,RPC_TASK_SOFTCONN );return PNFS_ATTEMPTED ;
@@ -528,7 +528,7 @@ filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync) hdr->args.offset =filelayout_get_dserver_offset (lseg, offset);/* Perform an asynchronous write */ -nfs_initiate_pgio (ds_clnt, hdr, hdr->cred, +nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_write_call_ops, sync,RPC_TASK_SOFTCONN );return PNFS_ATTEMPTED ;
fs/nfs/flexfilelayout/flexfilelayout.c +4 -2
@@ -1803,7 +1803,8 @@ ff_layout_read_pagelist(struct nfs_pgio_header *hdr) hdr->mds_offset = offset;/* Perform an asynchronous read to ds */ -nfs_initiate_pgio (ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, +nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, ds_cred, + ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_read_call_ops_v3 : &ff_layout_read_call_ops_v4,0 ,RPC_TASK_SOFTCONN );
@@ -1871,7 +1872,8 @@ ff_layout_write_pagelist(struct nfs_pgio_header *hdr, int sync) hdr->args.offset = offset;/* Perform an asynchronous write */ -nfs_initiate_pgio (ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, +nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, ds_cred, + ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_write_call_ops_v3 : &ff_layout_write_call_ops_v4, sync,RPC_TASK_SOFTCONN );
fs/nfs/internal.h +3 -2
@@ -306,8 +306,9 @@ extern const struct nfs_pageio_ops nfs_pgio_rw_ops;struct nfs_pgio_header *nfs_pgio_header_alloc (const struct nfs_rw_ops *);void nfs_pgio_header_free (struct nfs_pgio_header *);int nfs_generic_pgio (struct nfs_pageio_descriptor *,struct nfs_pgio_header *); -int nfs_initiate_pgio (struct rpc_clnt *clnt,struct nfs_pgio_header *hdr, -const struct cred *cred,const struct nfs_rpc_ops *rpc_ops, +int nfs_initiate_pgio (struct nfs_client *clp,struct rpc_clnt *rpc_clnt, +struct nfs_pgio_header *hdr,const struct cred *cred, +const struct nfs_rpc_ops *rpc_ops,const struct rpc_call_ops *call_ops,int how,int flags);void nfs_free_request (struct nfs_page *req); struct nfs_pgio_mirror *
fs/nfs/pagelist.c +6 -4
@@ -844,8 +844,9 @@ static void nfs_pgio_prepare(struct rpc_task *task, void *calldata)rpc_exit (task, err); } -int nfs_initiate_pgio (struct rpc_clnt *clnt,struct nfs_pgio_header *hdr, -const struct cred *cred,const struct nfs_rpc_ops *rpc_ops, +int nfs_initiate_pgio (struct nfs_client *clp,struct rpc_clnt *rpc_clnt, +struct nfs_pgio_header *hdr,const struct cred *cred, +const struct nfs_rpc_ops *rpc_ops,const struct rpc_call_ops *call_ops,int how,int flags) {struct rpc_task *task;
@@ -855,7 +856,7 @@ int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr, .rpc_cred = cred, };struct rpc_task_setup task_setup_data = { - .rpc_client = clnt, + .rpc_client = rpc_clnt, .task = &hdr->task, .rpc_message = &msg, .callback_ops = call_ops,
@@ -1070,7 +1071,8 @@ static int nfs_generic_pg_pgios(struct nfs_pageio_descriptor *desc)if (ret ==0 ) {if (NFS_SERVER (hdr->inode)->nfs_client->cl_minorversion) task_flags =RPC_TASK_MOVEABLE ; - ret = nfs_initiate_pgio(NFS_CLIENT(hdr->inode), + ret = nfs_initiate_pgio(NFS_SERVER(hdr->inode)->nfs_client, + NFS_CLIENT(hdr->inode), hdr, hdr->cred, NFS_PROTO(hdr->inode),
Signature · 1 line
2.44.0
PATCH v7 2/20 nfs: pass descriptor thru nfs_initiate_pgio path
In reply to Mike SnitzerFrom: Weston Andros Adamson <[email protected]>
This is needed for localio support.
--- fs/nfs/blocklayout/blocklayout.c | 6 ++++-- fs/nfs/filelayout/filelayout.c | 10 ++++++---- fs/nfs/flexfilelayout/flexfilelayout.c | 10 ++++++---- fs/nfs/internal.h | 6 +++--- fs/nfs/pagelist.c | 6 ++++-- fs/nfs/pnfs.c | 24 +++++++++++++----------- fs/nfs/pnfs.h | 6 ++++-- 7 files changed, 40 insertions(+), 28 deletions(-)
fs/nfs/blocklayout/blocklayout.c +4 -2
@@ -227,7 +227,8 @@ bl_end_par_io_read(void *data) }static enum pnfs_try_status -bl_read_pagelist (struct nfs_pgio_header *header) +bl_read_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *header) {struct pnfs_block_layout *bl =BLK_LSEG2EXT (header->lseg);struct pnfs_block_dev_map map = { .start =NFS4_MAX_UINT64 };
@@ -372,7 +373,8 @@ static void bl_end_par_io_write(void *data) }static enum pnfs_try_status -bl_write_pagelist (struct nfs_pgio_header *header,int sync) +bl_write_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *header,int sync) {struct pnfs_block_layout *bl =BLK_LSEG2EXT (header->lseg);struct pnfs_block_dev_map map = { .start =NFS4_MAX_UINT64 };
fs/nfs/filelayout/filelayout.c +6 -4
@@ -447,7 +447,8 @@ static const struct rpc_call_ops filelayout_commit_call_ops = { };static enum pnfs_try_status -filelayout_read_pagelist (struct nfs_pgio_header *hdr) +filelayout_read_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr) {struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;
@@ -486,7 +487,7 @@ filelayout_read_pagelist(struct nfs_pgio_header *hdr) hdr->mds_offset = offset;/* Perform an asynchronous read to ds */ -nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, hdr->cred, +nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_read_call_ops,0 ,RPC_TASK_SOFTCONN );return PNFS_ATTEMPTED ;
@@ -494,7 +495,8 @@ filelayout_read_pagelist(struct nfs_pgio_header *hdr)/* Perform async writes. */ static enum pnfs_try_status -filelayout_write_pagelist (struct nfs_pgio_header *hdr,int sync) +filelayout_write_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr,int sync) {struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;
@@ -528,7 +530,7 @@ filelayout_write_pagelist(struct nfs_pgio_header *hdr, int sync) hdr->args.offset =filelayout_get_dserver_offset (lseg, offset);/* Perform an asynchronous write */ -nfs_initiate_pgio (ds->ds_clp, ds_clnt, hdr, hdr->cred, +nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_write_call_ops, sync,RPC_TASK_SOFTCONN );return PNFS_ATTEMPTED ;
fs/nfs/flexfilelayout/flexfilelayout.c +6 -4
@@ -1751,7 +1751,8 @@ static const struct rpc_call_ops ff_layout_commit_call_ops_v4 = { };static enum pnfs_try_status -ff_layout_read_pagelist (struct nfs_pgio_header *hdr) +ff_layout_read_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr) {struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;
@@ -1803,7 +1804,7 @@ ff_layout_read_pagelist(struct nfs_pgio_header *hdr) hdr->mds_offset = offset;/* Perform an asynchronous read to ds */ - nfs_initiate_pgio(ds->ds_clp, ds_clnt, hdr, ds_cred, + nfs_initiate_pgio(desc, ds->ds_clp, ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, vers == 3 ? &ff_layout_read_call_ops_v3 : &ff_layout_read_call_ops_v4,
@@ -1822,7 +1823,8 @@ ff_layout_read_pagelist(struct nfs_pgio_header *hdr)/* Perform async writes. */ static enum pnfs_try_status -ff_layout_write_pagelist (struct nfs_pgio_header *hdr,int sync) +ff_layout_write_pagelist (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr,int sync) {struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;
@@ -1872,7 +1874,7 @@ ff_layout_write_pagelist(struct nfs_pgio_header *hdr, int sync) hdr->args.offset = offset;/* Perform an asynchronous write */ - nfs_initiate_pgio(ds->ds_clp, ds_clnt, hdr, ds_cred, + nfs_initiate_pgio(desc, ds->ds_clp, ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, vers == 3 ? &ff_layout_write_call_ops_v3 : &ff_layout_write_call_ops_v4,
fs/nfs/internal.h +3 -3
@@ -306,9 +306,9 @@ extern const struct nfs_pageio_ops nfs_pgio_rw_ops;struct nfs_pgio_header *nfs_pgio_header_alloc (const struct nfs_rw_ops *);void nfs_pgio_header_free (struct nfs_pgio_header *);int nfs_generic_pgio (struct nfs_pageio_descriptor *,struct nfs_pgio_header *); -int nfs_initiate_pgio (struct nfs_client *clp,struct rpc_clnt *rpc_clnt, -struct nfs_pgio_header *hdr,const struct cred *cred, -const struct nfs_rpc_ops *rpc_ops, +int nfs_initiate_pgio (struct nfs_pageio_descriptor *,struct nfs_client *clp, +struct rpc_clnt *rpc_clnt,struct nfs_pgio_header *hdr, +const struct cred *cred,const struct nfs_rpc_ops *rpc_ops,const struct rpc_call_ops *call_ops,int how,int flags);void nfs_free_request (struct nfs_page *req); struct nfs_pgio_mirror *
fs/nfs/pagelist.c +4 -2
@@ -844,7 +844,8 @@ static void nfs_pgio_prepare(struct rpc_task *task, void *calldata)rpc_exit (task, err); } -int nfs_initiate_pgio (struct nfs_client *clp,struct rpc_clnt *rpc_clnt, +int nfs_initiate_pgio (struct nfs_pageio_descriptor *desc, +struct nfs_client *clp,struct rpc_clnt *rpc_clnt,struct nfs_pgio_header *hdr,const struct cred *cred,const struct nfs_rpc_ops *rpc_ops,const struct rpc_call_ops *call_ops,int how,int flags)
@@ -1071,7 +1072,8 @@ static int nfs_generic_pg_pgios(struct nfs_pageio_descriptor *desc)if (ret ==0 ) {if (NFS_SERVER (hdr->inode)->nfs_client->cl_minorversion) task_flags =RPC_TASK_MOVEABLE ; - ret = nfs_initiate_pgio(NFS_SERVER(hdr->inode)->nfs_client, + ret = nfs_initiate_pgio(desc, + NFS_SERVER(hdr->inode)->nfs_client, NFS_CLIENT(hdr->inode), hdr, hdr->cred,
fs/nfs/pnfs.c +13 -11
@@ -2885,10 +2885,11 @@ pnfs_write_through_mds(struct nfs_pageio_descriptor *desc, }static enum pnfs_try_status -pnfs_try_to_write_data (struct nfs_pgio_header *hdr, -const struct rpc_call_ops *call_ops, -struct pnfs_layout_segment *lseg, -int how) +pnfs_try_to_write_data (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops, +struct pnfs_layout_segment *lseg, +int how) {struct inode *inode = hdr->inode;enum pnfs_try_status trypnfs;
@@ -2898,7 +2899,7 @@ pnfs_try_to_write_data(struct nfs_pgio_header *hdr,dprintk ("%s: Writing ino:%lu %u@%llu (how %d)\n" , __func__, inode->i_ino, hdr->args.count, hdr->args.offset, how); - trypnfs = nfss->pnfs_curr_ld->write_pagelist (hdr, how); + trypnfs = nfss->pnfs_curr_ld->write_pagelist (desc, hdr, how);if (trypnfs !=PNFS_NOT_ATTEMPTED )nfs_inc_stats (inode,NFSIOS_PNFS_WRITE );dprintk ("%s End (trypnfs:%d)\n" , __func__, trypnfs);
@@ -2913,7 +2914,7 @@ pnfs_do_write(struct nfs_pageio_descriptor *desc,struct pnfs_layout_segment *lseg = desc->pg_lseg;enum pnfs_try_status trypnfs; - trypnfs =pnfs_try_to_write_data (hdr, call_ops, lseg, how); + trypnfs =pnfs_try_to_write_data (desc, hdr, call_ops, lseg, how);switch (trypnfs) {case PNFS_NOT_ATTEMPTED :pnfs_write_through_mds (desc, hdr);
@@ -3012,9 +3013,10 @@ pnfs_read_through_mds(struct nfs_pageio_descriptor *desc,* Call the appropriate parallel I/O subsystem read function. */ static enum pnfs_try_status -pnfs_try_to_read_data (struct nfs_pgio_header *hdr, -const struct rpc_call_ops *call_ops, -struct pnfs_layout_segment *lseg) +pnfs_try_to_read_data (struct nfs_pageio_descriptor *desc, +struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops, +struct pnfs_layout_segment *lseg) {struct inode *inode = hdr->inode;struct nfs_server *nfss =NFS_SERVER (inode);
@@ -3025,7 +3027,7 @@ pnfs_try_to_read_data(struct nfs_pgio_header *hdr,dprintk ("%s: Reading ino:%lu %u@%llu\n" , __func__, inode->i_ino, hdr->args.count, hdr->args.offset); - trypnfs = nfss->pnfs_curr_ld->read_pagelist (hdr); + trypnfs = nfss->pnfs_curr_ld->read_pagelist (desc, hdr);if (trypnfs !=PNFS_NOT_ATTEMPTED )nfs_inc_stats (inode,NFSIOS_PNFS_READ );dprintk ("%s End (trypnfs:%d)\n" , __func__, trypnfs);
@@ -3058,7 +3060,7 @@ pnfs_do_read(struct nfs_pageio_descriptor *desc, struct nfs_pgio_header *hdr)struct pnfs_layout_segment *lseg = desc->pg_lseg;enum pnfs_try_status trypnfs; - trypnfs =pnfs_try_to_read_data (hdr, call_ops, lseg); + trypnfs =pnfs_try_to_read_data (desc, hdr, call_ops, lseg);switch (trypnfs) {case PNFS_NOT_ATTEMPTED :pnfs_read_through_mds (desc, hdr);
fs/nfs/pnfs.h +4 -2
@@ -157,8 +157,10 @@ struct pnfs_layoutdriver_type {* Return PNFS_ATTEMPTED to indicate the layout code has attempted * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS */ -enum pnfs_try_status (*read_pagelist)(struct nfs_pgio_header *); -enum pnfs_try_status (*write_pagelist)(struct nfs_pgio_header *,int ); +enum pnfs_try_status (*read_pagelist)(struct nfs_pageio_descriptor *, +struct nfs_pgio_header *); +enum pnfs_try_status (*write_pagelist)(struct nfs_pageio_descriptor *, +struct nfs_pgio_header *,int );void (*free_deviceid_node) (struct nfs4_deviceid_node *);struct nfs4_deviceid_node * (*alloc_deviceid_node)
Signature · 1 line
2.44.0
PATCH v7 3/20 nfs: pass struct file to nfs_init_pgio and nfs_init_commit
In reply to Mike SnitzerFrom: Weston Andros Adamson <[email protected]>
This is needed for localio support.
--- fs/nfs/filelayout/filelayout.c | 6 +++--- fs/nfs/flexfilelayout/flexfilelayout.c | 6 +++--- fs/nfs/internal.h | 6 ++++-- fs/nfs/pagelist.c | 6 ++++-- fs/nfs/pnfs_nfs.c | 2 +- fs/nfs/write.c | 5 +++-- 6 files changed, 18 insertions(+), 13 deletions(-)
fs/nfs/filelayout/filelayout.c +3 -3
@@ -489,7 +489,7 @@ filelayout_read_pagelist(struct nfs_pageio_descriptor *desc,/* Perform an asynchronous read to ds */ nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_read_call_ops, -0 ,RPC_TASK_SOFTCONN ); +0 ,RPC_TASK_SOFTCONN ,NULL );return PNFS_ATTEMPTED ; }
@@ -532,7 +532,7 @@ filelayout_write_pagelist(struct nfs_pageio_descriptor *desc,/* Perform an asynchronous write */ nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, hdr->cred,NFS_PROTO (hdr->inode), &filelayout_write_call_ops, - sync,RPC_TASK_SOFTCONN ); + sync,RPC_TASK_SOFTCONN ,NULL );return PNFS_ATTEMPTED ; }
@@ -1013,7 +1013,7 @@ static int filelayout_initiate_commit(struct nfs_commit_data *data, int how) data->args.fh = fh;return nfs_initiate_commit (ds_clnt, data,NFS_PROTO (data->inode), &filelayout_commit_call_ops, how, -RPC_TASK_SOFTCONN ); +RPC_TASK_SOFTCONN ,NULL ); out_err:pnfs_generic_prepare_to_resend_writes (data);pnfs_generic_commit_release (data);
fs/nfs/flexfilelayout/flexfilelayout.c +3 -3
@@ -1808,7 +1808,7 @@ ff_layout_read_pagelist(struct nfs_pageio_descriptor *desc, ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_read_call_ops_v3 : &ff_layout_read_call_ops_v4, - 0, RPC_TASK_SOFTCONN); + 0, RPC_TASK_SOFTCONN, NULL);put_cred (ds_cred);return PNFS_ATTEMPTED ;
@@ -1878,7 +1878,7 @@ ff_layout_write_pagelist(struct nfs_pageio_descriptor *desc, ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_write_call_ops_v3 : &ff_layout_write_call_ops_v4, - sync, RPC_TASK_SOFTCONN); + sync, RPC_TASK_SOFTCONN, NULL);put_cred (ds_cred);return PNFS_ATTEMPTED ;
@@ -1953,7 +1953,7 @@ static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how) ret =nfs_initiate_commit (ds_clnt, data, ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_commit_call_ops_v3 : &ff_layout_commit_call_ops_v4, - how,RPC_TASK_SOFTCONN ); + how,RPC_TASK_SOFTCONN ,NULL );put_cred (ds_cred);return ret; out_err:
fs/nfs/internal.h +4 -2
@@ -309,7 +309,8 @@ int nfs_generic_pgio(struct nfs_pageio_descriptor *, struct nfs_pgio_header *);int nfs_initiate_pgio (struct nfs_pageio_descriptor *,struct nfs_client *clp,struct rpc_clnt *rpc_clnt,struct nfs_pgio_header *hdr,const struct cred *cred,const struct nfs_rpc_ops *rpc_ops, -const struct rpc_call_ops *call_ops,int how,int flags); +const struct rpc_call_ops *call_ops,int how,int flags, +struct file *localio);void nfs_free_request (struct nfs_page *req);struct nfs_pgio_mirror *nfs_pgio_current_mirror (struct nfs_pageio_descriptor *desc);
@@ -529,7 +530,8 @@ extern int nfs_initiate_commit(struct rpc_clnt *clnt,struct nfs_commit_data *data, const struct nfs_rpc_ops *nfs_ops, const struct rpc_call_ops *call_ops, - int how, int flags); + int how, int flags, + struct file *localio); extern void nfs_init_commit(struct nfs_commit_data *data, struct list_head *head, struct pnfs_layout_segment *lseg,
fs/nfs/pagelist.c +4 -2
@@ -848,7 +848,8 @@ int nfs_initiate_pgio(struct nfs_pageio_descriptor *desc, struct nfs_client *clp, struct rpc_clnt *rpc_clnt, struct nfs_pgio_header *hdr, const struct cred *cred, const struct nfs_rpc_ops *rpc_ops, - const struct rpc_call_ops *call_ops, int how, int flags) + const struct rpc_call_ops *call_ops, int how, int flags, + struct file *localio) { struct rpc_task *task; struct rpc_message msg = {
@@ -1080,7 +1081,8 @@ static int nfs_generic_pg_pgios(struct nfs_pageio_descriptor *desc)NFS_PROTO (hdr->inode), desc->pg_rpc_callops, desc->pg_ioflags, - RPC_TASK_CRED_NOREF | task_flags); +RPC_TASK_CRED_NOREF | task_flags, + NULL); }return ret; }
fs/nfs/pnfs_nfs.c +1 -1
@@ -537,7 +537,7 @@ pnfs_generic_commit_pagelist(struct inode *inode, struct list_head *mds_pages,nfs_initiate_commit (NFS_CLIENT (inode), data,NFS_PROTO (data->inode), data->mds_ops, how, -RPC_TASK_CRED_NOREF ); +RPC_TASK_CRED_NOREF ,NULL ); }else {nfs_init_commit (data,NULL , data->lseg, cinfo);initiate_commit (data, how);
fs/nfs/write.c +3 -2
@@ -1670,7 +1670,8 @@ EXPORT_SYMBOL_GPL(nfs_commitdata_release);int nfs_initiate_commit (struct rpc_clnt *clnt,struct nfs_commit_data *data,const struct nfs_rpc_ops *nfs_ops,const struct rpc_call_ops *call_ops, -int how,int flags) +int how,int flags, +struct file *localio) {struct rpc_task *task;int priority =flush_task_priority (how);
@@ -1816,7 +1817,7 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how, task_flags =RPC_TASK_MOVEABLE ;return nfs_initiate_commit (NFS_CLIENT (inode), data,NFS_PROTO (inode), data->mds_ops, how, -RPC_TASK_CRED_NOREF | task_flags); +RPC_TASK_CRED_NOREF | task_flags,NULL ); }/*
Signature · 1 line
2.44.0
PATCH v7 4/20 sunrpc: add rpcauth_map_to_svc_cred_local
In reply to Mike SnitzerFrom: Weston Andros Adamson <[email protected]>
Add new funtion rpcauth_map_to_svc_cred_local which maps a generic cred to a svc_cred suitable for use in nfsd.
This is needed by the localio code to map nfs client creds to nfs server credentials.
--- include/linux/sunrpc/auth.h | 4 ++++ net/sunrpc/auth.c | 15 +++++++++++++++ 2 files changed, 19 insertions(+)
include/linux/sunrpc/auth.h +4 -0
@@ -11,6 +11,7 @@#define _LINUX_SUNRPC_AUTH_H#include <linux/sunrpc/sched.h> +#include <linux/sunrpc/svcauth.h> #include <linux/sunrpc/msg_prot.h> #include <linux/sunrpc/xdr.h>
@@ -184,6 +185,9 @@ int rpcauth_uptodatecred(struct rpc_task *);int rpcauth_init_credcache (struct rpc_auth *);void rpcauth_destroy_credcache (struct rpc_auth *);void rpcauth_clear_credcache (struct rpc_cred_cache *); +void rpcauth_map_to_svc_cred_local (struct rpc_auth *, +const struct cred *, +struct svc_cred *);char *rpcauth_stringify_acceptor (struct rpc_cred *); static inline
net/sunrpc/auth.c +15 -0
@@ -308,6 +308,21 @@ rpcauth_init_credcache(struct rpc_auth *auth) }EXPORT_SYMBOL_GPL (rpcauth_init_credcache); +void +rpcauth_map_to_svc_cred_local (struct rpc_auth *auth,const struct cred *cred, +struct svc_cred *svc) +{ + svc->cr_uid = cred->uid; + svc->cr_gid = cred->gid; + svc->cr_flavor = auth->au_flavor; +if (cred->group_info) + svc->cr_group_info =get_group_info (cred->group_info); +/* These aren't relevant for local (network is bypassed) */ + svc->cr_principal =NULL ; + svc->cr_gss_mech =NULL ; +} +EXPORT_SYMBOL_GPL (rpcauth_map_to_svc_cred_local); +char *rpcauth_stringify_acceptor (struct rpc_cred *cred) {
Signature · 1 line
2.44.0
PATCH v7 5/20 nfs_common: add NFS LOCALIO auxiliary protocol enablement
In reply to Mike SnitzerFirst use is in nfsd, to add access to a global nfsd_uuids list that will be used to identify local nfsd instances.
nfsd_uuids is protected by nfsd_mutex or RCU read lock. List is composed of nfsd_uuid_t instances that are managed as nfsd creates them (per network namespace).
nfsd_uuid_is_local() will be used to search all local nfsd for the client specified nfsd uuid.
This commit also adds all the nfs_client members required to implement the entire localio feature (which depends on the LOCALIO protocol).
--- fs/nfs/client.c | 8 +++++ fs/nfs_common/Makefile | 3 ++ fs/nfs_common/nfslocalio.c | 72 ++++++++++++++++++++++++++++++++++++++ fs/nfsd/netns.h | 4 +++ fs/nfsd/nfssvc.c | 12 ++++++- include/linux/nfs_fs_sb.h | 9 +++++ include/linux/nfslocalio.h | 39 +++++++++++++++++++++ 7 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 fs/nfs_common/nfslocalio.c create mode 100644 include/linux/nfslocalio.h
fs/nfs/client.c +8 -0
@@ -178,6 +178,14 @@ struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init) clp->cl_max_connect = cl_init->max_connect ? cl_init->max_connect :1 ; clp->cl_net =get_net (cl_init->net); +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +seqlock_init (&clp->cl_boot_lock); +ktime_get_real_ts64 (&clp->cl_nfssvc_boot); + clp->cl_rpcclient_localio =ERR_PTR (-EINVAL ); + clp->nfsd_open_local_fh =NULL ; + clp->cl_nfssvc_net =NULL ; +#endif /* CONFIG_NFS_LOCALIO */ + clp->cl_principal ="*" ; clp->cl_xprtsec = cl_init->xprtsec;return clp;
fs/nfs_common/Makefile +3 -0
@@ -6,5 +6,8 @@ obj-$(CONFIG_NFS_ACL_SUPPORT) += nfs_acl.o nfs_acl-objs := nfsacl.o +obj-$(CONFIG_NFS_COMMON_LOCALIO_SUPPORT) += nfs_localio.o +nfs_localio-objs := nfslocalio.o + obj-$(CONFIG_GRACE_PERIOD) += grace.o obj-$(CONFIG_NFS_V4_2_SSC_HELPER) += nfs_ssc.o
fs/nfs_common/nfslocalio.c new file +72 -0
72 lines not on this page · raw message
fs/nfsd/netns.h +4 -0
@@ -15,6 +15,7 @@#include <linux/percpu_counter.h> #include <linux/siphash.h> #include <linux/sunrpc/stats.h> +#include <linux/nfslocalio.h> /* Hash tables for nfs4_clientid state */ #define CLIENT_HASH_BITS 4
@@ -213,6 +214,9 @@ struct nfsd_net {/* last time an admin-revoke happened for NFSv4.0 */ time64_t nfs40_last_revoke; +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +nfsd_uuid_t nfsd_uuid; +#endif };/* Simple check to find out if a given net was properly initialized */
fs/nfsd/nfssvc.c +11 -1
@@ -19,6 +19,7 @@#include <linux/sunrpc/svc_xprt.h> #include <linux/lockd/bind.h> #include <linux/nfsacl.h> +#include <linux/nfslocalio.h> #include <linux/seq_file.h> #include <linux/inetdevice.h> #include <net/addrconf.h>
@@ -427,6 +428,10 @@ static int nfsd_startup_net(struct net *net, const struct cred *cred)#ifdef CONFIG_NFSD_V4_2_INTER_SSC nfsd4_ssc_init_umount_work (nn); +#endif +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +INIT_LIST_HEAD (&nn->nfsd_uuid.list); +list_add_tail_rcu (&nn->nfsd_uuid.list, &nfsd_uuids);#endif nn->nfsd_net_up = true;return 0 ;
@@ -456,6 +461,9 @@ static void nfsd_shutdown_net(struct net *net)lockd_down (net); nn->lockd_up = false; } +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +list_del_rcu (&nn->nfsd_uuid.list); +#endif nn->nfsd_net_up = false;nfsd_shutdown_generic (); }
@@ -802,7 +810,9 @@ nfsd_svc(int n, int *nthreads, struct net *net, const struct cred *cred, const cstrscpy (nn->nfsd_name, scope ? scope :utsname ()->nodename,sizeof (nn->nfsd_name)); - +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +uuid_gen (&nn->nfsd_uuid.uuid); +#endif error =nfsd_create_serv (net);if (error) goto out;
include/linux/nfs_fs_sb.h +9 -0
@@ -8,6 +8,7 @@#include <linux/wait.h> #include <linux/nfs_xdr.h> #include <linux/sunrpc/xprt.h> +#include <linux/nfslocalio.h> #include <linux/atomic.h> #include <linux/refcount.h>
@@ -125,6 +126,14 @@ struct nfs_client {struct net *cl_net;struct list_head pending_cb_stateids;struct rcu_head rcu; + +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +struct timespec64 cl_nfssvc_boot; +seqlock_t cl_boot_lock; +struct rpc_clnt * cl_rpcclient_localio; +struct net * cl_nfssvc_net; +nfs_to_nfsd_open_t nfsd_open_local_fh; +#endif /* CONFIG_NFS_LOCALIO */ };/*
include/linux/nfslocalio.h new file +39 -0
@@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ +#ifndef __LINUX_NFSLOCALIO_H +#define __LINUX_NFSLOCALIO_H + +#include <linux/list.h> +#include <linux/uuid.h> +#include <linux/nfs.h> +#include <net/net_namespace.h> + +/* +* Global list of nfsd_uuid_t instances, add/remove +* is protected by fs/nfsd/nfssvc.c:nfsd_mutex. +*/ +extern struct list_head nfsd_uuids; + +/* +* Each nfsd instance has an nfsd_uuid_t that is accessible through the +* global nfsd_uuids list. Useful to allow a client to negotiate if localio +* possible with its server. +*/ +typedef struct { +uuid_t uuid; +struct list_head list; +struct net *net;/* nfsd's network namespace */ +}nfsd_uuid_t ; + +bool nfsd_uuid_is_local (const uuid_t *uuid,struct net **netp); + +typedef int (*nfs_to_nfsd_open_t )(struct net *,struct rpc_clnt *, +const struct cred *,const struct nfs_fh *, +const fmode_t ,struct file **); + +nfs_to_nfsd_open_t get_nfsd_open_local_fh (void ); +void put_nfsd_open_local_fh (void ); + +#endif /* __LINUX_NFSLOCALIO_H */
Signature · 1 line
2.44.0
Re: [PATCH v7 05/20] nfs_common: add NFS LOCALIO auxiliary protocol enablement
Quoted 98 lines · Mike Snitzer
First use is in nfsd, to add access to a global
nfsd_uuidslist that will be used to identify local nfsd instances.
nfsd_uuidsis protected bynfsd_mutexor RCU read lock. List is composed ofnfsd_uuid_tinstances that are managed as nfsd creates them (per network namespace).
nfsd_uuid_is_local()will be used to search all local nfsd for the client specified nfsd uuid.This commit also adds all the
nfs_clientmembers required to implement the entire localio feature (which depends on the LOCALIO protocol).Signed-off-by Mike Snitzer <[email protected]>--- fs/nfs/client.c | 8 +++++ fs/nfs_common/Makefile | 3 ++ fs/nfs_common/nfslocalio.c | 72 ++++++++++++++++++++++++++++++++++++++ fs/nfsd/netns.h | 4 +++ fs/nfsd/nfssvc.c | 12 ++++++- include/linux/nfs_fs_sb.h | 9 +++++ include/linux/nfslocalio.h | 39 +++++++++++++++++++++ 7 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 fs/nfs_common/nfslocalio.c create mode 100644 include/linux/nfslocalio.hfs/nfs/client.c +8
-0@@ -178,6 +178,14 @@ struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init) clp->cl_max_connect = cl_init->max_connect ? cl_init->max_connect :1 ; clp->cl_net =get_net (cl_init->net); +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +seqlock_init (&clp->cl_boot_lock); +ktime_get_real_ts64 (&clp->cl_nfssvc_boot); + clp->cl_rpcclient_localio =ERR_PTR (-EINVAL ); + clp->nfsd_open_local_fh =NULL ; + clp->cl_nfssvc_net =NULL ; +#endif /* CONFIG_NFS_LOCALIO */ + clp->cl_principal ="*" ; clp->cl_xprtsec = cl_init->xprtsec;return clp;fs/nfs_common/Makefile +3
-0@@ -6,5 +6,8 @@ obj-$(CONFIG_NFS_ACL_SUPPORT) += nfs_acl.o nfs_acl-objs := nfsacl.o +obj-$(CONFIG_NFS_COMMON_LOCALIO_SUPPORT) += nfs_localio.o +nfs_localio-objs := nfslocalio.o + obj-$(CONFIG_GRACE_PERIOD) += grace.o obj-$(CONFIG_NFS_V4_2_SSC_HELPER) += nfs_ssc.ofs/nfs_common/nfslocalio.c new file +34
-0@@ -0,0 +1,72 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/module.h> +#include <linux/rculist.h> +#include <linux/nfslocalio.h> + +MODULE_LICENSE ("GPL" ); +MODULE_DESCRIPTION ("NFS localio protocol bypass support" ); + +/* +* Global list of nfsd_uuid_t instances, add/remove +* is protected by fs/nfsd/nfssvc.c:nfsd_mutex. +* Reads are protected by RCU read lock (see below). +*/ +LIST_HEAD (nfsd_uuids); +EXPORT_SYMBOL (nfsd_uuids); + +/* Must be called with RCU read lock held. */ +static const uuid_t *nfsd_uuid_lookup (const uuid_t *uuid, +struct net **netp) +{ +nfsd_uuid_t *nfsd_uuid; + +list_for_each_entry_rcu (nfsd_uuid, &nfsd_uuids, list) +if (uuid_equal (&nfsd_uuid->uuid, uuid)) { + *netp = nfsd_uuid->net; +return &nfsd_uuid->uuid; + } + +return &uuid_null; +}
fs/nfs_common/nfslocalio.c line 44
Quoted 10 lines
fs/nfs_common/nfslocalio.c new file +10
-0+ +bool nfsd_uuid_is_local (const uuid_t *uuid,struct net **netp) +{ +const uuid_t *nfsd_uuid; + +rcu_read_lock (); + nfsd_uuid =nfsd_uuid_lookup (uuid, netp); +rcu_read_unlock (); + +return !uuid_is_null (nfsd_uuid);
This is still unsafe. You can only safely dereference nfsd_uuid while still holding the rcu_read_lock.
NeilBrown
Quoted 171 lines
fs/nfs_common/nfslocalio.c new file +28
-0+} +EXPORT_SYMBOL_GPL (nfsd_uuid_is_local); + +/* +* The nfs localio code needs to call into nfsd to do the filehandle -> struct path +* mapping, but cannot be statically linked, because that will make the nfs module +* depend on the nfsd module. +* +* Instead, do dynamic linking to the nfsd module (via nfs_common module). The +* nfs_common module will only hold a reference on nfsd when localio is in use. +* This allows some sanity checking, like giving up on localio if nfsd isn't loaded. +*/ + +extern int nfsd_open_local_fh (struct net *,struct rpc_clnt *rpc_clnt, +const struct cred *cred,const struct nfs_fh *nfs_fh, +const fmode_t fmode,struct file **pfilp); + +nfs_to_nfsd_open_t get_nfsd_open_local_fh (void ) +{ +return symbol_request (nfsd_open_local_fh); +} +EXPORT_SYMBOL_GPL (get_nfsd_open_local_fh); + +void put_nfsd_open_local_fh (void ) +{ +symbol_put (nfsd_open_local_fh); +} +EXPORT_SYMBOL_GPL (put_nfsd_open_local_fh);fs/nfsd/netns.h +4
-0@@ -15,6 +15,7 @@#include <linux/percpu_counter.h> #include <linux/siphash.h> #include <linux/sunrpc/stats.h> +#include <linux/nfslocalio.h> /* Hash tables for nfs4_clientid state */ #define CLIENT_HASH_BITS 4@@ -213,6 +214,9 @@ struct nfsd_net {/* last time an admin-revoke happened for NFSv4.0 */ time64_t nfs40_last_revoke; +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +nfsd_uuid_t nfsd_uuid; +#endif };/* Simple check to find out if a given net was properly initialized */ fs/nfsd/nfssvc.c +11
-1@@ -19,6 +19,7 @@#include <linux/sunrpc/svc_xprt.h> #include <linux/lockd/bind.h> #include <linux/nfsacl.h> +#include <linux/nfslocalio.h> #include <linux/seq_file.h> #include <linux/inetdevice.h> #include <net/addrconf.h> @@ -427,6 +428,10 @@ static int nfsd_startup_net(struct net *net, const struct cred *cred)#ifdef CONFIG_NFSD_V4_2_INTER_SSC nfsd4_ssc_init_umount_work (nn); +#endif +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +INIT_LIST_HEAD (&nn->nfsd_uuid.list); +list_add_tail_rcu (&nn->nfsd_uuid.list, &nfsd_uuids);#endif nn->nfsd_net_up = true;return 0 ;@@ -456,6 +461,9 @@ static void nfsd_shutdown_net(struct net *net)lockd_down (net); nn->lockd_up = false; } +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +list_del_rcu (&nn->nfsd_uuid.list); +#endif nn->nfsd_net_up = false;nfsd_shutdown_generic (); }@@ -802,7 +810,9 @@ nfsd_svc(int n, int *nthreads, struct net *net, const struct cred *cred, const cstrscpy (nn->nfsd_name, scope ? scope :utsname ()->nodename,sizeof (nn->nfsd_name)); - +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +uuid_gen (&nn->nfsd_uuid.uuid); +#endif error =nfsd_create_serv (net);if (error) goto out;include/linux/nfs_fs_sb.h +9
-0@@ -8,6 +8,7 @@#include <linux/wait.h> #include <linux/nfs_xdr.h> #include <linux/sunrpc/xprt.h> +#include <linux/nfslocalio.h> #include <linux/atomic.h> #include <linux/refcount.h> @@ -125,6 +126,14 @@ struct nfs_client {struct net *cl_net;struct list_head pending_cb_stateids;struct rcu_head rcu; + +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +struct timespec64 cl_nfssvc_boot; +seqlock_t cl_boot_lock; +struct rpc_clnt * cl_rpcclient_localio; +struct net * cl_nfssvc_net; +nfs_to_nfsd_open_t nfsd_open_local_fh; +#endif /* CONFIG_NFS_LOCALIO */ };/* include/linux/nfslocalio.h new file +39
-0@@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ +#ifndef __LINUX_NFSLOCALIO_H +#define __LINUX_NFSLOCALIO_H + +#include <linux/list.h> +#include <linux/uuid.h> +#include <linux/nfs.h> +#include <net/net_namespace.h> + +/* +* Global list of nfsd_uuid_t instances, add/remove +* is protected by fs/nfsd/nfssvc.c:nfsd_mutex. +*/ +extern struct list_head nfsd_uuids; + +/* +* Each nfsd instance has an nfsd_uuid_t that is accessible through the +* global nfsd_uuids list. Useful to allow a client to negotiate if localio +* possible with its server. +*/ +typedef struct { +uuid_t uuid; +struct list_head list; +struct net *net;/* nfsd's network namespace */ +}nfsd_uuid_t ; + +bool nfsd_uuid_is_local (const uuid_t *uuid,struct net **netp); + +typedef int (*nfs_to_nfsd_open_t )(struct net *,struct rpc_clnt *, +const struct cred *,const struct nfs_fh *, +const fmode_t ,struct file **); + +nfs_to_nfsd_open_t get_nfsd_open_local_fh (void ); +void put_nfsd_open_local_fh (void ); + +#endif /* __LINUX_NFSLOCALIO_H */ Signature · 1 line
2.44.0
Re: [PATCH v7 05/20] nfs_common: add NFS LOCALIO auxiliary protocol enablement
Quoted 104 lines · NeilBrown
Quoted 103 lines · Mike Snitzer
First use is in nfsd, to add access to a global
nfsd_uuidslist that will be used to identify local nfsd instances.
nfsd_uuidsis protected bynfsd_mutexor RCU read lock. List is composed ofnfsd_uuid_tinstances that are managed as nfsd creates them (per network namespace).
nfsd_uuid_is_local()will be used to search all local nfsd for the client specified nfsd uuid.This commit also adds all the
nfs_clientmembers required to implement the entire localio feature (which depends on the LOCALIO protocol).Signed-off-by Mike Snitzer <[email protected]>--- fs/nfs/client.c | 8 +++++ fs/nfs_common/Makefile | 3 ++ fs/nfs_common/nfslocalio.c | 72 ++++++++++++++++++++++++++++++++++++++ fs/nfsd/netns.h | 4 +++ fs/nfsd/nfssvc.c | 12 ++++++- include/linux/nfs_fs_sb.h | 9 +++++ include/linux/nfslocalio.h | 39 +++++++++++++++++++++ 7 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 fs/nfs_common/nfslocalio.c create mode 100644 include/linux/nfslocalio.hfs/nfs/client.c +8
-0@@ -178,6 +178,14 @@ struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init) clp->cl_max_connect = cl_init->max_connect ? cl_init->max_connect :1 ; clp->cl_net =get_net (cl_init->net); +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +seqlock_init (&clp->cl_boot_lock); +ktime_get_real_ts64 (&clp->cl_nfssvc_boot); + clp->cl_rpcclient_localio =ERR_PTR (-EINVAL ); + clp->nfsd_open_local_fh =NULL ; + clp->cl_nfssvc_net =NULL ; +#endif /* CONFIG_NFS_LOCALIO */ + clp->cl_principal ="*" ; clp->cl_xprtsec = cl_init->xprtsec;return clp;fs/nfs_common/Makefile +3
-0@@ -6,5 +6,8 @@ obj-$(CONFIG_NFS_ACL_SUPPORT) += nfs_acl.o nfs_acl-objs := nfsacl.o +obj-$(CONFIG_NFS_COMMON_LOCALIO_SUPPORT) += nfs_localio.o +nfs_localio-objs := nfslocalio.o + obj-$(CONFIG_GRACE_PERIOD) += grace.o obj-$(CONFIG_NFS_V4_2_SSC_HELPER) += nfs_ssc.ofs/nfs_common/nfslocalio.c new file +39
-0@@ -0,0 +1,72 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/module.h> +#include <linux/rculist.h> +#include <linux/nfslocalio.h> + +MODULE_LICENSE ("GPL" ); +MODULE_DESCRIPTION ("NFS localio protocol bypass support" ); + +/* +* Global list of nfsd_uuid_t instances, add/remove +* is protected by fs/nfsd/nfssvc.c:nfsd_mutex. +* Reads are protected by RCU read lock (see below). +*/ +LIST_HEAD (nfsd_uuids); +EXPORT_SYMBOL (nfsd_uuids); + +/* Must be called with RCU read lock held. */ +static const uuid_t *nfsd_uuid_lookup (const uuid_t *uuid, +struct net **netp) +{ +nfsd_uuid_t *nfsd_uuid; + +list_for_each_entry_rcu (nfsd_uuid, &nfsd_uuids, list) +if (uuid_equal (&nfsd_uuid->uuid, uuid)) { + *netp = nfsd_uuid->net; +return &nfsd_uuid->uuid; + } + +return &uuid_null; +} + +bool nfsd_uuid_is_local (const uuid_t *uuid,struct net **netp) +{ +const uuid_t *nfsd_uuid; +
Quoted 8 lines
fs/nfs_common/nfslocalio.c line 44
Quoted 5 lines
fs/nfs_common/nfslocalio.c new file +5
-0+rcu_read_lock (); + nfsd_uuid =nfsd_uuid_lookup (uuid, netp); +rcu_read_unlock (); + +return !uuid_is_null (nfsd_uuid);This is still unsafe. You can only safely dereference
nfsd_uuidwhile still holding thercu_read_lock.
Fixed, thanks.
PATCH v7 6/20 nfs/nfsd: add "localio" support
In reply to Mike SnitzerFrom: Weston Andros Adamson <[email protected]>
Add client support for bypassing NFS for localhost reads, writes, and commits. This is only useful when the client and the server are running on the same host.
nfs_local_probe() is stubbed out, later commits will enable client and server handshake via a Linux-only LOCALIO auxiliary RPC protocol.
This has dynamic binding with the nfsd module (via nfs_localio module which is part of nfs_common). Localio will only work if nfsd is already loaded.
The "localio_enabled" nfs kernel module parameter can be used to disable and enable the ability to use localio support.
Tracepoints were added for nfs_local_open_fh, nfs_local_enable and nfs_local_disable.
Also, pass the stored cl_nfssvc_net from the client to the server as first argument to nfsd_open_local_fh() to ensure the proper network namespace is used for localio.
--- fs/nfs/Makefile | 1 + fs/nfs/client.c | 3 + fs/nfs/inode.c | 4 + fs/nfs/internal.h | 51 +++ fs/nfs/localio.c | 654 ++++++++++++++++++++++++++++++++++++++ fs/nfs/nfstrace.h | 61 ++++ fs/nfs/pagelist.c | 3 + fs/nfs/write.c | 3 + fs/nfsd/Makefile | 1 + fs/nfsd/filecache.c | 2 +- fs/nfsd/localio.c | 244 ++++++++++++++ fs/nfsd/nfssvc.c | 1 + fs/nfsd/trace.h | 3 +- fs/nfsd/vfs.h | 9 + include/linux/nfs.h | 2 + include/linux/nfs_fs.h | 2 + include/linux/nfs_fs_sb.h | 1 + 17 files changed, 1043 insertions(+), 2 deletions(-) create mode 100644 fs/nfs/localio.c create mode 100644 fs/nfsd/localio.c
fs/nfs/Makefile +1 -0
@@ -13,6 +13,7 @@ nfs-y := client.o dir.o file.o getroot.o inode.o super.o \ nfs-$(CONFIG_ROOT_NFS) += nfsroot.o nfs-$(CONFIG_SYSCTL) += sysctl.o nfs-$(CONFIG_NFS_FSCACHE) += fscache.o +nfs-$(CONFIG_NFS_LOCALIO) += localio.o obj-$(CONFIG_NFS_V2) += nfsv2.o nfsv2-y := nfs2super.o proc.o nfs2xdr.o
fs/nfs/client.c +3 -0
@@ -241,6 +241,8 @@ static void pnfs_init_server(struct nfs_server *server)*/ void nfs_free_client (struct nfs_client *clp) { +nfs_local_disable (clp); +/* -EIO all pending I/O */ if (!IS_ERR (clp->cl_rpcclient))rpc_shutdown_client (clp->cl_rpcclient);
@@ -432,6 +434,7 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)list_add_tail (&new->cl_share_link, &nn->nfs_client_list);spin_unlock (&nn->nfs_client_lock); +nfs_local_probe (new);return rpc_ops->init_client (new, cl_init); }
fs/nfs/inode.c +4 -0
@@ -39,6 +39,7 @@#include <linux/slab.h> #include <linux/compat.h> #include <linux/freezer.h> +#include <linux/file.h> #include <linux/uaccess.h> #include <linux/iversion.h>
@@ -1053,6 +1054,7 @@ struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, ctx->lock_context.open_context = ctx;INIT_LIST_HEAD (&ctx->list); ctx->mdsthreshold =NULL ; + ctx->local_filp =NULL ;return ctx; }EXPORT_SYMBOL_GPL (alloc_nfs_open_context);
@@ -1084,6 +1086,8 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)nfs_sb_deactive (sb);put_rpccred (rcu_dereference_protected (ctx->ll_cred,1 ));kfree (ctx->mdsthreshold); +if (!IS_ERR_OR_NULL (ctx->local_filp)) +fput (ctx->local_filp);kfree_rcu (ctx, rcu_head); }
fs/nfs/internal.h +51 -0
57 lines not on this page · raw message
fs/nfs/localio.c new file +654 -0
654 lines not on this page · raw message
fs/nfs/nfstrace.h +61 -0
67 lines not on this page · raw message
fs/nfs/pagelist.c +3 -0
@@ -879,6 +879,9 @@ int nfs_initiate_pgio(struct nfs_pageio_descriptor *desc, hdr->args.count, (unsigned long long)hdr->args.offset); +if (localio) +return nfs_local_doio (clp, localio, hdr, call_ops); + task =rpc_run_task (&task_setup_data);if (IS_ERR (task))return PTR_ERR (task);
fs/nfs/write.c +3 -0
@@ -1700,6 +1700,9 @@ int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,dprintk ("NFS: initiated commit call\n" ); +if (localio) +return nfs_local_commit (localio, data, call_ops, how); + task =rpc_run_task (&task_setup_data);if (IS_ERR (task))return PTR_ERR (task);
fs/nfsd/Makefile +1 -0
@@ -23,3 +23,4 @@ nfsd-$(CONFIG_NFSD_PNFS) += nfs4layouts.o nfsd-$(CONFIG_NFSD_BLOCKLAYOUT) += blocklayout.o blocklayoutxdr.o nfsd-$(CONFIG_NFSD_SCSILAYOUT) += blocklayout.o blocklayoutxdr.o nfsd-$(CONFIG_NFSD_FLEXFILELAYOUT) += flexfilelayout.o flexfilelayoutxdr.o +nfsd-$(CONFIG_NFSD_LOCALIO) += localio.o
fs/nfsd/filecache.c +1 -1
@@ -52,7 +52,7 @@#define NFSD_FILE_CACHE_UP (0)/* We only care about NFSD_MAY_READ/WRITE for this cache */ -#define NFSD_FILE_MAY_MASK (NFSD_MAY_READ|NFSD_MAY_WRITE) +#define NFSD_FILE_MAY_MASK (NFSD_MAY_READ|NFSD_MAY_WRITE|NFSD_MAY_LOCALIO) static DEFINE_PER_CPU(unsigned long, nfsd_file_cache_hits); static DEFINE_PER_CPU(unsigned long, nfsd_file_acquisitions);
fs/nfsd/localio.c new file +244 -0
244 lines not on this page · raw message
fs/nfsd/nfssvc.c +1 -0
@@ -431,6 +431,7 @@ static int nfsd_startup_net(struct net *net, const struct cred *cred)#endif #if IS_ENABLED (CONFIG_NFSD_LOCALIO )INIT_LIST_HEAD (&nn->nfsd_uuid.list); + nn->nfsd_uuid.net = net;list_add_tail_rcu (&nn->nfsd_uuid.list, &nfsd_uuids);#endif nn->nfsd_net_up = true;
fs/nfsd/trace.h +2 -1
@@ -86,7 +86,8 @@ DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ - { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) + { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }, \ + { NFSD_MAY_LOCALIO, "LOCALIO" }) TRACE_EVENT(nfsd_compound, TP_PROTO(
fs/nfsd/vfs.h +9 -0
@@ -36,6 +36,8 @@#define NFSD_MAY_CREATE (NFSD_MAY_EXEC|NFSD_MAY_WRITE)#define NFSD_MAY_REMOVE (NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC) +#define NFSD_MAY_LOCALIO 0x800000 +struct nfsd_file ;/*
@@ -158,6 +160,13 @@ __be32 nfsd_permission(struct svc_rqst *, struct svc_export *,void nfsd_filp_close (struct file *fp); +int nfsd_open_local_fh (struct net *net, +struct rpc_clnt *rpc_clnt, +const struct cred *cred, +const struct nfs_fh *nfs_fh, +const fmode_t fmode, +struct file **pfilp); +static inline int fh_want_write (struct svc_fh *fh) {int ret;
include/linux/nfs.h +2 -0
@@ -8,6 +8,8 @@#ifndef _LINUX_NFS_H#define _LINUX_NFS_H +#include <linux/cred.h> +#include <linux/sunrpc/auth.h> #include <linux/sunrpc/msg_prot.h> #include <linux/string.h> #include <linux/crc32.h>
include/linux/nfs_fs.h +2 -0
@@ -96,6 +96,8 @@ struct nfs_open_context {struct list_head list;struct nfs4_threshold *mdsthreshold;struct rcu_head rcu_head; + +struct file *local_filp; };struct nfs_open_dir_context {
include/linux/nfs_fs_sb.h +1 -0
@@ -50,6 +50,7 @@ struct nfs_client {#define NFS_CS_DS 7/* - Server is a DS */ #define NFS_CS_REUSEPORT 8/* - reuse src port on reconnect */ #define NFS_CS_PNFS 9/* - Server used for pnfs */ +#define NFS_CS_LOCAL_IO 10/* - client is local */ struct sockaddr_storage cl_addr;/* server identifier */ size_t cl_addrlen;char * cl_hostname;/* hostname of server */
Signature · 1 line
2.44.0
Re: [PATCH v7 06/20] nfs/nfsd: add "localio" support
Quoted 28 lines · Mike Snitzer
From: Weston Andros Adamson <[email protected]>
Add client support for bypassing NFS for localhost reads, writes, and commits. This is only useful when the client and the server are running on the same host.
nfs_local_probe()is stubbed out, later commits will enable client and server handshake via a Linux-only LOCALIO auxiliary RPC protocol.This has dynamic binding with the nfsd module (via
nfs_localiomodule which is part ofnfs_common). Localio will only work if nfsd is already loaded.The "
localio_enabled" nfs kernel module parameter can be used to disable and enable the ability to use localio support.Tracepoints were added for
nfs_local_open_fh,nfs_local_enableandnfs_local_disable.Also, pass the stored
cl_nfssvc_netfrom the client to the server as first argument tonfsd_open_local_fh()to ensure the proper network namespace is used for localio.Signed-off-by Weston Andros Adamson <[email protected]>Signed-off-by Peng Tao <[email protected]>Signed-off-by Lance Shelton <[email protected]>Signed-off-by Trond Myklebust <[email protected]>Signed-off-by Mike Snitzer <[email protected]>
Quoted 9 lines
--- fs/nfs/Makefile | 1 + fs/nfs/client.c | 3 + fs/nfs/inode.c | 4 + fs/nfs/internal.h | 51 +++ fs/nfs/localio.c | 654 ++++++++++++++++++++++++++++++++++++++ fs/nfs/nfstrace.h | 61 ++++ fs/nfs/pagelist.c | 3 + fs/nfs/write.c | 3 +
Hi Mike -
I'd prefer to see this patch split into two patches, one for the NFS client, and one for the NFS server. The other patches in this series seem to have a clear line between server and client changes.
One or two more remarks below.
Quoted 936 lines
fs/nfsd/Makefile | 1 + fs/nfsd/filecache.c | 2 +- fs/nfsd/localio.c | 244 ++++++++++++++ fs/nfsd/nfssvc.c | 1 + fs/nfsd/trace.h | 3 +- fs/nfsd/vfs.h | 9 + include/linux/nfs.h | 2 + include/linux/nfs_fs.h | 2 + include/linux/nfs_fs_sb.h | 1 + 17 files changed, 1043 insertions(+), 2 deletions(-) create mode 100644 fs/nfs/localio.c create mode 100644 fs/nfsd/localio.cfs/nfs/Makefile +1
-0@@ -13,6 +13,7 @@ nfs-y := client.o dir.o file.o getroot.o inode.o super.o \ nfs-$(CONFIG_ROOT_NFS) += nfsroot.o nfs-$(CONFIG_SYSCTL) += sysctl.o nfs-$(CONFIG_NFS_FSCACHE) += fscache.o +nfs-$(CONFIG_NFS_LOCALIO) += localio.o obj-$(CONFIG_NFS_V2) += nfsv2.o nfsv2-y := nfs2super.o proc.o nfs2xdr.ofs/nfs/client.c +3
-0@@ -241,6 +241,8 @@ static void pnfs_init_server(struct nfs_server *server)*/ void nfs_free_client (struct nfs_client *clp) { +nfs_local_disable (clp); +/* -EIO all pending I/O */ if (!IS_ERR (clp->cl_rpcclient))rpc_shutdown_client (clp->cl_rpcclient);@@ -432,6 +434,7 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)list_add_tail (&new->cl_share_link, &nn->nfs_client_list);spin_unlock (&nn->nfs_client_lock); +nfs_local_probe (new);return rpc_ops->init_client (new, cl_init); }fs/nfs/inode.c +4
-0@@ -39,6 +39,7 @@#include <linux/slab.h> #include <linux/compat.h> #include <linux/freezer.h> +#include <linux/file.h> #include <linux/uaccess.h> #include <linux/iversion.h> @@ -1053,6 +1054,7 @@ struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, ctx->lock_context.open_context = ctx;INIT_LIST_HEAD (&ctx->list); ctx->mdsthreshold =NULL ; + ctx->local_filp =NULL ;return ctx; }EXPORT_SYMBOL_GPL (alloc_nfs_open_context);@@ -1084,6 +1086,8 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)nfs_sb_deactive (sb);put_rpccred (rcu_dereference_protected (ctx->ll_cred,1 ));kfree (ctx->mdsthreshold); +if (!IS_ERR_OR_NULL (ctx->local_filp)) +fput (ctx->local_filp);kfree_rcu (ctx, rcu_head); }fs/nfs/internal.h +51
-0@@ -451,6 +451,57 @@ extern void nfs_set_cache_invalid(struct inode *inode, unsigned long flags);extern bool nfs_check_cache_invalid (struct inode *,unsigned long );extern int nfs_wait_bit_killable (struct wait_bit_key *key,int mode); +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +/* localio.c */ +extern void nfs_local_disable (struct nfs_client *); +extern void nfs_local_probe (struct nfs_client *); +extern struct file *nfs_local_open_fh (struct nfs_client *,const struct cred *, +struct nfs_fh *,const fmode_t ); +extern struct file *nfs_local_file_open (struct nfs_client *clp, +const struct cred *cred, +struct nfs_fh *fh, +struct nfs_open_context *ctx); +extern int nfs_local_doio (struct nfs_client *,struct file *, +struct nfs_pgio_header *, +const struct rpc_call_ops *); +extern int nfs_local_commit (struct file *,struct nfs_commit_data *, +const struct rpc_call_ops *,int ); +extern bool nfs_server_is_local (const struct nfs_client *clp); + +#else +static inline void nfs_local_disable (struct nfs_client *clp) {} +static inline void nfs_local_probe (struct nfs_client *clp) {} +static inline struct file *nfs_local_open_fh (struct nfs_client *clp, +const struct cred *cred, +struct nfs_fh *fh, +const fmode_t mode) +{ +return ERR_PTR (-EINVAL ); +} +static inline struct file *nfs_local_file_open (struct nfs_client *clp, +const struct cred *cred, +struct nfs_fh *fh, +struct nfs_open_context *ctx) +{ +return NULL ; +} +static inline int nfs_local_doio (struct nfs_client *clp,struct file *filep, +struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops) +{ +return -EINVAL ; +} +static inline int nfs_local_commit (struct file *filep,struct nfs_commit_data *data, +const struct rpc_call_ops *call_ops,int how) +{ +return -EINVAL ; +} +static inline bool nfs_server_is_local (const struct nfs_client *clp) +{ +return false; +} +#endif /* CONFIG_NFS_LOCALIO */ +/* super.c */ extern const struct super_operations nfs_sops;bool nfs_auth_info_match (const struct nfs_auth_info *,rpc_authflavor_t );fs/nfs/localio.c new file +654
-0@@ -0,0 +1,654 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NFS client support for local clients to bypass network stack +* +* Copyright (C) 2014 Weston Andros Adamson <[email protected]> +* Copyright (C) 2019 Trond Myklebust <[email protected]> +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/module.h> +#include <linux/errno.h> +#include <linux/vfs.h> +#include <linux/file.h> +#include <linux/inet.h> +#include <linux/sunrpc/addr.h> +#include <linux/inetdevice.h> +#include <net/addrconf.h> +#include <linux/module.h> +#include <linux/bvec.h> + +#include <linux/nfs.h> +#include <linux/nfs_fs.h> +#include <linux/nfs_xdr.h> + +#include "internal.h" +#include "pnfs.h" +#include "nfstrace.h" + +#define NFSDBG_FACILITY NFSDBG_VFS + +struct nfs_local_kiocb { +struct kiocb kiocb; +struct bio_vec *bvec; +struct nfs_pgio_header *hdr; +struct work_struct work; +}; + +struct nfs_local_fsync_ctx { +struct file *filp; +struct nfs_commit_data *data; +struct work_struct work; +struct kref kref; +struct completion *done; +}; +static void nfs_local_fsync_work (struct work_struct *work); + +/* +* We need to translate between nfs status return values and +* the local errno values which may not be the same. +*/ +static struct { +__u32 stat; +int errno; +} nfs_errtbl[] = { + {NFS4_OK ,0 }, + {NFS4ERR_PERM , -EPERM }, + {NFS4ERR_NOENT , -ENOENT }, + {NFS4ERR_IO , -EIO }, + {NFS4ERR_NXIO , -ENXIO }, + {NFS4ERR_FBIG , -E2BIG }, + {NFS4ERR_STALE , -EBADF }, + {NFS4ERR_ACCESS , -EACCES }, + {NFS4ERR_EXIST , -EEXIST }, + {NFS4ERR_XDEV , -EXDEV }, + {NFS4ERR_MLINK , -EMLINK }, + {NFS4ERR_NOTDIR , -ENOTDIR }, + {NFS4ERR_ISDIR , -EISDIR }, + {NFS4ERR_INVAL , -EINVAL }, + {NFS4ERR_FBIG , -EFBIG }, + {NFS4ERR_NOSPC , -ENOSPC }, + {NFS4ERR_ROFS , -EROFS }, + {NFS4ERR_NAMETOOLONG , -ENAMETOOLONG }, + {NFS4ERR_NOTEMPTY , -ENOTEMPTY }, + {NFS4ERR_DQUOT , -EDQUOT }, + {NFS4ERR_STALE , -ESTALE }, + {NFS4ERR_STALE , -EOPENSTALE }, + {NFS4ERR_DELAY , -ETIMEDOUT }, + {NFS4ERR_DELAY , -ERESTARTSYS }, + {NFS4ERR_DELAY , -EAGAIN }, + {NFS4ERR_DELAY , -ENOMEM }, + {NFS4ERR_IO , -ETXTBSY }, + {NFS4ERR_IO , -EBUSY }, + {NFS4ERR_BADHANDLE , -EBADHANDLE }, + {NFS4ERR_BAD_COOKIE , -EBADCOOKIE }, + {NFS4ERR_NOTSUPP , -EOPNOTSUPP }, + {NFS4ERR_TOOSMALL , -ETOOSMALL }, + {NFS4ERR_SERVERFAULT , -ESERVERFAULT }, + {NFS4ERR_SERVERFAULT , -ENFILE }, + {NFS4ERR_IO , -EREMOTEIO }, + {NFS4ERR_IO , -EUCLEAN }, + {NFS4ERR_PERM , -ENOKEY }, + {NFS4ERR_BADTYPE , -EBADTYPE }, + {NFS4ERR_SYMLINK , -ELOOP }, + {NFS4ERR_DEADLOCK , -EDEADLK }, +}; + +/* +* Convert an NFS error code to a local one. +* This one is used jointly by NFSv2 and NFSv3. +*/ +static __u32 +nfs4errno (int errno) +{ +unsigned int i; +for (i =0 ; i <ARRAY_SIZE (nfs_errtbl); i++) { +if (nfs_errtbl[i].errno == errno) +return nfs_errtbl[i].stat; + } +/* If we cannot translate the error, the recovery routines should +* handle it. +* Note: remaining NFSv4 error codes have values > 10000, so should +* not conflict with native Linux error codes. +*/ +return NFS4ERR_SERVERFAULT ; +} + +static bool localio_enabled__read_mostly = true; +module_param (localio_enabled, bool,0644 ); + +bool nfs_server_is_local (const struct nfs_client *clp) +{ +return test_bit (NFS_CS_LOCAL_IO , &clp->cl_flags) !=0 && + localio_enabled; +} +EXPORT_SYMBOL_GPL (nfs_server_is_local); + +/* +* nfs_local_enable - attempt to enable local i/o for an nfs_client +*/ +static void nfs_local_enable (struct nfs_client *clp,struct net *net) +{ +if (READ_ONCE (clp->nfsd_open_local_fh)) { +set_bit (NFS_CS_LOCAL_IO , &clp->cl_flags); + clp->cl_nfssvc_net = net; +trace_nfs_local_enable (clp); + } +} + +/* +* nfs_local_disable - disable local i/o for an nfs_client +*/ +void nfs_local_disable (struct nfs_client *clp) +{ +if (test_and_clear_bit (NFS_CS_LOCAL_IO , &clp->cl_flags)) { +trace_nfs_local_disable (clp); + clp->cl_nfssvc_net =NULL ; + } +} + +/* +* nfs_local_probe - probe local i/o support for an nfs_client +*/ +void +nfs_local_probe (struct nfs_client *clp) +{ +bool enable = false; + +if (enable) +nfs_local_enable (clp); +} +EXPORT_SYMBOL_GPL (nfs_local_probe); + +/* +* nfs_local_open_fh - open a local filehandle +* +* Returns a pointer to a struct file or an ERR_PTR +*/ +struct file * +nfs_local_open_fh (struct nfs_client *clp,const struct cred *cred, +struct nfs_fh *fh,const fmode_t mode) +{ +struct file *filp; +int status; + +if (mode & ~(FMODE_READ |FMODE_WRITE )) +return ERR_PTR (-EINVAL ); + + status = clp->nfsd_open_local_fh (clp->cl_nfssvc_net, clp->cl_rpcclient, + cred, fh, mode, &filp); +if (status <0 ) { +dprintk ("%s: open local file failed error=%d\n" , + __func__, status); +trace_nfs_local_open_fh (fh, mode, status); +switch (status) { +case -ENXIO : +nfs_local_disable (clp); + fallthrough; +case -ETIMEDOUT : + status = -EAGAIN ; + } + filp =ERR_PTR (status); + } +return filp; +} +EXPORT_SYMBOL_GPL (nfs_local_open_fh); + +static struct bio_vec * +nfs_bvec_alloc_and_import_pagevec (struct page **pagevec, +unsigned int npages,gfp_t flags) +{ +struct bio_vec *bvec, *p; + + bvec =kmalloc_array (npages,sizeof (*bvec), flags); +if (bvec !=NULL ) { +for (p = bvec; npages >0 ; p++, pagevec++, npages--) { + p->bv_page = *pagevec; + p->bv_len =PAGE_SIZE ; + p->bv_offset =0 ; + } + } +return bvec; +} + +static void +nfs_local_iocb_free (struct nfs_local_kiocb *iocb) +{ +kfree (iocb->bvec); +kfree (iocb); +} + +static struct nfs_local_kiocb * +nfs_local_iocb_alloc (struct nfs_pgio_header *hdr,struct file *filp, +gfp_t flags) +{ +struct nfs_local_kiocb *iocb; + + iocb =kmalloc (sizeof (*iocb), flags); +if (iocb ==NULL ) +return NULL ; + iocb->bvec =nfs_bvec_alloc_and_import_pagevec (hdr->page_array.pagevec, + hdr->page_array.npages, flags); +if (iocb->bvec ==NULL ) { +kfree (iocb); +return NULL ; + } +init_sync_kiocb (&iocb->kiocb, filp); + iocb->kiocb.ki_pos = hdr->args.offset; + iocb->hdr = hdr; + iocb->kiocb.ki_flags &= ~IOCB_APPEND ; +return iocb; +} + +static void +nfs_local_iter_init (struct iov_iter *i,struct nfs_local_kiocb *iocb,int dir) +{ +struct nfs_pgio_header *hdr = iocb->hdr; + +iov_iter_bvec (i, dir, iocb->bvec, hdr->page_array.npages, + hdr->args.count + hdr->args.pgbase); +if (hdr->args.pgbase !=0 ) +iov_iter_advance (i, hdr->args.pgbase); +} + +static void +nfs_local_hdr_release (struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops) +{ + call_ops->rpc_call_done (&hdr->task, hdr); + call_ops->rpc_release (hdr); +} + +static void +nfs_local_pgio_init (struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops) +{ + hdr->task.tk_ops = call_ops; +if (!hdr->task.tk_start) + hdr->task.tk_start =ktime_get (); +} + +static void +nfs_local_pgio_done (struct nfs_pgio_header *hdr,long status) +{ +if (status >=0 ) { + hdr->res.count = status; + hdr->res.op_status =NFS4_OK ; + hdr->task.tk_status =0 ; + }else { + hdr->res.op_status =nfs4errno (status); + hdr->task.tk_status = status; + } +} + +static void +nfs_local_pgio_release (struct nfs_local_kiocb *iocb) +{ +struct nfs_pgio_header *hdr = iocb->hdr; + +fput (iocb->kiocb.ki_filp); +nfs_local_iocb_free (iocb); +nfs_local_hdr_release (hdr, hdr->task.tk_ops); +} + +static void +nfs_local_read_done (struct nfs_local_kiocb *iocb,long status) +{ +struct nfs_pgio_header *hdr = iocb->hdr; +struct file *filp = iocb->kiocb.ki_filp; + +nfs_local_pgio_done (hdr, status); + +if (hdr->res.count != hdr->args.count || + hdr->args.offset + hdr->res.count >=i_size_read (file_inode (filp))) + hdr->res.eof = true; + +dprintk ("%s: read %ld bytes eof %d.\n" , __func__, + status >0 ? status :0 , hdr->res.eof); +} + +static int +nfs_do_local_read (struct nfs_pgio_header *hdr,struct file *filp, +const struct rpc_call_ops *call_ops) +{ +struct nfs_local_kiocb *iocb; +struct iov_iter iter; +ssize_t status; + +dprintk ("%s: vfs_read count=%u pos=%llu\n" , + __func__, hdr->args.count, hdr->args.offset); + + iocb =nfs_local_iocb_alloc (hdr, filp,GFP_KERNEL ); +if (iocb ==NULL ) +return -ENOMEM ; +nfs_local_iter_init (&iter, iocb,READ ); + +nfs_local_pgio_init (hdr, call_ops); + hdr->res.eof = false; + + status = filp->f_op->read_iter (&iocb->kiocb, &iter); +if (status != -EIOCBQUEUED ) { +nfs_local_read_done (iocb, status); +nfs_local_pgio_release (iocb); + } +return 0 ; +} + +static void +nfs_copy_boot_verifier (struct nfs_write_verifier *verifier,struct inode *inode) +{ +struct nfs_client *clp =NFS_SERVER (inode)->nfs_client; +u32 *verf = (u32 *)verifier->data; +int seq =0 ; + +do { +read_seqbegin_or_lock (&clp->cl_boot_lock, &seq); + verf[0 ] = (u32 )clp->cl_nfssvc_boot.tv_sec; + verf[1 ] = (u32 )clp->cl_nfssvc_boot.tv_nsec; + }while (need_seqretry (&clp->cl_boot_lock, seq)); +done_seqretry (&clp->cl_boot_lock, seq); +} + +static void +nfs_reset_boot_verifier (struct inode *inode) +{ +struct nfs_client *clp =NFS_SERVER (inode)->nfs_client; + +write_seqlock (&clp->cl_boot_lock); +ktime_get_real_ts64 (&clp->cl_nfssvc_boot); +write_sequnlock (&clp->cl_boot_lock); +} + +static void +nfs_set_local_verifier (struct inode *inode, +struct nfs_writeverf *verf, +enum nfs3_stable_how how) +{ + +nfs_copy_boot_verifier (&verf->verifier, inode); + verf->committed = how; +} + +static void +nfs_get_vfs_attr (struct file *filp,struct nfs_fattr *fattr) +{ +struct kstat stat; + +if (fattr !=NULL &&vfs_getattr (&filp->f_path, &stat, +STATX_INO | +STATX_ATIME | +STATX_MTIME | +STATX_CTIME | +STATX_SIZE | +STATX_BLOCKS , +AT_STATX_SYNC_AS_STAT ) ==0 ) { + fattr->valid =NFS_ATTR_FATTR_FILEID | +NFS_ATTR_FATTR_CHANGE | +NFS_ATTR_FATTR_SIZE | +NFS_ATTR_FATTR_ATIME | +NFS_ATTR_FATTR_MTIME | +NFS_ATTR_FATTR_CTIME | +NFS_ATTR_FATTR_SPACE_USED ; + fattr->fileid = stat.ino; + fattr->size = stat.size; + fattr->atime = stat.atime; + fattr->mtime = stat.mtime; + fattr->ctime = stat.ctime; + fattr->change_attr =nfs_timespec_to_change_attr (&fattr->ctime); + fattr->du.nfs3.used = stat.blocks <<9 ; + } +} + +static void +nfs_local_write_done (struct nfs_local_kiocb *iocb,long status) +{ +struct nfs_pgio_header *hdr = iocb->hdr; + +dprintk ("%s: wrote %ld bytes.\n" , __func__, status >0 ? status :0 ); + +/* Handle short writes as if they are ENOSPC */ +if (status >0 && status < hdr->args.count) { + hdr->mds_offset += status; + hdr->args.offset += status; + hdr->args.pgbase += status; + hdr->args.count -= status; +nfs_set_pgio_error (hdr, -ENOSPC , hdr->args.offset); + status = -ENOSPC ; + } +if (status <0 ) +nfs_reset_boot_verifier (hdr->inode); +nfs_local_pgio_done (hdr, status); +} + +static int +nfs_do_local_write (struct nfs_pgio_header *hdr,struct file *filp, +const struct rpc_call_ops *call_ops) +{ +struct nfs_local_kiocb *iocb; +struct iov_iter iter; +ssize_t status; + +dprintk ("%s: vfs_write count=%u pos=%llu %s\n" , + __func__, hdr->args.count, hdr->args.offset, + (hdr->args.stable ==NFS_UNSTABLE ) ?"unstable" :"stable" ); + + iocb =nfs_local_iocb_alloc (hdr, filp,GFP_NOIO ); +if (iocb ==NULL ) +return -ENOMEM ; +nfs_local_iter_init (&iter, iocb,WRITE ); + +switch (hdr->args.stable) { +default : +break ; +case NFS_DATA_SYNC : + iocb->kiocb.ki_flags |=IOCB_DSYNC ; +break ; +case NFS_FILE_SYNC : + iocb->kiocb.ki_flags |=IOCB_DSYNC |IOCB_SYNC ; + } +nfs_local_pgio_init (hdr, call_ops); + +nfs_set_local_verifier (hdr->inode, hdr->res.verf, hdr->args.stable); + +file_start_write (filp); + status = filp->f_op->write_iter (&iocb->kiocb, &iter); +file_end_write (filp); +if (status != -EIOCBQUEUED ) { +nfs_local_write_done (iocb, status); +nfs_get_vfs_attr (filp, hdr->res.fattr); +nfs_local_pgio_release (iocb); + } +return 0 ; +} + +static struct file * +nfs_local_file_open_cached (struct nfs_client *clp,const struct cred *cred, +struct nfs_fh *fh,struct nfs_open_context *ctx) +{ +struct file *filp = ctx->local_filp; + +if (!filp) { +struct file *new =nfs_local_open_fh (clp, cred, fh, ctx->mode); +if (IS_ERR_OR_NULL (new)) +return NULL ; +/* try to put this one in the slot */ + filp =cmpxchg (&ctx->local_filp,NULL , new); +if (filp !=NULL ) +fput (new); +else + filp = new; + } +return get_file (filp); +} + +struct file * +nfs_local_file_open (struct nfs_client *clp,const struct cred *cred, +struct nfs_fh *fh,struct nfs_open_context *ctx) +{ +if (!nfs_server_is_local (clp)) +return NULL ; +return nfs_local_file_open_cached (clp, cred, fh, ctx); +} + +int +nfs_local_doio (struct nfs_client *clp,struct file *filp, +struct nfs_pgio_header *hdr, +const struct rpc_call_ops *call_ops) +{ +int status =0 ; + +if (!hdr->args.count) + goto out_fput; +/* Don't support filesystems without read_iter/write_iter */ +if (!filp->f_op->read_iter || !filp->f_op->write_iter) { +nfs_local_disable (clp); + status = -EAGAIN ; + goto out_fput; + } + +switch (hdr->rw_mode) { +case FMODE_READ : + status =nfs_do_local_read (hdr, filp, call_ops); +break ; +case FMODE_WRITE : + status =nfs_do_local_write (hdr, filp, call_ops); +break ; +default : +dprintk ("%s: invalid mode: %d\n" , __func__, + hdr->rw_mode); + status = -EINVAL ; + } +out_fput: +if (status !=0 ) { +fput (filp); + hdr->task.tk_status = status; +nfs_local_hdr_release (hdr, call_ops); + } +return status; +} + +static void +nfs_local_init_commit (struct nfs_commit_data *data, +const struct rpc_call_ops *call_ops) +{ + data->task.tk_ops = call_ops; +} + +static int +nfs_local_run_commit (struct file *filp,struct nfs_commit_data *data) +{ +loff_t start = data->args.offset; +loff_t end =LLONG_MAX ; + +if (data->args.count >0 ) { + end = start + data->args.count -1 ; +if (end < start) + end =LLONG_MAX ; + } + +dprintk ("%s: commit %llu - %llu\n" , __func__, start, end); +return vfs_fsync_range (filp, start, end,0 ); +} + +static void +nfs_local_commit_done (struct nfs_commit_data *data,int status) +{ +if (status >=0 ) { +nfs_set_local_verifier (data->inode, + data->res.verf, +NFS_FILE_SYNC ); + data->res.op_status =NFS4_OK ; + data->task.tk_status =0 ; + }else { +nfs_reset_boot_verifier (data->inode); + data->res.op_status =nfs4errno (status); + data->task.tk_status = status; + } +} + +static void +nfs_local_release_commit_data (struct file *filp, +struct nfs_commit_data *data, +const struct rpc_call_ops *call_ops) +{ +fput (filp); + call_ops->rpc_call_done (&data->task, data); + call_ops->rpc_release (data); +} + +static struct nfs_local_fsync_ctx * +nfs_local_fsync_ctx_alloc (struct nfs_commit_data *data,struct file *filp, +gfp_t flags) +{ +struct nfs_local_fsync_ctx *ctx =kmalloc (sizeof (*ctx), flags); + +if (ctx !=NULL ) { + ctx->filp = filp; + ctx->data = data; +INIT_WORK (&ctx->work, nfs_local_fsync_work); +kref_init (&ctx->kref); + ctx->done =NULL ; + } +return ctx; +} + +static void +nfs_local_fsync_ctx_kref_free (struct kref *kref) +{ +kfree (container_of(kref ,struct nfs_local_fsync_ctx ,kref )); +} + +static void +nfs_local_fsync_ctx_put (struct nfs_local_fsync_ctx *ctx) +{ +kref_put (&ctx->kref, nfs_local_fsync_ctx_kref_free); +} + +static void +nfs_local_fsync_ctx_free (struct nfs_local_fsync_ctx *ctx) +{ +nfs_local_release_commit_data (ctx->filp, ctx->data, + ctx->data->task.tk_ops); +nfs_local_fsync_ctx_put (ctx); +} + +static void +nfs_local_fsync_work (struct work_struct *work) +{ +struct nfs_local_fsync_ctx *ctx; +int status; + + ctx = container_of(work, struct nfs_local_fsync_ctx, work); + + status =nfs_local_run_commit (ctx->filp, ctx->data); +nfs_local_commit_done (ctx->data, status); +if (ctx->done !=NULL ) +complete (ctx->done); +nfs_local_fsync_ctx_free (ctx); +} + +int +nfs_local_commit (struct file *filp,struct nfs_commit_data *data, +const struct rpc_call_ops *call_ops,int how) +{ +struct nfs_local_fsync_ctx *ctx; + + ctx =nfs_local_fsync_ctx_alloc (data, filp,GFP_KERNEL ); +if (!ctx) { +nfs_local_commit_done (data, -ENOMEM ); +nfs_local_release_commit_data (filp, data, call_ops); +return -ENOMEM ; + } + +nfs_local_init_commit (data, call_ops); +kref_get (&ctx->kref); +if (how &FLUSH_SYNC ) { +DECLARE_COMPLETION_ONSTACK (done); + ctx->done = &done; +queue_work (nfsiod_workqueue, &ctx->work); +wait_for_completion (&done); + }else +queue_work (nfsiod_workqueue, &ctx->work); +nfs_local_fsync_ctx_put (ctx); +return 0 ; +}fs/nfs/nfstrace.h +61
-0@@ -1681,6 +1681,67 @@ TRACE_EVENT(nfs_mount_path,TP_printk ("path='%s'" ,__get_str (path)) ); +TRACE_EVENT (nfs_local_open_fh, +TP_PROTO ( + const struct nfs_fh *fh, + fmode_t fmode, + int error + ), + +TP_ARGS (fh, fmode, error), + +TP_STRUCT__entry ( + __field(int, error) + __field(u32, fhandle) + __field(unsigned int, fmode) + ), + +TP_fast_assign ( + __entry->error = error; + __entry->fhandle = nfs_fhandle_hash(fh); + __entry->fmode = (__force unsigned int)fmode; + ), + +TP_printk ( +"error=%d fhandle=0x%08x mode=%s" , + __entry->error, + __entry->fhandle, +show_fs_fmode_flags (__entry->fmode) + ) +); + +DECLARE_EVENT_CLASS (nfs_local_client_event, +TP_PROTO ( + const struct nfs_client *clp + ), + +TP_ARGS (clp), + +TP_STRUCT__entry ( + __field(unsigned int, protocol) +__string (server, clp->cl_hostname) + ), + +TP_fast_assign ( + __entry->protocol = clp->rpc_ops->version; + __assign_str(server); + ), + +TP_printk ( +"server=%s NFSv%u" ,__get_str (server), __entry->protocol + ) +); + +#define DEFINE_NFS_LOCAL_CLIENT_EVENT (name) \ + DEFINE_EVENT(nfs_local_client_event, name, \ + TP_PROTO( \ + const struct nfs_client *clp \ + ), \ + TP_ARGS(clp)) + +DEFINE_NFS_LOCAL_CLIENT_EVENT (nfs_local_enable); +DEFINE_NFS_LOCAL_CLIENT_EVENT (nfs_local_disable); + DECLARE_EVENT_CLASS(nfs_xdr_event, TP_PROTO( const struct xdr_stream *xdr,fs/nfs/pagelist.c +3
-0@@ -879,6 +879,9 @@ int nfs_initiate_pgio(struct nfs_pageio_descriptor *desc, hdr->args.count, (unsigned long long)hdr->args.offset); +if (localio) +return nfs_local_doio (clp, localio, hdr, call_ops); + task =rpc_run_task (&task_setup_data);if (IS_ERR (task))return PTR_ERR (task);fs/nfs/write.c +3
-0@@ -1700,6 +1700,9 @@ int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,dprintk ("NFS: initiated commit call\n" ); +if (localio) +return nfs_local_commit (localio, data, call_ops, how); + task =rpc_run_task (&task_setup_data);if (IS_ERR (task))return PTR_ERR (task);fs/nfsd/Makefile +1
-0@@ -23,3 +23,4 @@ nfsd-$(CONFIG_NFSD_PNFS) += nfs4layouts.o nfsd-$(CONFIG_NFSD_BLOCKLAYOUT) += blocklayout.o blocklayoutxdr.o nfsd-$(CONFIG_NFSD_SCSILAYOUT) += blocklayout.o blocklayoutxdr.o nfsd-$(CONFIG_NFSD_FLEXFILELAYOUT) += flexfilelayout.o flexfilelayoutxdr.o +nfsd-$(CONFIG_NFSD_LOCALIO) += localio.ofs/nfsd/filecache.c +1
-1@@ -52,7 +52,7 @@#define NFSD_FILE_CACHE_UP (0)/* We only care about NFSD_MAY_READ/WRITE for this cache */ -#define NFSD_FILE_MAY_MASK (NFSD_MAY_READ|NFSD_MAY_WRITE) +#define NFSD_FILE_MAY_MASK (NFSD_MAY_READ|NFSD_MAY_WRITE|NFSD_MAY_LOCALIO) static DEFINE_PER_CPU(unsigned long, nfsd_file_cache_hits); static DEFINE_PER_CPU(unsigned long, nfsd_file_acquisitions);fs/nfsd/localio.c new file +11
-0@@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NFS server support for local clients to bypass network stack +* +* Copyright (C) 2014 Weston Andros Adamson <[email protected]> +* Copyright (C) 2019 Trond Myklebust <[email protected]> +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/exportfs.h> +#include <linux/sunrpc/svcauth_gss.h>
fs/nfsd/localio.c line 21
Quoted 10 lines
fs/nfsd/localio.c new file +10
-0+#include <linux/sunrpc/clnt.h> +#include <linux/nfs.h> +#include <linux/string.h> + +#include "nfsd.h" +#include "vfs.h" +#include "netns.h" +#include "filecache.h" + +#define NFSDDBG_FACILITY NFSDDBG_FH
I think I'd rather prefer to see trace points in here rather than new dprintk call sites. In any event, perhaps NFSDDBG_FH is not especially appropriate?
Quoted 54 lines
fs/nfsd/localio.c new file +54
-0+ +/* +* We need to translate between nfs status return values and +* the local errno values which may not be the same. +* - duplicated from fs/nfs/nfs2xdr.c to avoid needless bloat of +* all compiled nfs objects if it were in include/linux/nfs.h +*/ +static const struct { +int stat; +int errno; +} nfs_common_errtbl[] = { + {NFS_OK ,0 }, + {NFSERR_PERM , -EPERM }, + {NFSERR_NOENT , -ENOENT }, + {NFSERR_IO , -EIO }, + {NFSERR_NXIO , -ENXIO }, +/* { NFSERR_EAGAIN, -EAGAIN }, */ + {NFSERR_ACCES , -EACCES }, + {NFSERR_EXIST , -EEXIST }, + {NFSERR_XDEV , -EXDEV }, + {NFSERR_NODEV , -ENODEV }, + {NFSERR_NOTDIR , -ENOTDIR }, + {NFSERR_ISDIR , -EISDIR }, + {NFSERR_INVAL , -EINVAL }, + {NFSERR_FBIG , -EFBIG }, + {NFSERR_NOSPC , -ENOSPC }, + {NFSERR_ROFS , -EROFS }, + {NFSERR_MLINK , -EMLINK }, + {NFSERR_NAMETOOLONG , -ENAMETOOLONG }, + {NFSERR_NOTEMPTY , -ENOTEMPTY }, + {NFSERR_DQUOT , -EDQUOT }, + {NFSERR_STALE , -ESTALE }, + {NFSERR_REMOTE , -EREMOTE }, +#ifdef EWFLUSH + {NFSERR_WFLUSH , -EWFLUSH }, +#endif + {NFSERR_BADHANDLE , -EBADHANDLE }, + {NFSERR_NOT_SYNC , -ENOTSYNC }, + {NFSERR_BAD_COOKIE , -EBADCOOKIE }, + {NFSERR_NOTSUPP , -ENOTSUPP }, + {NFSERR_TOOSMALL , -ETOOSMALL }, + {NFSERR_SERVERFAULT , -EREMOTEIO }, + {NFSERR_BADTYPE , -EBADTYPE }, + {NFSERR_JUKEBOX , -EJUKEBOX }, + {-1 , -EIO } +}; + +/** +* nfs_stat_to_errno - convert an NFS status code to a local errno +* @status: NFS status code to convert +* +* Returns a local errno value, or -EIO if the NFS status code is +* not recognized. This function is used jointly by NFSv2 and NFSv3. +*/
fs/nfsd/localio.c line 85
Quoted 10 lines
fs/nfsd/localio.c new file +10
-0+static int nfs_stat_to_errno (enum nfs_stat status) +{ +int i; + +for (i =0 ; nfs_common_errtbl[i].stat !=-1 ; i++) { +if (nfs_common_errtbl[i].stat == (int )status) +return nfs_common_errtbl[i].errno; + } +return nfs_common_errtbl[i].errno; +}
I get it: The existing nfserrno() function on the server is the reverse mapping from this one, and you need to undo the nfsstat returned from nfsd_file_acquire().
The documenting comments here confusing in the context of why this function is necessary on the server. For example, "This function is used jointly by NFSv2 and NFSv3"... Maybe instead, explain that nfsd_file_acquire() returns an nfsstat that needs to be translated to an errno before being returned to a local client application.
Quoted 12 lines
fs/nfsd/localio.c new file +12
-0+static void +nfsd_local_fakerqst_destroy (struct svc_rqst *rqstp) +{ +if (rqstp->rq_client) +auth_domain_put (rqstp->rq_client); +if (rqstp->rq_cred.cr_group_info) +put_group_info (rqstp->rq_cred.cr_group_info); +/* rpcauth_map_to_svc_cred_local() clears cr_principal */ +WARN_ON_ONCE (rqstp->rq_cred.cr_principal !=NULL ); +kfree (rqstp->rq_xprt); +kfree (rqstp); +}
fs/nfsd/localio.c line 108
Quoted 10 lines
fs/nfsd/localio.c new file +10
-0+ +static struct svc_rqst * +nfsd_local_fakerqst_create (struct net *net,struct rpc_clnt *rpc_clnt, +const struct cred *cred) +{ +struct svc_rqst *rqstp; +struct nfsd_net *nn =net_generic (net, nfsd_net_id); +int status; + +/* FIXME: not running in nfsd context, must get reference on nfsd_serv */
What's your plan for addressing this FIXME?
Quoted 167 lines
fs/nfsd/localio.c new file +136
-0+if (unlikely (!READ_ONCE (nn->nfsd_serv))) { +dprintk ("%s: localio denied. Server not running\n" , __func__); +return ERR_PTR (-ENXIO ); + } + + rqstp =kzalloc (sizeof (*rqstp),GFP_KERNEL ); +if (!rqstp) +return ERR_PTR (-ENOMEM ); + + rqstp->rq_xprt =kzalloc (sizeof (*rqstp->rq_xprt),GFP_KERNEL ); +if (!rqstp->rq_xprt) { + status = -ENOMEM ; + goto out_err; + } + + rqstp->rq_xprt->xpt_net = net; +__set_bit (RQ_SECURE , &rqstp->rq_flags); + rqstp->rq_proc =1 ; + rqstp->rq_vers =3 ; + rqstp->rq_prot =IPPROTO_TCP ; + rqstp->rq_server = nn->nfsd_serv; + +/* Note: we're connecting to ourself, so source addr == peer addr */ + rqstp->rq_addrlen =rpc_peeraddr (rpc_clnt, + (struct sockaddr *)&rqstp->rq_addr, +sizeof (rqstp->rq_addr)); + +rpcauth_map_to_svc_cred_local (rpc_clnt->cl_auth, cred, &rqstp->rq_cred); + +/* +* set up enough for svcauth_unix_set_client to be able to wait +* for the cache downcall. Note that we do _not_ want to allow the +* request to be deferred for later revisit since this rqst and xprt +* are not set up to run inside of the normal svc_rqst engine. +*/ +INIT_LIST_HEAD (&rqstp->rq_xprt->xpt_deferred); +kref_init (&rqstp->rq_xprt->xpt_ref); +spin_lock_init (&rqstp->rq_xprt->xpt_lock); + rqstp->rq_chandle.thread_wait =5 *HZ ; + + status =svcauth_unix_set_client (rqstp); +switch (status) { +case SVC_OK : +break ; +case SVC_DENIED : + status = -ENXIO ; +dprintk ("%s: client %pISpc denied localio access\n" , + __func__, (struct sockaddr *)&rqstp->rq_addr); + goto out_err; +default : + status = -ETIMEDOUT ; +dprintk ("%s: client %pISpc temporarily denied localio access\n" , + __func__, (struct sockaddr *)&rqstp->rq_addr); + goto out_err; + } + +return rqstp; + +out_err: +nfsd_local_fakerqst_destroy (rqstp); +return ERR_PTR (status); +} + +/* +* nfsd_open_local_fh - lookup a local filehandle @nfs_fh and map to @file +* +* This function maps a local fh to a path on a local filesystem. +* This is useful when the nfs client has the local server mounted - it can +* avoid all the NFS overhead with reads, writes and commits. +* +* on successful return, caller is responsible for calling path_put. Also +* note that this is called from nfs.ko via find_symbol() to avoid an explicit +* dependency on knfsd. So, there is no forward declaration in a header file +* for it. +*/ +int nfsd_open_local_fh (struct net *net, +struct rpc_clnt *rpc_clnt, +const struct cred *cred, +const struct nfs_fh *nfs_fh, +const fmode_t fmode, +struct file **pfilp) +{ +const struct cred *save_cred; +struct svc_rqst *rqstp; +struct svc_fh fh; +struct nfsd_file *nf; +int status =0 ; +int mayflags =NFSD_MAY_LOCALIO ; +__be32 beres; + +/* Save creds before calling into nfsd */ + save_cred =get_current_cred (); + + rqstp =nfsd_local_fakerqst_create (net, rpc_clnt, cred); +if (IS_ERR (rqstp)) { + status =PTR_ERR (rqstp); + goto out_revertcred; + } + +/* nfs_fh -> svc_fh */ +if (nfs_fh->size >NFS4_FHSIZE ) { + status = -EINVAL ; + goto out; + } +fh_init (&fh,NFS4_FHSIZE ); + fh.fh_handle.fh_size = nfs_fh->size; +memcpy (fh.fh_handle.fh_raw, nfs_fh->data, nfs_fh->size); + +if (fmode &FMODE_READ ) + mayflags |=NFSD_MAY_READ ; +if (fmode &FMODE_WRITE ) + mayflags |=NFSD_MAY_WRITE ; + + beres =nfsd_file_acquire (rqstp, &fh, mayflags, &nf); +if (beres) { + status =nfs_stat_to_errno (be32_to_cpu (beres)); +dprintk ("%s: fh_verify failed %d\n" , __func__, status); + goto out_fh_put; + } + + *pfilp =get_file (nf->nf_file); + +nfsd_file_put (nf); +out_fh_put: +fh_put (&fh); + +out: +nfsd_local_fakerqst_destroy (rqstp); +out_revertcred: +revert_creds (save_cred); +return status; +} +EXPORT_SYMBOL_GPL (nfsd_open_local_fh); + +/* Compile time type checking, not used by anything */ +static nfs_to_nfsd_open_t __maybe_unused nfsd_open_local_fh_typecheck = nfsd_open_local_fh;fs/nfsd/nfssvc.c +1
-0@@ -431,6 +431,7 @@ static int nfsd_startup_net(struct net *net, const struct cred *cred)#endif #if IS_ENABLED (CONFIG_NFSD_LOCALIO )INIT_LIST_HEAD (&nn->nfsd_uuid.list); + nn->nfsd_uuid.net = net;list_add_tail_rcu (&nn->nfsd_uuid.list, &nfsd_uuids);#endif nn->nfsd_net_up = true;fs/nfsd/trace.h +2
-1@@ -86,7 +86,8 @@ DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ - { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) + { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }, \ + { NFSD_MAY_LOCALIO, "LOCALIO" }) TRACE_EVENT(nfsd_compound, TP_PROTO(fs/nfsd/vfs.h +0
-0
fs/nfsd/vfs.h line 40
Quoted 5 lines
fs/nfsd/vfs.h +2
-0@@ -36,6 +36,8 @@#define NFSD_MAY_CREATE (NFSD_MAY_EXEC|NFSD_MAY_WRITE)#define NFSD_MAY_REMOVE (NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC) +#define NFSD_MAY_LOCALIO 0x800000 +
Nit: I'd prefer to see NFSD_MAY_LOCALIO inserted just after NFSD_MAY_64BIT_COOKIE. Is there a reason the value of the new flag should not be 0x2000 ?
Quoted 58 lines
fs/nfsd/vfs.h +7
-0struct nfsd_file ;/* @@ -158,6 +160,13 @@ __be32 nfsd_permission(struct svc_rqst *, struct svc_export *,void nfsd_filp_close (struct file *fp); +int nfsd_open_local_fh (struct net *net, +struct rpc_clnt *rpc_clnt, +const struct cred *cred, +const struct nfs_fh *nfs_fh, +const fmode_t fmode, +struct file **pfilp); +static inline int fh_want_write (struct svc_fh *fh) {int ret;include/linux/nfs.h +2
-0@@ -8,6 +8,8 @@#ifndef _LINUX_NFS_H#define _LINUX_NFS_H +#include <linux/cred.h> +#include <linux/sunrpc/auth.h> #include <linux/sunrpc/msg_prot.h> #include <linux/string.h> #include <linux/crc32.h> include/linux/nfs_fs.h +2
-0@@ -96,6 +96,8 @@ struct nfs_open_context {struct list_head list;struct nfs4_threshold *mdsthreshold;struct rcu_head rcu_head; + +struct file *local_filp; };struct nfs_open_dir_context {include/linux/nfs_fs_sb.h +1
-0@@ -50,6 +50,7 @@ struct nfs_client {#define NFS_CS_DS 7/* - Server is a DS */ #define NFS_CS_REUSEPORT 8/* - reuse src port on reconnect */ #define NFS_CS_PNFS 9/* - Server used for pnfs */ +#define NFS_CS_LOCAL_IO 10/* - client is local */ struct sockaddr_storage cl_addr;/* server identifier */ size_t cl_addrlen;char * cl_hostname;/* hostname of server */ Signature · 1 line
2.44.0
Signature · 1 line
Chuck Lever
Re: [PATCH v7 06/20] nfs/nfsd: add "localio" support
Quoted 39 lines · Chuck Lever
Quoted 28 lines · Mike Snitzer
From: Weston Andros Adamson <[email protected]>
Add client support for bypassing NFS for localhost reads, writes, and commits. This is only useful when the client and the server are running on the same host.
nfs_local_probe()is stubbed out, later commits will enable client and server handshake via a Linux-only LOCALIO auxiliary RPC protocol.This has dynamic binding with the nfsd module (via
nfs_localiomodule which is part ofnfs_common). Localio will only work if nfsd is already loaded.The "
localio_enabled" nfs kernel module parameter can be used to disable and enable the ability to use localio support.Tracepoints were added for
nfs_local_open_fh,nfs_local_enableandnfs_local_disable.Also, pass the stored
cl_nfssvc_netfrom the client to the server as first argument tonfsd_open_local_fh()to ensure the proper network namespace is used for localio.Signed-off-by Weston Andros Adamson <[email protected]>Signed-off-by Peng Tao <[email protected]>Signed-off-by Lance Shelton <[email protected]>Signed-off-by Trond Myklebust <[email protected]>Signed-off-by Mike Snitzer <[email protected]>Quoted 9 lines
--- fs/nfs/Makefile | 1 + fs/nfs/client.c | 3 + fs/nfs/inode.c | 4 + fs/nfs/internal.h | 51 +++ fs/nfs/localio.c | 654 ++++++++++++++++++++++++++++++++++++++ fs/nfs/nfstrace.h | 61 ++++ fs/nfs/pagelist.c | 3 + fs/nfs/write.c | 3 +
Quoted 6 lines
Hi Mike -
I'd prefer to see this patch split into two patches, one for the NFS client, and one for the NFS server. The other patches in this series seem to have a clear line between server and client changes.
Will do.
Quoted 23 lines
Quoted 23 lines
fs/nfsd/localio.c new file +17
-0@@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NFS server support for local clients to bypass network stack +* +* Copyright (C) 2014 Weston Andros Adamson <[email protected]> +* Copyright (C) 2019 Trond Myklebust <[email protected]> +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/exportfs.h> +#include <linux/sunrpc/svcauth_gss.h> +#include <linux/sunrpc/clnt.h> +#include <linux/nfs.h> +#include <linux/string.h> + +#include "nfsd.h" +#include "vfs.h"
Quoted 8 lines
fs/nfsd/localio.c line 21
Quoted 4 lines
fs/nfsd/localio.c new file +4
-0+#include "netns.h" +#include "filecache.h" + +#define NFSDDBG_FACILITY NFSDDBG_FHI think I'd rather prefer to see trace points in here rather than new dprintk call sites. In any event, perhaps
NFSDDBG_FHis not especially appropriate?
I think NFSDDBG_FH is most appropriate given this localio is most focused on opening a file handle. (The getuuid not so much)
I'm not loving how overdone the trace points interface is. in my experience, trace points are also a serious source of conflicts when backporting changes to older kernels.
But if you were inclined to switch this code over to trace points once it is merged, who am I to stop you! ;)
Quoted 23 lines
Quoted 8 lines
fs/nfsd/localio.c new file +8
-0+ +/** +* nfs_stat_to_errno - convert an NFS status code to a local errno +* @status: NFS status code to convert +* +* Returns a local errno value, or -EIO if the NFS status code is +* not recognized. This function is used jointly by NFSv2 and NFSv3. +*/ fs/nfsd/localio.c line 85
Quoted 10 lines
fs/nfsd/localio.c new file +10
-0+static int nfs_stat_to_errno (enum nfs_stat status) +{ +int i; + +for (i =0 ; nfs_common_errtbl[i].stat !=-1 ; i++) { +if (nfs_common_errtbl[i].stat == (int )status) +return nfs_common_errtbl[i].errno; + } +return nfs_common_errtbl[i].errno; +}I get it: The existing
nfserrno()function on the server is the reverse mapping from this one, and you need to undo the nfsstat returned fromnfsd_file_acquire().
Quoted 5 lines
The documenting comments here confusing in the context of why this function is necessary on the server. For example, "This function is used jointly by NFSv2 and NFSv3"... Maybe instead, explain that
nfsd_file_acquire()returns an nfsstat that needs to be translated to an errno before being returned to a local client application.
Thanks, fixed.
Quoted 16 lines
Quoted 16 lines
fs/nfsd/localio.c new file +16
-0+static void +nfsd_local_fakerqst_destroy (struct svc_rqst *rqstp) +{ +if (rqstp->rq_client) +auth_domain_put (rqstp->rq_client); +if (rqstp->rq_cred.cr_group_info) +put_group_info (rqstp->rq_cred.cr_group_info); +/* rpcauth_map_to_svc_cred_local() clears cr_principal */ +WARN_ON_ONCE (rqstp->rq_cred.cr_principal !=NULL ); +kfree (rqstp->rq_xprt); +kfree (rqstp); +} + +static struct svc_rqst * +nfsd_local_fakerqst_create (struct net *net,struct rpc_clnt *rpc_clnt, +const struct cred *cred)
Quoted 8 lines
fs/nfsd/localio.c line 108
Quoted 6 lines
fs/nfsd/localio.c new file +6
-0+{ +struct svc_rqst *rqstp; +struct nfsd_net *nn =net_generic (net, nfsd_net_id); +int status; + +/* FIXME: not running in nfsd context, must get reference on nfsd_serv */ What's your plan for addressing this FIXME?
The SRCU (and nfsd_serv_get, nfsd_serv_put and nfsd_serv_sync) in later patches addresses it.
FYI: And now that I looked closer at Neil's earlier suggestion (to have a single SRCU for all of nfsd_net -- rather than having one embedded in each): I'll try to include that change for v8.
Quoted 8 lines
Quoted 8 lines
fs/nfsd/vfs.h +0
-0@@ -36,6 +36,8 @@#define NFSD_MAY_CREATE (NFSD_MAY_EXEC|NFSD_MAY_WRITE)#define NFSD_MAY_REMOVE (NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC)
Quoted 6 lines
fs/nfsd/vfs.h line 40
Quoted 2 lines
fs/nfsd/vfs.h +2
-0+#define NFSD_MAY_LOCALIO 0x800000 +Nit: I'd prefer to see
NFSD_MAY_LOCALIOinserted just afterNFSD_MAY_64BIT_COOKIE. Is there a reason the value of the new flag should not be0x2000?
Fixed.
Re: [PATCH v7 06/20] nfs/nfsd: add "localio" support
Quoted 35 lines · Mike Snitzer
Quoted 25 lines · Chuck Lever
Quoted 24 lines · Mike Snitzer
From: Weston Andros Adamson <[email protected]>
fs/nfsd/localio.c new file +17
-0@@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NFS server support for local clients to bypass network stack +* +* Copyright (C) 2014 Weston Andros Adamson <[email protected]> +* Copyright (C) 2019 Trond Myklebust <[email protected]> +* Copyright (C) 2024 Mike Snitzer <[email protected]> +*/ + +#include <linux/exportfs.h> +#include <linux/sunrpc/svcauth_gss.h> +#include <linux/sunrpc/clnt.h> +#include <linux/nfs.h> +#include <linux/string.h> + +#include "nfsd.h" +#include "vfs.h" Quoted 8 lines
fs/nfsd/localio.c line 21
Quoted 4 lines
fs/nfsd/localio.c new file +4
-0+#include "netns.h" +#include "filecache.h" + +#define NFSDDBG_FACILITY NFSDDBG_FHI think I'd rather prefer to see trace points in here rather than new dprintk call sites. In any event, perhaps
NFSDDBG_FHis not especially appropriate?
Quoted 2 lines
I think
NFSDDBG_FHis most appropriate given this localio is most focused on opening a file handle. (The getuuid not so much)
If more than one debugging facility is appropriate, consider using dfprintk() instead so each call site can specify its preferred facility.
Quoted 6 lines
I'm not loving how overdone the trace points interface is. in my experience, trace points are also a serious source of conflicts when backporting changes to older kernels.
But if you were inclined to switch this code over to trace points once it is merged, who am I to stop you! ;)
Have a heartfelt conversation with yourself about whether all of these dprintk's need to stay, then.
Anything you've been using strictly as a development tool can be considered disposable. Anything an admin or support engineer might want to enable to diagnose a local configuration or deployment issue is a candidate for staying in the code. And so on and so forth.
Signature · 1 line
Chuck Lever
PATCH v7 7/20 nfsd/localio: manage netns reference in nfsd_open_local_fh
In reply to Mike SnitzerUse maybe_get_net() and put_net() in nfsd_open_local_fh(). Also refactor nfsd_open_local_fh() slightly.
--- fs/nfsd/localio.c | 45 ++++++++++++++++++++++++++------------------- 1 file changed, 26 insertions(+), 19 deletions(-)
fs/nfsd/localio.c +26 -19
@@ -99,18 +99,11 @@ nfsd_local_fakerqst_destroy(struct svc_rqst *rqstp)static struct svc_rqst *nfsd_local_fakerqst_create (struct net *net,struct rpc_clnt *rpc_clnt, -const struct cred *cred) +const struct cred *cred,struct svc_serv *serv) {struct svc_rqst *rqstp; -struct nfsd_net *nn =net_generic (net, nfsd_net_id);int status; -/* FIXME: not running in nfsd context, must get reference on nfsd_serv */ -if (unlikely (!READ_ONCE (nn->nfsd_serv))) { -dprintk ("%s: localio denied. Server not running\n" , __func__); -return ERR_PTR (-ENXIO ); - } - rqstp =kzalloc (sizeof (*rqstp),GFP_KERNEL );if (!rqstp)return ERR_PTR (-ENOMEM );
@@ -120,13 +113,13 @@ nfsd_local_fakerqst_create(struct net *net, struct rpc_clnt *rpc_clnt, status = -ENOMEM ; goto out_err; } - rqstp->rq_xprt->xpt_net = net; +__set_bit (RQ_SECURE , &rqstp->rq_flags); rqstp->rq_proc =1 ; rqstp->rq_vers =3 ; rqstp->rq_prot =IPPROTO_TCP ; - rqstp->rq_server = nn->nfsd_serv; + rqstp->rq_server = serv;/* Note: we're connecting to ourself, so source addr == peer addr */ rqstp->rq_addrlen = rpc_peeraddr(rpc_clnt,
@@ -188,28 +181,44 @@ int nfsd_open_local_fh(struct net *net,const fmode_t fmode, struct file **pfilp) { + struct nfsd_net *nn;const struct cred *save_cred;struct svc_rqst *rqstp;struct svc_fh fh;struct nfsd_file *nf;int status =0 ;int mayflags =NFSD_MAY_LOCALIO ; +struct svc_serv *serv;__be32 beres; +if (nfs_fh->size >NFS4_FHSIZE ) +return -EINVAL ; + +/* Not running in nfsd context, must safely get reference on nfsd_serv */ + net =maybe_get_net (net); +if (!net) { +dprintk ("%s: localio denied. Server netns not available\n" , __func__); +return -ENXIO ; + } + nn =net_generic (net, nfsd_net_id); + + serv =READ_ONCE (nn->nfsd_serv); +if (unlikely (!serv)) { +dprintk ("%s: localio denied. Server not running\n" , __func__); + status = -ENXIO ; + goto out_net; + } +/* Save creds before calling into nfsd */ save_cred =get_current_cred (); - rqstp =nfsd_local_fakerqst_create (net, rpc_clnt, cred); + rqstp =nfsd_local_fakerqst_create (net, rpc_clnt, cred, serv);if (IS_ERR (rqstp)) { status =PTR_ERR (rqstp); goto out_revertcred; }/* nfs_fh -> svc_fh */ -if (nfs_fh->size >NFS4_FHSIZE ) { - status = -EINVAL ; - goto out; - }fh_init (&fh,NFS4_FHSIZE ); fh.fh_handle.fh_size = nfs_fh->size;memcpy (fh.fh_handle.fh_raw, nfs_fh->data, nfs_fh->size);
@@ -225,17 +234,15 @@ int nfsd_open_local_fh(struct net *net,dprintk ("%s: fh_verify failed %d\n" , __func__, status); goto out_fh_put; } - *pfilp =get_file (nf->nf_file); -nfsd_file_put (nf); out_fh_put:fh_put (&fh); - -out:nfsd_local_fakerqst_destroy (rqstp); out_revertcred:revert_creds (save_cred); +out_net: +put_net (net);return status; }EXPORT_SYMBOL_GPL (nfsd_open_local_fh);
Signature · 1 line
2.44.0
PATCH v7 8/20 NFS: Enable localio for non-pNFS I/O
In reply to Mike SnitzerFrom: Trond Myklebust <[email protected]>
Try a local open of the file we're writing to, and if it succeeds, then do local I/O.
--- fs/nfs/pagelist.c | 19 ++++++++++--------- fs/nfs/write.c | 7 ++++++- 2 files changed, 16 insertions(+), 10 deletions(-)
fs/nfs/pagelist.c +10 -9
@@ -1063,6 +1063,7 @@ EXPORT_SYMBOL_GPL(nfs_generic_pgio);static int nfs_generic_pg_pgios (struct nfs_pageio_descriptor *desc) {struct nfs_pgio_header *hdr; +struct file *filp;int ret;unsigned short task_flags =0 ;
@@ -1074,18 +1075,18 @@ static int nfs_generic_pg_pgios(struct nfs_pageio_descriptor *desc)nfs_pgheader_init (desc, hdr, nfs_pgio_header_free); ret =nfs_generic_pgio (desc, hdr);if (ret ==0 ) { +struct nfs_client *clp =NFS_SERVER (hdr->inode)->nfs_client; + + filp =nfs_local_file_open (clp, hdr->cred, hdr->args.fh, + hdr->args.context); +if (NFS_SERVER (hdr->inode)->nfs_client->cl_minorversion) task_flags =RPC_TASK_MOVEABLE ; - ret =nfs_initiate_pgio (desc, -NFS_SERVER (hdr->inode)->nfs_client, -NFS_CLIENT (hdr->inode), - hdr, - hdr->cred, -NFS_PROTO (hdr->inode), - desc->pg_rpc_callops, - desc->pg_ioflags, + ret =nfs_initiate_pgio (desc, clp,NFS_CLIENT (hdr->inode), + hdr, hdr->cred,NFS_PROTO (hdr->inode), + desc->pg_rpc_callops, desc->pg_ioflags,RPC_TASK_CRED_NOREF | task_flags, -NULL ); + filp); }return ret; }
fs/nfs/write.c +6 -1
@@ -1802,6 +1802,8 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how, struct nfs_commit_info *cinfo) {struct nfs_commit_data *data; +struct nfs_client *clp =NFS_SERVER (inode)->nfs_client; +struct file *filp;unsigned short task_flags =0 ;/* another commit raced with us */
@@ -1818,9 +1820,12 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how,nfs_init_commit (data, head,NULL , cinfo);if (NFS_SERVER (inode)->nfs_client->cl_minorversion) task_flags =RPC_TASK_MOVEABLE ; + + filp =nfs_local_file_open (clp, data->cred, data->args.fh, + data->context);return nfs_initiate_commit (NFS_CLIENT (inode), data,NFS_PROTO (inode), data->mds_ops, how, -RPC_TASK_CRED_NOREF | task_flags,NULL ); +RPC_TASK_CRED_NOREF | task_flags, filp); }/*
Signature · 1 line
2.44.0
PATCH v7 9/20 pnfs/flexfiles: Enable localio for flexfiles I/O
In reply to Mike SnitzerFrom: Trond Myklebust <[email protected]>
If the DS is local to this client, then we should be able to use local I/O to write the data.
--- fs/nfs/flexfilelayout/flexfilelayout.c | 113 ++++++++++++++++++++-- fs/nfs/flexfilelayout/flexfilelayout.h | 2 + fs/nfs/flexfilelayout/flexfilelayoutdev.c | 6 ++ 3 files changed, 112 insertions(+), 9 deletions(-)
fs/nfs/flexfilelayout/flexfilelayout.c +104 -9
@@ -11,6 +11,7 @@#include <linux/nfs_mount.h> #include <linux/nfs_page.h> #include <linux/module.h> +#include <linux/file.h> #include <linux/sched/mm.h> #include <linux/sunrpc/metrics.h>
@@ -162,6 +163,52 @@ decode_name(struct xdr_stream *xdr, u32 *id)return 0 ; } +static struct file * +ff_local_open_fh (struct pnfs_layout_segment *lseg, +u32 ds_idx, +struct nfs_client *clp, +const struct cred *cred, +struct nfs_fh *fh, +fmode_t mode) +{ +struct nfs4_ff_layout_mirror *mirror =FF_LAYOUT_COMP (lseg, ds_idx); +struct file *filp, *new,__rcu **pfile; + +if (!nfs_server_is_local (clp)) +return NULL ; +if (mode &FMODE_WRITE ) { +/* +* Always request read and write access since this corresponds +* to a rw layout. +*/ + mode |=FMODE_READ ; + pfile = &mirror->rw_file; + }else + pfile = &mirror->ro_file; + + new =NULL ; +rcu_read_lock (); + filp =rcu_dereference (*pfile); +if (!filp) { +rcu_read_unlock (); + new =nfs_local_open_fh (clp, cred, fh, mode); +if (IS_ERR (new)) +return NULL ; +rcu_read_lock (); +/* try to swap in the pointer */ + filp =cmpxchg (pfile,NULL , new); +if (!filp) { + filp = new; + new =NULL ; + } + } + filp =get_file_rcu (&filp); +rcu_read_unlock (); +if (new) +fput (new); +return filp; +} +static bool ff_mirror_match_fh (const struct nfs4_ff_layout_mirror *m1,const struct nfs4_ff_layout_mirror *m2) {
@@ -237,8 +284,15 @@ static struct nfs4_ff_layout_mirror *ff_layout_alloc_mirror(gfp_t gfp_flags)static void ff_layout_free_mirror (struct nfs4_ff_layout_mirror *mirror) { +struct file *filp;const struct cred *cred; + filp =rcu_access_pointer (mirror->ro_file); +if (filp) +fput (filp); + filp =rcu_access_pointer (mirror->rw_file); +if (filp) +fput (filp);ff_layout_remove_mirror (mirror);kfree (mirror->fh_versions); cred =rcu_access_pointer (mirror->ro_cred);
@@ -414,6 +468,7 @@ ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh,struct nfs4_ff_layout_mirror *mirror;struct cred *kcred;const struct cred __rcu *cred; +const struct cred __rcu *old;kuid_t uid;kgid_t gid;u32 ds_count, fh_count, id;
@@ -513,13 +568,26 @@ ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh, mirror =ff_layout_add_mirror (lh, fls->mirror_array[i]);if (mirror != fls->mirror_array[i]) { +struct file *filp; +/* swap cred ptrs so free_mirror will clean up old */ if (lgr->range.iomode ==IOMODE_READ ) { - cred =xchg (&mirror->ro_cred, cred); -rcu_assign_pointer (fls->mirror_array[i]->ro_cred, cred); + old =xchg (&mirror->ro_cred, cred); +rcu_assign_pointer (fls->mirror_array[i]->ro_cred, old); +/* drop file if creds changed */ +if (old != cred) { + filp =rcu_dereference_protected (xchg (&mirror->ro_file,NULL ),1 ); +if (filp) +fput (filp); + } }else { - cred =xchg (&mirror->rw_cred, cred); -rcu_assign_pointer (fls->mirror_array[i]->rw_cred, cred); + old =xchg (&mirror->rw_cred, cred); +rcu_assign_pointer (fls->mirror_array[i]->rw_cred, old); +if (old != cred) { + filp =rcu_dereference_protected (xchg (&mirror->rw_file,NULL ),1 ); +if (filp) +fput (filp); + } }ff_layout_free_mirror (fls->mirror_array[i]); fls->mirror_array[i] = mirror;
@@ -1757,6 +1825,7 @@ ff_layout_read_pagelist(struct nfs_pageio_descriptor *desc,struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;struct rpc_clnt *ds_clnt; +struct file *filp;struct nfs4_ff_layout_mirror *mirror;const struct cred *ds_cred;loff_t offset = hdr->args.offset;
@@ -1803,12 +1872,20 @@ ff_layout_read_pagelist(struct nfs_pageio_descriptor *desc, hdr->args.offset = offset; hdr->mds_offset = offset; +/* Start IO accounting for local read */ + filp =ff_local_open_fh (lseg, idx, ds->ds_clp, ds_cred, fh, +FMODE_READ ); +if (filp) { + hdr->task.tk_start =ktime_get (); +ff_layout_read_record_layoutstats_start (&hdr->task, hdr); + } +/* Perform an asynchronous read to ds */ nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_read_call_ops_v3 : &ff_layout_read_call_ops_v4, -0 ,RPC_TASK_SOFTCONN ,NULL ); +0 ,RPC_TASK_SOFTCONN , filp);put_cred (ds_cred);return PNFS_ATTEMPTED ;
@@ -1829,6 +1906,7 @@ ff_layout_write_pagelist(struct nfs_pageio_descriptor *desc,struct pnfs_layout_segment *lseg = hdr->lseg;struct nfs4_pnfs_ds *ds;struct rpc_clnt *ds_clnt; +struct file *filp;struct nfs4_ff_layout_mirror *mirror;const struct cred *ds_cred;loff_t offset = hdr->args.offset;
@@ -1873,12 +1951,20 @@ ff_layout_write_pagelist(struct nfs_pageio_descriptor *desc,*/ hdr->args.offset = offset; +/* Start IO accounting for local write */ + filp =ff_local_open_fh (lseg, idx, ds->ds_clp, ds_cred, fh, +FMODE_READ |FMODE_WRITE ); +if (filp) { + hdr->task.tk_start =ktime_get (); +ff_layout_write_record_layoutstats_start (&hdr->task, hdr); + } +/* Perform an asynchronous write */ nfs_initiate_pgio (desc, ds->ds_clp, ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops, vers ==3 ? &ff_layout_write_call_ops_v3 : &ff_layout_write_call_ops_v4, - sync,RPC_TASK_SOFTCONN ,NULL ); + sync,RPC_TASK_SOFTCONN , filp);put_cred (ds_cred);return PNFS_ATTEMPTED ;
@@ -1912,6 +1998,7 @@ static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how)struct pnfs_layout_segment *lseg = data->lseg;struct nfs4_pnfs_ds *ds;struct rpc_clnt *ds_clnt; +struct file *filp;struct nfs4_ff_layout_mirror *mirror;const struct cred *ds_cred;u32 idx;
@@ -1950,10 +2037,18 @@ static int ff_layout_initiate_commit(struct nfs_commit_data *data, int how)if (fh) data->args.fh = fh; +/* Start IO accounting for local commit */ + filp =ff_local_open_fh (lseg, idx, ds->ds_clp, ds_cred, fh, +FMODE_READ |FMODE_WRITE ); +if (filp) { + data->task.tk_start =ktime_get (); +ff_layout_commit_record_layoutstats_start (&data->task, data); + } + ret =nfs_initiate_commit (ds_clnt, data, ds->ds_clp->rpc_ops, - vers ==3 ? &ff_layout_commit_call_ops_v3 : - &ff_layout_commit_call_ops_v4, - how,RPC_TASK_SOFTCONN ,NULL ); + vers ==3 ? &ff_layout_commit_call_ops_v3 : + &ff_layout_commit_call_ops_v4, + how,RPC_TASK_SOFTCONN , filp);put_cred (ds_cred);return ret; out_err:
fs/nfs/flexfilelayout/flexfilelayout.h +2 -0
@@ -82,7 +82,9 @@ struct nfs4_ff_layout_mirror {struct nfs_fh *fh_versions;nfs4_stateid stateid;const struct cred __rcu *ro_cred; +struct file __rcu *ro_file;const struct cred __rcu *rw_cred; +struct file __rcu *rw_file;refcount_t ref;spinlock_t lock;unsigned long flags;
fs/nfs/flexfilelayout/flexfilelayoutdev.c +6 -0
@@ -395,6 +395,12 @@ nfs4_ff_layout_prepare_ds(struct pnfs_layout_segment *lseg,/* connect success, check rsize/wsize limit */ if (!status) { +/* +* ds_clp is put in destroy_ds(). +* keep ds_clp even if DS is local, so that if local IO cannot +* proceed somehow, we can fall back to NFS whenever we want. +*/ +nfs_local_probe (ds->ds_clp); max_payload =nfs_block_size (rpc_max_payload (ds->ds_clp->cl_rpcclient),NULL );
Signature · 1 line
2.44.0
PATCH v7 10/20 nfs/localio: use dedicated workqueues for filesystem read and write
In reply to Mike SnitzerFrom: Trond Myklebust <[email protected]>
For localio access, don't call filesystem read() and write() routines directly.
Some filesystem writeback routines can end up taking up a lot of stack space (particularly xfs). Instead of risking running over due to the extra overhead from the NFS stack, we should just call these routines from a workqueue job.
Use of dedicated workqueues improves performance over using the system_unbound_wq. Localio is motivated by the promise of improved performance, it makes little sense to yield it back.
But further analysis of the latest stack depth requirements would be useful. It'd be nice to root cause and fix the latest stack hogs, because using workqueues at all can cause a loss in performance due to context switches.
--- fs/nfs/inode.c | 57 +++++++++++++++++--------- fs/nfs/internal.h | 1 + fs/nfs/localio.c | 102 +++++++++++++++++++++++++++++++++++----------- 3 files changed, 118 insertions(+), 42 deletions(-)
fs/nfs/inode.c +38 -19
@@ -2394,35 +2394,54 @@ static void nfs_destroy_inodecache(void)kmem_cache_destroy (nfs_inode_cachep); } +struct workqueue_struct *nfslocaliod_workqueue;struct workqueue_struct *nfsiod_workqueue;EXPORT_SYMBOL_GPL (nfsiod_workqueue);/* -* start up the nfsiod workqueue -*/ -static int nfsiod_start (void ) -{ -struct workqueue_struct *wq; -dprintk ("RPC: creating workqueue nfsiod\n" ); - wq =alloc_workqueue ("nfsiod" ,WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); -if (wq ==NULL ) -return -ENOMEM ; - nfsiod_workqueue = wq; -return 0 ; -} - -/* -* Destroy the nfsiod workqueue +* Destroy the nfsiod workqueues */ static void nfsiod_stop (void ) {struct workqueue_struct *wq; wq = nfsiod_workqueue; -if (wq ==NULL ) -return ; - nfsiod_workqueue =NULL ; -destroy_workqueue (wq); +if (wq !=NULL ) { + nfsiod_workqueue =NULL ; +destroy_workqueue (wq); + } +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) + wq = nfslocaliod_workqueue; +if (wq !=NULL ) { + nfslocaliod_workqueue =NULL ; +destroy_workqueue (wq); + } +#endif /* CONFIG_NFS_LOCALIO */ +} + +/* +* Start the nfsiod workqueues +*/ +static int nfsiod_start (void ) +{ +dprintk ("RPC: creating workqueue nfsiod\n" ); + nfsiod_workqueue =alloc_workqueue ("nfsiod" ,WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (nfsiod_workqueue ==NULL ) +return -ENOMEM ; +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +/* +* localio writes need to use a normal (non-memreclaim) workqueue. +* When we start getting low on space, XFS goes and calls flush_work() on +* a non-memreclaim work queue, which causes a priority inversion problem. +*/ +dprintk ("RPC: creating workqueue nfslocaliod\n" ); + nfslocaliod_workqueue =alloc_workqueue ("nfslocaliod" ,WQ_UNBOUND ,0 ); +if (unlikely (nfslocaliod_workqueue ==NULL )) { +nfsiod_stop (); +return -ENOMEM ; + } +#endif /* CONFIG_NFS_LOCALIO */ +return 0 ; }unsigned int nfs_net_id;
fs/nfs/internal.h +1 -0
@@ -440,6 +440,7 @@ int nfs_check_flags(int);/* inode.c */ extern struct workqueue_struct *nfsiod_workqueue; +extern struct workqueue_struct *nfslocaliod_workqueue;extern struct inode *nfs_alloc_inode (struct super_block *sb);extern void nfs_free_inode (struct inode *);extern int nfs_write_inode (struct inode *,struct writeback_control *);
fs/nfs/localio.c +79 -23
150 lines not on this page · raw message
Signature · 1 line
2.44.0
Re: [PATCH v7 10/20] nfs/localio: use dedicated workqueues for filesystem read and write
Quoted 10 lines · Mike Snitzer
From: Trond Myklebust <[email protected]>
For localio access, don't call filesystem
read()andwrite()routines directly.Some filesystem writeback routines can end up taking up a lot of stack space (particularly xfs). Instead of risking running over due to the extra overhead from the NFS stack, we should just call these routines from a workqueue job.
Quoted 9 lines
Use of dedicated workqueues improves performance over using the
system_unbound_wq. Localio is motivated by the promise of improved performance, it makes little sense to yield it back.But further analysis of the latest stack depth requirements would be useful. It'd be nice to root cause and fix the latest stack hogs, because using workqueues at all can cause a loss in performance due to context switches.
I would rather this patch were left out of the final submission, and only added if/when we have documented evidence that it helps.
Thanks,
NeilBrown
Quoted 263 lines
Signed-off-by Trond Myklebust <[email protected]>Signed-off-by Mike Snitzer <[email protected]>--- fs/nfs/inode.c | 57 +++++++++++++++++--------- fs/nfs/internal.h | 1 + fs/nfs/localio.c | 102 +++++++++++++++++++++++++++++++++++----------- 3 files changed, 118 insertions(+), 42 deletions(-)fs/nfs/inode.c +38
-19@@ -2394,35 +2394,54 @@ static void nfs_destroy_inodecache(void)kmem_cache_destroy (nfs_inode_cachep); } +struct workqueue_struct *nfslocaliod_workqueue;struct workqueue_struct *nfsiod_workqueue;EXPORT_SYMBOL_GPL (nfsiod_workqueue);/* -* start up the nfsiod workqueue -*/ -static int nfsiod_start (void ) -{ -struct workqueue_struct *wq; -dprintk ("RPC: creating workqueue nfsiod\n" ); - wq =alloc_workqueue ("nfsiod" ,WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); -if (wq ==NULL ) -return -ENOMEM ; - nfsiod_workqueue = wq; -return 0 ; -} - -/* -* Destroy the nfsiod workqueue +* Destroy the nfsiod workqueues */ static void nfsiod_stop (void ) {struct workqueue_struct *wq; wq = nfsiod_workqueue; -if (wq ==NULL ) -return ; - nfsiod_workqueue =NULL ; -destroy_workqueue (wq); +if (wq !=NULL ) { + nfsiod_workqueue =NULL ; +destroy_workqueue (wq); + } +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) + wq = nfslocaliod_workqueue; +if (wq !=NULL ) { + nfslocaliod_workqueue =NULL ; +destroy_workqueue (wq); + } +#endif /* CONFIG_NFS_LOCALIO */ +} + +/* +* Start the nfsiod workqueues +*/ +static int nfsiod_start (void ) +{ +dprintk ("RPC: creating workqueue nfsiod\n" ); + nfsiod_workqueue =alloc_workqueue ("nfsiod" ,WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (nfsiod_workqueue ==NULL ) +return -ENOMEM ; +#if IS_ENABLED (CONFIG_NFS_LOCALIO ) +/* +* localio writes need to use a normal (non-memreclaim) workqueue. +* When we start getting low on space, XFS goes and calls flush_work() on +* a non-memreclaim work queue, which causes a priority inversion problem. +*/ +dprintk ("RPC: creating workqueue nfslocaliod\n" ); + nfslocaliod_workqueue =alloc_workqueue ("nfslocaliod" ,WQ_UNBOUND ,0 ); +if (unlikely (nfslocaliod_workqueue ==NULL )) { +nfsiod_stop (); +return -ENOMEM ; + } +#endif /* CONFIG_NFS_LOCALIO */ +return 0 ; }unsigned int nfs_net_id;fs/nfs/internal.h +1
-0@@ -440,6 +440,7 @@ int nfs_check_flags(int);/* inode.c */ extern struct workqueue_struct *nfsiod_workqueue; +extern struct workqueue_struct *nfslocaliod_workqueue;extern struct inode *nfs_alloc_inode (struct super_block *sb);extern void nfs_free_inode (struct inode *);extern int nfs_write_inode (struct inode *,struct writeback_control *);fs/nfs/localio.c +79
-23@@ -44,6 +44,12 @@ struct nfs_local_fsync_ctx { };static void nfs_local_fsync_work (struct work_struct *work); +struct nfs_local_io_args { +struct nfs_local_kiocb *iocb; +struct work_struct work; +struct completion *done; +}; +/* * We need to translate between nfs status return values and * the local errno values which may not be the same. @@ -307,30 +313,54 @@ nfs_local_read_done(struct nfs_local_kiocb *iocb, long status) status > 0 ? status : 0, hdr->res.eof); } -static int -nfs_do_local_read (struct nfs_pgio_header *hdr,struct file *filp, -const struct rpc_call_ops *call_ops) +static void nfs_local_call_read (struct work_struct *work) { -struct nfs_local_kiocb *iocb; +struct nfs_local_io_args *args = + container_of(work, struct nfs_local_io_args, work); +struct nfs_local_kiocb *iocb = args->iocb; +struct file *filp = iocb->kiocb.ki_filp;struct iov_iter iter;ssize_t status; +nfs_local_iter_init (&iter, iocb,READ ); + + status = filp->f_op->read_iter (&iocb->kiocb, &iter); +if (status != -EIOCBQUEUED ) { +nfs_local_read_done (iocb, status); +nfs_local_pgio_release (iocb); + } +complete (args->done); +} + +static int nfs_do_local_read (struct nfs_pgio_header *hdr,struct file *filp, +const struct rpc_call_ops *call_ops) +{ +struct nfs_local_io_args args; +DECLARE_COMPLETION_ONSTACK (done); +struct nfs_local_kiocb *iocb; +dprintk ("%s: vfs_read count=%u pos=%llu\n" , __func__, hdr->args.count, hdr->args.offset); iocb =nfs_local_iocb_alloc (hdr, filp,GFP_KERNEL );if (iocb ==NULL )return -ENOMEM ; -nfs_local_iter_init (&iter, iocb,READ );nfs_local_pgio_init (hdr, call_ops); hdr->res.eof = false; - status = filp->f_op->read_iter (&iocb->kiocb, &iter); -if (status != -EIOCBQUEUED ) { -nfs_local_read_done (iocb, status); -nfs_local_pgio_release (iocb); - } +/* +* Don't call filesystem read() routines directly. +* In order to avoid issues with stack overflow, +* call the read routines from a workqueue job. +*/ + args.iocb = iocb; + args.done = &done; +INIT_WORK_ONSTACK (&args.work, nfs_local_call_read); +queue_work (nfslocaliod_workqueue, &args.work); +wait_for_completion (&done); +destroy_work_on_stack (&args.work); +return 0 ; }@@ -420,14 +450,35 @@ nfs_local_write_done(struct nfs_local_kiocb *iocb, long status)nfs_local_pgio_done (hdr, status); } -static int -nfs_do_local_write (struct nfs_pgio_header *hdr,struct file *filp, -const struct rpc_call_ops *call_ops) +static void nfs_local_call_write (struct work_struct *work) { -struct nfs_local_kiocb *iocb; +struct nfs_local_io_args *args = + container_of(work, struct nfs_local_io_args, work); +struct nfs_local_kiocb *iocb = args->iocb; +struct file *filp = iocb->kiocb.ki_filp;struct iov_iter iter;ssize_t status; +nfs_local_iter_init (&iter, iocb,WRITE ); + +file_start_write (filp); + status = filp->f_op->write_iter (&iocb->kiocb, &iter); +file_end_write (filp); +if (status != -EIOCBQUEUED ) { +nfs_local_write_done (iocb, status); +nfs_get_vfs_attr (filp, iocb->hdr->res.fattr); +nfs_local_pgio_release (iocb); + } +complete (args->done); +} + +static int nfs_do_local_write (struct nfs_pgio_header *hdr,struct file *filp, +const struct rpc_call_ops *call_ops) +{ +struct nfs_local_io_args args; +DECLARE_COMPLETION_ONSTACK (done); +struct nfs_local_kiocb *iocb; +dprintk ("%s: vfs_write count=%u pos=%llu %s\n" , __func__, hdr->args.count, hdr->args.offset, (hdr->args.stable ==NFS_UNSTABLE ) ?"unstable" :"stable" );@@ -435,7 +486,6 @@ nfs_do_local_write(struct nfs_pgio_header *hdr, struct file *filp, iocb =nfs_local_iocb_alloc (hdr, filp,GFP_NOIO );if (iocb ==NULL )return -ENOMEM ; -nfs_local_iter_init (&iter, iocb,WRITE );switch (hdr->args.stable) {default :@@ -450,14 +500,20 @@ nfs_do_local_write(struct nfs_pgio_header *hdr, struct file *filp,nfs_set_local_verifier (hdr->inode, hdr->res.verf, hdr->args.stable); -file_start_write (filp); - status = filp->f_op->write_iter (&iocb->kiocb, &iter); -file_end_write (filp); -if (status != -EIOCBQUEUED ) { -nfs_local_write_done (iocb, status); -nfs_get_vfs_attr (filp, hdr->res.fattr); -nfs_local_pgio_release (iocb); - } +/* +* Don't call filesystem write() routines directly. +* Some filesystem writeback routines can end up taking up a lot of +* stack (particularly xfs). Instead of risking running over due to +* the extra overhead from the NFS stack, call these write routines +* from a workqueue job. +*/ + args.iocb = iocb; + args.done = &done; +INIT_WORK_ONSTACK (&args.work, nfs_local_call_write); +queue_work (nfslocaliod_workqueue, &args.work); +wait_for_completion (&done); +destroy_work_on_stack (&args.work); +return 0 ; }Signature · 1 line
2.44.0
PATCH v7 11/20 nfs/nfsd: factor out {encode,decode}_opaque_fixed to nfs_xdr.h
In reply to Mike SnitzerEliminates duplicate functions in various files to allow for additional callers.
--- fs/nfs/flexfilelayout/flexfilelayout.c | 6 ------ fs/nfs/nfs4xdr.c | 13 ------------- include/linux/nfs_xdr.h | 20 +++++++++++++++++++- 3 files changed, 19 insertions(+), 20 deletions(-)
fs/nfs/flexfilelayout/flexfilelayout.c +0 -6
@@ -2185,12 +2185,6 @@ static int ff_layout_encode_ioerr(struct xdr_stream *xdr,return ff_layout_encode_ds_ioerr (xdr, &ff_args->errors); } -static void -encode_opaque_fixed (struct xdr_stream *xdr,const void *buf,size_t len) -{ -WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); -} - static void ff_layout_encode_ff_iostat_head(struct xdr_stream *xdr, const nfs4_stateid *stateid,
fs/nfs/nfs4xdr.c +0 -13
@@ -968,11 +968,6 @@ static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)return p; } -static void encode_opaque_fixed (struct xdr_stream *xdr,const void *buf,size_t len) -{ -WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); -} -static void encode_string (struct xdr_stream *xdr,unsigned int len,const char *str) {WARN_ON_ONCE (xdr_stream_encode_opaque (xdr, str, len) <0 );
@@ -4352,14 +4347,6 @@ static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)return 0 ; } -static int decode_opaque_fixed (struct xdr_stream *xdr,void *buf,size_t len) -{ -ssize_t ret =xdr_stream_decode_opaque_fixed (xdr, buf, len); -if (unlikely (ret <0 )) -return -EIO ; -return 0 ; -} -static int decode_stateid (struct xdr_stream *xdr,nfs4_stateid *stateid) {return decode_opaque_fixed (xdr, stateid,NFS4_STATEID_SIZE );
include/linux/nfs_xdr.h +19 -1
@@ -1820,6 +1820,24 @@ struct nfs_rpc_ops {void (*disable_swap)(struct inode *inode); }; +/* +* Helper functions used by NFS client and/or server +*/ +static inline void encode_opaque_fixed (struct xdr_stream *xdr, +const void *buf,size_t len) +{ +WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); +} + +static inline int decode_opaque_fixed (struct xdr_stream *xdr, +void *buf,size_t len) +{ +ssize_t ret =xdr_stream_decode_opaque_fixed (xdr, buf, len); +if (unlikely (ret <0 )) +return -EIO ; +return 0 ; +} +/* * Function vectors etc. for the NFS client */
@@ -1833,4 +1851,4 @@ extern const struct rpc_version nfs_version4;extern const struct rpc_version nfsacl_version3;extern const struct rpc_program nfsacl_program; -#endif +#endif /* _LINUX_NFS_XDR_H */
Signature · 1 line
2.44.0
Re: [PATCH v7 11/20] nfs/nfsd: factor out {encode,decode}_opaque_fixed to nfs_xdr.h
Quoted 9 lines · Mike Snitzer
Eliminates duplicate functions in various files to allow for additional callers.
Signed-off-by Mike Snitzer <[email protected]>--- fs/nfs/flexfilelayout/flexfilelayout.c | 6 ------ fs/nfs/nfs4xdr.c | 13 ------------- include/linux/nfs_xdr.h | 20 +++++++++++++++++++- 3 files changed, 19 insertions(+), 20 deletions(-)
Nit: The "nfsd" can be removed from the Subject line since there are no NFSD changes in this patch.
Quoted 86 lines
fs/nfs/flexfilelayout/flexfilelayout.c +0
-6@@ -2185,12 +2185,6 @@ static int ff_layout_encode_ioerr(struct xdr_stream *xdr,return ff_layout_encode_ds_ioerr (xdr, &ff_args->errors); } -static void -encode_opaque_fixed (struct xdr_stream *xdr,const void *buf,size_t len) -{ -WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); -} - static void ff_layout_encode_ff_iostat_head(struct xdr_stream *xdr, const nfs4_stateid *stateid,fs/nfs/nfs4xdr.c +0
-13@@ -968,11 +968,6 @@ static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)return p; } -static void encode_opaque_fixed (struct xdr_stream *xdr,const void *buf,size_t len) -{ -WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); -} -static void encode_string (struct xdr_stream *xdr,unsigned int len,const char *str) {WARN_ON_ONCE (xdr_stream_encode_opaque (xdr, str, len) <0 );@@ -4352,14 +4347,6 @@ static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)return 0 ; } -static int decode_opaque_fixed (struct xdr_stream *xdr,void *buf,size_t len) -{ -ssize_t ret =xdr_stream_decode_opaque_fixed (xdr, buf, len); -if (unlikely (ret <0 )) -return -EIO ; -return 0 ; -} -static int decode_stateid (struct xdr_stream *xdr,nfs4_stateid *stateid) {return decode_opaque_fixed (xdr, stateid,NFS4_STATEID_SIZE );include/linux/nfs_xdr.h +19
-1@@ -1820,6 +1820,24 @@ struct nfs_rpc_ops {void (*disable_swap)(struct inode *inode); }; +/* +* Helper functions used by NFS client and/or server +*/ +static inline void encode_opaque_fixed (struct xdr_stream *xdr, +const void *buf,size_t len) +{ +WARN_ON_ONCE (xdr_stream_encode_opaque_fixed (xdr, buf, len) <0 ); +} + +static inline int decode_opaque_fixed (struct xdr_stream *xdr, +void *buf,size_t len) +{ +ssize_t ret =xdr_stream_decode_opaque_fixed (xdr, buf, len); +if (unlikely (ret <0 )) +return -EIO ; +return 0 ; +} +/* * Function vectors etc. for the NFS client */ @@ -1833,4 +1851,4 @@ extern const struct rpc_version nfs_version4;extern const struct rpc_version nfsacl_version3;extern const struct rpc_program nfsacl_program; -#endif +#endif /* _LINUX_NFS_XDR_H */ Signature · 1 line
2.44.0
Signature · 1 line
Chuck Lever
PATCH v7 12/20 SUNRPC: remove call_allocate() BUG_ON if p_arglen=0 to allow RPC with void arg
In reply to Mike SnitzerThis is needed for the LOCALIO protocol's GETUUID RPC which takes a void arg. The LOCALIO protocol spec in rpcgen syntax is:
/* raw RFC 9562 UUID */
typedef u8 uuid_t<UUID_SIZE>;
program NFS_LOCALIO_PROGRAM {
version LOCALIO_V1 {
void
NULL(void) = 0;
uuid_t
GETUUID(void) = 1;
} = 1;
} = 400122;--- net/sunrpc/clnt.c | 1 - 1 file changed, 1 deletion(-)
net/sunrpc/clnt.c +0 -1
@@ -1894,7 +1894,6 @@ call_allocate(struct rpc_task *task)return ;if (proc->p_proc !=0 ) { -BUG_ON (proc->p_arglen ==0 );if (proc->p_decode !=NULL )BUG_ON (proc->p_replen ==0 ); }
Signature · 1 line
2.44.0
Re: [PATCH v7 12/20] SUNRPC: remove call_allocate() BUG_ON if p_arglen=0 to allow RPC with void arg
Quoted 26 lines · Mike Snitzer
This is needed for the LOCALIO protocol's GETUUID RPC which takes a void arg. The LOCALIO protocol spec in rpcgen syntax is:
/* raw RFC 9562 UUID */
typedef u8 uuid_t<UUID_SIZE>;program NFS_LOCALIO_PROGRAM { version LOCALIO_V1 { void NULL(void) = 0; uuid_t GETUUID(void) = 1; } = 1; } = 400122;Signed-off-by Mike Snitzer <[email protected]>--- net/sunrpc/clnt.c | 1 - 1 file changed, 1 deletion(-)net/sunrpc/clnt.c +0
-0
net/sunrpc/clnt.c call_allocate(struct rpc_task *task) · line 1899
Quoted 7 lines
net/sunrpc/clnt.c +0
-1@@ -1894,7 +1894,6 @@ call_allocate(struct rpc_task *task)return ;if (proc->p_proc !=0 ) { -BUG_ON (proc->p_arglen ==0 );if (proc->p_decode !=NULL )BUG_ON (proc->p_replen ==0 ); }
I would be in favour get rid of all 5 lines. I wonder if p_decode is ever NULL. It would cause rpcauth_unwrap_resp_decode() problems.
NeilBrown
Quoted 4 lines
Signature · 1 line
2.44.0
Re: [PATCH v7 12/20] SUNRPC: remove call_allocate() BUG_ON if p_arglen=0 to allow RPC with void arg
Quoted 29 lines · NeilBrown
Quoted 28 lines · Mike Snitzer
This is needed for the LOCALIO protocol's GETUUID RPC which takes a void arg. The LOCALIO protocol spec in rpcgen syntax is:
/* raw RFC 9562 UUID */
typedef u8 uuid_t<UUID_SIZE>;program NFS_LOCALIO_PROGRAM { version LOCALIO_V1 { void NULL(void) = 0; uuid_t GETUUID(void) = 1; } = 1; } = 400122;Signed-off-by Mike Snitzer <[email protected]>--- net/sunrpc/clnt.c | 1 - 1 file changed, 1 deletion(-)net/sunrpc/clnt.c +0
-0@@ -1894,7 +1894,6 @@ call_allocate(struct rpc_task *task)return ;
Quoted 9 lines
net/sunrpc/clnt.c call_allocate(struct rpc_task *task) · line 1899
Quoted 5 lines
net/sunrpc/clnt.c +0
-1if (proc->p_proc !=0 ) { -BUG_ON (proc->p_arglen ==0 );if (proc->p_decode !=NULL )BUG_ON (proc->p_replen ==0 ); }I would be in favour get rid of all 5 lines. I wonder if
p_decodeis ever NULL. It would causerpcauth_unwrap_resp_decode()problems.
OK, but that broader cleanup can happen with an incremental follow-up patch.
PATCH v7 13/20 nfs: implement client support for NFS_LOCALIO_PROGRAM
In reply to Mike SnitzerLOCALIOPROC_GETUUID allows a client to discover the server's uuid.
nfs_local_probe() will retrieve server's uuid via LOCALIO protocol and verify the server with that uuid it is known to be local. This ensures client and server 1: support localio 2: are local to each other.
All the knowledge of the LOCALIO RPC protocol is in fs/nfs/localio.c which implements just a single version (1) that is used independently of what NFS version is used.
Get nfsd_open_local_fh and store it in rpc_client during client creation, put the symbol during nfs_local_disable -- which is also called during client destruction.
--- fs/nfs/client.c | 6 +- fs/nfs/localio.c | 159 +++++++++++++++++++++++++++++++++++++++++--- include/linux/nfs.h | 7 ++ 3 files changed, 161 insertions(+), 11 deletions(-)
fs/nfs/client.c +4 -2
@@ -434,8 +434,10 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)list_add_tail (&new->cl_share_link, &nn->nfs_client_list);spin_unlock (&nn->nfs_client_lock); -nfs_local_probe (new); -return rpc_ops->init_client (new, cl_init); + new = rpc_ops->init_client (new, cl_init); +if (!IS_ERR (new)) +nfs_local_probe (new); +return new; }spin_unlock (&nn->nfs_client_lock);
fs/nfs/localio.c +150 -9
196 lines not on this page · raw message
include/linux/nfs.h +7 -0
@@ -15,6 +15,13 @@#include <linux/crc32.h> #include <uapi/linux/nfs.h> +/* The localio program is entirely private to Linux and is +* NOT part of the uapi. +*/ +#define NFS_LOCALIO_PROGRAM 400122 +#define LOCALIOPROC_NULL 0 +#define LOCALIOPROC_GETUUID 1 +/* * This is the kernel NFS client file handle representation */
Signature · 1 line
2.44.0
Re: [PATCH v7 13/20] nfs: implement client support for NFS_LOCALIO_PROGRAM
Quoted 29 lines · Mike Snitzer
LOCALIOPROC_GETUUIDallows a client to discover the server's uuid.
nfs_local_probe()will retrieve server's uuid via LOCALIO protocol and verify the server with that uuid it is known to be local. This ensures client and server 1: support localio 2: are local to each other.All the knowledge of the LOCALIO RPC protocol is in
fs/nfs/localio.cwhich implements just a single version (1) that is used independently of what NFS version is used.Get
nfsd_open_local_fhand store it inrpc_clientduring client creation, put the symbol duringnfs_local_disable-- which is also called during client destruction.Signed-off-by Mike Snitzer <[email protected]>[neilb: factored out and simplified single localio protocol]Co-developed-by NeilBrown <[email protected]>Signed-off-by NeilBrown <[email protected]>--- fs/nfs/client.c | 6 +- fs/nfs/localio.c | 159 +++++++++++++++++++++++++++++++++++++++++--- include/linux/nfs.h | 7 ++ 3 files changed, 161 insertions(+), 11 deletions(-)fs/nfs/client.c +0
-0
fs/nfs/client.c struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init) · line 440
Quoted 9 lines
fs/nfs/client.c +4
-2@@ -434,8 +434,10 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)list_add_tail (&new->cl_share_link, &nn->nfs_client_list);spin_unlock (&nn->nfs_client_lock); -nfs_local_probe (new); -return rpc_ops->init_client (new, cl_init); + new = rpc_ops->init_client (new, cl_init); +if (!IS_ERR (new)) +nfs_local_probe (new); +return new;
I would fold this back into the earlier patch that introduced nfs_local_probe(). It makes this patch ugly.
But I won't insist.
NeilBrown
Quoted 229 lines
fs/nfs/client.c +0
-0}spin_unlock (&nn->nfs_client_lock);fs/nfs/localio.c +150
-9@@ -15,6 +15,7 @@#include <linux/sunrpc/addr.h> #include <linux/inetdevice.h> #include <net/addrconf.h> +#include <linux/nfslocalio.h> #include <linux/module.h> #include <linux/bvec.h> @@ -123,13 +124,72 @@ nfs4errno(int errno)static bool localio_enabled__read_mostly = true;module_param (localio_enabled, bool,0644 ); +static inline bool nfs_client_is_local (const struct nfs_client *clp) +{ +return !!test_bit (NFS_CS_LOCAL_IO , &clp->cl_flags); +} +bool nfs_server_is_local (const struct nfs_client *clp) { -return test_bit (NFS_CS_LOCAL_IO , &clp->cl_flags) !=0 && - localio_enabled; +return nfs_client_is_local (clp) && localio_enabled; }EXPORT_SYMBOL_GPL (nfs_server_is_local); +/* +* GETUUID XDR functions +*/ + +static void localio_xdr_enc_getuuidargs (struct rpc_rqst *req, +struct xdr_stream *xdr, +const void *data) +{ +/* void function */ +} + +static int localio_xdr_dec_getuuidres (struct rpc_rqst *req, +struct xdr_stream *xdr, +void *result) +{ +u8 *uuid = result; + +return decode_opaque_fixed (xdr, uuid,UUID_SIZE ); +} + +static const struct rpc_procinfo nfs_localio_procedures[] = { + [LOCALIOPROC_GETUUID ] = { + .p_proc =LOCALIOPROC_GETUUID , + .p_encode = localio_xdr_enc_getuuidargs, + .p_decode = localio_xdr_dec_getuuidres, + .p_arglen =0 , + .p_replen =XDR_QUADLEN (UUID_SIZE ), + .p_statidx =LOCALIOPROC_GETUUID , + .p_name ="GETUUID" , + }, +}; + +static unsigned int nfs_localio_counts[ARRAY_SIZE (nfs_localio_procedures)]; +const struct rpc_version nfslocalio_version1 = { + .number =1 , + .nrprocs =ARRAY_SIZE (nfs_localio_procedures), + .procs = nfs_localio_procedures, + .counts = nfs_localio_counts, +}; + +static const struct rpc_version *nfslocalio_version[] = { + [1 ] = &nfslocalio_version1, +}; + +extern const struct rpc_program nfslocalio_program; +static struct rpc_stat nfslocalio_rpcstat = { &nfslocalio_program }; + +const struct rpc_program nfslocalio_program = { + .name ="nfslocalio" , + .number =NFS_LOCALIO_PROGRAM , + .nrvers =ARRAY_SIZE (nfslocalio_version), + .version = nfslocalio_version, + .stats = &nfslocalio_rpcstat, +}; +/* * nfs_local_enable - attempt to enable local i/o for an nfs_client */ @@ -149,20 +209,100 @@ void nfs_local_disable(struct nfs_client *clp) {if (test_and_clear_bit (NFS_CS_LOCAL_IO , &clp->cl_flags)) {trace_nfs_local_disable (clp); +put_nfsd_open_local_fh (); + clp->nfsd_open_local_fh =NULL ; +if (!IS_ERR (clp->cl_rpcclient_localio)) { +rpc_shutdown_client (clp->cl_rpcclient_localio); + clp->cl_rpcclient_localio =ERR_PTR (-EINVAL ); + } clp->cl_nfssvc_net =NULL ; } }/* -* nfs_local_probe - probe local i/o support for an nfs_client +* nfs_init_localioclient - Initialise an NFS localio client connection */ -void -nfs_local_probe (struct nfs_client *clp) +static void nfs_init_localioclient (struct nfs_client *clp) { -bool enable = false; +if (unlikely (!IS_ERR (clp->cl_rpcclient_localio))) + goto out; + clp->cl_rpcclient_localio =rpc_bind_new_program (clp->cl_rpcclient, + &nfslocalio_program,1 ); +if (IS_ERR (clp->cl_rpcclient_localio)) + goto out; +/* No errors! Assume that localio is supported */ + clp->nfsd_open_local_fh =get_nfsd_open_local_fh (); +if (!clp->nfsd_open_local_fh) { +rpc_shutdown_client (clp->cl_rpcclient_localio); + clp->cl_rpcclient_localio =ERR_PTR (-EINVAL ); + } +out: +dprintk_rcu ("%s: server (%s) %s NFS LOCALIO, nfsd_open_local_fh is %s.\n" , + __func__,rpc_peeraddr2str (clp->cl_rpcclient,RPC_DISPLAY_ADDR ), + (IS_ERR (clp->cl_rpcclient_localio) ?"does not support" :"supports" ), + (clp->nfsd_open_local_fh ?"set" :"not set" )); +} -if (enable) -nfs_local_enable (clp); +static bool nfs_local_server_getuuid (struct nfs_client *clp,uuid_t *nfsd_uuid) +{ +u8 uuid[UUID_SIZE ]; +struct rpc_message msg = { + .rpc_resp = &uuid, + }; +int status; + +nfs_init_localioclient (clp); +if (IS_ERR (clp->cl_rpcclient_localio)) +return false; + +dprintk ("%s: NFS issuing getuuid\n" , __func__); + msg.rpc_proc = &nfs_localio_procedures[LOCALIOPROC_GETUUID ]; + status =rpc_call_sync (clp->cl_rpcclient_localio, &msg,0 ); +dprintk ("%s: NFS reply getuuid: status=%d uuid=%pU\n" , + __func__, status, uuid); +if (status) +return false; + +import_uuid (nfsd_uuid, uuid); + +return true; +} + +/* +* nfs_local_probe - probe local i/o support for an nfs_server and nfs_client +* - called after alloc_client and init_client (so cl_rpcclient exists) +* - this function is idempotent, it can be called for old or new clients +*/ +void nfs_local_probe (struct nfs_client *clp) +{ +uuid_t uuid; +struct net *net =NULL ; + +if (!localio_enabled || clp->cl_rpcclient->cl_vers ==2 ) + goto unsupported; + +if (nfs_client_is_local (clp)) { +/* If already enabled, disable and re-enable */ +nfs_local_disable (clp); + } + +/* +* Retrieve server's uuid via LOCALIO protocol and verify the +* server with that uuid is known to be local. This ensures +* client and server 1: support localio 2: are local to each other +* by verifying client's nfsd, with specified uuid, is local. +*/ +if (!nfs_local_server_getuuid (clp, &uuid) || + !nfsd_uuid_is_local (&uuid, &net)) + goto unsupported; + +dprintk ("%s: detected local server.\n" , __func__); +nfs_local_enable (clp, net); +return ; + +unsupported: +/* localio not supported */ +nfs_local_disable (clp); }EXPORT_SYMBOL_GPL (nfs_local_probe);@@ -189,7 +329,8 @@ nfs_local_open_fh(struct nfs_client *clp, const struct cred *cred,trace_nfs_local_open_fh (fh, mode, status);switch (status) {case -ENXIO : -nfs_local_disable (clp); +/* Revalidate localio, will disable if unsupported */ +nfs_local_probe (clp); fallthrough;case -ETIMEDOUT : status = -EAGAIN ;include/linux/nfs.h +7
-0@@ -15,6 +15,13 @@#include <linux/crc32.h> #include <uapi/linux/nfs.h> +/* The localio program is entirely private to Linux and is +* NOT part of the uapi. +*/ +#define NFS_LOCALIO_PROGRAM 400122 +#define LOCALIOPROC_NULL 0 +#define LOCALIOPROC_GETUUID 1 +/* * This is the kernel NFS client file handle representation */ Signature · 1 line
2.44.0
Re: [PATCH v7 13/20] nfs: implement client support for NFS_LOCALIO_PROGRAM
Quoted 35 lines · NeilBrown
Quoted 34 lines · Mike Snitzer
LOCALIOPROC_GETUUIDallows a client to discover the server's uuid.
nfs_local_probe()will retrieve server's uuid via LOCALIO protocol and verify the server with that uuid it is known to be local. This ensures client and server 1: support localio 2: are local to each other.All the knowledge of the LOCALIO RPC protocol is in
fs/nfs/localio.cwhich implements just a single version (1) that is used independently of what NFS version is used.Get
nfsd_open_local_fhand store it inrpc_clientduring client creation, put the symbol duringnfs_local_disable-- which is also called during client destruction.Signed-off-by Mike Snitzer <[email protected]>[neilb: factored out and simplified single localio protocol]Co-developed-by NeilBrown <[email protected]>Signed-off-by NeilBrown <[email protected]>--- fs/nfs/client.c | 6 +- fs/nfs/localio.c | 159 +++++++++++++++++++++++++++++++++++++++++--- include/linux/nfs.h | 7 ++ 3 files changed, 161 insertions(+), 11 deletions(-)fs/nfs/client.c +0
-2@@ -434,8 +434,10 @@ struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)list_add_tail (&new->cl_share_link, &nn->nfs_client_list);spin_unlock (&nn->nfs_client_lock); -nfs_local_probe (new); -return rpc_ops->init_client (new, cl_init);
Quoted 8 lines
fs/nfs/client.c struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init) · line 440
Quoted 4 lines
fs/nfs/client.c +4
-0+ new = rpc_ops->init_client (new, cl_init); +if (!IS_ERR (new)) +nfs_local_probe (new); +return new;I would fold this back into the earlier patch that introduced
nfs_local_probe(). It makes this patch ugly.
But I won't insist.
I cleaned it up a bit so that this patch is cleaner, but I'd prefer to leave it split out.
Thanks.
Mike
PATCH v7 14/20 nfsd: implement server support for NFS_LOCALIO_PROGRAM
In reply to Mike SnitzerLOCALIOPROC_GETUUID encodes the server's uuid_t in terms of the fixed UUID_SIZE (16). The fixed size opaque encode and decode XDR methods are used instead of the less efficient variable sized methods.
Aside from a bit of code in nfssvc.c, all the knowledge of the LOCALIO RPC protocol is in fs/nfsd/localio.c which implements just a single version (1) that is used independently of what NFS version is used.
--- fs/nfsd/localio.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfsd/nfssvc.c | 29 ++++++++++++++++++- 2 files changed, 102 insertions(+), 1 deletion(-)
fs/nfsd/localio.c +74 -0
@@ -11,12 +11,15 @@#include <linux/sunrpc/svcauth_gss.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs.h> +#include <linux/nfs_fs.h> +#include <linux/nfs_xdr.h> #include <linux/string.h> #include "nfsd.h" #include "vfs.h" #include "netns.h" #include "filecache.h" +#include "cache.h" #define NFSDDBG_FACILITY NFSDDBG_FH
@@ -249,3 +252,74 @@ EXPORT_SYMBOL_GPL(nfsd_open_local_fh);/* Compile time type checking, not used by anything */ static nfs_to_nfsd_open_t __maybe_unused nfsd_open_local_fh_typecheck = nfsd_open_local_fh; + +/* +* GETUUID XDR encode functions +*/ + +static __be32 nfsd_proc_null (struct svc_rqst *rqstp) +{ +return rpc_success; +} + +struct nfsd_getuuidres { +uuid_t uuid; +}; + +static __be32 nfsd_proc_getuuid (struct svc_rqst *rqstp) +{ +struct nfsd_net *nn =net_generic (SVC_NET (rqstp), nfsd_net_id); +struct nfsd_getuuidres *resp = rqstp->rq_resp; + +uuid_copy (&resp->uuid, &nn->nfsd_uuid.uuid); + +return rpc_success; +} + +static bool nfslocalio_encode_getuuidres (struct svc_rqst *rqstp, +struct xdr_stream *xdr) +{ +struct nfsd_getuuidres *resp = rqstp->rq_resp; +u8 uuid[UUID_SIZE ]; + +export_uuid (uuid, &resp->uuid); +encode_opaque_fixed (xdr, uuid,UUID_SIZE ); +dprintk ("%s: uuid=%pU\n" , __func__, uuid); + +return true; +} + +static const struct svc_procedure nfsd_localio_procedures[2 ] = { + [LOCALIOPROC_NULL ] = { + .pc_func = nfsd_proc_null, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfssvc_encode_voidres, + .pc_argsize =sizeof (struct nfsd_voidargs ), + .pc_ressize =sizeof (struct nfsd_voidres ), + .pc_cachetype =RC_NOCACHE , + .pc_xdrressize =0 , + .pc_name ="NULL" , + }, + [LOCALIOPROC_GETUUID ] = { + .pc_func = nfsd_proc_getuuid, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfslocalio_encode_getuuidres, + .pc_argsize =sizeof (struct nfsd_voidargs ), + .pc_ressize =sizeof (struct nfsd_getuuidres ), + .pc_cachetype =RC_NOCACHE , + .pc_xdrressize =XDR_QUADLEN (UUID_SIZE ), + .pc_name ="GETUUID" , + }, +}; + +static DEFINE_PER_CPU_ALIGNED(unsigned long, + nfsd_localio_count[ARRAY_SIZE(nfsd_localio_procedures)]); +const struct svc_version nfsd_localio_version1 = { + .vs_vers =1 , + .vs_nproc =2 , + .vs_proc = nfsd_localio_procedures, + .vs_dispatch = nfsd_dispatch, + .vs_count = nfsd_localio_count, + .vs_xdrsize =XDR_QUADLEN (UUID_SIZE ), + .vs_hidden = true, +};
fs/nfsd/nfssvc.c +28 -1
@@ -81,6 +81,26 @@ DEFINE_SPINLOCK(nfsd_drc_lock);unsigned long nfsd_drc_max_mem;unsigned long nfsd_drc_mem_used; +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +extern const struct svc_version nfsd_localio_version1; +static const struct svc_version *nfsd_localio_version[] = { + [1 ] = &nfsd_localio_version1, +}; + +#define NFSD_LOCALIO_NRVERS ARRAY_SIZE(nfsd_localio_version) + +static struct svc_program nfsd_localio_program = { + .pg_prog =NFS_LOCALIO_PROGRAM , + .pg_nvers =NFSD_LOCALIO_NRVERS , + .pg_vers = nfsd_localio_version, + .pg_name ="nfslocalio" , + .pg_class ="nfsd" , + .pg_authenticate = &svc_set_client, + .pg_init_request = svc_generic_init_request, + .pg_rpcbind_set = svc_generic_rpcbind_set, +}; +#endif /* CONFIG_NFSD_LOCALIO */ + #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) static const struct svc_version *nfsd_acl_version[] = { # if defined(CONFIG_NFSD_V2_ACL)
@@ -95,6 +115,9 @@ static const struct svc_version *nfsd_acl_version[] = {#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)static struct svc_program nfsd_acl_program = { +#if IS_ENABLED(CONFIG_NFSD_LOCALIO) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ .pg_prog =NFS_ACL_PROGRAM , .pg_nvers =NFSD_ACL_NRVERS , .pg_vers = nfsd_acl_version,
@@ -123,6 +146,10 @@ static const struct svc_version *nfsd_version[] = { struct svc_program nfsd_program = {#if defined(CONFIG_NFSD_V2_ACL ) || defined(CONFIG_NFSD_V3_ACL ) .pg_next = &nfsd_acl_program, +#else +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ #endif .pg_prog = NFS_PROGRAM, /* program number */ .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
@@ -975,7 +1002,7 @@ nfsd(void *vrqstp) }/** -* nfsd_dispatch - Process an NFS or NFSACL Request +* nfsd_dispatch - Process an NFS or NFSACL or NFSLOCALIO Request * @rqstp: incoming request * * This RPC dispatcher integrates the NFS server's duplicate reply cache.
Signature · 1 line
2.44.0
Re: [PATCH v7 14/20] nfsd: implement server support for NFS_LOCALIO_PROGRAM
Quoted 40 lines · Mike Snitzer
LOCALIOPROC_GETUUIDencodes the server'suuid_tin terms of the fixedUUID_SIZE(16). The fixed size opaque encode and decode XDR methods are used instead of the less efficient variable sized methods.Aside from a bit of code in
nfssvc.c, all the knowledge of the LOCALIO RPC protocol is infs/nfsd/localio.cwhich implements just a single version (1) that is used independently of what NFS version is used.Signed-off-by Mike Snitzer <[email protected]>[neilb: factored out and simplified single localio protocol]Co-developed-by NeilBrown <[email protected]>Signed-off-by NeilBrown <[email protected]>--- fs/nfsd/localio.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfsd/nfssvc.c | 29 ++++++++++++++++++- 2 files changed, 102 insertions(+), 1 deletion(-)fs/nfsd/localio.c +3
-0@@ -11,12 +11,15 @@#include <linux/sunrpc/svcauth_gss.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs.h> +#include <linux/nfs_fs.h> +#include <linux/nfs_xdr.h> #include <linux/string.h> #include "nfsd.h" #include "vfs.h" #include "netns.h" #include "filecache.h" +#include "cache.h" #define NFSDDBG_FACILITY NFSDDBG_FH@@ -249,3 +252,74 @@ EXPORT_SYMBOL_GPL(nfsd_open_local_fh);/* Compile time type checking, not used by anything */
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 263
Quoted 10 lines
fs/nfsd/localio.c +9
-0static nfs_to_nfsd_open_t __maybe_unused nfsd_open_local_fh_typecheck = nfsd_open_local_fh; + +/* +* GETUUID XDR encode functions +*/ + +static __be32 nfsd_proc_null (struct svc_rqst *rqstp) +{ +return rpc_success; +}
We already have an nfsd_proc_null() (for NFSv2). Let's use
localio_proc_null()
instead.
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 269
Quoted 5 lines
fs/nfsd/localio.c +5
-0+struct nfsd_getuuidres { +uuid_t uuid; +}; + +static __be32 nfsd_proc_getuuid (struct svc_rqst *rqstp)
And here, please use
localio_proc_getuuid()
instead.
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 280
Quoted 11 lines
fs/nfsd/localio.c +11
-0+{ +struct nfsd_net *nn =net_generic (SVC_NET (rqstp), nfsd_net_id); +struct nfsd_getuuidres *resp = rqstp->rq_resp; + +uuid_copy (&resp->uuid, &nn->nfsd_uuid.uuid); + +return rpc_success; +} + +static bool nfslocalio_encode_getuuidres (struct svc_rqst *rqstp, +struct xdr_stream *xdr)
Please use
localio_encode_getuuidres()
instead.
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 292
Quoted 12 lines
fs/nfsd/localio.c +12
-0+{ +struct nfsd_getuuidres *resp = rqstp->rq_resp; +u8 uuid[UUID_SIZE ]; + +export_uuid (uuid, &resp->uuid); +encode_opaque_fixed (xdr, uuid,UUID_SIZE ); +dprintk ("%s: uuid=%pU\n" , __func__, uuid); + +return true; +} + +static const struct svc_procedure nfsd_localio_procedures[2 ] = {
I think I prefer:
localio_procedures1
Quoted 15 lines
fs/nfsd/localio.c +15
-0+ [LOCALIOPROC_NULL] = { + .pc_func = nfsd_proc_null, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfssvc_encode_voidres, + .pc_argsize = sizeof(struct nfsd_voidargs), + .pc_ressize = sizeof(struct nfsd_voidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = 0, + .pc_name = "NULL", + }, + [LOCALIOPROC_GETUUID] = { + .pc_func = nfsd_proc_getuuid, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfslocalio_encode_getuuidres, + .pc_argsize = sizeof(struct nfsd_voidargs),
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 317
Quoted 10 lines
fs/nfsd/localio.c +10
-0+ .pc_ressize = sizeof(struct nfsd_getuuidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = XDR_QUADLEN(UUID_SIZE), + .pc_name = "GETUUID", + }, +}; + +static DEFINE_PER_CPU_ALIGNED(unsigned long, + nfsd_localio_count[ARRAY_SIZE(nfsd_localio_procedures)]); +const struct svc_version nfsd_localio_version1 = {
I'd prefer:
localiosvc_version1
Quoted 13 lines
fs/nfsd/localio.c +8
-0+ .vs_vers = 1, + .vs_nproc = 2, + .vs_proc = nfsd_localio_procedures, + .vs_dispatch = nfsd_dispatch, + .vs_count = nfsd_localio_count, + .vs_xdrsize = XDR_QUADLEN(UUID_SIZE), + .vs_hidden = true, +};fs/nfsd/nfssvc.c +0
-0
fs/nfsd/nfssvc.c DEFINE_SPINLOCK(nfsd_drc_lock); · line 86
Quoted 6 lines
fs/nfsd/nfssvc.c +3
-0@@ -81,6 +81,26 @@ DEFINE_SPINLOCK(nfsd_drc_lock);unsigned long nfsd_drc_max_mem;unsigned long nfsd_drc_mem_used; +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +extern const struct svc_version nfsd_localio_version1; +static const struct svc_version *nfsd_localio_version[] = {
Instead:
localio_versions[]
Quoted 42 lines
fs/nfsd/nfssvc.c +24
-0+ [1] = &nfsd_localio_version1, +}; + +#define NFSD_LOCALIO_NRVERS ARRAY_SIZE(nfsd_localio_version) + +static struct svc_program nfsd_localio_program = { + .pg_prog =NFS_LOCALIO_PROGRAM , + .pg_nvers =NFSD_LOCALIO_NRVERS , + .pg_vers = nfsd_localio_version, + .pg_name ="nfslocalio" , + .pg_class ="nfsd" , + .pg_authenticate = &svc_set_client, + .pg_init_request = svc_generic_init_request, + .pg_rpcbind_set = svc_generic_rpcbind_set, +}; +#endif /* CONFIG_NFSD_LOCALIO */ + #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) static const struct svc_version *nfsd_acl_version[] = { # if defined(CONFIG_NFSD_V2_ACL)@@ -95,6 +115,9 @@ static const struct svc_version *nfsd_acl_version[] = {#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)static struct svc_program nfsd_acl_program = { +#if IS_ENABLED(CONFIG_NFSD_LOCALIO) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ .pg_prog =NFS_ACL_PROGRAM , .pg_nvers =NFSD_ACL_NRVERS , .pg_vers = nfsd_acl_version,@@ -123,6 +146,10 @@ static const struct svc_version *nfsd_version[] = { struct svc_program nfsd_program = {#if defined(CONFIG_NFSD_V2_ACL ) || defined(CONFIG_NFSD_V3_ACL ) .pg_next = &nfsd_acl_program, +#else +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ #endif .pg_prog = NFS_PROGRAM, /* program number */ .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
fs/nfsd/nfssvc.c nfsd(void *vrqstp) · line 1005
Quoted 5 lines
fs/nfsd/nfssvc.c +1
-1@@ -975,7 +1002,7 @@ nfsd(void *vrqstp) }/** -* nfsd_dispatch - Process an NFS or NFSACL Request +* nfsd_dispatch - Process an NFS or NFSACL or NFSLOCALIO Request
Nit: "nfsd_dispatch - Process an NFS, NFSACL, or LOCALIO request"
Quoted 6 lines
fs/nfsd/nfssvc.c +0
-0* @rqstp: incoming request * * This RPC dispatcher integrates the NFS server's duplicate reply cache. Signature · 1 line
2.44.0
Signature · 1 line
Chuck Lever
Re: [PATCH v7 14/20] nfsd: implement server support for NFS_LOCALIO_PROGRAM
In reply to Mike SnitzerQuoted 69 lines · Mike Snitzer
LOCALIOPROC_GETUUIDencodes the server'suuid_tin terms of the fixedUUID_SIZE(16). The fixed size opaque encode and decode XDR methods are used instead of the less efficient variable sized methods.Aside from a bit of code in
nfssvc.c, all the knowledge of the LOCALIO RPC protocol is infs/nfsd/localio.cwhich implements just a single version (1) that is used independently of what NFS version is used.Signed-off-by Mike Snitzer <[email protected]>[neilb: factored out and simplified single localio protocol]Co-developed-by NeilBrown <[email protected]>Signed-off-by NeilBrown <[email protected]>--- fs/nfsd/localio.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfsd/nfssvc.c | 29 ++++++++++++++++++- 2 files changed, 102 insertions(+), 1 deletion(-)fs/nfsd/localio.c +31
-0@@ -11,12 +11,15 @@#include <linux/sunrpc/svcauth_gss.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs.h> +#include <linux/nfs_fs.h> +#include <linux/nfs_xdr.h> #include <linux/string.h> #include "nfsd.h" #include "vfs.h" #include "netns.h" #include "filecache.h" +#include "cache.h" #define NFSDDBG_FACILITY NFSDDBG_FH@@ -249,3 +252,74 @@ EXPORT_SYMBOL_GPL(nfsd_open_local_fh);/* Compile time type checking, not used by anything */ static nfs_to_nfsd_open_t __maybe_unused nfsd_open_local_fh_typecheck = nfsd_open_local_fh; + +/* +* GETUUID XDR encode functions +*/ + +static __be32 nfsd_proc_null (struct svc_rqst *rqstp) +{ +return rpc_success; +} + +struct nfsd_getuuidres { +uuid_t uuid; +}; + +static __be32 nfsd_proc_getuuid (struct svc_rqst *rqstp) +{ +struct nfsd_net *nn =net_generic (SVC_NET (rqstp), nfsd_net_id); +struct nfsd_getuuidres *resp = rqstp->rq_resp; + +uuid_copy (&resp->uuid, &nn->nfsd_uuid.uuid); + +return rpc_success; +} + +static bool nfslocalio_encode_getuuidres (struct svc_rqst *rqstp, +struct xdr_stream *xdr) +{ +struct nfsd_getuuidres *resp = rqstp->rq_resp;
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 292
Quoted 10 lines
fs/nfsd/localio.c +10
-0+u8 uuid[UUID_SIZE ]; + +export_uuid (uuid, &resp->uuid); +encode_opaque_fixed (xdr, uuid,UUID_SIZE ); +dprintk ("%s: uuid=%pU\n" , __func__, uuid); + +return true; +} + +static const struct svc_procedure nfsd_localio_procedures[2 ] = {
Including a '2' here is unnecessary.
Quoted 14 lines
fs/nfsd/localio.c +14
-0+ [LOCALIOPROC_NULL] = { + .pc_func = nfsd_proc_null, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfssvc_encode_voidres, + .pc_argsize = sizeof(struct nfsd_voidargs), + .pc_ressize = sizeof(struct nfsd_voidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = 0, + .pc_name = "NULL", + }, + [LOCALIOPROC_GETUUID] = { + .pc_func = nfsd_proc_getuuid, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfslocalio_encode_getuuidres,
fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 316
Quoted 10 lines
fs/nfsd/localio.c +10
-0+ .pc_argsize = sizeof(struct nfsd_voidargs), + .pc_ressize = sizeof(struct nfsd_getuuidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = XDR_QUADLEN(UUID_SIZE), + .pc_name = "GETUUID", + }, +}; + +static DEFINE_PER_CPU_ALIGNED(unsigned long, + nfsd_localio_count[ARRAY_SIZE(nfsd_localio_procedures)]);
We have ARRAY_SIZE above and "= 2" below, both referring to the same value.
Maybe #define LOCALIO_NR_PROCEEDURES ARRAY_SIZE(nfsd_localio_procedures) ??
NeilBrown
Quoted 74 lines
fs/nfsd/localio.c +9
-0+const struct svc_version nfsd_localio_version1 = { + .vs_vers =1 , + .vs_nproc =2 , + .vs_proc = nfsd_localio_procedures, + .vs_dispatch = nfsd_dispatch, + .vs_count = nfsd_localio_count, + .vs_xdrsize =XDR_QUADLEN (UUID_SIZE ), + .vs_hidden = true, +};fs/nfsd/nfssvc.c +28
-1@@ -81,6 +81,26 @@ DEFINE_SPINLOCK(nfsd_drc_lock);unsigned long nfsd_drc_max_mem;unsigned long nfsd_drc_mem_used; +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) +extern const struct svc_version nfsd_localio_version1; +static const struct svc_version *nfsd_localio_version[] = { + [1 ] = &nfsd_localio_version1, +}; + +#define NFSD_LOCALIO_NRVERS ARRAY_SIZE(nfsd_localio_version) + +static struct svc_program nfsd_localio_program = { + .pg_prog =NFS_LOCALIO_PROGRAM , + .pg_nvers =NFSD_LOCALIO_NRVERS , + .pg_vers = nfsd_localio_version, + .pg_name ="nfslocalio" , + .pg_class ="nfsd" , + .pg_authenticate = &svc_set_client, + .pg_init_request = svc_generic_init_request, + .pg_rpcbind_set = svc_generic_rpcbind_set, +}; +#endif /* CONFIG_NFSD_LOCALIO */ + #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) static const struct svc_version *nfsd_acl_version[] = { # if defined(CONFIG_NFSD_V2_ACL)@@ -95,6 +115,9 @@ static const struct svc_version *nfsd_acl_version[] = {#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)static struct svc_program nfsd_acl_program = { +#if IS_ENABLED(CONFIG_NFSD_LOCALIO) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ .pg_prog =NFS_ACL_PROGRAM , .pg_nvers =NFSD_ACL_NRVERS , .pg_vers = nfsd_acl_version,@@ -123,6 +146,10 @@ static const struct svc_version *nfsd_version[] = { struct svc_program nfsd_program = {#if defined(CONFIG_NFSD_V2_ACL ) || defined(CONFIG_NFSD_V3_ACL ) .pg_next = &nfsd_acl_program, +#else +#if IS_ENABLED (CONFIG_NFSD_LOCALIO ) + .pg_next = &nfsd_localio_program, +#endif /* CONFIG_NFSD_LOCALIO */ #endif .pg_prog = NFS_PROGRAM, /* program number */ .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */@@ -975,7 +1002,7 @@ nfsd(void *vrqstp) }/** -* nfsd_dispatch - Process an NFS or NFSACL Request +* nfsd_dispatch - Process an NFS or NFSACL or NFSLOCALIO Request * @rqstp: incoming request * * This RPC dispatcher integrates the NFS server's duplicate reply cache. Signature · 1 line
2.44.0
Re: [PATCH v7 14/20] nfsd: implement server support for NFS_LOCALIO_PROGRAM
Quoted 111 lines · NeilBrown
Quoted 69 lines · Mike Snitzer
LOCALIOPROC_GETUUIDencodes the server'suuid_tin terms of the fixedUUID_SIZE(16). The fixed size opaque encode and decode XDR methods are used instead of the less efficient variable sized methods.Aside from a bit of code in
nfssvc.c, all the knowledge of the LOCALIO RPC protocol is infs/nfsd/localio.cwhich implements just a single version (1) that is used independently of what NFS version is used.Signed-off-by Mike Snitzer <[email protected]>[neilb: factored out and simplified single localio protocol]Co-developed-by NeilBrown <[email protected]>Signed-off-by NeilBrown <[email protected]>--- fs/nfsd/localio.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfsd/nfssvc.c | 29 ++++++++++++++++++- 2 files changed, 102 insertions(+), 1 deletion(-)fs/nfsd/localio.c +31
-0@@ -11,12 +11,15 @@#include <linux/sunrpc/svcauth_gss.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs.h> +#include <linux/nfs_fs.h> +#include <linux/nfs_xdr.h> #include <linux/string.h> #include "nfsd.h" #include "vfs.h" #include "netns.h" #include "filecache.h" +#include "cache.h" #define NFSDDBG_FACILITY NFSDDBG_FH@@ -249,3 +252,74 @@ EXPORT_SYMBOL_GPL(nfsd_open_local_fh);/* Compile time type checking, not used by anything */ static nfs_to_nfsd_open_t __maybe_unused nfsd_open_local_fh_typecheck = nfsd_open_local_fh; + +/* +* GETUUID XDR encode functions +*/ + +static __be32 nfsd_proc_null (struct svc_rqst *rqstp) +{ +return rpc_success; +} + +struct nfsd_getuuidres { +uuid_t uuid; +}; + +static __be32 nfsd_proc_getuuid (struct svc_rqst *rqstp) +{ +struct nfsd_net *nn =net_generic (SVC_NET (rqstp), nfsd_net_id); +struct nfsd_getuuidres *resp = rqstp->rq_resp; + +uuid_copy (&resp->uuid, &nn->nfsd_uuid.uuid); + +return rpc_success; +} + +static bool nfslocalio_encode_getuuidres (struct svc_rqst *rqstp, +struct xdr_stream *xdr) +{ +struct nfsd_getuuidres *resp = rqstp->rq_resp;fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 292
Quoted 10 lines
fs/nfsd/localio.c +10
-0+u8 uuid[UUID_SIZE ]; + +export_uuid (uuid, &resp->uuid); +encode_opaque_fixed (xdr, uuid,UUID_SIZE ); +dprintk ("%s: uuid=%pU\n" , __func__, uuid); + +return true; +} + +static const struct svc_procedure nfsd_localio_procedures[2 ] = {Including a '2' here is unnecessary.
Quoted 14 lines
fs/nfsd/localio.c +14
-0+ [LOCALIOPROC_NULL] = { + .pc_func = nfsd_proc_null, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfssvc_encode_voidres, + .pc_argsize = sizeof(struct nfsd_voidargs), + .pc_ressize = sizeof(struct nfsd_voidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = 0, + .pc_name = "NULL", + }, + [LOCALIOPROC_GETUUID] = { + .pc_func = nfsd_proc_getuuid, + .pc_decode = nfssvc_decode_voidarg, + .pc_encode = nfslocalio_encode_getuuidres,fs/nfsd/localio.c EXPORT_SYMBOL_GPL(nfsd_open_local_fh); · line 316
Quoted 10 lines
fs/nfsd/localio.c +10
-0+ .pc_argsize = sizeof(struct nfsd_voidargs), + .pc_ressize = sizeof(struct nfsd_getuuidres), + .pc_cachetype = RC_NOCACHE, + .pc_xdrressize = XDR_QUADLEN(UUID_SIZE), + .pc_name = "GETUUID", + }, +}; + +static DEFINE_PER_CPU_ALIGNED(unsigned long, + nfsd_localio_count[ARRAY_SIZE(nfsd_localio_procedures)]);We have
ARRAY_SIZEabove and "= 2" below, both referring to the same value.
Quoted 2 lines
Maybe #define
LOCALIO_NR_PROCEEDURESARRAY_SIZE(nfsd_localio_procedures)??
Yeap, sounds good, fixed for v8.
PATCH v7 15/20 SUNRPC: replace program list with program array
In reply to Mike SnitzerFrom: NeilBrown <[email protected]>
A service created with svc_create_pooled() can be given a linked list of programs and all of these will be served.
Using a linked list makes it cumbersome when there are several programs that can be optionally selected with CONFIG settings.
So change to use an array with explicit size. svc_create() is always passed a single program. svc_create_pooled() now must be used for multiple programs.
--- fs/nfsd/nfsctl.c | 2 +- fs/nfsd/nfsd.h | 2 +- fs/nfsd/nfssvc.c | 69 ++++++++++++++++++-------------------- include/linux/sunrpc/svc.h | 7 ++-- net/sunrpc/svc.c | 68 +++++++++++++++++++++---------------- net/sunrpc/svc_xprt.c | 2 +- net/sunrpc/svcauth_unix.c | 3 +- 7 files changed, 80 insertions(+), 73 deletions(-)
fs/nfsd/nfsctl.c +1 -1
@@ -2265,7 +2265,7 @@ static __net_init int nfsd_net_init(struct net *net)if (retval) goto out_repcache_error;memset (&nn->nfsd_svcstats,0 ,sizeof (nn->nfsd_svcstats)); - nn->nfsd_svcstats.program = &nfsd_program; + nn->nfsd_svcstats.program = &nfsd_programs[0 ]; nn->nfsd_versions =NULL ; nn->nfsd4_minorversions =NULL ;nfsd4_init_leases_net (nn);
fs/nfsd/nfsd.h +1 -1
@@ -80,7 +80,7 @@ struct nfsd_genl_rqstp {u32 rq_opnum[NFSD_MAX_OPS_PER_COMPOUND ]; }; -extern struct svc_program nfsd_program; +extern struct svc_program nfsd_programs[];extern const struct svc_version nfsd_version2, nfsd_version3, nfsd_version4;extern struct mutex nfsd_mutex;extern spinlock_t nfsd_drc_lock;
fs/nfsd/nfssvc.c +32 -37
110 lines not on this page · raw message
include/linux/sunrpc/svc.h +4 -3
@@ -66,9 +66,10 @@ enum {* We currently do not support more than one RPC program per daemon. */ struct svc_serv { -struct svc_program * sv_program;/* RPC program */ +struct svc_program * sv_programs;/* RPC programs */ struct svc_stat * sv_stats;/* RPC statistics */ spinlock_t sv_lock; +unsigned int sv_nprogs;/* Number of sv_programs */ unsigned int sv_nrthreads;/* # of server threads */ unsigned int sv_maxconn;/* max connections allowed or * '0' causing max to be based
@@ -329,10 +330,9 @@ struct svc_process_info { };/* -* List of RPC programs on the same transport endpoint +* RPC program - an array of these can use the same transport endpoint */ struct svc_program { -struct svc_program * pg_next;/* other programs (same xprt) */ u32 pg_prog;/* program number */ unsigned int pg_lovers;/* lowest version */ unsigned int pg_hivers;/* highest version */
@@ -414,6 +414,7 @@ void svc_rqst_release_pages(struct svc_rqst *rqstp);void svc_rqst_free (struct svc_rqst *);void svc_exit_thread (struct svc_rqst *);struct svc_serv *svc_create_pooled (struct svc_program *prog, +unsigned int nprog,struct svc_stat *stats,unsigned int bufsize,int (*threadfn)(void *data));
net/sunrpc/svc.c +39 -29
166 lines not on this page · raw message
net/sunrpc/svc_xprt.c +1 -1
@@ -268,7 +268,7 @@ static int _svc_xprt_create(struct svc_serv *serv, const char *xprt_name,spin_unlock (&svc_xprt_class_lock); newxprt = xcl->xcl_ops->xpo_create (serv, net, sap, len, flags);if (IS_ERR (newxprt)) { -trace_svc_xprt_create_err (serv->sv_program->pg_name, +trace_svc_xprt_create_err (serv->sv_programs->pg_name, xcl->xcl_name, sap, len, newxprt);module_put (xcl->xcl_owner);
net/sunrpc/svcauth_unix.c +2 -1
@@ -697,7 +697,8 @@ svcauth_unix_set_client(struct svc_rqst *rqstp) rqstp->rq_auth_stat = rpc_autherr_badcred; ipm =ip_map_cached_get (xprt);if (ipm ==NULL ) - ipm =__ip_map_lookup (sn->ip_map_cache, rqstp->rq_server->sv_program->pg_class, + ipm =__ip_map_lookup (sn->ip_map_cache, + rqstp->rq_server->sv_programs->pg_class, &sin6->sin6_addr);if (ipm ==NULL )
Signature · 1 line
2.44.0
PATCH v7 16/20 nfsd: prepare to use SRCU to dereference nn->nfsd_serv
In reply to Mike SnitzerThe next commit switches the nfsd_serv member for struct nfsd_net over to a void pointer (void __rcu *). Prepare for this by assigning nn->nfsd_serv to an struct svc_serv pointer that is then happily dereferenced. This eliminates what would otherwise be numerous void pointer dereferences after the next commit.
All nfsd code what audited so that methods that hold nfsd_mutex will continue to directly dereference nn->nfsd_serv.
--- fs/nfsd/nfsctl.c | 21 +++++++++++++-------- fs/nfsd/nfssvc.c | 34 ++++++++++++++++++---------------- 2 files changed, 31 insertions(+), 24 deletions(-)
fs/nfsd/nfsctl.c +13 -8
@@ -687,10 +687,11 @@ static ssize_t write_versions(struct file *file, char *buf, size_t size)static ssize_t __write_ports_names (char *buf,struct net *net) {struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv = nn->nfsd_serv; -if (nn->nfsd_serv ==NULL ) +if (serv ==NULL )return 0 ; -return svc_xprt_names (nn->nfsd_serv, buf,SIMPLE_TRANSACTION_LIMIT ); +return svc_xprt_names (serv, buf,SIMPLE_TRANSACTION_LIMIT ); }/*
@@ -717,7 +718,7 @@ static ssize_t __write_ports_addfd(char *buf, struct net *net, const struct cred serv = nn->nfsd_serv; err =svc_addsock (serv, net, fd, buf,SIMPLE_TRANSACTION_LIMIT , cred); -if (!serv->sv_nrthreads &&list_empty (&nn->nfsd_serv->sv_permsocks)) +if (!serv->sv_nrthreads &&list_empty (&serv->sv_permsocks))nfsd_destroy_serv (net);return err;
@@ -765,7 +766,7 @@ static ssize_t __write_ports_addxprt(char *buf, struct net *net, const struct crsvc_xprt_put (xprt); } out_err: -if (!serv->sv_nrthreads &&list_empty (&nn->nfsd_serv->sv_permsocks)) +if (!serv->sv_nrthreads &&list_empty (&serv->sv_permsocks))nfsd_destroy_serv (net);return err;
@@ -1674,6 +1675,7 @@ int nfsd_nl_threads_set_doit(struct sk_buff *skb, struct genl_info *info)int *nthreads, count =0 , nrpools, i, ret = -EOPNOTSUPP , rem;struct net *net =genl_info_net (info);struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv;const struct nlattr *attr;const char *scope =NULL ;
@@ -1708,7 +1710,8 @@ int nfsd_nl_threads_set_doit(struct sk_buff *skb, struct genl_info *info) info->attrs[NFSD_A_SERVER_LEASETIME] || info->attrs[NFSD_A_SERVER_SCOPE]) { ret = -EBUSY ; -if (nn->nfsd_serv && nn->nfsd_serv->sv_nrthreads) + serv = nn->nfsd_serv; +if (serv && serv->sv_nrthreads) goto out_unlock; ret = -EINVAL ;
@@ -1757,6 +1760,7 @@ int nfsd_nl_threads_get_doit(struct sk_buff *skb, struct genl_info *info) {struct net *net =genl_info_net (info);struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv;void *hdr;int err;
@@ -1781,11 +1785,12 @@ int nfsd_nl_threads_get_doit(struct sk_buff *skb, struct genl_info *info)if (err) goto err_unlock; -if (nn->nfsd_serv) { + serv = nn->nfsd_serv; +if (serv) {int i;for (i =0 ; i <nfsd_nrpools (net); ++i) { -struct svc_pool *sp = &nn->nfsd_serv->sv_pools[i]; +struct svc_pool *sp = &serv->sv_pools[i]; err =nla_put_u32 (skb,NFSD_A_SERVER_THREADS ,atomic_read (&sp->sp_nrthreads));
@@ -2103,7 +2108,7 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, struct genl_info *info) err = ret; } -if (!serv->sv_nrthreads &&list_empty (&nn->nfsd_serv->sv_permsocks)) +if (!serv->sv_nrthreads &&list_empty (&serv->sv_permsocks))nfsd_destroy_serv (net); out_unlock_mtx:
fs/nfsd/nfssvc.c +18 -16
@@ -288,10 +288,12 @@ int nfsd_nrthreads(struct net *net) {int rv =0 ;struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv;mutex_lock (&nfsd_mutex); -if (nn->nfsd_serv) - rv = nn->nfsd_serv->sv_nrthreads; + serv = nn->nfsd_serv; +if (serv) + rv = serv->sv_nrthreads;mutex_unlock (&nfsd_mutex);return rv; }
@@ -300,16 +302,17 @@ static int nfsd_init_socks(struct net *net, const struct cred *cred) {int error;struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv = nn->nfsd_serv; -if (!list_empty (&nn->nfsd_serv->sv_permsocks)) +if (!list_empty (&serv->sv_permsocks))return 0 ; - error =svc_xprt_create (nn->nfsd_serv,"udp" , net,PF_INET ,NFS_PORT , + error =svc_xprt_create (serv,"udp" , net,PF_INET ,NFS_PORT ,SVC_SOCK_DEFAULTS , cred);if (error <0 )return error; - error =svc_xprt_create (nn->nfsd_serv,"tcp" , net,PF_INET ,NFS_PORT , + error =svc_xprt_create (serv,"tcp" , net,PF_INET ,NFS_PORT ,SVC_SOCK_DEFAULTS , cred);if (error <0 )return error;
@@ -722,11 +725,12 @@ int nfsd_create_serv(struct net *net)int nfsd_nrpools (struct net *net) {struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv = nn->nfsd_serv; -if (nn->nfsd_serv ==NULL ) +if (serv ==NULL )return 0 ;else -return nn->nfsd_serv->sv_nrpools; +return serv->sv_nrpools; }int nfsd_get_nrthreads (int n,int *nthreads,struct net *net)
@@ -760,14 +764,15 @@ int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)int tot =0 ;int err =0 ;struct nfsd_net *nn =net_generic (net, nfsd_net_id); +struct svc_serv *serv = nn->nfsd_serv;lockdep_assert_held (&nfsd_mutex); -if (nn->nfsd_serv ==NULL || n <=0 ) +if (serv ==NULL || n <=0 )return 0 ; -if (n > nn->nfsd_serv->sv_nrpools) - n = nn->nfsd_serv->sv_nrpools; +if (n > serv->sv_nrpools) + n = serv->sv_nrpools;/* enforce a global maximum number of threads */ tot =0 ;
@@ -790,18 +795,15 @@ int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)/* apply the new numbers */ for (i =0 ; i < n; i++) { - err =svc_set_num_threads (nn->nfsd_serv, - &nn->nfsd_serv->sv_pools[i], + err =svc_set_num_threads (serv, &serv->sv_pools[i], nthreads[i]);if (err) goto out; }/* Anything undefined in array is considered to be 0 */ -for (i = n; i < nn->nfsd_serv->sv_nrpools; ++i) { - err =svc_set_num_threads (nn->nfsd_serv, - &nn->nfsd_serv->sv_pools[i], -0 ); +for (i = n; i < serv->sv_nrpools; ++i) { + err =svc_set_num_threads (serv, &serv->sv_pools[i],0 );if (err) goto out; }
Signature · 1 line
2.44.0
PATCH v7 17/20 nfsd: use SRCU to dereference nn->nfsd_serv
In reply to Mike SnitzerIntroduce nfsd_serv_get, nfsd_serv_put and nfsd_serv_sync and update the nfsd code to prevent nfsd_destroy_serv from destroying nn->nfsd_serv until all nfsd code is done with it (particularly the localio code that doesn't run in the context of nfsd's svc threads, nor does it take the nfsd_mutex).
Commit 83d5e5b0af90 ("dm: optimize use SRCU and RCU") provided a familiar well-worn pattern for how implement.
--- fs/nfsd/filecache.c | 13 ++++++++--- fs/nfsd/netns.h | 14 ++++++++++-- fs/nfsd/nfs4state.c | 25 ++++++++++++++------- fs/nfsd/nfsctl.c | 7 ++++-- fs/nfsd/nfssvc.c | 54 ++++++++++++++++++++++++++++++++++++--------- 5 files changed, 88 insertions(+), 25 deletions(-)
fs/nfsd/filecache.c +10 -3
@@ -413,12 +413,15 @@ nfsd_file_dispose_list_delayed(struct list_head *dispose)struct nfsd_file *nf =list_first_entry (dispose, struct nfsd_file, nf_lru);struct nfsd_net *nn =net_generic (nf->nf_net, nfsd_net_id); +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);struct nfsd_fcache_disposal *l = nn->fcache_disposal;spin_lock (&l->lock);list_move_tail (&nf->nf_lru, &l->freeme);spin_unlock (&l->lock); -svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx); } }
@@ -443,11 +446,15 @@ void nfsd_file_net_dispose(struct nfsd_net *nn)for (i =0 ; i <8 && !list_empty (&l->freeme); i++)list_move (l->freeme.next, &dispose);spin_unlock (&l->lock); -if (!list_empty (&l->freeme)) +if (!list_empty (&l->freeme)) { +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);/* Wake up another thread to share the work * *before* doing any actual disposing. */ -svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx); + }nfsd_file_dispose_list (&dispose); } }
fs/nfsd/netns.h +12 -2
@@ -139,8 +139,14 @@ struct nfsd_net {u32 clverifier_counter;struct svc_info nfsd_info; -#define nfsd_serv nfsd_info.serv - +/* +* The current 'nfsd_serv' at nfsd_info.serv. Using 'void' rather than +* 'struct svc_serv' to guard against new code dereferencing nfsd_serv +* without using proper synchronization. +* Use nfsd_serv_get() or take nfsd_mutex to dereference. +*/ +void __rcu *nfsd_serv; +struct srcu_struct nfsd_serv_srcu;/* * clientid and stateid data for construction of net unique COPY
@@ -225,6 +231,10 @@ struct nfsd_net {extern bool nfsd_support_version (int vers);extern void nfsd_netns_free_versions (struct nfsd_net *nn); +extern struct svc_serv *nfsd_serv_get (struct nfsd_net *nn,int *srcu_idx); +extern void nfsd_serv_put (struct nfsd_net *nn,int srcu_idx); +extern void nfsd_serv_sync (struct nfsd_net *nn); +extern unsigned int nfsd_net_id;void nfsd_copy_write_verifier (__be32 verf[2 ],struct nfsd_net *nn);
fs/nfsd/nfs4state.c +17 -8
@@ -1919,6 +1919,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nnu32 num = ca->maxreqs;unsigned long avail, total_avail;unsigned int scale_factor; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);spin_lock (&nfsd_drc_lock);if (nfsd_drc_max_mem > nfsd_drc_mem_used)
@@ -1940,7 +1942,7 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn* Give the client one slot even if that would require * over-allocation--it is better than failure. */ - scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads); + scale_factor = max_t(unsigned int, 8, serv->sv_nrthreads); avail = clamp_t(unsigned long, avail, slotsize, total_avail/scale_factor);
@@ -1949,6 +1951,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn nfsd_drc_mem_used += num * slotsize;spin_unlock (&nfsd_drc_lock); +nfsd_serv_put (nn, srcu_idx); +return num; }
@@ -3702,12 +3706,16 @@ nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,static __be32 check_forechannel_attrs (struct nfsd4_channel_attrs *ca,struct nfsd_net *nn) { -u32 maxrpc = nn->nfsd_serv->sv_max_mesg; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); +u32 maxrpc = serv->sv_max_mesg; +__be32 status = nfs_ok; -if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ ) -return nfserr_toosmall; -if (ca->maxresp_sz <NFSD_MIN_RESP_HDR_SEQ_SZ ) -return nfserr_toosmall; +if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ || + ca->maxresp_sz <NFSD_MIN_RESP_HDR_SEQ_SZ ) { + status = nfserr_toosmall; + goto out; + } ca->headerpadsz =0 ; ca->maxreq_sz =min_t (u32, ca->maxreq_sz, maxrpc); ca->maxresp_sz =min_t (u32, ca->maxresp_sz, maxrpc);
@@ -3726,8 +3734,9 @@ static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfs* accounting is soft and provides no guarantees either way. */ ca->maxreqs =nfsd4_get_drc_mem (ca, nn); - -return nfs_ok; +out: +nfsd_serv_put (nn, srcu_idx); +return status; }/*
fs/nfsd/nfsctl.c +5 -2
@@ -1569,10 +1569,12 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, {struct nfsd_net *nn =net_generic (sock_net (skb->sk), nfsd_net_id);int i, ret, rqstp_index =0 ; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);rcu_read_lock (); -for (i =0 ; i < nn->nfsd_serv->sv_nrpools; i++) { +for (i =0 ; i < serv->sv_nrpools; i++) {struct svc_rqst *rqstp;if (i < cb->args[0 ])/* already consumed */
@@ -1580,7 +1582,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, rqstp_index =0 ;list_for_each_entry_rcu (rqstp, - &nn->nfsd_serv->sv_pools[i].sp_all_threads, + &serv->sv_pools[i].sp_all_threads, rq_all) {struct nfsd_genl_rqstp genl_rqstp;unsigned int status_counter;
@@ -1645,6 +1647,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, ret = skb->len; out:rcu_read_unlock (); +nfsd_serv_put (nn, srcu_idx);return ret; }
fs/nfsd/nfssvc.c +44 -10
126 lines not on this page · raw message
Signature · 1 line
2.44.0
Jeff Layton
maintainerRe: [PATCH v7 17/20] nfsd: use SRCU to dereference nn->nfsd_serv
Quoted 66 lines · Mike Snitzer
Introduce
nfsd_serv_get,nfsd_serv_putandnfsd_serv_syncand update the nfsd code to preventnfsd_destroy_servfrom destroyingnn->nfsd_servuntil all nfsd code is done with it (particularly the localio code that doesn't run in the context of nfsd's svc threads, nor does it take thenfsd_mutex).Commit
83d5e5b0af90("dm: optimize use SRCU and RCU") provided a familiar well-worn pattern for how implement.Suggested-by NeilBrown <[email protected]>Signed-off-by Mike Snitzer <[email protected]>---
fs/nfsd/filecache.c | 13 ++++++++---
fs/nfsd/netns.h | 14 ++++++++++--
fs/nfsd/nfs4state.c | 25 ++++++++++++++------- fs/nfsd/nfsctl.c | 7 ++++--
fs/nfsd/nfssvc.c | 54 ++++++++++++++++++++++++++++++++++++---------5 files changed, 88 insertions(+), 25 deletions(-)fs/nfsd/filecache.c +2
-0@@ -413,12 +413,15 @@ nfsd_file_dispose_list_delayed(struct list_head *dispose) struct nfsd_file *nf = list_first_entry(dispose, struct nfsd_file, nf_lru); struct nfsd_net *nn = net_generic(nf->nf_net, nfsd_net_id); +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); struct nfsd_fcache_disposal *l = nn->fcache_disposal;
spin_lock(&l->lock);list_move_tail(&nf->nf_lru, &l->freeme);spin_unlock(&l->lock);fs/nfsd/filecache.c +2
-1-svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx);}
}fs/nfsd/filecache.c +6
-2@@ -443,11 +446,15 @@ void nfsd_file_net_dispose(struct nfsd_net *nn) for (i = 0; i < 8 && !list_empty(&l->freeme); i++) list_move(l->freeme.next, &dispose); spin_unlock(&l->lock); -if (!list_empty (&l->freeme)) +if (!list_empty (&l->freeme)) { +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); /* Wake up another thread to share the work* *before* doing any actual disposing. */ -svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx); + } nfsd_file_dispose_list(&dispose); } }fs/nfsd/netns.h +0
-0@@ -139,8 +139,14 @@ struct nfsd_net { u32 clverifier_counter;
structsvc_infonfsd_info;
fs/nfsd/netns.h struct nfsd_net { · line 149
Quoted 10 lines
fs/nfsd/netns.h +8
-2-#define nfsd_serv nfsd_info.serv - +/* +* The current 'nfsd_serv' at nfsd_info.serv. Using 'void' rather than +* 'struct svc_serv' to guard against new code dereferencing nfsd_serv +* without using proper synchronization. +* Use nfsd_serv_get() or take nfsd_mutex to dereference. +*/ +void __rcu *nfsd_serv; +struct srcu_struct nfsd_serv_srcu;
I'm still not sold on the use of a void pointer here. It might protect you from using nn->nfsd_serv directly, but if you do:
struct svc_serv *serv = nn->nfsd_serv;
...that will still work. If you really want to guard against direct dereferencing, maybe it should be an unsigned long? Then you really will have to cast to use it.
Quoted 252 lines
/*
* clientid and stateid data for construction of net unique COPYfs/nfsd/netns.h +0
-0@@ -225,6 +231,10 @@ struct nfsd_net { extern bool nfsd_support_version(int vers); extern void nfsd_netns_free_versions(struct nfsd_net *nn);fs/nfsd/netns.h +4
-0+extern struct svc_serv *nfsd_serv_get (struct nfsd_net *nn,int *srcu_idx); +extern void nfsd_serv_put (struct nfsd_net *nn,int srcu_idx); +extern void nfsd_serv_sync (struct nfsd_net *nn); +extern unsigned int
nfsd_net_id;
voidnfsd_copy_write_verifier(__be32 verf[2], struct nfsd_net *nn);fs/nfsd/nfs4state.c +2
-0@@ -1919,6 +1919,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn u32 num = ca->maxreqs; unsigned long avail, total_avail; unsigned int scale_factor; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);
spin_lock(&nfsd_drc_lock);
if (nfsd_drc_max_mem>nfsd_drc_mem_used)fs/nfsd/nfs4state.c +1
-1@@ -1940,7 +1942,7 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn* Give the client one slot even if that would require * over-allocation--it is better than failure. */ - scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads); + scale_factor = max_t(unsigned int, 8, serv->sv_nrthreads);
avail =clamp_t(unsigned long, avail, slotsize, total_avail/scale_factor);fs/nfsd/nfs4state.c +0
-0@@ -1949,6 +1951,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn nfsd_drc_mem_used += num * slotsize; spin_unlock(&nfsd_drc_lock);fs/nfsd/nfs4state.c +2
-0+nfsd_serv_put (nn, srcu_idx); +return num;
}fs/nfsd/nfs4state.c +0
-0@@ -3702,12 +3706,16 @@ nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
static__be32check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn){fs/nfsd/nfs4state.c +4
-1-u32 maxrpc = nn->nfsd_serv->sv_max_mesg; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); +u32 maxrpc = serv->sv_max_mesg; +__be32 status = nfs_ok;fs/nfsd/nfs4state.c +5
-4-if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ ) -return nfserr_toosmall; -if (ca->maxresp_sz <NFSD_MIN_RESP_HDR_SEQ_SZ ) -return nfserr_toosmall; +if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ || + ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ) { + status = nfserr_toosmall; + goto out; + }
ca->headerpadsz= 0;
ca->maxreq_sz=min_t(u32, ca->maxreq_sz, maxrpc);ca->maxresp_sz=min_t(u32, ca->maxresp_sz, maxrpc);fs/nfsd/nfs4state.c +3
-2@@ -3726,8 +3734,9 @@ static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfs* accounting is soft and provides no guarantees either way. */ ca->maxreqs = nfsd4_get_drc_mem(ca, nn); - -return nfs_ok; +out: +nfsd_serv_put (nn, srcu_idx); +return status; }
/*fs/nfsd/nfsctl.c +2
-0@@ -1569,10 +1569,12 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, { struct nfsd_net *nn = net_generic(sock_net(skb->sk), nfsd_net_id); int i, ret, rqstp_index = 0; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);
rcu_read_lock();fs/nfsd/nfsctl.c +1
-1-for (i =0 ; i < nn->nfsd_serv->sv_nrpools; i++) { +for (i =0 ; i < serv->sv_nrpools; i++) {struct
svc_rqst*rqstp;
if (i < cb->args[0]) /* already consumed */fs/nfsd/nfsctl.c +0
-0@@ -1580,7 +1582,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
rqstp_index= 0;
list_for_each_entry_rcu(rqstp,fs/nfsd/nfsctl.c +1
-1- &nn->nfsd_serv->sv_pools[i].sp_all_threads, + &serv->sv_pools[i].sp_all_threads,
rq_all) {
structnfsd_genl_rqstpgenl_rqstp; unsigned intstatus_counter;fs/nfsd/nfsctl.c +0
-0@@ -1645,6 +1647,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, ret = skb->len;out:
rcu_read_unlock();fs/nfsd/nfsctl.c +1
-0+nfsd_serv_put (nn, srcu_idx);
return ret;
}fs/nfsd/nfssvc.c +0
-0@@ -279,6 +279,26 @@ int nfsd_minorversion(struct nfsd_net *nn, u32 minorversion, enum vers_op change return 0; }fs/nfsd/nfssvc.c +20
-0+struct svc_serv *nfsd_serv_get (struct nfsd_net *nn,int *srcu_idx) + __acquires(nn->nfsd_serv_srcu) +{ + *srcu_idx =srcu_read_lock (&nn->nfsd_serv_srcu); + +return srcu_dereference (nn->nfsd_serv, &nn->nfsd_serv_srcu); +} + +void nfsd_serv_put (struct nfsd_net *nn,int srcu_idx) + __releases(nn->nfsd_serv_srcu) +{ +srcu_read_unlock (&nn->nfsd_serv_srcu, srcu_idx); +} + +void nfsd_serv_sync (struct nfsd_net *nn) +{ +synchronize_srcu (&nn->nfsd_serv_srcu); +synchronize_rcu_expedited (); +} +/*
* Maximum number of nfsd processes
*/fs/nfsd/nfssvc.c +1
-0@@ -486,6 +506,7 @@ static void nfsd_shutdown_net(struct net *net) lockd_down(net); nn->lockd_up = false; } +cleanup_srcu_struct (&nn->nfsd_serv_srcu); #if IS_ENABLED(CONFIG_NFSD_LOCALIO) list_del_rcu(&nn->nfsd_uuid.list); #endif@@ -493,6 +514,7 @@ static void nfsd_shutdown_net(struct net *net) nfsd_shutdown_generic(); }
+// FIXME: nfsd_serv_{get,put} should make it safe to eliminatenfsd_notifier_lockstaticDEFINE_SPINLOCK(nfsd_notifier_lock);
static intnfsd_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)fs/nfsd/nfssvc.c +2
-0@@ -502,20 +524,22 @@ static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event, struct net *net = dev_net(dev); struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct sockaddr_in sin; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);fs/nfsd/nfssvc.c +1
-1-if (event !=NETDEV_DOWN || !nn->nfsd_serv) +if (event !=NETDEV_DOWN || !serv)goto out;
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1-if (nn->nfsd_serv) { +if (serv) {
dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local); sin.sin_family =AF_INET;
sin.sin_addr.s_addr =ifa->ifa_local;fs/nfsd/nfssvc.c +1
-1-svc_age_temp_xprts_now (nn->nfsd_serv, (struct sockaddr *)&sin); +svc_age_temp_xprts_now (serv, (struct sockaddr *)&sin);}
spin_unlock(&nfsd_notifier_lock);
-
out:fs/nfsd/nfssvc.c +1
-0+nfsd_serv_put (nn, srcu_idx);return
NOTIFY_DONE;
}fs/nfsd/nfssvc.c +2
-0@@ -532,22 +556,24 @@ static int nfsd_inet6addr_event(struct notifier_block *this, struct net *net = dev_net(dev); struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct sockaddr_in6 sin6; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);fs/nfsd/nfssvc.c +1
-1-if (event !=NETDEV_DOWN || !nn->nfsd_serv) +if (event !=NETDEV_DOWN || !serv)goto out;
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1-if (nn->nfsd_serv) { +if (serv) {
dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr); sin6.sin6_family =AF_INET6;
sin6.sin6_addr =ifa->addr;
if (ipv6_addr_type(&sin6.sin6_addr)&IPV6_ADDR_LINKLOCAL) sin6.sin6_scope_id =ifa->idev->dev->ifindex;fs/nfsd/nfssvc.c +1
-1-svc_age_temp_xprts_now (nn->nfsd_serv, (struct sockaddr *)&sin6); +svc_age_temp_xprts_now (serv, (struct sockaddr *)&sin6);}
spin_unlock(&nfsd_notifier_lock);
-
out:fs/nfsd/nfssvc.c +1
-0+nfsd_serv_put (nn, srcu_idx);return
NOTIFY_DONE;
}fs/nfsd/nfssvc.c +0
-0@@ -568,9 +594,12 @@ void nfsd_destroy_serv(struct net *net) struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct svc_serv *serv = nn->nfsd_serv;fs/nfsd/nfssvc.c +2
-0+lockdep_assert_held (&nfsd_mutex); +
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1- nn->nfsd_serv =NULL ; +rcu_assign_pointer (nn->nfsd_serv,NULL );
spin_unlock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-0+nfsd_serv_sync (nn);
/* check if the notifier still has clients */ if (atomic_dec_return(&nfsd_notifier_refcount)== 0) {fs/nfsd/nfssvc.c +0
-0@@ -690,6 +719,10 @@ int nfsd_create_serv(struct net *net) if (nn->nfsd_serv) return 0;fs/nfsd/nfssvc.c +4
-0+ error =init_srcu_struct (&nn->nfsd_serv_srcu); +if (error) +return error; +if (
nfsd_max_blksize== 0)
nfsd_max_blksize=nfsd_get_default_max_blksize();nfsd_reset_versions(nn);fs/nfsd/nfssvc.c +2
-1@@ -707,7 +740,8 @@ int nfsd_create_serv(struct net *net) } spin_lock(&nfsd_notifier_lock); nn->nfsd_info.mutex = &nfsd_mutex; - nn->nfsd_serv = serv; + nn->nfsd_info.serv = serv; +rcu_assign_pointer (nn->nfsd_serv, nn->nfsd_info.serv); spin_unlock(&nfsd_notifier_lock);
set_max_drc();
Signature · 1 line
Jeff Layton <[email protected]>
Re: [PATCH v7 17/20] nfsd: use SRCU to dereference nn->nfsd_serv
Quoted 81 lines · Jeff Layton
Quoted 66 lines · Mike Snitzer
Introduce
nfsd_serv_get,nfsd_serv_putandnfsd_serv_syncand update the nfsd code to preventnfsd_destroy_servfrom destroyingnn->nfsd_servuntil all nfsd code is done with it (particularly the localio code that doesn't run in the context of nfsd's svc threads, nor does it take thenfsd_mutex).Commit
83d5e5b0af90("dm: optimize use SRCU and RCU") provided a familiar well-worn pattern for how implement.Suggested-by NeilBrown <[email protected]>Signed-off-by Mike Snitzer <[email protected]>---
fs/nfsd/filecache.c | 13 ++++++++---
fs/nfsd/netns.h | 14 ++++++++++--
fs/nfsd/nfs4state.c | 25 ++++++++++++++------- fs/nfsd/nfsctl.c | 7 ++++--
fs/nfsd/nfssvc.c | 54 ++++++++++++++++++++++++++++++++++++---------5 files changed, 88 insertions(+), 25 deletions(-)fs/nfsd/filecache.c +2
-0@@ -413,12 +413,15 @@ nfsd_file_dispose_list_delayed(struct list_head *dispose) struct nfsd_file *nf = list_first_entry(dispose, struct nfsd_file, nf_lru); struct nfsd_net *nn = net_generic(nf->nf_net, nfsd_net_id); +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); struct nfsd_fcache_disposal *l = nn->fcache_disposal;
spin_lock(&l->lock);list_move_tail(&nf->nf_lru, &l->freeme);spin_unlock(&l->lock);fs/nfsd/filecache.c +2
-1-svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx);}
}fs/nfsd/filecache.c +6
-2@@ -443,11 +446,15 @@ void nfsd_file_net_dispose(struct nfsd_net *nn) for (i = 0; i < 8 && !list_empty(&l->freeme); i++) list_move(l->freeme.next, &dispose); spin_unlock(&l->lock); -if (!list_empty (&l->freeme)) +if (!list_empty (&l->freeme)) { +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); /* Wake up another thread to share the work* *before* doing any actual disposing. */ -svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx); + } nfsd_file_dispose_list(&dispose); } }fs/nfsd/netns.h +0
-0@@ -139,8 +139,14 @@ struct nfsd_net { u32 clverifier_counter;
structsvc_infonfsd_info;fs/nfsd/netns.h struct nfsd_net { · line 149
Quoted 10 lines
fs/nfsd/netns.h +8
-2-#define nfsd_serv nfsd_info.serv - +/* +* The current 'nfsd_serv' at nfsd_info.serv. Using 'void' rather than +* 'struct svc_serv' to guard against new code dereferencing nfsd_serv +* without using proper synchronization. +* Use nfsd_serv_get() or take nfsd_mutex to dereference. +*/ +void __rcu *nfsd_serv; +struct srcu_struct nfsd_serv_srcu;I'm still not sold on the use of a void pointer here. It might protect you from using
nn->nfsd_servdirectly, but if you do:
Quoted 5 lines
struct svc_serv *serv = nn->nfsd_serv;...that will still work. If you really want to guard against direct dereferencing, maybe it should be an unsigned long? Then you really will have to cast to use it.
I agree. The point of the "__rcu" attribute is that sparse will complain if you use the pointer without using srcu_dereference(). And CONFIG_PROVE_RCU gives you run-time splats.
We should use the tools we already have.
Thanks,
NeilBrown
Quoted 257 lines
Quoted 253 lines
/*
* clientid and stateid data for construction of net unique COPYfs/nfsd/netns.h +0
-0@@ -225,6 +231,10 @@ struct nfsd_net { extern bool nfsd_support_version(int vers); extern void nfsd_netns_free_versions(struct nfsd_net *nn);fs/nfsd/netns.h +4
-0+extern struct svc_serv *nfsd_serv_get (struct nfsd_net *nn,int *srcu_idx); +extern void nfsd_serv_put (struct nfsd_net *nn,int srcu_idx); +extern void nfsd_serv_sync (struct nfsd_net *nn); +extern unsigned int
nfsd_net_id;
voidnfsd_copy_write_verifier(__be32 verf[2], struct nfsd_net *nn);fs/nfsd/nfs4state.c +2
-0@@ -1919,6 +1919,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn u32 num = ca->maxreqs; unsigned long avail, total_avail; unsigned int scale_factor; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);
spin_lock(&nfsd_drc_lock);
if (nfsd_drc_max_mem>nfsd_drc_mem_used)fs/nfsd/nfs4state.c +1
-1@@ -1940,7 +1942,7 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn* Give the client one slot even if that would require * over-allocation--it is better than failure. */ - scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads); + scale_factor = max_t(unsigned int, 8, serv->sv_nrthreads);
avail =clamp_t(unsigned long, avail, slotsize, total_avail/scale_factor);fs/nfsd/nfs4state.c +0
-0@@ -1949,6 +1951,8 @@ static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn nfsd_drc_mem_used += num * slotsize; spin_unlock(&nfsd_drc_lock);fs/nfsd/nfs4state.c +2
-0+nfsd_serv_put (nn, srcu_idx); +return num;
}fs/nfsd/nfs4state.c +0
-0@@ -3702,12 +3706,16 @@ nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
static__be32check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn){fs/nfsd/nfs4state.c +4
-1-u32 maxrpc = nn->nfsd_serv->sv_max_mesg; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); +u32 maxrpc = serv->sv_max_mesg; +__be32 status = nfs_ok;fs/nfsd/nfs4state.c +5
-4-if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ ) -return nfserr_toosmall; -if (ca->maxresp_sz <NFSD_MIN_RESP_HDR_SEQ_SZ ) -return nfserr_toosmall; +if (ca->maxreq_sz <NFSD_MIN_REQ_HDR_SEQ_SZ || + ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ) { + status = nfserr_toosmall; + goto out; + }
ca->headerpadsz= 0;
ca->maxreq_sz=min_t(u32, ca->maxreq_sz, maxrpc);ca->maxresp_sz=min_t(u32, ca->maxresp_sz, maxrpc);fs/nfsd/nfs4state.c +3
-2@@ -3726,8 +3734,9 @@ static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfs* accounting is soft and provides no guarantees either way. */ ca->maxreqs = nfsd4_get_drc_mem(ca, nn); - -return nfs_ok; +out: +nfsd_serv_put (nn, srcu_idx); +return status; }
/*fs/nfsd/nfsctl.c +2
-0@@ -1569,10 +1569,12 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, { struct nfsd_net *nn = net_generic(sock_net(skb->sk), nfsd_net_id); int i, ret, rqstp_index = 0; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);
rcu_read_lock();fs/nfsd/nfsctl.c +1
-1-for (i =0 ; i < nn->nfsd_serv->sv_nrpools; i++) { +for (i =0 ; i < serv->sv_nrpools; i++) {struct
svc_rqst*rqstp;
if (i < cb->args[0]) /* already consumed */fs/nfsd/nfsctl.c +0
-0@@ -1580,7 +1582,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
rqstp_index= 0;
list_for_each_entry_rcu(rqstp,fs/nfsd/nfsctl.c +1
-1- &nn->nfsd_serv->sv_pools[i].sp_all_threads, + &serv->sv_pools[i].sp_all_threads,
rq_all) {
structnfsd_genl_rqstpgenl_rqstp; unsigned intstatus_counter;fs/nfsd/nfsctl.c +0
-0@@ -1645,6 +1647,7 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb, ret = skb->len;out:
rcu_read_unlock();fs/nfsd/nfsctl.c +1
-0+nfsd_serv_put (nn, srcu_idx);
return ret;
}fs/nfsd/nfssvc.c +0
-0@@ -279,6 +279,26 @@ int nfsd_minorversion(struct nfsd_net *nn, u32 minorversion, enum vers_op change return 0; }fs/nfsd/nfssvc.c +20
-0+struct svc_serv *nfsd_serv_get (struct nfsd_net *nn,int *srcu_idx) + __acquires(nn->nfsd_serv_srcu) +{ + *srcu_idx =srcu_read_lock (&nn->nfsd_serv_srcu); + +return srcu_dereference (nn->nfsd_serv, &nn->nfsd_serv_srcu); +} + +void nfsd_serv_put (struct nfsd_net *nn,int srcu_idx) + __releases(nn->nfsd_serv_srcu) +{ +srcu_read_unlock (&nn->nfsd_serv_srcu, srcu_idx); +} + +void nfsd_serv_sync (struct nfsd_net *nn) +{ +synchronize_srcu (&nn->nfsd_serv_srcu); +synchronize_rcu_expedited (); +} +/*
* Maximum number of nfsd processes
*/fs/nfsd/nfssvc.c +1
-0@@ -486,6 +506,7 @@ static void nfsd_shutdown_net(struct net *net) lockd_down(net); nn->lockd_up = false; } +cleanup_srcu_struct (&nn->nfsd_serv_srcu); #if IS_ENABLED(CONFIG_NFSD_LOCALIO) list_del_rcu(&nn->nfsd_uuid.list); #endif@@ -493,6 +514,7 @@ static void nfsd_shutdown_net(struct net *net) nfsd_shutdown_generic(); }
+// FIXME: nfsd_serv_{get,put} should make it safe to eliminatenfsd_notifier_lockstaticDEFINE_SPINLOCK(nfsd_notifier_lock);
static intnfsd_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)fs/nfsd/nfssvc.c +2
-0@@ -502,20 +524,22 @@ static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event, struct net *net = dev_net(dev); struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct sockaddr_in sin; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);fs/nfsd/nfssvc.c +1
-1-if (event !=NETDEV_DOWN || !nn->nfsd_serv) +if (event !=NETDEV_DOWN || !serv)goto out;
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1-if (nn->nfsd_serv) { +if (serv) {
dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local); sin.sin_family =AF_INET;
sin.sin_addr.s_addr =ifa->ifa_local;fs/nfsd/nfssvc.c +1
-1-svc_age_temp_xprts_now (nn->nfsd_serv, (struct sockaddr *)&sin); +svc_age_temp_xprts_now (serv, (struct sockaddr *)&sin);}
spin_unlock(&nfsd_notifier_lock);
-
out:fs/nfsd/nfssvc.c +1
-0+nfsd_serv_put (nn, srcu_idx);return
NOTIFY_DONE;
}fs/nfsd/nfssvc.c +2
-0@@ -532,22 +556,24 @@ static int nfsd_inet6addr_event(struct notifier_block *this, struct net *net = dev_net(dev); struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct sockaddr_in6 sin6; +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx);fs/nfsd/nfssvc.c +1
-1-if (event !=NETDEV_DOWN || !nn->nfsd_serv) +if (event !=NETDEV_DOWN || !serv)goto out;
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1-if (nn->nfsd_serv) { +if (serv) {
dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr); sin6.sin6_family =AF_INET6;
sin6.sin6_addr =ifa->addr;
if (ipv6_addr_type(&sin6.sin6_addr)&IPV6_ADDR_LINKLOCAL) sin6.sin6_scope_id =ifa->idev->dev->ifindex;fs/nfsd/nfssvc.c +1
-1-svc_age_temp_xprts_now (nn->nfsd_serv, (struct sockaddr *)&sin6); +svc_age_temp_xprts_now (serv, (struct sockaddr *)&sin6);}
spin_unlock(&nfsd_notifier_lock);
-
out:fs/nfsd/nfssvc.c +1
-0+nfsd_serv_put (nn, srcu_idx);return
NOTIFY_DONE;
}fs/nfsd/nfssvc.c +0
-0@@ -568,9 +594,12 @@ void nfsd_destroy_serv(struct net *net) struct nfsd_net *nn = net_generic(net, nfsd_net_id); struct svc_serv *serv = nn->nfsd_serv;fs/nfsd/nfssvc.c +2
-0+lockdep_assert_held (&nfsd_mutex); +
spin_lock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-1- nn->nfsd_serv =NULL ; +rcu_assign_pointer (nn->nfsd_serv,NULL );
spin_unlock(&nfsd_notifier_lock);fs/nfsd/nfssvc.c +1
-0+nfsd_serv_sync (nn);
/* check if the notifier still has clients */ if (atomic_dec_return(&nfsd_notifier_refcount)== 0) {fs/nfsd/nfssvc.c +0
-0@@ -690,6 +719,10 @@ int nfsd_create_serv(struct net *net) if (nn->nfsd_serv) return 0;fs/nfsd/nfssvc.c +4
-0+ error =init_srcu_struct (&nn->nfsd_serv_srcu); +if (error) +return error; +if (
nfsd_max_blksize== 0)
nfsd_max_blksize=nfsd_get_default_max_blksize();nfsd_reset_versions(nn);fs/nfsd/nfssvc.c +2
-1@@ -707,7 +740,8 @@ int nfsd_create_serv(struct net *net) } spin_lock(&nfsd_notifier_lock); nn->nfsd_info.mutex = &nfsd_mutex; - nn->nfsd_serv = serv; + nn->nfsd_info.serv = serv; +rcu_assign_pointer (nn->nfsd_serv, nn->nfsd_info.serv); spin_unlock(&nfsd_notifier_lock);
set_max_drc();Signature · 1 line
Jeff Layton <[email protected]>
Re: [PATCH v7 17/20] nfsd: use SRCU to dereference nn->nfsd_serv
Quoted 84 lines · NeilBrown
Quoted 83 lines · Jeff Layton
Quoted 66 lines · Mike Snitzer
Introduce
nfsd_serv_get,nfsd_serv_putandnfsd_serv_syncand update the nfsd code to preventnfsd_destroy_servfrom destroyingnn->nfsd_servuntil all nfsd code is done with it (particularly the localio code that doesn't run in the context of nfsd's svc threads, nor does it take thenfsd_mutex).Commit
83d5e5b0af90("dm: optimize use SRCU and RCU") provided a familiar well-worn pattern for how implement.Suggested-by NeilBrown <[email protected]>Signed-off-by Mike Snitzer <[email protected]>---
fs/nfsd/filecache.c | 13 ++++++++---
fs/nfsd/netns.h | 14 ++++++++++--
fs/nfsd/nfs4state.c | 25 ++++++++++++++------- fs/nfsd/nfsctl.c | 7 ++++--
fs/nfsd/nfssvc.c | 54 ++++++++++++++++++++++++++++++++++++---------5 files changed, 88 insertions(+), 25 deletions(-)fs/nfsd/filecache.c +2
-0@@ -413,12 +413,15 @@ nfsd_file_dispose_list_delayed(struct list_head *dispose) struct nfsd_file *nf = list_first_entry(dispose, struct nfsd_file, nf_lru); struct nfsd_net *nn = net_generic(nf->nf_net, nfsd_net_id); +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); struct nfsd_fcache_disposal *l = nn->fcache_disposal;
spin_lock(&l->lock);list_move_tail(&nf->nf_lru, &l->freeme);spin_unlock(&l->lock);fs/nfsd/filecache.c +2
-1-svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx);}
}fs/nfsd/filecache.c +6
-2@@ -443,11 +446,15 @@ void nfsd_file_net_dispose(struct nfsd_net *nn) for (i = 0; i < 8 && !list_empty(&l->freeme); i++) list_move(l->freeme.next, &dispose); spin_unlock(&l->lock); -if (!list_empty (&l->freeme)) +if (!list_empty (&l->freeme)) { +int srcu_idx; +struct svc_serv *serv =nfsd_serv_get (nn, &srcu_idx); /* Wake up another thread to share the work* *before* doing any actual disposing. */ -svc_wake_up (nn->nfsd_serv); +svc_wake_up (serv); +nfsd_serv_put (nn, srcu_idx); + } nfsd_file_dispose_list(&dispose); } }fs/nfsd/netns.h +0
-0@@ -139,8 +139,14 @@ struct nfsd_net { u32 clverifier_counter;
structsvc_infonfsd_info;fs/nfsd/netns.h struct nfsd_net { · line 149
Quoted 10 lines
fs/nfsd/netns.h +8
-2-#define nfsd_serv nfsd_info.serv - +/* +* The current 'nfsd_serv' at nfsd_info.serv. Using 'void' rather than +* 'struct svc_serv' to guard against new code dereferencing nfsd_serv +* without using proper synchronization. +* Use nfsd_serv_get() or take nfsd_mutex to dereference. +*/ +void __rcu *nfsd_serv; +struct srcu_struct nfsd_serv_srcu;I'm still not sold on the use of a void pointer here. It might protect you from using
nn->nfsd_servdirectly, but if you do:struct svc_serv *serv = nn->nfsd_serv;
Quoted 8 lines
Quoted 3 lines
...that will still work. If you really want to guard against direct dereferencing, maybe it should be an unsigned long? Then you really will have to cast to use it.
I agree. The point of the "
__rcu" attribute is that sparse will complain if you use the pointer without usingsrcu_dereference(). AndCONFIG_PROVE_RCUgives you run-time splats.
We should use the tools we already have.
Good news, I've switched from using SRCU to a percpu-refcount. So v8 will be considerably cleaner (less shotgun blast due to dropping the excessive churn from SRCU prep and implementation).
SRCU would've enabled us to drop the client notifier spinlock, and maybe more but certianly best to avoid all the SRCU changes.
Mike
PATCH v7 18/20 nfsd/localio: use SRCU to dereference nn->nfsd_serv in nfsd_open_local_fh
In reply to Mike SnitzerUse nfsd_serv_get to SRCU deference nn->nfsd_serv and pass the resulting svc_serv to nfsd_local_fakerqst_create, open the file handle and then drop the reference using nfsd_serv_put at the end of nfsd_open_local_fh.
Verified to fix an easy to hit crash that would occur if an nfsd instance running in a container, with a localio client mounted, is shutdown. Upon restart of the container and associated nfsd the client would go on to crash due to NULL pointer dereference that occuured due to the nfs client's localio attempting to nfsd_open_local_fh(), using nn->nfsd_serv, without having a proper reference on nn->nfsd_serv.
--- fs/nfsd/localio.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/nfsd/localio.c +3 -1
@@ -191,6 +191,7 @@ int nfsd_open_local_fh(struct net *net,struct nfsd_file *nf;int status =0 ;int mayflags =NFSD_MAY_LOCALIO ; +int srcu_idx;struct svc_serv *serv;__be32 beres;
@@ -205,7 +206,7 @@ int nfsd_open_local_fh(struct net *net, } nn =net_generic (net, nfsd_net_id); - serv =READ_ONCE (nn->nfsd_serv); + serv =nfsd_serv_get (nn, &srcu_idx);if (unlikely (!serv)) {dprintk ("%s: localio denied. Server not running\n" , __func__); status = -ENXIO ;
@@ -245,6 +246,7 @@ int nfsd_open_local_fh(struct net *net, out_revertcred:revert_creds (save_cred); out_net: +nfsd_serv_put (nn, srcu_idx);put_net (net);return status; }
Signature · 1 line
2.44.0
PATCH v7 19/20 nfs: add Documentation/filesystems/nfs/localio.rst
In reply to Mike SnitzerThis document gives an overview of the LOCALIO auxiliary RPC protocol added to the Linux NFS client and server (both v3 and v4) to allow a client and server to reliably handshake to determine if they are on the same host. The LOCALIO auxiliary protocol's implementation, which uses the same connection as NFS traffic, follows the pattern established by the NFS ACL protocol extension.
The robust handshake between local client and server is just the beginning, the ultimate usecase this locality makes possible is the client is able to issue reads, writes and commits directly to the server without having to go over the network. This is particularly useful for container usecases (e.g. kubernetes) where it is possible to run an IO job local to the server.
--- Documentation/filesystems/nfs/localio.rst | 134 ++++++++++++++++++++++ include/linux/nfslocalio.h | 2 + 2 files changed, 136 insertions(+) create mode 100644 Documentation/filesystems/nfs/localio.rst
Documentation/filesystems/nfs/localio.rst new file +134 -0
@@ -0,0 +1,134 @@ +=========== +NFS localio +=========== + +This document gives an overview of the LOCALIO auxiliary RPC protocol +added to the Linux NFS client and server (both v3 and v4) to allow a +client and server to reliably handshake to determine if they are on the +same host. The LOCALIO auxiliary protocol's implementation, which uses +the same connection as NFS traffic, follows the pattern established by +the NFS ACL protocol extension. + +The LOCALIO auxiliary protocol is needed to allow robust discovery of +clients local to their servers. Prior to this LOCALIO protocol a +fragile sockaddr network address based match against all local network +interfaces was attempted. But unlike the LOCALIO protocol, the +sockaddr-based matching didn't handle use of iptables or containers. + +The robust handshake between local client and server is just the +beginning, the ultimate usecase this locality makes possible is the +client is able to issue reads, writes and commits directly to the server +without having to go over the network. This is particularly useful for +container usecases (e.g. kubernetes) where it is possible to run an IO +job local to the server. + +The performance advantage realized from localio's ability to bypass +using XDR and RPC for reads, writes and commits can be extreme, e.g.: +fio for 20 secs with 24 libaio threads, 64k directio reads, qd of 8, +- With localio: + read: IOPS=691k, BW=42.2GiB/s (45.3GB/s)(843GiB/20002msec) +- Without localio: + read: IOPS=15.7k, BW=984MiB/s (1032MB/s)(19.2GiB/20013msec) + +RPC +--- + +The LOCALIO auxiliary RPC protocol consists of a single "GETUUID" RPC +method that allows the Linux NFS client to retrieve a Linux NFS server's +uuid. This protocol isn't part of an IETF standard, nor does it need to +be considering it is Linux-to-Linux auxiliary RPC protocol that amounts +to an implementation detail. + +The GETUUID method encodes the server's uuid_t in terms of the fixed +UUID_SIZE (16 bytes). The fixed size opaque encode and decode XDR +methods are used instead of the less efficient variable sized methods. + +The RPC program number for the NFS_LOCALIO_PROGRAM is 400122 (as assigned +by IANA, see https://www.iana.org/assignments/rpc-program-numbers/ ): +Linux Kernel Organization 400122 nfslocalio + +The LOCALIO protocol spec in rpcgen syntax is: + +/* raw RFC 9562 UUID */ +#define UUID_SIZE 16 +typedef u8 uuid_t<UUID_SIZE>; + +program NFS_LOCALIO_PROGRAM { + version LOCALIO_V1 { + void + NULL(void) = 0; + + uuid_t + GETUUID(void) = 1; + } = 1; +} = 400122; + +LOCALIO uses the same transport connection as NFS traffic. As such, +LOCALIO is not registered with rpcbind. + +Once an NFS client and server handshake as "local", the client will +bypass the network RPC protocol for read, write and commit operations. +Due to this XDR and RPC bypass, these operations will operate faster. + +NFS Common and Server +--------------------- + +First use is in nfsd, to add access to a global nfsd_uuids list in +nfs_common that is used to register and then identify local nfsd +instances. + +nfsd_uuids is protected by the nfsd_mutex or RCU read lock and is +composed of nfsd_uuid_t instances that are managed as nfsd creates them +(per network namespace). + +nfsd_uuid_is_local() and nfsd_uuid_lookup() are used to search all local +nfsd for the client specified nfsd uuid. + +The nfsd_uuids list is the basis for localio enablement, as such it has +members that point to nfsd memory for direct use by the client +(e.g. 'net' is the server's network namespace, through it the client can +access nn->nfsd_serv with proper rcu read access). It is this client +and server synchronization that enables advanced usage and lifetime of +objects to span from the host kernel's nfsd to per-container knfsd +instances that are connected to nfs client's running on the same local +host. + +NFS Client +---------- + +fs/nfs/localio.c:nfs_local_probe() will retrieve a server's uuid via +LOCALIO protocol and check if the server with that uuid is known to be +local. This ensures client and server 1: support localio 2: are local +to each other. + +See fs/nfs/localio.c:nfs_local_open_fh() and +fs/nfsd/localio.c:nfsd_open_local_fh() for the interface that makes +focused use of nfsd_uuid_t struct to allow a client local to a server to +open a file pointer without needing to go over the network. + +The client's fs/nfs/localio.c:nfs_local_open_fh() will call into the +server's fs/nfsd/localio.c:nfsd_open_local_fh() and carefully access +both the nfsd network namespace and the associated nn->nfsd_serv in +terms of RCU. If nfsd_open_local_fh() finds that client no longer sees +valid nfsd objects (be it struct net or nn->nfsd_serv) it returns ENXIO +to nfs_local_open_fh() and the client will try to reestablish the +LOCALIO resources needed by calling nfs_local_probe() again. This +recovery is needed if/when an nfsd instance running in a container were +to reboot while a localio client is connected to it. + +Testing +------- + +The LOCALIO auxiliary protocol and associated NFS localio read, write +and commit access have proven stable against various test scenarios but +these have not yet been formalized in any testsuite: + +- Client and server both on localhost (for both v3 and v4.2). + +- Various permutations of client and server support enablement for + both local and remote client and server. Testing against NFS storage + products that don't support the LOCALIO protocol was also performed. + +- Client on host, server within a container (for both v3 and v4.2) + The container testing was in terms of podman managed containers and + includes container stop/restart scenario.
include/linux/nfslocalio.h +2 -0
@@ -20,6 +20,8 @@ extern struct list_head nfsd_uuids;* Each nfsd instance has an nfsd_uuid_t that is accessible through the * global nfsd_uuids list. Useful to allow a client to negotiate if localio * possible with its server. +* +* See Documentation/filesystems/nfs/localio.rst for more detail. */ typedef struct { uuid_t uuid;
Signature · 1 line
2.44.0
Jeff Layton
maintainerRe: [PATCH v7 19/20] nfs: add Documentation/filesystems/nfs/localio.rst
Quoted 34 lines · Mike Snitzer
This document gives an overview of the LOCALIO auxiliary RPC protocol added to the Linux NFS client and server (both v3 and v4) to allow a client and server to reliably handshake to determine if they are on the same host. The LOCALIO auxiliary protocol's implementation, which uses the same connection as NFS traffic, follows the pattern established by the NFS ACL protocol extension.
The robust handshake between local client and server is just the beginning, the ultimate usecase this locality makes possible is the client is able to issue reads, writes and commits directly to the server without having to go over the network. This is particularly useful for container usecases (e.g. kubernetes) where it is possible to run an IO job local to the server.
Signed-off-by Mike Snitzer <[email protected]>---
Documentation/filesystems/nfs/localio.rst | 134 ++++++++++++++++++++++ include/linux/nfslocalio.h | 2 +2 files changed, 136 insertions(+)create mode 100644
Documentation/filesystems/nfs/localio.rstDocumentation/filesystems/nfs/localio.rst new file +7
-0@@ -0,0 +1,134 @@ +=========== +NFS localio +=========== + +This document gives an overview of the LOCALIO auxiliary RPC protocol +added to the Linux NFS client and server (both v3 and v4) to allow a +client and server to reliably handshake to determine if they are on the
Documentation/filesystems/nfs/localio.rst line 17
Quoted 10 lines
Documentation/filesystems/nfs/localio.rst new file +10
-0+same host. The LOCALIO auxiliary protocol's implementation, which uses +the same connection as NFS traffic, follows the pattern established by +the NFS ACL protocol extension. + +The LOCALIO auxiliary protocol is needed to allow robust discovery of +clients local to their servers. Prior to this LOCALIO protocol a +fragile sockaddr network address based match against all local network +interfaces was attempted. But unlike the LOCALIO protocol, the +sockaddr-based matching didn't handle use of iptables or containers. +
The above paragraph sounds like there was an earlier implementation in mainline kernels that used address matching. It might be good to point out that that was a private implementation.
Quoted 22 lines
Documentation/filesystems/nfs/localio.rst new file +22
-0+The robust handshake between local client and server is just the +beginning, the ultimate usecase this locality makes possible is the +client is able to issue reads, writes and commits directly to the server +without having to go over the network. This is particularly useful for +container usecases (e.g. kubernetes) where it is possible to run an IO +job local to the server. + +The performance advantage realized from localio's ability to bypass +using XDR and RPC for reads, writes and commits can be extreme, e.g.: +fio for 20 secs with 24 libaio threads, 64k directio reads, qd of 8, +- With localio: + read: IOPS=691k, BW=42.2GiB/s (45.3GB/s)(843GiB/20002msec) +- Without localio: + read: IOPS=15.7k, BW=984MiB/s (1032MB/s)(19.2GiB/20013msec) + +RPC +--- + +The LOCALIO auxiliary RPC protocol consists of a single "GETUUID" RPC +method that allows the Linux NFS client to retrieve a Linux NFS server's +uuid. This protocol isn't part of an IETF standard, nor does it need to +be considering it is Linux-to-Linux auxiliary RPC protocol that amounts
Documentation/filesystems/nfs/localio.rst line 49
Quoted 10 lines
Documentation/filesystems/nfs/localio.rst new file +10
-0+to an implementation detail. + +The GETUUID method encodes the server's uuid_t in terms of the fixed +UUID_SIZE (16 bytes). The fixed size opaque encode and decode XDR +methods are used instead of the less efficient variable sized methods. + +The RPC program number for the NFS_LOCALIO_PROGRAM is 400122 (as assigned +by IANA, see https://www.iana.org/assignments/rpc-program-numbers/ ): +Linux Kernel Organization 400122 nfslocalio +
Nice! Glad this got officially registered fast.
Quoted 20 lines
Documentation/filesystems/nfs/localio.rst new file +20
-0+The LOCALIO protocol spec in rpcgen syntax is: + +/* raw RFC 9562 UUID */ +#define UUID_SIZE 16 +typedef u8 uuid_t<UUID_SIZE>; + +program NFS_LOCALIO_PROGRAM { + version LOCALIO_V1 { + void + NULL(void) = 0; + + uuid_t + GETUUID(void) = 1; + } = 1; +} = 400122; + +LOCALIO uses the same transport connection as NFS traffic. As such, +LOCALIO is not registered with rpcbind. + +Once an NFS client and server handshake as "local", the client will
Documentation/filesystems/nfs/localio.rst line 79
Quoted 10 lines
Documentation/filesystems/nfs/localio.rst new file +10
-0+bypass the network RPC protocol for read, write and commit operations. +Due to this XDR and RPC bypass, these operations will operate faster. + +NFS Common and Server +--------------------- + +First use is in nfsd, to add access to a global nfsd_uuids list in +nfs_common that is used to register and then identify local nfsd +instances. +
First use of what? This sentence doesn't parse well.
Quoted 68 lines
Documentation/filesystems/nfs/localio.rst new file +55
-0+nfsd_uuids is protected by the nfsd_mutex or RCU read lock and is +composed of nfsd_uuid_t instances that are managed as nfsd creates them +(per network namespace). + +nfsd_uuid_is_local() and nfsd_uuid_lookup() are used to search all local +nfsd for the client specified nfsd uuid. + +The nfsd_uuids list is the basis for localio enablement, as such it has +members that point to nfsd memory for direct use by the client +(e.g. 'net' is the server's network namespace, through it the client can +access nn->nfsd_serv with proper rcu read access). It is this client +and server synchronization that enables advanced usage and lifetime of +objects to span from the host kernel's nfsd to per-container knfsd +instances that are connected to nfs client's running on the same local +host. + +NFS Client +---------- + +fs/nfs/localio.c:nfs_local_probe() will retrieve a server's uuid via +LOCALIO protocol and check if the server with that uuid is known to be +local. This ensures client and server 1: support localio 2: are local +to each other. + +See fs/nfs/localio.c:nfs_local_open_fh() and +fs/nfsd/localio.c:nfsd_open_local_fh() for the interface that makes +focused use of nfsd_uuid_t struct to allow a client local to a server to +open a file pointer without needing to go over the network. + +The client's fs/nfs/localio.c:nfs_local_open_fh() will call into the +server's fs/nfsd/localio.c:nfsd_open_local_fh() and carefully access +both the nfsd network namespace and the associated nn->nfsd_serv in +terms of RCU. If nfsd_open_local_fh() finds that client no longer sees +valid nfsd objects (be it struct net or nn->nfsd_serv) it returns ENXIO +to nfs_local_open_fh() and the client will try to reestablish the +LOCALIO resources needed by calling nfs_local_probe() again. This +recovery is needed if/when an nfsd instance running in a container were +to reboot while a localio client is connected to it. + +Testing +------- + +The LOCALIO auxiliary protocol and associated NFS localio read, write +and commit access have proven stable against various test scenarios but +these have not yet been formalized in any testsuite: + +- Client and server both on localhost (for both v3 and v4.2). + +- Various permutations of client and server support enablement for + both local and remote client and server. Testing against NFS storage + products that don't support the LOCALIO protocol was also performed. + +- Client on host, server within a container (for both v3 and v4.2) + The container testing was in terms of podman managed containers and + includes container stop/restart scenario.include/linux/nfslocalio.h +2
-0@@ -20,6 +20,8 @@ extern struct list_head nfsd_uuids;* Each nfsd instance has an nfsd_uuid_t that is accessible through the * global nfsd_uuids list. Useful to allow a client to negotiate if localio * possible with its server. +* +* See Documentation/filesystems/nfs/localio.rst for more detail. */ typedef struct { uuid_t uuid;
Signature · 1 line
Jeff Layton <[email protected]>
PATCH v7 20/20 nfs/nfsd: add Kconfig options to allow localio to be enabled
In reply to Mike SnitzerNow that all the localio code is complete, allow users to enable it.
CONFIG_NFS_LOCALIO controls the client enablement and CONFIG_NFSD_LOCALIO the server enablement.
While it is true that it doesn't make sense, on a using LOCALIO level, to have one without the other: it is useful to allow a mix be configured for testing purposes. It could be that the same control could be achieved by exposing a discrete "localio_enabled" module_param in the server (nfsd.ko) like is already available in the client (nfs.ko).
--- fs/Kconfig | 3 +++ fs/nfs/Kconfig | 14 ++++++++++++++ fs/nfsd/Kconfig | 14 ++++++++++++++ 3 files changed, 31 insertions(+)
fs/Kconfig +3 -0
@@ -377,6 +377,9 @@ config NFS_ACL_SUPPORT tristate select FS_POSIX_ACL +config NFS_COMMON_LOCALIO_SUPPORT + tristate + config NFS_COMMON bool depends on NFSD || NFS_FS || LOCKD
fs/nfs/Kconfig +14 -0
@@ -86,6 +86,20 @@ config NFS_V4 If unsure, say Y. +config NFS_LOCALIO + tristate "NFS client support for the LOCALIO auxiliary protocol" + depends on NFS_V3 || NFS_V4 + select NFS_COMMON_LOCALIO_SUPPORT + help + Some NFS servers support an auxiliary NFS LOCALIO protocol + that is not an official part of the NFS version 3 or 4 protocol. + + This option enables support for the LOCALIO protocol in the + kernel's NFS client. Enable this to bypass using the NFS + protocol when issuing reads, writes and commits to the server. + + If unsure, say N. + config NFS_SWAP bool "Provide swap over NFS support" default n
fs/nfsd/Kconfig +14 -0
@@ -89,6 +89,20 @@ config NFSD_V4 If unsure, say N. +config NFSD_LOCALIO + tristate "NFS server support for the LOCALIO auxiliary protocol" + depends on NFSD || NFSD_V4 + select NFS_COMMON_LOCALIO_SUPPORT + help + Some NFS servers support an auxiliary NFS LOCALIO protocol + that is not an official part of the NFS version 3 or 4 protocol. + + This option enables support for the LOCALIO protocol in the + kernel's NFS server. Enable this to bypass using the NFS + protocol when issuing reads, writes and commits to the server. + + If unsure, say N. + config NFSD_PNFS bool
Signature · 1 line
2.44.0
Quoted 123 lines · Mike Snitzer
Hi,
IANA has assigned the RPC program number 400122 for localio!
Tested with xfstests, all is passing agsint NFS v3 and v4.2 (localio ontop of XFS) except generic/355 (which tests if suid bit gets cleared
with directio).My git tree is here:
https://git.kernel.org/pub/scm/linux/kernel/git/snitzer/linux.git/This v7 is both branch nfs-localio-for-6.11 (always tracks latest) and nfs-localio-for-6.11.v7
Quite a bit has changed since v6:
- Updated to use IANA assigned RPC program number 400122.
- Thanks to Neil the localio protocol stands on its own and is simplified, all of Neil's changes were included. But a patch is needed to sunrpc to remove theBUG_ONifp_arglenis 0 (otherwise the NULL rpc used during connection triggers theBUG_ON.
- ReducedKconfigknobs down toNFS_LOCALIOandNFSD_LOCALIO. Left them piece-wise for reason detailed in the last patch.
- AddedMODULE_DESCRIPTIONtonfs_localiomodule.
- Removed all the AIO directio code fromfs/nfs/localio.cbecause it wasn't used (since nothing ever set NFS_IOHDR_ODIRECT). But even if
enabled the async kiocb completion wasn't ever used in practice.TODO:
- For directio, fix kiocb so that it conveysIOCB_DIRECTto underlying
filesystem.
- Must fix xfstests generic/355.
- Look closer at implementing standlone SRCU to avoid bloatingnfsd_net-- idea of shared SRCU is very unintuitive to me...FYI:
- Really rather not play games with 'localio_enabled' to get all of localio code to build but be disabled by default.. just too fiddley.All review and comments are welcome!
Thanks,
MikeMike Snitzer (11):
nfs_common: add NFS LOCALIO auxiliary protocol enablement nfsd/localio: manage netns reference innfsd_open_local_fhnfs/nfsd: factor out {encode,decode}_opaque_fixed tonfs_xdr.h
SUNRPC: removecall_allocate()BUG_ONif p_arglen=0 to allow RPC with void arg
nfs: implement client support forNFS_LOCALIO_PROGRAM
nfsd: implement server support forNFS_LOCALIO_PROGRAM
nfsd: prepare to use SRCU to dereferencenn->nfsd_serv
nfsd: use SRCU to dereferencenn->nfsd_servnfsd/localio: use SRCU to dereferencenn->nfsd_servinnfsd_open_local_fh
nfs: addDocumentation/filesystems/nfs/localio.rstnfs/nfsd: addKconfigoptions to allow localio to be enabledNeilBrown (1):
SUNRPC: replace program list with program arrayTrond Myklebust (3):
NFS: Enable localio for non-pNFS I/O
pnfs/flexfiles: Enable localio for flexfiles I/O nfs/localio: use dedicated workqueues for filesystem read and writeWeston Andros Adamson (5):
nfs: passnfs_clienttonfs_initiate_pgio
nfs: pass descriptor thrunfs_initiate_pgiopath
nfs: pass struct file tonfs_init_pgioandnfs_init_commit
sunrpc: addrpcauth_map_to_svc_cred_localnfs/nfsd: add "localio" supportDocumentation/filesystems/nfs/localio.rst | 134 ++++ fs/Kconfig | 3 + fs/nfs/Kconfig | 14 + fs/nfs/Makefile | 1 + fs/nfs/blocklayout/blocklayout.c | 6 +- fs/nfs/client.c | 15 +- fs/nfs/filelayout/filelayout.c | 16 +- fs/nfs/flexfilelayout/flexfilelayout.c | 131 +++- fs/nfs/flexfilelayout/flexfilelayout.h | 2 +
fs/nfs/flexfilelayout/flexfilelayoutdev.c| 6 + fs/nfs/inode.c | 61 +- fs/nfs/internal.h | 61 +- fs/nfs/localio.c | 851
++++++++++++++++++++++
fs/nfs/nfs4xdr.c | 13 - fs/nfs/nfstrace.h | 61 ++ fs/nfs/pagelist.c | 32 +- fs/nfs/pnfs.c | 24 +- fs/nfs/pnfs.h | 6 +- fs/nfs/pnfs_nfs.c | 2 +- fs/nfs/write.c | 13 +- fs/nfs_common/Makefile | 3 + fs/nfs_common/nfslocalio.c | 72 ++ fs/nfsd/Kconfig | 14 + fs/nfsd/Makefile | 1 + fs/nfsd/filecache.c | 15 +- fs/nfsd/localio.c | 327 +++++++++ fs/nfsd/netns.h | 18 +- fs/nfsd/nfs4state.c | 25 +- fs/nfsd/nfsctl.c | 30 +- fs/nfsd/nfsd.h | 2 +- fs/nfsd/nfssvc.c | 165 +++-- fs/nfsd/trace.h | 3 +- fs/nfsd/vfs.h | 9 + include/linux/nfs.h | 9 + include/linux/nfs_fs.h | 2 + include/linux/nfs_fs_sb.h | 10 + include/linux/nfs_xdr.h | 20 +- include/linux/nfslocalio.h | 41 ++ include/linux/sunrpc/auth.h | 4 + include/linux/sunrpc/svc.h | 7 +- net/sunrpc/auth.c | 15 + net/sunrpc/clnt.c | 1 - net/sunrpc/svc.c | 68 +- net/sunrpc/svc_xprt.c | 2 +- net/sunrpc/svcauth_unix.c | 3 +-
Quoted 7 lines
45 files changed, 2116 insertions(+), 202 deletions(-)create mode 100644
Documentation/filesystems/nfs/localio.rstcreate mode 100644fs/nfs/localio.c
create mode 100644fs/nfs_common/nfslocalio.ccreate mode 100644fs/nfsd/localio.c
create mode 100644include/linux/nfslocalio.h
This is looking pretty good now! I know Chuck noted some nits and I'm still hung up on the making nfsd_serv a void *, but I don't see it as a show stopper and we can always fix that later. You can add: