Revamp the old NFS server's File Handle Affinity (FHA) code so that

it will work with either the old or new server.

The FHA code keeps a cache of currently active file handles for
NFSv2 and v3 requests, so that read and write requests for the same
file are directed to the same group of threads (reads) or thread
(writes).  It does not currently work for NFSv4 requests.  They are
more complex, and will take more work to support.

This improves read-ahead performance, especially with ZFS, if the
FHA tuning parameters are configured appropriately.  Without the
FHA code, concurrent reads that are part of a sequential read from
a file will be directed to separate NFS threads.  This has the
effect of confusing the ZFS zfetch (prefetch) code and makes
sequential reads significantly slower with clients like Linux that
do a lot of prefetching.

The FHA code has also been updated to direct write requests to nearby
file offsets to the same thread in the same way it batches reads,
and the FHA code will now also send writes to multiple threads when
needed.

This improves sequential write performance in ZFS, because writes
to a file are now more ordered.  Since NFS writes (generally
less than 64K) are smaller than the typical ZFS record size
(usually 128K), out of order NFS writes to the same block can
trigger a read in ZFS.  Sending them down the same thread increases
the odds of their being in order.

In order for multiple write threads per file in the FHA code to be
useful, writes in the NFS server have been changed to use a LK_SHARED
vnode lock, and upgrade that to LK_EXCLUSIVE if the filesystem
doesn't allow multiple writers to a file at once.  ZFS is currently
the only filesystem that allows multiple writers to a file, because
it has internal file range locking.  This change does not affect the
NFSv4 code.

This improves random write performance to a single file in ZFS, since
we can now have multiple writers inside ZFS at one time.

I have changed the default tuning parameters to a 22 bit (4MB)
window size (from 256K) and unlimited commands per thread as a
result of my benchmarking with ZFS.

The FHA code has been updated to allow configuring the tuning
parameters from loader tunable variables in addition to sysctl
variables.  The read offset window calculation has been slightly
modified as well.  Instead of having separate bins, each file
handle has a rolling window of bin_shift size.  This minimizes
glitches in throughput when shifting from one bin to another.

sys/conf/files:
	Add nfs_fha_new.c and nfs_fha_old.c.  Compile nfs_fha.c
	when either the old or the new NFS server is built.

sys/fs/nfs/nfsport.h,
sys/fs/nfs/nfs_commonport.c:
	Bring in changes from Rick Macklem to newnfs_realign that
	allow it to operate in blocking (M_WAITOK) or non-blocking
	(M_NOWAIT) mode.

sys/fs/nfs/nfs_commonsubs.c,
sys/fs/nfs/nfs_var.h:
	Bring in a change from Rick Macklem to allow telling
	nfsm_dissect() whether or not to wait for mallocs.

sys/fs/nfs/nfsm_subs.h:
	Bring in changes from Rick Macklem to create a new
	nfsm_dissect_nonblock() inline function and
	NFSM_DISSECT_NONBLOCK() macro.

sys/fs/nfs/nfs_commonkrpc.c,
sys/fs/nfsclient/nfs_clkrpc.c:
	Add the malloc wait flag to a newnfs_realign() call.

sys/fs/nfsserver/nfs_nfsdkrpc.c:
	Setup the new NFS server's RPC thread pool so that it will
	call the FHA code.

	Add the malloc flag argument to newnfs_realign().

	Unstaticize newnfs_nfsv3_procid[] so that we can use it in
	the FHA code.

sys/fs/nfsserver/nfs_nfsdsocket.c:
	In nfsrvd_dorpc(), add NFSPROC_WRITE to the list of RPC types
	that use the LK_SHARED lock type.

sys/fs/nfsserver/nfs_nfsdport.c:
	In nfsd_fhtovp(), if we're starting a write, check to see
	whether the underlying filesystem supports shared writes.
	If not, upgrade the lock type from LK_SHARED to LK_EXCLUSIVE.

sys/nfsserver/nfs_fha.c:
	Remove all code that is specific to the NFS server
	implementation.  Anything that is server-specific is now
	accessed through a callback supplied by that server's FHA
	shim in the new softc.

	There are now separate sysctls and tunables for the FHA
	implementations for the old and new NFS servers.  The new
	NFS server has its tunables under vfs.nfsd.fha, the old
	NFS server's tunables are under vfs.nfsrv.fha as before.

	In fha_extract_info(), use callouts for all server-specific
	code.  Getting file handles and offsets is now done in the
	individual server's shim module.

	In fha_hash_entry_choose_thread(), change the way we decide
	whether two reads are in proximity to each other.
	Previously, the calculation was a simple shift operation to
	see whether the offsets were in the same power of 2 bucket.
	The issue was that there would be a bucket (and therefore
	thread) transition, even if the reads were in close
	proximity.  When there is a thread transition, reads wind
	up going somewhat out of order, and ZFS gets confused.

	The new calculation simply tries to see whether the offsets
	are within 1 << bin_shift of each other.  If they are, the
	reads will be sent to the same thread.

	The effect of this change is that for sequential reads, if
	the client doesn't exceed the max_reqs_per_nfsd parameter
	and the bin_shift is set to a reasonable value (22, or
	4MB works well in my tests), the reads in any sequential
	stream will largely be confined to a single thread.

	Change fha_assign() so that it takes a softc argument.  It
	is now called from the individual server's shim code, which
	will pass in the softc.

	Change fhe_stats_sysctl() so that it takes a softc
	parameter.  It is now called from the individual server's
	shim code.  Add the current offset to the list of things
	printed out about each active thread.

	Change the num_reads and num_writes counters in the
	fha_hash_entry structure to 32-bit values, and rename them
	num_rw and num_exclusive, respectively, to reflect their
	changed usage.

	Add an enable sysctl and tunable that allows the user to
	disable the FHA code (when vfs.XXX.fha.enable = 0).  This
	is useful for before/after performance comparisons.

nfs_fha.h:
	Move most structure definitions out of nfs_fha.c and into
	the header file, so that the individual server shims can
	see them.

	Change the default bin_shift to 22 (4MB) instead of 18
	(256K).  Allow unlimited commands per thread.

sys/nfsserver/nfs_fha_old.c,
sys/nfsserver/nfs_fha_old.h,
sys/fs/nfsserver/nfs_fha_new.c,
sys/fs/nfsserver/nfs_fha_new.h:
	Add shims for the old and new NFS servers to interface with
	the FHA code, and callbacks for the

	The shims contain all of the code and definitions that are
	specific to the NFS servers.

	They setup the server-specific callbacks and set the server
	name for the sysctl and loader tunable variables.

sys/nfsserver/nfs_srvkrpc.c:
	Configure the RPC code to call fhaold_assign() instead of
	fha_assign().

sys/modules/nfsd/Makefile:
	Add nfs_fha.c and nfs_fha_new.c.

sys/modules/nfsserver/Makefile:
	Add nfs_fha_old.c.

Reviewed by:	rmacklem
Sponsored by:	Spectra Logic
MFC after:	2 weeks

1 files changed, 272 insertions, 0 deletions

diff --git a/sys/fs/nfsserver/nfs_fha_new.c b/sys/fs/nfsserver/nfs_fha_new.c
new file mode 100644
index 0000000..7e461e7
--- /dev/null
+++ b/sys/fs/nfsserver/nfs_fha_new.c
@@ -0,0 +1,272 @@
+/*-
+ * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
+ * Copyright (c) 2013 Spectra Logic Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <fs/nfs/nfsport.h>
+
+#include <rpc/rpc.h>
+#include <fs/nfs/xdr_subs.h>
+#include <fs/nfs/nfs.h>
+#include <fs/nfs/nfsproto.h>
+#include <fs/nfs/nfsm_subs.h>
+#include <nfsserver/nfs_fha.h>
+#include <fs/nfsserver/nfs_fha_new.h>
+
+static void fhanew_init(void *foo);
+static void fhanew_uninit(void *foo);
+rpcproc_t fhanew_get_procnum(rpcproc_t procnum);
+int fhanew_realign(struct mbuf **mb, int malloc_flags);
+int fhanew_get_fh(fhandle_t *fh, int v3, struct mbuf **md, caddr_t *dpos);
+int fhanew_is_read(rpcproc_t procnum);
+int fhanew_is_write(rpcproc_t procnum);
+int fhanew_get_offset(struct mbuf **md, caddr_t *dpos, int v3,
+		      struct fha_info *info);
+int fhanew_no_offset(rpcproc_t procnum);
+void fhanew_set_locktype(rpcproc_t procnum, struct fha_info *info);
+static int fhenew_stats_sysctl(SYSCTL_HANDLER_ARGS);
+
+static struct fha_params fhanew_softc;
+
+SYSCTL_DECL(_vfs_nfsd);
+
+extern int newnfs_nfsv3_procid[];
+extern SVCPOOL	*nfsrvd_pool;
+
+SYSINIT(nfs_fhanew, SI_SUB_ROOT_CONF, SI_ORDER_ANY, fhanew_init, NULL);
+SYSUNINIT(nfs_fhanew, SI_SUB_ROOT_CONF, SI_ORDER_ANY, fhanew_uninit, NULL);
+
+static void
+fhanew_init(void *foo)
+{
+	struct fha_params *softc;
+
+	softc = &fhanew_softc;
+
+	bzero(softc, sizeof(*softc));
+
+	/*
+	 * Setup the callbacks for this FHA personality.
+	 */
+	softc->callbacks.get_procnum = fhanew_get_procnum;
+	softc->callbacks.realign = fhanew_realign;
+	softc->callbacks.get_fh = fhanew_get_fh;
+	softc->callbacks.is_read = fhanew_is_read;
+	softc->callbacks.is_write = fhanew_is_write;
+	softc->callbacks.get_offset = fhanew_get_offset;
+	softc->callbacks.no_offset = fhanew_no_offset;
+	softc->callbacks.set_locktype = fhanew_set_locktype;
+	softc->callbacks.fhe_stats_sysctl = fhenew_stats_sysctl;
+
+	snprintf(softc->server_name, sizeof(softc->server_name),
+	    FHANEW_SERVER_NAME);
+
+	softc->pool = &nfsrvd_pool;
+
+	/*
+	 * Initialize the sysctl context list for the fha module.
+	 */
+	sysctl_ctx_init(&softc->sysctl_ctx);
+	softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
+	    SYSCTL_STATIC_CHILDREN(_vfs_nfsd), OID_AUTO, "fha", CTLFLAG_RD,
+	    0, "fha node");
+	if (softc->sysctl_tree == NULL) {
+		printf("%s: unable to allocate sysctl tree\n", __func__);
+		return;
+	}
+
+	fha_init(softc);
+}
+
+static void
+fhanew_uninit(void *foo)
+{
+	struct fha_params *softc;
+
+	softc = &fhanew_softc;
+
+	fha_uninit(softc);
+}
+
+rpcproc_t
+fhanew_get_procnum(rpcproc_t procnum)
+{
+	if (procnum > NFSV2PROC_STATFS)
+		return (-1);
+
+	return (newnfs_nfsv3_procid[procnum]);
+}
+
+int
+fhanew_realign(struct mbuf **mb, int malloc_flags)
+{
+	return (newnfs_realign(mb, malloc_flags));
+}
+
+int
+fhanew_get_fh(fhandle_t *fh, int v3, struct mbuf **md, caddr_t *dpos)
+{
+	struct nfsrv_descript lnd, *nd;
+	uint32_t *tl;
+	int error, len;
+
+	error = 0;
+	len = 0;
+	nd = &lnd;
+
+	nd->nd_md = *md;
+	nd->nd_dpos = *dpos;
+
+	if (v3) {
+		NFSM_DISSECT_NONBLOCK(tl, uint32_t *, NFSX_UNSIGNED);
+		if ((len = fxdr_unsigned(int, *tl)) <= 0 || len > NFSX_FHMAX) {
+			error = EBADRPC;
+			goto nfsmout;
+		}
+	} else {
+		len = NFSX_V2FH;
+	}
+
+	if (len != 0) {
+		NFSM_DISSECT_NONBLOCK(tl, uint32_t *, len);
+		bcopy(tl, fh, len);
+	} else
+		bzero(fh, sizeof(*fh));
+
+nfsmout:
+	*md = nd->nd_md;
+	*dpos = nd->nd_dpos;
+
+	return (error);
+}
+
+int
+fhanew_is_read(rpcproc_t procnum)
+{
+	if (procnum == NFSPROC_READ)
+		return (1);
+	else
+		return (0);
+}
+
+int
+fhanew_is_write(rpcproc_t procnum)
+{
+	if (procnum == NFSPROC_WRITE)
+		return (1);
+	else
+		return (0);
+}
+
+int
+fhanew_get_offset(struct mbuf **md, caddr_t *dpos, int v3,
+		  struct fha_info *info)
+{
+	struct nfsrv_descript lnd, *nd;
+	uint32_t *tl;
+	int error;
+
+	error = 0;
+
+	nd = &lnd;
+	nd->nd_md = *md;
+	nd->nd_dpos = *dpos;
+
+	if (v3) {
+		NFSM_DISSECT_NONBLOCK(tl, uint32_t *, 2 * NFSX_UNSIGNED);
+		info->offset = fxdr_hyper(tl);
+	} else {
+		NFSM_DISSECT_NONBLOCK(tl, uint32_t *, NFSX_UNSIGNED);
+		info->offset = fxdr_unsigned(uint32_t, *tl);
+	}
+
+nfsmout:
+	*md = nd->nd_md;
+	*dpos = nd->nd_dpos;
+
+	return (error);
+}
+
+int
+fhanew_no_offset(rpcproc_t procnum)
+{
+	if (procnum == NFSPROC_FSSTAT ||
+	    procnum == NFSPROC_FSINFO ||
+	    procnum == NFSPROC_PATHCONF ||
+	    procnum == NFSPROC_NOOP ||
+	    procnum == NFSPROC_NULL)
+		return (1);
+	else
+		return (0);
+}
+
+void
+fhanew_set_locktype(rpcproc_t procnum, struct fha_info *info)
+{
+	switch (procnum) {
+	case NFSPROC_NULL:
+	case NFSPROC_GETATTR:
+	case NFSPROC_LOOKUP:
+	case NFSPROC_ACCESS:
+	case NFSPROC_READLINK:
+	case NFSPROC_READ:
+	case NFSPROC_READDIR:
+	case NFSPROC_READDIRPLUS:
+	case NFSPROC_WRITE:
+		info->locktype = LK_SHARED;
+		break;
+	case NFSPROC_SETATTR:
+	case NFSPROC_CREATE:
+	case NFSPROC_MKDIR:
+	case NFSPROC_SYMLINK:
+	case NFSPROC_MKNOD:
+	case NFSPROC_REMOVE:
+	case NFSPROC_RMDIR:
+	case NFSPROC_RENAME:
+	case NFSPROC_LINK:
+	case NFSPROC_FSSTAT:
+	case NFSPROC_FSINFO:
+	case NFSPROC_PATHCONF:
+	case NFSPROC_COMMIT:
+	case NFSPROC_NOOP:
+		info->locktype = LK_EXCLUSIVE;
+		break;
+	}
+}
+
+static int
+fhenew_stats_sysctl(SYSCTL_HANDLER_ARGS)
+{
+	return (fhe_stats_sysctl(oidp, arg1, arg2, req, &fhanew_softc));
+}
+
+
+SVCTHREAD *
+fhanew_assign(SVCTHREAD *this_thread, struct svc_req *req)
+{
+	return (fha_assign(this_thread, req, &fhanew_softc));
+}