2019-05-19 20:08:55 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2007-12-31 11:07:15 +08:00
|
|
|
/*
|
|
|
|
* linux/net/sunrpc/svc_xprt.c
|
|
|
|
*
|
|
|
|
* Author: Tom Tucker <tom@opengridcomputing.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/freezer.h>
|
2008-02-08 05:34:54 +08:00
|
|
|
#include <linux/kthread.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-12-31 11:07:15 +08:00
|
|
|
#include <net/sock.h>
|
2015-12-12 05:45:58 +08:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2007-12-31 11:07:15 +08:00
|
|
|
#include <linux/sunrpc/stats.h>
|
|
|
|
#include <linux/sunrpc/svc_xprt.h>
|
2009-04-23 08:18:19 +08:00
|
|
|
#include <linux/sunrpc/svcsock.h>
|
2010-12-09 01:45:44 +08:00
|
|
|
#include <linux/sunrpc/xprt.h>
|
2011-05-27 21:12:25 +08:00
|
|
|
#include <linux/module.h>
|
2015-12-12 05:45:58 +08:00
|
|
|
#include <linux/netdevice.h>
|
2014-10-29 02:24:12 +08:00
|
|
|
#include <trace/events/sunrpc.h>
|
2007-12-31 11:07:15 +08:00
|
|
|
|
|
|
|
#define RPCDBG_FACILITY RPCDBG_SVCXPRT
|
|
|
|
|
2016-06-24 22:55:50 +08:00
|
|
|
static unsigned int svc_rpc_per_connection_limit __read_mostly;
|
|
|
|
module_param(svc_rpc_per_connection_limit, uint, 0644);
|
|
|
|
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt);
|
|
|
|
static int svc_deferred_recv(struct svc_rqst *rqstp);
|
|
|
|
static struct cache_deferred_req *svc_defer(struct cache_req *req);
|
2017-10-17 08:29:42 +08:00
|
|
|
static void svc_age_temp_xprts(struct timer_list *t);
|
2011-11-26 07:44:05 +08:00
|
|
|
static void svc_delete_xprt(struct svc_xprt *xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/* apparently the "standard" is that clients close
|
|
|
|
* idle connections after 5 minutes, servers after
|
|
|
|
* 6 minutes
|
2019-06-19 04:43:11 +08:00
|
|
|
* http://nfsv4bat.org/Documents/ConnectAThon/1996/nfstcp.pdf
|
2007-12-31 11:08:27 +08:00
|
|
|
*/
|
|
|
|
static int svc_conn_age_period = 6*60;
|
|
|
|
|
2007-12-31 11:07:15 +08:00
|
|
|
/* List of registered transport classes */
|
|
|
|
static DEFINE_SPINLOCK(svc_xprt_class_lock);
|
|
|
|
static LIST_HEAD(svc_xprt_class_list);
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
/* SMP locking strategy:
|
|
|
|
*
|
|
|
|
* svc_pool->sp_lock protects most of the fields of that pool.
|
|
|
|
* svc_serv->sv_lock protects sv_tempsocks, sv_permsocks, sv_tmpcnt.
|
|
|
|
* when both need to be taken (rare), svc_serv->sv_lock is first.
|
2015-01-22 21:19:32 +08:00
|
|
|
* The "service mutex" protects svc_serv->sv_nrthread.
|
2007-12-31 11:08:27 +08:00
|
|
|
* svc_sock->sk_lock protects the svc_sock->sk_deferred list
|
|
|
|
* and the ->sk_info_authunix cache.
|
|
|
|
*
|
|
|
|
* The XPT_BUSY bit in xprt->xpt_flags prevents a transport being
|
|
|
|
* enqueued multiply. During normal transport processing this bit
|
|
|
|
* is set by svc_xprt_enqueue and cleared by svc_xprt_received.
|
|
|
|
* Providers should not manipulate this bit directly.
|
|
|
|
*
|
|
|
|
* Some flags can be set to certain values at any time
|
|
|
|
* providing that certain rules are followed:
|
|
|
|
*
|
|
|
|
* XPT_CONN, XPT_DATA:
|
|
|
|
* - Can be set or cleared at any time.
|
|
|
|
* - After a set, svc_xprt_enqueue must be called to enqueue
|
|
|
|
* the transport for processing.
|
|
|
|
* - After a clear, the transport must be read/accepted.
|
|
|
|
* If this succeeds, it must be set again.
|
|
|
|
* XPT_CLOSE:
|
|
|
|
* - Can set at any time. It is never cleared.
|
|
|
|
* XPT_DEAD:
|
|
|
|
* - Can only be set while XPT_BUSY is held which ensures
|
|
|
|
* that no other thread will be using the transport or will
|
|
|
|
* try to set XPT_DEAD.
|
|
|
|
*/
|
2007-12-31 11:07:15 +08:00
|
|
|
int svc_reg_xprt_class(struct svc_xprt_class *xcl)
|
|
|
|
{
|
|
|
|
struct svc_xprt_class *cl;
|
|
|
|
int res = -EEXIST;
|
|
|
|
|
|
|
|
dprintk("svc: Adding svc transport class '%s'\n", xcl->xcl_name);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&xcl->xcl_list);
|
|
|
|
spin_lock(&svc_xprt_class_lock);
|
|
|
|
/* Make sure there isn't already a class with the same name */
|
|
|
|
list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {
|
|
|
|
if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
list_add_tail(&xcl->xcl_list, &svc_xprt_class_list);
|
|
|
|
res = 0;
|
|
|
|
out:
|
|
|
|
spin_unlock(&svc_xprt_class_lock);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_reg_xprt_class);
|
|
|
|
|
|
|
|
void svc_unreg_xprt_class(struct svc_xprt_class *xcl)
|
|
|
|
{
|
|
|
|
dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
|
|
|
|
spin_lock(&svc_xprt_class_lock);
|
|
|
|
list_del_init(&xcl->xcl_list);
|
|
|
|
spin_unlock(&svc_xprt_class_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_unreg_xprt_class);
|
|
|
|
|
2020-03-28 00:15:39 +08:00
|
|
|
/**
|
|
|
|
* svc_print_xprts - Format the transport list for printing
|
|
|
|
* @buf: target buffer for formatted address
|
|
|
|
* @maxlen: length of target buffer
|
|
|
|
*
|
|
|
|
* Fills in @buf with a string containing a list of transport names, each name
|
|
|
|
* terminated with '\n'. If the buffer is too small, some entries may be
|
|
|
|
* missing, but it is guaranteed that all lines in the output buffer are
|
|
|
|
* complete.
|
|
|
|
*
|
|
|
|
* Returns positive length of the filled-in string.
|
2007-12-31 11:08:31 +08:00
|
|
|
*/
|
|
|
|
int svc_print_xprts(char *buf, int maxlen)
|
|
|
|
{
|
2010-10-06 03:30:19 +08:00
|
|
|
struct svc_xprt_class *xcl;
|
2007-12-31 11:08:31 +08:00
|
|
|
char tmpstr[80];
|
|
|
|
int len = 0;
|
|
|
|
buf[0] = '\0';
|
|
|
|
|
|
|
|
spin_lock(&svc_xprt_class_lock);
|
2010-10-06 03:30:19 +08:00
|
|
|
list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
|
2007-12-31 11:08:31 +08:00
|
|
|
int slen;
|
|
|
|
|
2020-03-28 00:15:39 +08:00
|
|
|
slen = snprintf(tmpstr, sizeof(tmpstr), "%s %d\n",
|
|
|
|
xcl->xcl_name, xcl->xcl_max_payload);
|
|
|
|
if (slen >= sizeof(tmpstr) || len + slen >= maxlen)
|
2007-12-31 11:08:31 +08:00
|
|
|
break;
|
|
|
|
len += slen;
|
|
|
|
strcat(buf, tmpstr);
|
|
|
|
}
|
|
|
|
spin_unlock(&svc_xprt_class_lock);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2007-12-31 11:07:46 +08:00
|
|
|
static void svc_xprt_free(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt =
|
|
|
|
container_of(kref, struct svc_xprt, xpt_ref);
|
|
|
|
struct module *owner = xprt->xpt_class->xcl_owner;
|
2010-09-27 17:58:42 +08:00
|
|
|
if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags))
|
|
|
|
svcauth_unix_info_release(xprt);
|
2019-04-10 00:13:37 +08:00
|
|
|
put_cred(xprt->xpt_cred);
|
2010-09-27 18:00:49 +08:00
|
|
|
put_net(xprt->xpt_net);
|
2010-12-09 01:45:44 +08:00
|
|
|
/* See comment on corresponding get in xs_setup_bc_tcp(): */
|
|
|
|
if (xprt->xpt_bc_xprt)
|
|
|
|
xprt_put(xprt->xpt_bc_xprt);
|
2016-05-18 00:38:21 +08:00
|
|
|
if (xprt->xpt_bc_xps)
|
|
|
|
xprt_switch_put(xprt->xpt_bc_xps);
|
2020-03-18 05:41:43 +08:00
|
|
|
trace_svc_xprt_free(xprt);
|
2007-12-31 11:07:46 +08:00
|
|
|
xprt->xpt_ops->xpo_free(xprt);
|
|
|
|
module_put(owner);
|
|
|
|
}
|
|
|
|
|
|
|
|
void svc_xprt_put(struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
kref_put(&xprt->xpt_ref, svc_xprt_free);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_put);
|
|
|
|
|
2007-12-31 11:07:15 +08:00
|
|
|
/*
|
|
|
|
* Called by transport drivers to initialize the transport independent
|
|
|
|
* portion of the transport instance.
|
|
|
|
*/
|
2011-12-06 19:19:10 +08:00
|
|
|
void svc_xprt_init(struct net *net, struct svc_xprt_class *xcl,
|
|
|
|
struct svc_xprt *xprt, struct svc_serv *serv)
|
2007-12-31 11:07:15 +08:00
|
|
|
{
|
|
|
|
memset(xprt, 0, sizeof(*xprt));
|
|
|
|
xprt->xpt_class = xcl;
|
|
|
|
xprt->xpt_ops = xcl->xcl_ops;
|
2007-12-31 11:07:46 +08:00
|
|
|
kref_init(&xprt->xpt_ref);
|
2007-12-31 11:07:50 +08:00
|
|
|
xprt->xpt_server = serv;
|
2007-12-31 11:07:53 +08:00
|
|
|
INIT_LIST_HEAD(&xprt->xpt_list);
|
|
|
|
INIT_LIST_HEAD(&xprt->xpt_ready);
|
2007-12-31 11:08:10 +08:00
|
|
|
INIT_LIST_HEAD(&xprt->xpt_deferred);
|
2010-03-23 03:37:17 +08:00
|
|
|
INIT_LIST_HEAD(&xprt->xpt_users);
|
2007-12-31 11:07:59 +08:00
|
|
|
mutex_init(&xprt->xpt_mutex);
|
2007-12-31 11:08:08 +08:00
|
|
|
spin_lock_init(&xprt->xpt_lock);
|
2007-12-31 11:08:20 +08:00
|
|
|
set_bit(XPT_BUSY, &xprt->xpt_flags);
|
2011-12-06 19:19:10 +08:00
|
|
|
xprt->xpt_net = get_net(net);
|
2018-03-27 22:51:00 +08:00
|
|
|
strcpy(xprt->xpt_remotebuf, "uninitialized");
|
2007-12-31 11:07:15 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_init);
|
2007-12-31 11:07:42 +08:00
|
|
|
|
2008-07-01 06:45:37 +08:00
|
|
|
static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
|
|
|
|
struct svc_serv *serv,
|
2010-09-29 20:04:18 +08:00
|
|
|
struct net *net,
|
2009-03-19 08:46:21 +08:00
|
|
|
const int family,
|
|
|
|
const unsigned short port,
|
|
|
|
int flags)
|
2007-12-31 11:07:42 +08:00
|
|
|
{
|
|
|
|
struct sockaddr_in sin = {
|
|
|
|
.sin_family = AF_INET,
|
2008-03-18 13:44:53 +08:00
|
|
|
.sin_addr.s_addr = htonl(INADDR_ANY),
|
2007-12-31 11:07:42 +08:00
|
|
|
.sin_port = htons(port),
|
|
|
|
};
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2008-07-01 06:45:37 +08:00
|
|
|
struct sockaddr_in6 sin6 = {
|
|
|
|
.sin6_family = AF_INET6,
|
|
|
|
.sin6_addr = IN6ADDR_ANY_INIT,
|
|
|
|
.sin6_port = htons(port),
|
|
|
|
};
|
2011-12-10 17:48:31 +08:00
|
|
|
#endif
|
2020-04-29 05:13:32 +08:00
|
|
|
struct svc_xprt *xprt;
|
2008-07-01 06:45:37 +08:00
|
|
|
struct sockaddr *sap;
|
|
|
|
size_t len;
|
|
|
|
|
2009-03-19 08:46:21 +08:00
|
|
|
switch (family) {
|
|
|
|
case PF_INET:
|
2008-07-01 06:45:37 +08:00
|
|
|
sap = (struct sockaddr *)&sin;
|
|
|
|
len = sizeof(sin);
|
|
|
|
break;
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2009-03-19 08:46:21 +08:00
|
|
|
case PF_INET6:
|
2008-07-01 06:45:37 +08:00
|
|
|
sap = (struct sockaddr *)&sin6;
|
|
|
|
len = sizeof(sin6);
|
|
|
|
break;
|
2011-12-10 17:48:31 +08:00
|
|
|
#endif
|
2008-07-01 06:45:37 +08:00
|
|
|
default:
|
|
|
|
return ERR_PTR(-EAFNOSUPPORT);
|
|
|
|
}
|
|
|
|
|
2020-04-29 05:13:32 +08:00
|
|
|
xprt = xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
|
|
|
|
if (IS_ERR(xprt))
|
|
|
|
trace_svc_xprt_create_err(serv->sv_program->pg_name,
|
|
|
|
xcl->xcl_name, sap, xprt);
|
|
|
|
return xprt;
|
2008-07-01 06:45:37 +08:00
|
|
|
}
|
|
|
|
|
2012-08-18 10:12:19 +08:00
|
|
|
/*
|
|
|
|
* svc_xprt_received conditionally queues the transport for processing
|
|
|
|
* by another thread. The caller must hold the XPT_BUSY bit and must
|
|
|
|
* not thereafter touch transport data.
|
|
|
|
*
|
|
|
|
* Note: XPT_DATA only gets cleared when a read-attempt finds no (or
|
|
|
|
* insufficient) data.
|
|
|
|
*/
|
|
|
|
static void svc_xprt_received(struct svc_xprt *xprt)
|
|
|
|
{
|
2014-12-02 02:45:24 +08:00
|
|
|
if (!test_bit(XPT_BUSY, &xprt->xpt_flags)) {
|
|
|
|
WARN_ONCE(1, "xprt=0x%p already busy!", xprt);
|
2012-10-23 22:43:40 +08:00
|
|
|
return;
|
2014-12-02 02:45:24 +08:00
|
|
|
}
|
|
|
|
|
2012-08-18 10:12:19 +08:00
|
|
|
/* As soon as we clear busy, the xprt could be closed and
|
2015-06-09 03:06:51 +08:00
|
|
|
* 'put', so we need a reference to call svc_enqueue_xprt with:
|
2012-08-18 10:12:19 +08:00
|
|
|
*/
|
|
|
|
svc_xprt_get(xprt);
|
2014-07-25 11:59:31 +08:00
|
|
|
smp_mb__before_atomic();
|
2012-08-18 10:12:19 +08:00
|
|
|
clear_bit(XPT_BUSY, &xprt->xpt_flags);
|
2015-06-09 03:06:51 +08:00
|
|
|
xprt->xpt_server->sv_ops->svo_enqueue_xprt(xprt);
|
2012-08-18 10:12:19 +08:00
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
|
2012-08-15 03:50:34 +08:00
|
|
|
void svc_add_new_perm_xprt(struct svc_serv *serv, struct svc_xprt *new)
|
|
|
|
{
|
|
|
|
clear_bit(XPT_TEMP, &new->xpt_flags);
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
|
|
|
list_add(&new->xpt_list, &serv->sv_permsocks);
|
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
svc_xprt_received(new);
|
|
|
|
}
|
|
|
|
|
2017-10-16 21:40:21 +08:00
|
|
|
static int _svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
|
|
|
|
struct net *net, const int family,
|
2019-04-10 00:13:37 +08:00
|
|
|
const unsigned short port, int flags,
|
|
|
|
const struct cred *cred)
|
2008-07-01 06:45:37 +08:00
|
|
|
{
|
|
|
|
struct svc_xprt_class *xcl;
|
|
|
|
|
2007-12-31 11:07:42 +08:00
|
|
|
spin_lock(&svc_xprt_class_lock);
|
|
|
|
list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
|
2007-12-31 11:08:20 +08:00
|
|
|
struct svc_xprt *newxprt;
|
sunrpc: prevent use-after-free on clearing XPT_BUSY
When an xprt is created, it has a refcount of 1, and XPT_BUSY is set.
The refcount is *not* owned by the thread that created the xprt
(as is clear from the fact that creators never put the reference).
Rather, it is owned by the absence of XPT_DEAD. Once XPT_DEAD is set,
(And XPT_BUSY is clear) that initial reference is dropped and the xprt
can be freed.
So when a creator clears XPT_BUSY it is dropping its only reference and
so must not touch the xprt again.
However svc_recv, after calling ->xpo_accept (and so getting an XPT_BUSY
reference on a new xprt), calls svc_xprt_recieved. This clears
XPT_BUSY and then svc_xprt_enqueue - this last without owning a reference.
This is dangerous and has been seen to leave svc_xprt_enqueue working
with an xprt containing garbage.
So we need to hold an extra counted reference over that call to
svc_xprt_received.
For safety, any time we clear XPT_BUSY and then use the xprt again, we
first get a reference, and the put it again afterwards.
Note that svc_close_all does not need this extra protection as there are
no threads running, and the final free can only be called asynchronously
from such a thread.
Signed-off-by: NeilBrown <neilb@suse.de>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2010-11-16 13:55:19 +08:00
|
|
|
unsigned short newport;
|
2007-12-31 11:08:20 +08:00
|
|
|
|
|
|
|
if (strcmp(xprt_name, xcl->xcl_name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!try_module_get(xcl->xcl_owner))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
spin_unlock(&svc_xprt_class_lock);
|
2010-09-29 20:04:18 +08:00
|
|
|
newxprt = __svc_xpo_create(xcl, serv, net, family, port, flags);
|
2007-12-31 11:08:20 +08:00
|
|
|
if (IS_ERR(newxprt)) {
|
|
|
|
module_put(xcl->xcl_owner);
|
|
|
|
return PTR_ERR(newxprt);
|
2007-12-31 11:07:42 +08:00
|
|
|
}
|
2019-04-10 00:13:37 +08:00
|
|
|
newxprt->xpt_cred = get_cred(cred);
|
2012-08-15 03:50:34 +08:00
|
|
|
svc_add_new_perm_xprt(serv, newxprt);
|
sunrpc: prevent use-after-free on clearing XPT_BUSY
When an xprt is created, it has a refcount of 1, and XPT_BUSY is set.
The refcount is *not* owned by the thread that created the xprt
(as is clear from the fact that creators never put the reference).
Rather, it is owned by the absence of XPT_DEAD. Once XPT_DEAD is set,
(And XPT_BUSY is clear) that initial reference is dropped and the xprt
can be freed.
So when a creator clears XPT_BUSY it is dropping its only reference and
so must not touch the xprt again.
However svc_recv, after calling ->xpo_accept (and so getting an XPT_BUSY
reference on a new xprt), calls svc_xprt_recieved. This clears
XPT_BUSY and then svc_xprt_enqueue - this last without owning a reference.
This is dangerous and has been seen to leave svc_xprt_enqueue working
with an xprt containing garbage.
So we need to hold an extra counted reference over that call to
svc_xprt_received.
For safety, any time we clear XPT_BUSY and then use the xprt again, we
first get a reference, and the put it again afterwards.
Note that svc_close_all does not need this extra protection as there are
no threads running, and the final free can only be called asynchronously
from such a thread.
Signed-off-by: NeilBrown <neilb@suse.de>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2010-11-16 13:55:19 +08:00
|
|
|
newport = svc_xprt_local_port(newxprt);
|
|
|
|
return newport;
|
2007-12-31 11:07:42 +08:00
|
|
|
}
|
2007-12-31 11:08:20 +08:00
|
|
|
err:
|
2007-12-31 11:07:42 +08:00
|
|
|
spin_unlock(&svc_xprt_class_lock);
|
2010-01-27 03:04:13 +08:00
|
|
|
/* This errno is exposed to user space. Provide a reasonable
|
|
|
|
* perror msg for a bad transport. */
|
|
|
|
return -EPROTONOSUPPORT;
|
2007-12-31 11:07:42 +08:00
|
|
|
}
|
2016-05-19 02:50:14 +08:00
|
|
|
|
|
|
|
int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
|
|
|
|
struct net *net, const int family,
|
2019-04-10 00:13:37 +08:00
|
|
|
const unsigned short port, int flags,
|
|
|
|
const struct cred *cred)
|
2016-05-19 02:50:14 +08:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2019-04-10 00:13:37 +08:00
|
|
|
err = _svc_create_xprt(serv, xprt_name, net, family, port, flags, cred);
|
2016-05-19 02:50:14 +08:00
|
|
|
if (err == -EPROTONOSUPPORT) {
|
|
|
|
request_module("svc%s", xprt_name);
|
2019-04-10 00:13:37 +08:00
|
|
|
err = _svc_create_xprt(serv, xprt_name, net, family, port, flags, cred);
|
2016-05-19 02:50:14 +08:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
2007-12-31 11:07:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_create_xprt);
|
2007-12-31 11:08:12 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the local and remote xprt addresses to the rqstp structure
|
|
|
|
*/
|
|
|
|
void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
memcpy(&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen);
|
|
|
|
rqstp->rq_addrlen = xprt->xpt_remotelen;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Destination address in request is needed for binding the
|
|
|
|
* source address in RPC replies/callbacks later.
|
|
|
|
*/
|
2011-08-30 17:18:41 +08:00
|
|
|
memcpy(&rqstp->rq_daddr, &xprt->xpt_local, xprt->xpt_locallen);
|
|
|
|
rqstp->rq_daddrlen = xprt->xpt_locallen;
|
2007-12-31 11:08:12 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_copy_addrs);
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
/**
|
|
|
|
* svc_print_addr - Format rq_addr field for printing
|
|
|
|
* @rqstp: svc_rqst struct containing address to print
|
|
|
|
* @buf: target buffer for formatted address
|
|
|
|
* @len: length of target buffer
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
char *svc_print_addr(struct svc_rqst *rqstp, char *buf, size_t len)
|
|
|
|
{
|
|
|
|
return __svc_print_addr(svc_addr(rqstp), buf, len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_print_addr);
|
|
|
|
|
2016-06-24 22:55:50 +08:00
|
|
|
static bool svc_xprt_slots_in_range(struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
unsigned int limit = svc_rpc_per_connection_limit;
|
|
|
|
int nrqsts = atomic_read(&xprt->xpt_nr_rqsts);
|
|
|
|
|
|
|
|
return limit == 0 || (nrqsts >= 0 && nrqsts < limit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool svc_xprt_reserve_slot(struct svc_rqst *rqstp, struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
if (!test_bit(RQ_DATA, &rqstp->rq_flags)) {
|
|
|
|
if (!svc_xprt_slots_in_range(xprt))
|
|
|
|
return false;
|
|
|
|
atomic_inc(&xprt->xpt_nr_rqsts);
|
|
|
|
set_bit(RQ_DATA, &rqstp->rq_flags);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void svc_xprt_release_slot(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt = rqstp->rq_xprt;
|
|
|
|
if (test_and_clear_bit(RQ_DATA, &rqstp->rq_flags)) {
|
|
|
|
atomic_dec(&xprt->xpt_nr_rqsts);
|
svcrpc: fix unlikely races preventing queueing of sockets
In the rpc server, When something happens that might be reason to wake
up a thread to do something, what we do is
- modify xpt_flags, sk_sock->flags, xpt_reserved, or
xpt_nr_rqsts to indicate the new situation
- call svc_xprt_enqueue() to decide whether to wake up a thread.
svc_xprt_enqueue may require multiple conditions to be true before
queueing up a thread to handle the xprt. In the SMP case, one of the
other CPU's may have set another required condition, and in that case,
although both CPUs run svc_xprt_enqueue(), it's possible that neither
call sees the writes done by the other CPU in time, and neither one
recognizes that all the required conditions have been set. A socket
could therefore be ignored indefinitely.
Add memory barries to ensure that any svc_xprt_enqueue() call will
always see the conditions changed by other CPUs before deciding to
ignore a socket.
I've never seen this race reported. In the unlikely event it happens,
another event will usually come along and the problem will fix itself.
So I don't think this is worth backporting to stable.
Chuck tried this patch and said "I don't see any performance
regressions, but my server has only a single last-level CPU cache."
Tested-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2019-01-12 04:36:40 +08:00
|
|
|
smp_wmb(); /* See smp_rmb() in svc_xprt_ready() */
|
2016-06-24 22:55:50 +08:00
|
|
|
svc_xprt_enqueue(xprt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-12 04:57:09 +08:00
|
|
|
static bool svc_xprt_ready(struct svc_xprt *xprt)
|
2010-10-26 23:32:03 +08:00
|
|
|
{
|
2019-01-03 22:17:12 +08:00
|
|
|
unsigned long xpt_flags;
|
|
|
|
|
svcrpc: fix unlikely races preventing queueing of sockets
In the rpc server, When something happens that might be reason to wake
up a thread to do something, what we do is
- modify xpt_flags, sk_sock->flags, xpt_reserved, or
xpt_nr_rqsts to indicate the new situation
- call svc_xprt_enqueue() to decide whether to wake up a thread.
svc_xprt_enqueue may require multiple conditions to be true before
queueing up a thread to handle the xprt. In the SMP case, one of the
other CPU's may have set another required condition, and in that case,
although both CPUs run svc_xprt_enqueue(), it's possible that neither
call sees the writes done by the other CPU in time, and neither one
recognizes that all the required conditions have been set. A socket
could therefore be ignored indefinitely.
Add memory barries to ensure that any svc_xprt_enqueue() call will
always see the conditions changed by other CPUs before deciding to
ignore a socket.
I've never seen this race reported. In the unlikely event it happens,
another event will usually come along and the problem will fix itself.
So I don't think this is worth backporting to stable.
Chuck tried this patch and said "I don't see any performance
regressions, but my server has only a single last-level CPU cache."
Tested-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2019-01-12 04:36:40 +08:00
|
|
|
/*
|
|
|
|
* If another cpu has recently updated xpt_flags,
|
|
|
|
* sk_sock->flags, xpt_reserved, or xpt_nr_rqsts, we need to
|
|
|
|
* know about it; otherwise it's possible that both that cpu and
|
|
|
|
* this one could call svc_xprt_enqueue() without either
|
|
|
|
* svc_xprt_enqueue() recognizing that the conditions below
|
|
|
|
* are satisfied, and we could stall indefinitely:
|
|
|
|
*/
|
|
|
|
smp_rmb();
|
2019-01-03 22:17:12 +08:00
|
|
|
xpt_flags = READ_ONCE(xprt->xpt_flags);
|
|
|
|
|
|
|
|
if (xpt_flags & (BIT(XPT_CONN) | BIT(XPT_CLOSE)))
|
2010-10-26 23:32:03 +08:00
|
|
|
return true;
|
2019-01-03 22:17:12 +08:00
|
|
|
if (xpt_flags & (BIT(XPT_DATA) | BIT(XPT_DEFERRED))) {
|
2016-06-24 22:55:50 +08:00
|
|
|
if (xprt->xpt_ops->xpo_has_wspace(xprt) &&
|
|
|
|
svc_xprt_slots_in_range(xprt))
|
2016-06-24 22:55:45 +08:00
|
|
|
return true;
|
|
|
|
trace_svc_xprt_no_write_space(xprt);
|
|
|
|
return false;
|
|
|
|
}
|
2010-10-26 23:32:03 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-06-09 03:06:51 +08:00
|
|
|
void svc_xprt_do_enqueue(struct svc_xprt *xprt)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
|
|
|
struct svc_pool *pool;
|
2014-11-22 03:19:31 +08:00
|
|
|
struct svc_rqst *rqstp = NULL;
|
2007-12-31 11:08:27 +08:00
|
|
|
int cpu;
|
|
|
|
|
2019-01-12 04:57:09 +08:00
|
|
|
if (!svc_xprt_ready(xprt))
|
2018-03-27 22:50:27 +08:00
|
|
|
return;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/* Mark transport as busy. It will remain in this state until
|
|
|
|
* the provider calls svc_xprt_received. We update XPT_BUSY
|
|
|
|
* atomically because it also guards against trying to enqueue
|
|
|
|
* the transport twice.
|
|
|
|
*/
|
2018-03-27 22:50:27 +08:00
|
|
|
if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
|
|
|
|
return;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2014-08-04 01:03:12 +08:00
|
|
|
cpu = get_cpu();
|
|
|
|
pool = svc_pool_for_cpu(xprt->xpt_server, cpu);
|
|
|
|
|
2014-11-22 03:19:29 +08:00
|
|
|
atomic_long_inc(&pool->sp_stats.packets);
|
2014-08-04 01:03:12 +08:00
|
|
|
|
2017-10-11 05:31:43 +08:00
|
|
|
spin_lock_bh(&pool->sp_lock);
|
|
|
|
list_add_tail(&xprt->xpt_ready, &pool->sp_sockets);
|
|
|
|
pool->sp_stats.sockets_queued++;
|
|
|
|
spin_unlock_bh(&pool->sp_lock);
|
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
/* find a thread for this xprt */
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) {
|
2017-10-11 05:31:43 +08:00
|
|
|
if (test_and_set_bit(RQ_BUSY, &rqstp->rq_flags))
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
continue;
|
2014-11-22 03:19:29 +08:00
|
|
|
atomic_long_inc(&pool->sp_stats.threads_woken);
|
2018-03-27 22:52:27 +08:00
|
|
|
rqstp->rq_qtime = ktime_get();
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
wake_up_process(rqstp->rq_task);
|
2017-10-11 05:31:43 +08:00
|
|
|
goto out_unlock;
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2017-10-11 05:31:43 +08:00
|
|
|
set_bit(SP_CONGESTED, &pool->sp_flags);
|
2014-11-22 03:19:31 +08:00
|
|
|
rqstp = NULL;
|
2017-10-11 05:31:43 +08:00
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
2014-08-04 01:03:10 +08:00
|
|
|
put_cpu();
|
2014-11-22 03:19:31 +08:00
|
|
|
trace_svc_xprt_do_enqueue(xprt, rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2015-06-09 03:06:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_do_enqueue);
|
2014-07-25 11:59:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Queue up a transport with data pending. If there are idle nfsd
|
|
|
|
* processes, wake 'em up.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void svc_xprt_enqueue(struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
if (test_bit(XPT_BUSY, &xprt->xpt_flags))
|
|
|
|
return;
|
2015-06-09 03:06:51 +08:00
|
|
|
xprt->xpt_server->sv_ops->svo_enqueue_xprt(xprt);
|
2014-07-25 11:59:31 +08:00
|
|
|
}
|
2007-12-31 11:08:27 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_enqueue);
|
|
|
|
|
|
|
|
/*
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
* Dequeue the first transport, if there is one.
|
2007-12-31 11:08:27 +08:00
|
|
|
*/
|
|
|
|
static struct svc_xprt *svc_xprt_dequeue(struct svc_pool *pool)
|
|
|
|
{
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
struct svc_xprt *xprt = NULL;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
if (list_empty(&pool->sp_sockets))
|
2014-11-22 03:19:31 +08:00
|
|
|
goto out;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
spin_lock_bh(&pool->sp_lock);
|
|
|
|
if (likely(!list_empty(&pool->sp_sockets))) {
|
|
|
|
xprt = list_first_entry(&pool->sp_sockets,
|
|
|
|
struct svc_xprt, xpt_ready);
|
|
|
|
list_del_init(&xprt->xpt_ready);
|
|
|
|
svc_xprt_get(xprt);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&pool->sp_lock);
|
2014-11-22 03:19:31 +08:00
|
|
|
out:
|
2007-12-31 11:08:27 +08:00
|
|
|
return xprt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* svc_reserve - change the space reserved for the reply to a request.
|
|
|
|
* @rqstp: The request in question
|
|
|
|
* @space: new max space to reserve
|
|
|
|
*
|
|
|
|
* Each request reserves some space on the output queue of the transport
|
|
|
|
* to make sure the reply fits. This function reduces that reserved
|
|
|
|
* space to be the amount of space used already, plus @space.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void svc_reserve(struct svc_rqst *rqstp, int space)
|
|
|
|
{
|
2018-12-24 19:44:52 +08:00
|
|
|
struct svc_xprt *xprt = rqstp->rq_xprt;
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
space += rqstp->rq_res.head[0].iov_len;
|
|
|
|
|
2018-12-24 19:44:52 +08:00
|
|
|
if (xprt && space < rqstp->rq_reserved) {
|
2007-12-31 11:08:27 +08:00
|
|
|
atomic_sub((rqstp->rq_reserved - space), &xprt->xpt_reserved);
|
|
|
|
rqstp->rq_reserved = space;
|
svcrpc: fix unlikely races preventing queueing of sockets
In the rpc server, When something happens that might be reason to wake
up a thread to do something, what we do is
- modify xpt_flags, sk_sock->flags, xpt_reserved, or
xpt_nr_rqsts to indicate the new situation
- call svc_xprt_enqueue() to decide whether to wake up a thread.
svc_xprt_enqueue may require multiple conditions to be true before
queueing up a thread to handle the xprt. In the SMP case, one of the
other CPU's may have set another required condition, and in that case,
although both CPUs run svc_xprt_enqueue(), it's possible that neither
call sees the writes done by the other CPU in time, and neither one
recognizes that all the required conditions have been set. A socket
could therefore be ignored indefinitely.
Add memory barries to ensure that any svc_xprt_enqueue() call will
always see the conditions changed by other CPUs before deciding to
ignore a socket.
I've never seen this race reported. In the unlikely event it happens,
another event will usually come along and the problem will fix itself.
So I don't think this is worth backporting to stable.
Chuck tried this patch and said "I don't see any performance
regressions, but my server has only a single last-level CPU cache."
Tested-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2019-01-12 04:36:40 +08:00
|
|
|
smp_wmb(); /* See smp_rmb() in svc_xprt_ready() */
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_enqueue(xprt);
|
|
|
|
}
|
|
|
|
}
|
2008-12-24 05:30:12 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_reserve);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
static void svc_xprt_release(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt = rqstp->rq_xprt;
|
|
|
|
|
2018-03-27 22:49:22 +08:00
|
|
|
xprt->xpt_ops->xpo_release_rqst(rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2009-01-06 01:12:52 +08:00
|
|
|
kfree(rqstp->rq_deferred);
|
|
|
|
rqstp->rq_deferred = NULL;
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_free_res_pages(rqstp);
|
|
|
|
rqstp->rq_res.page_len = 0;
|
|
|
|
rqstp->rq_res.page_base = 0;
|
|
|
|
|
|
|
|
/* Reset response buffer and release
|
|
|
|
* the reservation.
|
|
|
|
* But first, check that enough space was reserved
|
|
|
|
* for the reply, otherwise we have a bug!
|
|
|
|
*/
|
|
|
|
if ((rqstp->rq_res.len) > rqstp->rq_reserved)
|
|
|
|
printk(KERN_ERR "RPC request reserved %d but used %d\n",
|
|
|
|
rqstp->rq_reserved,
|
|
|
|
rqstp->rq_res.len);
|
|
|
|
|
|
|
|
rqstp->rq_res.head[0].iov_len = 0;
|
|
|
|
svc_reserve(rqstp, 0);
|
2016-06-24 22:55:50 +08:00
|
|
|
svc_xprt_release_slot(rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_xprt = NULL;
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-11-19 20:51:21 +08:00
|
|
|
* Some svc_serv's will have occasional work to do, even when a xprt is not
|
|
|
|
* waiting to be serviced. This function is there to "kick" a task in one of
|
|
|
|
* those services so that it can wake up and do that work. Note that we only
|
|
|
|
* bother with pool 0 as we don't need to wake up more than one thread for
|
|
|
|
* this purpose.
|
2007-12-31 11:08:27 +08:00
|
|
|
*/
|
|
|
|
void svc_wake_up(struct svc_serv *serv)
|
|
|
|
{
|
|
|
|
struct svc_rqst *rqstp;
|
|
|
|
struct svc_pool *pool;
|
|
|
|
|
2014-11-19 20:51:21 +08:00
|
|
|
pool = &serv->sv_pools[0];
|
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) {
|
|
|
|
/* skip any that aren't queued */
|
|
|
|
if (test_bit(RQ_BUSY, &rqstp->rq_flags))
|
|
|
|
continue;
|
|
|
|
rcu_read_unlock();
|
2014-11-19 20:51:21 +08:00
|
|
|
wake_up_process(rqstp->rq_task);
|
2014-11-22 03:19:31 +08:00
|
|
|
trace_svc_wake_up(rqstp->rq_task->pid);
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
/* No free entries available */
|
|
|
|
set_bit(SP_TASK_PENDING, &pool->sp_flags);
|
|
|
|
smp_wmb();
|
2014-11-22 03:19:31 +08:00
|
|
|
trace_svc_wake_up(0);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2008-12-24 05:30:12 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_wake_up);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
int svc_port_is_privileged(struct sockaddr *sin)
|
|
|
|
{
|
|
|
|
switch (sin->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
return ntohs(((struct sockaddr_in *)sin)->sin_port)
|
|
|
|
< PROT_SOCK;
|
|
|
|
case AF_INET6:
|
|
|
|
return ntohs(((struct sockaddr_in6 *)sin)->sin6_port)
|
|
|
|
< PROT_SOCK;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-10-20 23:51:57 +08:00
|
|
|
* Make sure that we don't have too many active connections. If we have,
|
|
|
|
* something must be dropped. It's not clear what will happen if we allow
|
|
|
|
* "too many" connections, but when dealing with network-facing software,
|
|
|
|
* we have to code defensively. Here we do that by imposing hard limits.
|
2007-12-31 11:08:27 +08:00
|
|
|
*
|
|
|
|
* There's no point in trying to do random drop here for DoS
|
|
|
|
* prevention. The NFS clients does 1 reconnect in 15 seconds. An
|
|
|
|
* attacker can easily beat that.
|
|
|
|
*
|
|
|
|
* The only somewhat efficient mechanism would be if drop old
|
|
|
|
* connections from the same IP first. But right now we don't even
|
|
|
|
* record the client IP in svc_sock.
|
2008-10-20 23:51:57 +08:00
|
|
|
*
|
|
|
|
* single-threaded services that expect a lot of clients will probably
|
|
|
|
* need to set sv_maxconn to override the default value which is based
|
|
|
|
* on the number of threads
|
2007-12-31 11:08:27 +08:00
|
|
|
*/
|
|
|
|
static void svc_check_conn_limits(struct svc_serv *serv)
|
|
|
|
{
|
2008-10-20 23:51:57 +08:00
|
|
|
unsigned int limit = serv->sv_maxconn ? serv->sv_maxconn :
|
|
|
|
(serv->sv_nrthreads+3) * 20;
|
|
|
|
|
|
|
|
if (serv->sv_tmpcnt > limit) {
|
2007-12-31 11:08:27 +08:00
|
|
|
struct svc_xprt *xprt = NULL;
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
|
|
|
if (!list_empty(&serv->sv_tempsocks)) {
|
2012-05-14 05:56:26 +08:00
|
|
|
/* Try to help the admin */
|
|
|
|
net_notice_ratelimited("%s: too many open connections, consider increasing the %s\n",
|
|
|
|
serv->sv_name, serv->sv_maxconn ?
|
|
|
|
"max number of connections" :
|
|
|
|
"number of threads");
|
2007-12-31 11:08:27 +08:00
|
|
|
/*
|
|
|
|
* Always select the oldest connection. It's not fair,
|
|
|
|
* but so is life
|
|
|
|
*/
|
|
|
|
xprt = list_entry(serv->sv_tempsocks.prev,
|
|
|
|
struct svc_xprt,
|
|
|
|
xpt_list);
|
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
|
|
|
svc_xprt_get(xprt);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
|
|
|
|
if (xprt) {
|
|
|
|
svc_xprt_enqueue(xprt);
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 01:03:03 +08:00
|
|
|
static int svc_alloc_arg(struct svc_rqst *rqstp)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
2012-08-19 03:33:51 +08:00
|
|
|
struct svc_serv *serv = rqstp->rq_server;
|
|
|
|
struct xdr_buf *arg;
|
|
|
|
int pages;
|
|
|
|
int i;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/* now allocate needed pages. If we get a failure, sleep briefly */
|
2017-07-01 00:03:54 +08:00
|
|
|
pages = (serv->sv_max_mesg + 2 * PAGE_SIZE) >> PAGE_SHIFT;
|
|
|
|
if (pages > RPCSVC_MAXPAGES) {
|
|
|
|
pr_warn_once("svc: warning: pages=%u > RPCSVC_MAXPAGES=%lu\n",
|
|
|
|
pages, RPCSVC_MAXPAGES);
|
2012-10-23 22:43:41 +08:00
|
|
|
/* use as many pages as possible */
|
2017-07-01 00:03:54 +08:00
|
|
|
pages = RPCSVC_MAXPAGES;
|
|
|
|
}
|
2007-12-31 11:08:27 +08:00
|
|
|
for (i = 0; i < pages ; i++)
|
|
|
|
while (rqstp->rq_pages[i] == NULL) {
|
|
|
|
struct page *p = alloc_page(GFP_KERNEL);
|
|
|
|
if (!p) {
|
2008-02-13 00:47:24 +08:00
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
if (signalled() || kthread_should_stop()) {
|
|
|
|
set_current_state(TASK_RUNNING);
|
2008-02-08 05:34:54 +08:00
|
|
|
return -EINTR;
|
2008-02-13 00:47:24 +08:00
|
|
|
}
|
|
|
|
schedule_timeout(msecs_to_jiffies(500));
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
|
|
|
rqstp->rq_pages[i] = p;
|
|
|
|
}
|
2013-08-27 04:04:46 +08:00
|
|
|
rqstp->rq_page_end = &rqstp->rq_pages[i];
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */
|
|
|
|
|
|
|
|
/* Make arg->head point to first page and arg->pages point to rest */
|
|
|
|
arg = &rqstp->rq_arg;
|
|
|
|
arg->head[0].iov_base = page_address(rqstp->rq_pages[0]);
|
|
|
|
arg->head[0].iov_len = PAGE_SIZE;
|
|
|
|
arg->pages = rqstp->rq_pages + 1;
|
|
|
|
arg->page_base = 0;
|
|
|
|
/* save at least one page for response */
|
|
|
|
arg->page_len = (pages-2)*PAGE_SIZE;
|
|
|
|
arg->len = (pages-1)*PAGE_SIZE;
|
|
|
|
arg->tail[0].iov_len = 0;
|
2012-08-19 03:33:51 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
static bool
|
|
|
|
rqst_should_sleep(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct svc_pool *pool = rqstp->rq_pool;
|
|
|
|
|
|
|
|
/* did someone call svc_wake_up? */
|
|
|
|
if (test_and_clear_bit(SP_TASK_PENDING, &pool->sp_flags))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* was a socket queued? */
|
|
|
|
if (!list_empty(&pool->sp_sockets))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* are we shutting down? */
|
|
|
|
if (signalled() || kthread_should_stop())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* are we freezing? */
|
|
|
|
if (freezing(current))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-10 01:03:03 +08:00
|
|
|
static struct svc_xprt *svc_get_next_xprt(struct svc_rqst *rqstp, long timeout)
|
2012-08-19 03:33:51 +08:00
|
|
|
{
|
|
|
|
struct svc_pool *pool = rqstp->rq_pool;
|
2014-08-04 01:03:11 +08:00
|
|
|
long time_left = 0;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
/* rq_xprt should be clear on entry */
|
|
|
|
WARN_ON_ONCE(rqstp->rq_xprt);
|
|
|
|
|
2017-10-11 05:31:43 +08:00
|
|
|
rqstp->rq_xprt = svc_xprt_dequeue(pool);
|
|
|
|
if (rqstp->rq_xprt)
|
|
|
|
goto out_found;
|
2008-02-08 05:34:54 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
/*
|
|
|
|
* We have to be able to interrupt this wait
|
|
|
|
* to bring down the daemons ...
|
|
|
|
*/
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2017-10-11 05:31:43 +08:00
|
|
|
smp_mb__before_atomic();
|
|
|
|
clear_bit(SP_CONGESTED, &pool->sp_flags);
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
clear_bit(RQ_BUSY, &rqstp->rq_flags);
|
2017-10-11 05:31:43 +08:00
|
|
|
smp_mb__after_atomic();
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
if (likely(rqst_should_sleep(rqstp)))
|
|
|
|
time_left = schedule_timeout(timeout);
|
|
|
|
else
|
|
|
|
__set_current_state(TASK_RUNNING);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
try_to_freeze();
|
2007-12-31 11:08:27 +08:00
|
|
|
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
set_bit(RQ_BUSY, &rqstp->rq_flags);
|
2017-10-11 05:31:43 +08:00
|
|
|
smp_mb__after_atomic();
|
|
|
|
rqstp->rq_xprt = svc_xprt_dequeue(pool);
|
|
|
|
if (rqstp->rq_xprt)
|
|
|
|
goto out_found;
|
sunrpc: convert to lockless lookup of queued server threads
Testing has shown that the pool->sp_lock can be a bottleneck on a busy
server. Every time data is received on a socket, the server must take
that lock in order to dequeue a thread from the sp_threads list.
Address this problem by eliminating the sp_threads list (which contains
threads that are currently idle) and replacing it with a RQ_BUSY flag in
svc_rqst. This allows us to walk the sp_all_threads list under the
rcu_read_lock and find a suitable thread for the xprt by doing a
test_and_set_bit.
Note that we do still have a potential atomicity problem however with
this approach. We don't want svc_xprt_do_enqueue to set the
rqst->rq_xprt pointer unless a test_and_set_bit of RQ_BUSY returned
zero (which indicates that the thread was idle). But, by the time we
check that, the bit could be flipped by a waking thread.
To address this, we acquire a new per-rqst spinlock (rq_lock) and take
that before doing the test_and_set_bit. If that returns false, then we
can set rq_xprt and drop the spinlock. Then, when the thread wakes up,
it must set the bit under the same spinlock and can trust that if it was
already set then the rq_xprt is also properly set.
With this scheme, the case where we have an idle thread no longer needs
to take the highly contended pool->sp_lock at all, and that removes the
bottleneck.
That still leaves one issue: What of the case where we walk the whole
sp_all_threads list and don't find an idle thread? Because the search is
lockess, it's possible for the queueing to race with a thread that is
going to sleep. To address that, we queue the xprt and then search again.
If we find an idle thread at that point, we can't attach the xprt to it
directly since that might race with a different thread waking up and
finding it. All we can do is wake the idle thread back up and let it
attempt to find the now-queued xprt.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Tested-by: Chris Worley <chris.worley@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-11-22 03:19:30 +08:00
|
|
|
|
|
|
|
if (!time_left)
|
|
|
|
atomic_long_inc(&pool->sp_stats.threads_timedout);
|
|
|
|
|
|
|
|
if (signalled() || kthread_should_stop())
|
|
|
|
return ERR_PTR(-EINTR);
|
|
|
|
return ERR_PTR(-EAGAIN);
|
2017-10-11 05:31:43 +08:00
|
|
|
out_found:
|
|
|
|
/* Normally we will wait up to 5 seconds for any required
|
|
|
|
* cache information to be provided.
|
|
|
|
*/
|
|
|
|
if (!test_bit(SP_CONGESTED, &pool->sp_flags))
|
|
|
|
rqstp->rq_chandle.thread_wait = 5*HZ;
|
|
|
|
else
|
|
|
|
rqstp->rq_chandle.thread_wait = 1*HZ;
|
2018-03-27 22:52:27 +08:00
|
|
|
trace_svc_xprt_dequeue(rqstp);
|
2017-10-11 05:31:43 +08:00
|
|
|
return rqstp->rq_xprt;
|
2012-08-19 03:33:51 +08:00
|
|
|
}
|
|
|
|
|
2014-02-10 01:03:03 +08:00
|
|
|
static void svc_add_new_temp_xprt(struct svc_serv *serv, struct svc_xprt *newxpt)
|
2012-08-19 03:44:33 +08:00
|
|
|
{
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
|
|
|
set_bit(XPT_TEMP, &newxpt->xpt_flags);
|
|
|
|
list_add(&newxpt->xpt_list, &serv->sv_tempsocks);
|
|
|
|
serv->sv_tmpcnt++;
|
|
|
|
if (serv->sv_temptimer.function == NULL) {
|
|
|
|
/* setup timer to age temp transports */
|
2017-10-23 15:40:42 +08:00
|
|
|
serv->sv_temptimer.function = svc_age_temp_xprts;
|
2012-08-19 03:44:33 +08:00
|
|
|
mod_timer(&serv->sv_temptimer,
|
|
|
|
jiffies + svc_conn_age_period * HZ);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
svc_xprt_received(newxpt);
|
|
|
|
}
|
|
|
|
|
2012-08-19 03:33:51 +08:00
|
|
|
static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
struct svc_serv *serv = rqstp->rq_server;
|
|
|
|
int len = 0;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2010-03-01 05:33:31 +08:00
|
|
|
if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
|
2017-01-06 05:34:51 +08:00
|
|
|
if (test_and_clear_bit(XPT_KILL_TEMP, &xprt->xpt_flags))
|
|
|
|
xprt->xpt_ops->xpo_kill_temp_xprt(xprt);
|
2010-03-01 05:33:31 +08:00
|
|
|
svc_delete_xprt(xprt);
|
2010-10-26 02:12:40 +08:00
|
|
|
/* Leave XPT_BUSY set on the dead xprt: */
|
2014-11-22 03:19:31 +08:00
|
|
|
goto out;
|
2010-10-26 02:12:40 +08:00
|
|
|
}
|
|
|
|
if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
|
2007-12-31 11:08:27 +08:00
|
|
|
struct svc_xprt *newxpt;
|
2012-08-19 03:44:33 +08:00
|
|
|
/*
|
|
|
|
* We know this module_get will succeed because the
|
|
|
|
* listener holds a reference too
|
|
|
|
*/
|
|
|
|
__module_get(xprt->xpt_class->xcl_owner);
|
|
|
|
svc_check_conn_limits(xprt->xpt_server);
|
2007-12-31 11:08:27 +08:00
|
|
|
newxpt = xprt->xpt_ops->xpo_accept(xprt);
|
2019-04-10 00:13:38 +08:00
|
|
|
if (newxpt) {
|
|
|
|
newxpt->xpt_cred = get_cred(xprt->xpt_cred);
|
2012-08-19 03:44:33 +08:00
|
|
|
svc_add_new_temp_xprt(serv, newxpt);
|
2020-03-18 05:41:43 +08:00
|
|
|
trace_svc_xprt_accept(newxpt, serv->sv_name);
|
2019-04-10 00:13:38 +08:00
|
|
|
} else
|
2014-05-19 02:05:22 +08:00
|
|
|
module_put(xprt->xpt_class->xcl_owner);
|
2016-06-24 22:55:50 +08:00
|
|
|
} else if (svc_xprt_reserve_slot(rqstp, xprt)) {
|
2012-08-19 03:33:51 +08:00
|
|
|
/* XPT_DATA|XPT_DEFERRED case: */
|
2007-12-31 11:08:27 +08:00
|
|
|
dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
|
2012-08-19 03:33:51 +08:00
|
|
|
rqstp, rqstp->rq_pool->sp_id, xprt,
|
2016-11-15 00:29:48 +08:00
|
|
|
kref_read(&xprt->xpt_ref));
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_deferred = svc_deferred_dequeue(xprt);
|
2010-10-26 02:12:40 +08:00
|
|
|
if (rqstp->rq_deferred)
|
2007-12-31 11:08:27 +08:00
|
|
|
len = svc_deferred_recv(rqstp);
|
2010-10-26 02:12:40 +08:00
|
|
|
else
|
2007-12-31 11:08:27 +08:00
|
|
|
len = xprt->xpt_ops->xpo_recvfrom(rqstp);
|
2020-03-03 04:01:08 +08:00
|
|
|
if (len > 0)
|
2020-05-13 05:13:28 +08:00
|
|
|
trace_svc_xdr_recvfrom(rqstp, &rqstp->rq_arg);
|
2018-03-27 22:51:39 +08:00
|
|
|
rqstp->rq_stime = ktime_get();
|
2012-08-18 05:31:53 +08:00
|
|
|
rqstp->rq_reserved = serv->sv_max_mesg;
|
|
|
|
atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2012-08-19 03:33:51 +08:00
|
|
|
/* clear XPT_BUSY: */
|
2010-10-26 02:12:40 +08:00
|
|
|
svc_xprt_received(xprt);
|
2014-11-22 03:19:31 +08:00
|
|
|
out:
|
|
|
|
trace_svc_handle_xprt(xprt, len);
|
2012-08-19 03:33:51 +08:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Receive the next request on any transport. This code is carefully
|
|
|
|
* organised not to touch any cachelines in the shared svc_serv
|
|
|
|
* structure, only cachelines in the local svc_pool.
|
|
|
|
*/
|
|
|
|
int svc_recv(struct svc_rqst *rqstp, long timeout)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt = NULL;
|
|
|
|
struct svc_serv *serv = rqstp->rq_server;
|
|
|
|
int len, err;
|
|
|
|
|
|
|
|
err = svc_alloc_arg(rqstp);
|
|
|
|
if (err)
|
2014-10-29 02:24:12 +08:00
|
|
|
goto out;
|
2012-08-19 03:33:51 +08:00
|
|
|
|
|
|
|
try_to_freeze();
|
|
|
|
cond_resched();
|
2014-10-29 02:24:12 +08:00
|
|
|
err = -EINTR;
|
2012-08-19 03:33:51 +08:00
|
|
|
if (signalled() || kthread_should_stop())
|
2014-10-29 02:24:12 +08:00
|
|
|
goto out;
|
2012-08-19 03:33:51 +08:00
|
|
|
|
|
|
|
xprt = svc_get_next_xprt(rqstp, timeout);
|
2014-10-29 02:24:12 +08:00
|
|
|
if (IS_ERR(xprt)) {
|
|
|
|
err = PTR_ERR(xprt);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-19 03:33:51 +08:00
|
|
|
|
|
|
|
len = svc_handle_xprt(rqstp, xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/* No data, incomplete (TCP) read, or accept() */
|
2014-10-29 02:24:12 +08:00
|
|
|
err = -EAGAIN;
|
2012-08-18 09:35:24 +08:00
|
|
|
if (len <= 0)
|
2014-10-29 02:24:12 +08:00
|
|
|
goto out_release;
|
2010-10-26 02:12:40 +08:00
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
clear_bit(XPT_OLD, &xprt->xpt_flags);
|
|
|
|
|
2018-03-27 22:49:38 +08:00
|
|
|
xprt->xpt_ops->xpo_secure_port(rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_chandle.defer = svc_defer;
|
2014-10-29 02:24:12 +08:00
|
|
|
rqstp->rq_xid = svc_getu32(&rqstp->rq_arg.head[0]);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
if (serv->sv_stats)
|
|
|
|
serv->sv_stats->netcnt++;
|
2014-10-29 02:24:12 +08:00
|
|
|
trace_svc_recv(rqstp, len);
|
2007-12-31 11:08:27 +08:00
|
|
|
return len;
|
2014-10-29 02:24:12 +08:00
|
|
|
out_release:
|
2010-10-26 02:12:40 +08:00
|
|
|
rqstp->rq_res.len = 0;
|
|
|
|
svc_xprt_release(rqstp);
|
2014-10-29 02:24:12 +08:00
|
|
|
out:
|
|
|
|
return err;
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2008-12-24 05:30:12 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_recv);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop request
|
|
|
|
*/
|
|
|
|
void svc_drop(struct svc_rqst *rqstp)
|
|
|
|
{
|
2016-06-24 22:55:46 +08:00
|
|
|
trace_svc_drop(rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_release(rqstp);
|
|
|
|
}
|
2008-12-24 05:30:12 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_drop);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return reply to client.
|
|
|
|
*/
|
|
|
|
int svc_send(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
2014-10-29 02:24:12 +08:00
|
|
|
int len = -EFAULT;
|
2007-12-31 11:08:27 +08:00
|
|
|
struct xdr_buf *xb;
|
|
|
|
|
|
|
|
xprt = rqstp->rq_xprt;
|
|
|
|
if (!xprt)
|
2014-10-29 02:24:12 +08:00
|
|
|
goto out;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
/* calculate over-all length */
|
|
|
|
xb = &rqstp->rq_res;
|
|
|
|
xb->len = xb->head[0].iov_len +
|
|
|
|
xb->page_len +
|
|
|
|
xb->tail[0].iov_len;
|
2020-05-13 05:13:28 +08:00
|
|
|
trace_svc_xdr_sendto(rqstp, xb);
|
2018-03-27 22:51:39 +08:00
|
|
|
trace_svc_stats_latency(rqstp);
|
2020-05-02 22:37:44 +08:00
|
|
|
|
|
|
|
len = xprt->xpt_ops->xpo_sendto(rqstp);
|
|
|
|
|
2018-03-27 22:51:00 +08:00
|
|
|
trace_svc_send(rqstp, len);
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_release(rqstp);
|
|
|
|
|
|
|
|
if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN)
|
2014-10-29 02:24:12 +08:00
|
|
|
len = 0;
|
|
|
|
out:
|
2007-12-31 11:08:27 +08:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Timer function to close old temporary transports, using
|
|
|
|
* a mark-and-sweep algorithm.
|
|
|
|
*/
|
2017-10-17 08:29:42 +08:00
|
|
|
static void svc_age_temp_xprts(struct timer_list *t)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
2017-10-17 08:29:42 +08:00
|
|
|
struct svc_serv *serv = from_timer(serv, t, sv_temptimer);
|
2007-12-31 11:08:27 +08:00
|
|
|
struct svc_xprt *xprt;
|
|
|
|
struct list_head *le, *next;
|
|
|
|
|
|
|
|
dprintk("svc_age_temp_xprts\n");
|
|
|
|
|
|
|
|
if (!spin_trylock_bh(&serv->sv_lock)) {
|
|
|
|
/* busy, try again 1 sec later */
|
|
|
|
dprintk("svc_age_temp_xprts: busy\n");
|
|
|
|
mod_timer(&serv->sv_temptimer, jiffies + HZ);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_safe(le, next, &serv->sv_tempsocks) {
|
|
|
|
xprt = list_entry(le, struct svc_xprt, xpt_list);
|
|
|
|
|
|
|
|
/* First time through, just mark it OLD. Second time
|
|
|
|
* through, close it. */
|
|
|
|
if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags))
|
|
|
|
continue;
|
2016-11-15 00:29:48 +08:00
|
|
|
if (kref_read(&xprt->xpt_ref) > 1 ||
|
2009-11-30 08:55:45 +08:00
|
|
|
test_bit(XPT_BUSY, &xprt->xpt_flags))
|
2007-12-31 11:08:27 +08:00
|
|
|
continue;
|
2013-02-11 00:33:48 +08:00
|
|
|
list_del_init(le);
|
2007-12-31 11:08:27 +08:00
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
|
|
|
dprintk("queuing xprt %p for closing\n", xprt);
|
|
|
|
|
|
|
|
/* a thread will dequeue and close it soon */
|
|
|
|
svc_xprt_enqueue(xprt);
|
|
|
|
}
|
2013-02-11 00:33:48 +08:00
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
mod_timer(&serv->sv_temptimer, jiffies + svc_conn_age_period * HZ);
|
|
|
|
}
|
|
|
|
|
2015-12-12 05:45:58 +08:00
|
|
|
/* Close temporary transports whose xpt_local matches server_addr immediately
|
|
|
|
* instead of waiting for them to be picked up by the timer.
|
|
|
|
*
|
|
|
|
* This is meant to be called from a notifier_block that runs when an ip
|
|
|
|
* address is deleted.
|
|
|
|
*/
|
|
|
|
void svc_age_temp_xprts_now(struct svc_serv *serv, struct sockaddr *server_addr)
|
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
|
|
|
struct list_head *le, *next;
|
|
|
|
LIST_HEAD(to_be_closed);
|
|
|
|
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
|
|
|
list_for_each_safe(le, next, &serv->sv_tempsocks) {
|
|
|
|
xprt = list_entry(le, struct svc_xprt, xpt_list);
|
|
|
|
if (rpc_cmp_addr(server_addr, (struct sockaddr *)
|
|
|
|
&xprt->xpt_local)) {
|
|
|
|
dprintk("svc_age_temp_xprts_now: found %p\n", xprt);
|
|
|
|
list_move(le, &to_be_closed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
|
|
|
|
while (!list_empty(&to_be_closed)) {
|
|
|
|
le = to_be_closed.next;
|
|
|
|
list_del_init(le);
|
|
|
|
xprt = list_entry(le, struct svc_xprt, xpt_list);
|
2017-01-06 05:34:51 +08:00
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
|
|
|
set_bit(XPT_KILL_TEMP, &xprt->xpt_flags);
|
|
|
|
dprintk("svc_age_temp_xprts_now: queuing xprt %p for closing\n",
|
|
|
|
xprt);
|
|
|
|
svc_xprt_enqueue(xprt);
|
2015-12-12 05:45:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_age_temp_xprts_now);
|
|
|
|
|
2010-03-23 03:37:17 +08:00
|
|
|
static void call_xpt_users(struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
struct svc_xpt_user *u;
|
|
|
|
|
|
|
|
spin_lock(&xprt->xpt_lock);
|
|
|
|
while (!list_empty(&xprt->xpt_users)) {
|
|
|
|
u = list_first_entry(&xprt->xpt_users, struct svc_xpt_user, list);
|
2018-10-10 03:54:15 +08:00
|
|
|
list_del_init(&u->list);
|
2010-03-23 03:37:17 +08:00
|
|
|
u->callback(u);
|
|
|
|
}
|
|
|
|
spin_unlock(&xprt->xpt_lock);
|
|
|
|
}
|
|
|
|
|
2007-12-31 11:08:27 +08:00
|
|
|
/*
|
|
|
|
* Remove a dead transport
|
|
|
|
*/
|
2011-11-26 07:44:05 +08:00
|
|
|
static void svc_delete_xprt(struct svc_xprt *xprt)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
|
|
|
struct svc_serv *serv = xprt->xpt_server;
|
2009-01-06 05:21:19 +08:00
|
|
|
struct svc_deferred_req *dr;
|
|
|
|
|
|
|
|
if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags))
|
2020-03-18 05:41:43 +08:00
|
|
|
return;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2020-03-18 05:41:43 +08:00
|
|
|
trace_svc_xprt_detach(xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
xprt->xpt_ops->xpo_detach(xprt);
|
2020-04-18 00:40:31 +08:00
|
|
|
if (xprt->xpt_bc_xprt)
|
|
|
|
xprt->xpt_bc_xprt->ops->close(xprt->xpt_bc_xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
2014-11-18 06:02:57 +08:00
|
|
|
list_del_init(&xprt->xpt_list);
|
2012-10-23 22:43:48 +08:00
|
|
|
WARN_ON_ONCE(!list_empty(&xprt->xpt_ready));
|
2009-01-06 05:21:19 +08:00
|
|
|
if (test_bit(XPT_TEMP, &xprt->xpt_flags))
|
|
|
|
serv->sv_tmpcnt--;
|
2010-03-30 09:02:31 +08:00
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
2009-01-06 05:21:19 +08:00
|
|
|
|
2010-02-27 06:33:40 +08:00
|
|
|
while ((dr = svc_deferred_dequeue(xprt)) != NULL)
|
2009-01-06 05:21:19 +08:00
|
|
|
kfree(dr);
|
|
|
|
|
2010-03-23 03:37:17 +08:00
|
|
|
call_xpt_users(xprt);
|
2009-01-06 05:21:19 +08:00
|
|
|
svc_xprt_put(xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void svc_close_xprt(struct svc_xprt *xprt)
|
|
|
|
{
|
2020-03-18 05:41:43 +08:00
|
|
|
trace_svc_xprt_close(xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
|
|
|
if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
|
|
|
|
/* someone else will have to effect the close */
|
|
|
|
return;
|
2010-10-26 08:24:48 +08:00
|
|
|
/*
|
|
|
|
* We expect svc_close_xprt() to work even when no threads are
|
|
|
|
* running (e.g., while configuring the server before starting
|
|
|
|
* any threads), so if the transport isn't busy, we delete
|
|
|
|
* it ourself:
|
|
|
|
*/
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_delete_xprt(xprt);
|
|
|
|
}
|
2007-12-31 11:08:35 +08:00
|
|
|
EXPORT_SYMBOL_GPL(svc_close_xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
static int svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
2013-02-11 05:08:11 +08:00
|
|
|
int ret = 0;
|
2007-12-31 11:08:27 +08:00
|
|
|
|
2012-08-14 05:03:00 +08:00
|
|
|
spin_lock(&serv->sv_lock);
|
svcrpc: avoid memory-corruption on pool shutdown
Socket callbacks use svc_xprt_enqueue() to add an xprt to a
pool->sp_sockets list. In normal operation a server thread will later
come along and take the xprt off that list. On shutdown, after all the
threads have exited, we instead manually walk the sv_tempsocks and
sv_permsocks lists to find all the xprt's and delete them.
So the sp_sockets lists don't really matter any more. As a result,
we've mostly just ignored them and hoped they would go away.
Which has gotten us into trouble; witness for example ebc63e531cc6
"svcrpc: fix list-corrupting race on nfsd shutdown", the result of Ben
Greear noticing that a still-running svc_xprt_enqueue() could re-add an
xprt to an sp_sockets list just before it was deleted. The fix was to
remove it from the list at the end of svc_delete_xprt(). But that only
made corruption less likely--I can see nothing that prevents a
svc_xprt_enqueue() from adding another xprt to the list at the same
moment that we're removing this xprt from the list. In fact, despite
the earlier xpo_detach(), I don't even see what guarantees that
svc_xprt_enqueue() couldn't still be running on this xprt.
So, instead, note that svc_xprt_enqueue() essentially does:
lock sp_lock
if XPT_BUSY unset
add to sp_sockets
unlock sp_lock
So, if we do:
set XPT_BUSY on every xprt.
Empty every sp_sockets list, under the sp_socks locks.
Then we're left knowing that the sp_sockets lists are all empty and will
stay that way, since any svc_xprt_enqueue() will check XPT_BUSY under
the sp_lock and see it set.
And *then* we can continue deleting the xprt's.
(Thanks to Jeff Layton for being correctly suspicious of this code....)
Cc: Ben Greear <greearb@candelatech.com>
Cc: Jeff Layton <jlayton@redhat.com>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-11-30 06:00:26 +08:00
|
|
|
list_for_each_entry(xprt, xprt_list, xpt_list) {
|
2012-01-31 18:09:17 +08:00
|
|
|
if (xprt->xpt_net != net)
|
|
|
|
continue;
|
2013-02-11 05:08:11 +08:00
|
|
|
ret++;
|
2007-12-31 11:08:27 +08:00
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
2013-02-11 05:08:11 +08:00
|
|
|
svc_xprt_enqueue(xprt);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2012-08-14 05:03:00 +08:00
|
|
|
spin_unlock(&serv->sv_lock);
|
2013-02-11 05:08:11 +08:00
|
|
|
return ret;
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
static struct svc_xprt *svc_dequeue_net(struct svc_serv *serv, struct net *net)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
svcrpc: avoid memory-corruption on pool shutdown
Socket callbacks use svc_xprt_enqueue() to add an xprt to a
pool->sp_sockets list. In normal operation a server thread will later
come along and take the xprt off that list. On shutdown, after all the
threads have exited, we instead manually walk the sv_tempsocks and
sv_permsocks lists to find all the xprt's and delete them.
So the sp_sockets lists don't really matter any more. As a result,
we've mostly just ignored them and hoped they would go away.
Which has gotten us into trouble; witness for example ebc63e531cc6
"svcrpc: fix list-corrupting race on nfsd shutdown", the result of Ben
Greear noticing that a still-running svc_xprt_enqueue() could re-add an
xprt to an sp_sockets list just before it was deleted. The fix was to
remove it from the list at the end of svc_delete_xprt(). But that only
made corruption less likely--I can see nothing that prevents a
svc_xprt_enqueue() from adding another xprt to the list at the same
moment that we're removing this xprt from the list. In fact, despite
the earlier xpo_detach(), I don't even see what guarantees that
svc_xprt_enqueue() couldn't still be running on this xprt.
So, instead, note that svc_xprt_enqueue() essentially does:
lock sp_lock
if XPT_BUSY unset
add to sp_sockets
unlock sp_lock
So, if we do:
set XPT_BUSY on every xprt.
Empty every sp_sockets list, under the sp_socks locks.
Then we're left knowing that the sp_sockets lists are all empty and will
stay that way, since any svc_xprt_enqueue() will check XPT_BUSY under
the sp_lock and see it set.
And *then* we can continue deleting the xprt's.
(Thanks to Jeff Layton for being correctly suspicious of this code....)
Cc: Ben Greear <greearb@candelatech.com>
Cc: Jeff Layton <jlayton@redhat.com>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-11-30 06:00:26 +08:00
|
|
|
struct svc_pool *pool;
|
2007-12-31 11:08:27 +08:00
|
|
|
struct svc_xprt *xprt;
|
|
|
|
struct svc_xprt *tmp;
|
svcrpc: avoid memory-corruption on pool shutdown
Socket callbacks use svc_xprt_enqueue() to add an xprt to a
pool->sp_sockets list. In normal operation a server thread will later
come along and take the xprt off that list. On shutdown, after all the
threads have exited, we instead manually walk the sv_tempsocks and
sv_permsocks lists to find all the xprt's and delete them.
So the sp_sockets lists don't really matter any more. As a result,
we've mostly just ignored them and hoped they would go away.
Which has gotten us into trouble; witness for example ebc63e531cc6
"svcrpc: fix list-corrupting race on nfsd shutdown", the result of Ben
Greear noticing that a still-running svc_xprt_enqueue() could re-add an
xprt to an sp_sockets list just before it was deleted. The fix was to
remove it from the list at the end of svc_delete_xprt(). But that only
made corruption less likely--I can see nothing that prevents a
svc_xprt_enqueue() from adding another xprt to the list at the same
moment that we're removing this xprt from the list. In fact, despite
the earlier xpo_detach(), I don't even see what guarantees that
svc_xprt_enqueue() couldn't still be running on this xprt.
So, instead, note that svc_xprt_enqueue() essentially does:
lock sp_lock
if XPT_BUSY unset
add to sp_sockets
unlock sp_lock
So, if we do:
set XPT_BUSY on every xprt.
Empty every sp_sockets list, under the sp_socks locks.
Then we're left knowing that the sp_sockets lists are all empty and will
stay that way, since any svc_xprt_enqueue() will check XPT_BUSY under
the sp_lock and see it set.
And *then* we can continue deleting the xprt's.
(Thanks to Jeff Layton for being correctly suspicious of this code....)
Cc: Ben Greear <greearb@candelatech.com>
Cc: Jeff Layton <jlayton@redhat.com>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-11-30 06:00:26 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < serv->sv_nrpools; i++) {
|
|
|
|
pool = &serv->sv_pools[i];
|
|
|
|
|
|
|
|
spin_lock_bh(&pool->sp_lock);
|
2012-01-31 18:09:00 +08:00
|
|
|
list_for_each_entry_safe(xprt, tmp, &pool->sp_sockets, xpt_ready) {
|
2012-01-31 18:09:17 +08:00
|
|
|
if (xprt->xpt_net != net)
|
|
|
|
continue;
|
svcrpc: avoid memory-corruption on pool shutdown
Socket callbacks use svc_xprt_enqueue() to add an xprt to a
pool->sp_sockets list. In normal operation a server thread will later
come along and take the xprt off that list. On shutdown, after all the
threads have exited, we instead manually walk the sv_tempsocks and
sv_permsocks lists to find all the xprt's and delete them.
So the sp_sockets lists don't really matter any more. As a result,
we've mostly just ignored them and hoped they would go away.
Which has gotten us into trouble; witness for example ebc63e531cc6
"svcrpc: fix list-corrupting race on nfsd shutdown", the result of Ben
Greear noticing that a still-running svc_xprt_enqueue() could re-add an
xprt to an sp_sockets list just before it was deleted. The fix was to
remove it from the list at the end of svc_delete_xprt(). But that only
made corruption less likely--I can see nothing that prevents a
svc_xprt_enqueue() from adding another xprt to the list at the same
moment that we're removing this xprt from the list. In fact, despite
the earlier xpo_detach(), I don't even see what guarantees that
svc_xprt_enqueue() couldn't still be running on this xprt.
So, instead, note that svc_xprt_enqueue() essentially does:
lock sp_lock
if XPT_BUSY unset
add to sp_sockets
unlock sp_lock
So, if we do:
set XPT_BUSY on every xprt.
Empty every sp_sockets list, under the sp_socks locks.
Then we're left knowing that the sp_sockets lists are all empty and will
stay that way, since any svc_xprt_enqueue() will check XPT_BUSY under
the sp_lock and see it set.
And *then* we can continue deleting the xprt's.
(Thanks to Jeff Layton for being correctly suspicious of this code....)
Cc: Ben Greear <greearb@candelatech.com>
Cc: Jeff Layton <jlayton@redhat.com>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-11-30 06:00:26 +08:00
|
|
|
list_del_init(&xprt->xpt_ready);
|
2013-02-11 05:08:11 +08:00
|
|
|
spin_unlock_bh(&pool->sp_lock);
|
|
|
|
return xprt;
|
svcrpc: avoid memory-corruption on pool shutdown
Socket callbacks use svc_xprt_enqueue() to add an xprt to a
pool->sp_sockets list. In normal operation a server thread will later
come along and take the xprt off that list. On shutdown, after all the
threads have exited, we instead manually walk the sv_tempsocks and
sv_permsocks lists to find all the xprt's and delete them.
So the sp_sockets lists don't really matter any more. As a result,
we've mostly just ignored them and hoped they would go away.
Which has gotten us into trouble; witness for example ebc63e531cc6
"svcrpc: fix list-corrupting race on nfsd shutdown", the result of Ben
Greear noticing that a still-running svc_xprt_enqueue() could re-add an
xprt to an sp_sockets list just before it was deleted. The fix was to
remove it from the list at the end of svc_delete_xprt(). But that only
made corruption less likely--I can see nothing that prevents a
svc_xprt_enqueue() from adding another xprt to the list at the same
moment that we're removing this xprt from the list. In fact, despite
the earlier xpo_detach(), I don't even see what guarantees that
svc_xprt_enqueue() couldn't still be running on this xprt.
So, instead, note that svc_xprt_enqueue() essentially does:
lock sp_lock
if XPT_BUSY unset
add to sp_sockets
unlock sp_lock
So, if we do:
set XPT_BUSY on every xprt.
Empty every sp_sockets list, under the sp_socks locks.
Then we're left knowing that the sp_sockets lists are all empty and will
stay that way, since any svc_xprt_enqueue() will check XPT_BUSY under
the sp_lock and see it set.
And *then* we can continue deleting the xprt's.
(Thanks to Jeff Layton for being correctly suspicious of this code....)
Cc: Ben Greear <greearb@candelatech.com>
Cc: Jeff Layton <jlayton@redhat.com>
Cc: stable@kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-11-30 06:00:26 +08:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&pool->sp_lock);
|
|
|
|
}
|
2013-02-11 05:08:11 +08:00
|
|
|
return NULL;
|
2012-01-31 18:09:00 +08:00
|
|
|
}
|
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
static void svc_clean_up_xprts(struct svc_serv *serv, struct net *net)
|
2012-01-31 18:09:00 +08:00
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
2012-08-14 05:03:00 +08:00
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
while ((xprt = svc_dequeue_net(serv, net))) {
|
|
|
|
set_bit(XPT_CLOSE, &xprt->xpt_flags);
|
2012-08-14 05:03:00 +08:00
|
|
|
svc_delete_xprt(xprt);
|
2013-02-11 05:08:11 +08:00
|
|
|
}
|
2012-01-31 18:09:08 +08:00
|
|
|
}
|
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
/*
|
|
|
|
* Server threads may still be running (especially in the case where the
|
|
|
|
* service is still running in other network namespaces).
|
|
|
|
*
|
|
|
|
* So we shut down sockets the same way we would on a running server, by
|
|
|
|
* setting XPT_CLOSE, enqueuing, and letting a thread pick it up to do
|
|
|
|
* the close. In the case there are no such other threads,
|
|
|
|
* threads running, svc_clean_up_xprts() does a simple version of a
|
|
|
|
* server's main event loop, and in the case where there are other
|
|
|
|
* threads, we may need to wait a little while and then check again to
|
|
|
|
* see if they're done.
|
|
|
|
*/
|
2012-01-31 18:09:17 +08:00
|
|
|
void svc_close_net(struct svc_serv *serv, struct net *net)
|
2012-01-31 18:09:08 +08:00
|
|
|
{
|
2013-02-11 05:08:11 +08:00
|
|
|
int delay = 0;
|
2012-01-31 18:09:00 +08:00
|
|
|
|
2013-02-11 05:08:11 +08:00
|
|
|
while (svc_close_list(serv, &serv->sv_permsocks, net) +
|
|
|
|
svc_close_list(serv, &serv->sv_tempsocks, net)) {
|
|
|
|
|
|
|
|
svc_clean_up_xprts(serv, net);
|
|
|
|
msleep(delay++);
|
|
|
|
}
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle defer and revisit of requests
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void svc_revisit(struct cache_deferred_req *dreq, int too_many)
|
|
|
|
{
|
|
|
|
struct svc_deferred_req *dr =
|
|
|
|
container_of(dreq, struct svc_deferred_req, handle);
|
|
|
|
struct svc_xprt *xprt = dr->xprt;
|
|
|
|
|
2009-01-06 05:21:19 +08:00
|
|
|
spin_lock(&xprt->xpt_lock);
|
|
|
|
set_bit(XPT_DEFERRED, &xprt->xpt_flags);
|
|
|
|
if (too_many || test_bit(XPT_DEAD, &xprt->xpt_flags)) {
|
|
|
|
spin_unlock(&xprt->xpt_lock);
|
2020-04-15 21:05:26 +08:00
|
|
|
trace_svc_defer_drop(dr);
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_put(xprt);
|
|
|
|
kfree(dr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
dr->xprt = NULL;
|
|
|
|
list_add(&dr->handle.recent, &xprt->xpt_deferred);
|
|
|
|
spin_unlock(&xprt->xpt_lock);
|
2020-04-15 21:05:26 +08:00
|
|
|
trace_svc_defer_queue(dr);
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_enqueue(xprt);
|
|
|
|
svc_xprt_put(xprt);
|
|
|
|
}
|
|
|
|
|
2007-12-31 11:08:29 +08:00
|
|
|
/*
|
|
|
|
* Save the request off for later processing. The request buffer looks
|
|
|
|
* like this:
|
|
|
|
*
|
|
|
|
* <xprt-header><rpc-header><rpc-pagelist><rpc-tail>
|
|
|
|
*
|
|
|
|
* This code can only handle requests that consist of an xprt-header
|
|
|
|
* and rpc-header.
|
|
|
|
*/
|
2007-12-31 11:08:27 +08:00
|
|
|
static struct cache_deferred_req *svc_defer(struct cache_req *req)
|
|
|
|
{
|
|
|
|
struct svc_rqst *rqstp = container_of(req, struct svc_rqst, rq_chandle);
|
|
|
|
struct svc_deferred_req *dr;
|
|
|
|
|
2014-11-19 20:51:16 +08:00
|
|
|
if (rqstp->rq_arg.page_len || !test_bit(RQ_USEDEFERRAL, &rqstp->rq_flags))
|
2007-12-31 11:08:27 +08:00
|
|
|
return NULL; /* if more than a page, give up FIXME */
|
|
|
|
if (rqstp->rq_deferred) {
|
|
|
|
dr = rqstp->rq_deferred;
|
|
|
|
rqstp->rq_deferred = NULL;
|
|
|
|
} else {
|
2007-12-31 11:08:29 +08:00
|
|
|
size_t skip;
|
|
|
|
size_t size;
|
2007-12-31 11:08:27 +08:00
|
|
|
/* FIXME maybe discard if size too large */
|
2007-12-31 11:08:29 +08:00
|
|
|
size = sizeof(struct svc_deferred_req) + rqstp->rq_arg.len;
|
2007-12-31 11:08:27 +08:00
|
|
|
dr = kmalloc(size, GFP_KERNEL);
|
|
|
|
if (dr == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dr->handle.owner = rqstp->rq_server;
|
|
|
|
dr->prot = rqstp->rq_prot;
|
|
|
|
memcpy(&dr->addr, &rqstp->rq_addr, rqstp->rq_addrlen);
|
|
|
|
dr->addrlen = rqstp->rq_addrlen;
|
|
|
|
dr->daddr = rqstp->rq_daddr;
|
|
|
|
dr->argslen = rqstp->rq_arg.len >> 2;
|
2007-12-31 11:08:29 +08:00
|
|
|
dr->xprt_hlen = rqstp->rq_xprt_hlen;
|
|
|
|
|
|
|
|
/* back up head to the start of the buffer and copy */
|
|
|
|
skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0].iov_len;
|
|
|
|
memcpy(dr->args, rqstp->rq_arg.head[0].iov_base - skip,
|
|
|
|
dr->argslen << 2);
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
2020-04-15 21:05:26 +08:00
|
|
|
trace_svc_defer(rqstp);
|
2007-12-31 11:08:27 +08:00
|
|
|
svc_xprt_get(rqstp->rq_xprt);
|
|
|
|
dr->xprt = rqstp->rq_xprt;
|
2014-11-19 20:51:17 +08:00
|
|
|
set_bit(RQ_DROPME, &rqstp->rq_flags);
|
2007-12-31 11:08:27 +08:00
|
|
|
|
|
|
|
dr->handle.revisit = svc_revisit;
|
|
|
|
return &dr->handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* recv data from a deferred request into an active one
|
|
|
|
*/
|
2020-04-15 21:05:26 +08:00
|
|
|
static noinline int svc_deferred_recv(struct svc_rqst *rqstp)
|
2007-12-31 11:08:27 +08:00
|
|
|
{
|
|
|
|
struct svc_deferred_req *dr = rqstp->rq_deferred;
|
|
|
|
|
2020-04-15 21:05:26 +08:00
|
|
|
trace_svc_defer_recv(dr);
|
|
|
|
|
2007-12-31 11:08:29 +08:00
|
|
|
/* setup iov_base past transport header */
|
|
|
|
rqstp->rq_arg.head[0].iov_base = dr->args + (dr->xprt_hlen>>2);
|
|
|
|
/* The iov_len does not include the transport header bytes */
|
|
|
|
rqstp->rq_arg.head[0].iov_len = (dr->argslen<<2) - dr->xprt_hlen;
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_arg.page_len = 0;
|
2007-12-31 11:08:29 +08:00
|
|
|
/* The rq_arg.len includes the transport header bytes */
|
|
|
|
rqstp->rq_arg.len = dr->argslen<<2;
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_prot = dr->prot;
|
|
|
|
memcpy(&rqstp->rq_addr, &dr->addr, dr->addrlen);
|
|
|
|
rqstp->rq_addrlen = dr->addrlen;
|
2007-12-31 11:08:29 +08:00
|
|
|
/* Save off transport header len in case we get deferred again */
|
|
|
|
rqstp->rq_xprt_hlen = dr->xprt_hlen;
|
2007-12-31 11:08:27 +08:00
|
|
|
rqstp->rq_daddr = dr->daddr;
|
|
|
|
rqstp->rq_respages = rqstp->rq_pages;
|
2007-12-31 11:08:29 +08:00
|
|
|
return (dr->argslen<<2) - dr->xprt_hlen;
|
2007-12-31 11:08:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)
|
|
|
|
{
|
|
|
|
struct svc_deferred_req *dr = NULL;
|
|
|
|
|
|
|
|
if (!test_bit(XPT_DEFERRED, &xprt->xpt_flags))
|
|
|
|
return NULL;
|
|
|
|
spin_lock(&xprt->xpt_lock);
|
|
|
|
if (!list_empty(&xprt->xpt_deferred)) {
|
|
|
|
dr = list_entry(xprt->xpt_deferred.next,
|
|
|
|
struct svc_deferred_req,
|
|
|
|
handle.recent);
|
|
|
|
list_del_init(&dr->handle.recent);
|
2010-10-26 00:50:15 +08:00
|
|
|
} else
|
|
|
|
clear_bit(XPT_DEFERRED, &xprt->xpt_flags);
|
2007-12-31 11:08:27 +08:00
|
|
|
spin_unlock(&xprt->xpt_lock);
|
|
|
|
return dr;
|
|
|
|
}
|
2007-12-31 11:08:33 +08:00
|
|
|
|
2009-03-19 08:45:58 +08:00
|
|
|
/**
|
|
|
|
* svc_find_xprt - find an RPC transport instance
|
|
|
|
* @serv: pointer to svc_serv to search
|
|
|
|
* @xcl_name: C string containing transport's class name
|
2012-01-20 20:50:53 +08:00
|
|
|
* @net: owner net pointer
|
2009-03-19 08:45:58 +08:00
|
|
|
* @af: Address family of transport's local address
|
|
|
|
* @port: transport's IP port number
|
|
|
|
*
|
2007-12-31 11:08:33 +08:00
|
|
|
* Return the transport instance pointer for the endpoint accepting
|
|
|
|
* connections/peer traffic from the specified transport class,
|
|
|
|
* address family and port.
|
|
|
|
*
|
|
|
|
* Specifying 0 for the address family or port is effectively a
|
|
|
|
* wild-card, and will result in matching the first transport in the
|
|
|
|
* service's list that has a matching class name.
|
|
|
|
*/
|
2009-03-19 08:45:58 +08:00
|
|
|
struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
|
2012-01-20 20:50:53 +08:00
|
|
|
struct net *net, const sa_family_t af,
|
|
|
|
const unsigned short port)
|
2007-12-31 11:08:33 +08:00
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
|
|
|
struct svc_xprt *found = NULL;
|
|
|
|
|
|
|
|
/* Sanity check the args */
|
2009-03-19 08:45:58 +08:00
|
|
|
if (serv == NULL || xcl_name == NULL)
|
2007-12-31 11:08:33 +08:00
|
|
|
return found;
|
|
|
|
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
|
|
|
list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
|
2012-01-20 20:50:53 +08:00
|
|
|
if (xprt->xpt_net != net)
|
|
|
|
continue;
|
2007-12-31 11:08:33 +08:00
|
|
|
if (strcmp(xprt->xpt_class->xcl_name, xcl_name))
|
|
|
|
continue;
|
|
|
|
if (af != AF_UNSPEC && af != xprt->xpt_local.ss_family)
|
|
|
|
continue;
|
2009-03-19 08:45:58 +08:00
|
|
|
if (port != 0 && port != svc_xprt_local_port(xprt))
|
2007-12-31 11:08:33 +08:00
|
|
|
continue;
|
|
|
|
found = xprt;
|
2007-12-31 11:08:35 +08:00
|
|
|
svc_xprt_get(xprt);
|
2007-12-31 11:08:33 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_find_xprt);
|
2007-12-31 11:08:37 +08:00
|
|
|
|
2009-04-24 07:32:25 +08:00
|
|
|
static int svc_one_xprt_name(const struct svc_xprt *xprt,
|
|
|
|
char *pos, int remaining)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = snprintf(pos, remaining, "%s %u\n",
|
|
|
|
xprt->xpt_class->xcl_name,
|
|
|
|
svc_xprt_local_port(xprt));
|
|
|
|
if (len >= remaining)
|
|
|
|
return -ENAMETOOLONG;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* svc_xprt_names - format a buffer with a list of transport names
|
|
|
|
* @serv: pointer to an RPC service
|
|
|
|
* @buf: pointer to a buffer to be filled in
|
|
|
|
* @buflen: length of buffer to be filled in
|
|
|
|
*
|
|
|
|
* Fills in @buf with a string containing a list of transport names,
|
|
|
|
* each name terminated with '\n'.
|
|
|
|
*
|
|
|
|
* Returns positive length of the filled-in string on success; otherwise
|
|
|
|
* a negative errno value is returned if an error occurs.
|
2007-12-31 11:08:37 +08:00
|
|
|
*/
|
2009-04-24 07:32:25 +08:00
|
|
|
int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen)
|
2007-12-31 11:08:37 +08:00
|
|
|
{
|
|
|
|
struct svc_xprt *xprt;
|
2009-04-24 07:32:25 +08:00
|
|
|
int len, totlen;
|
|
|
|
char *pos;
|
2007-12-31 11:08:37 +08:00
|
|
|
|
|
|
|
/* Sanity check args */
|
|
|
|
if (!serv)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_bh(&serv->sv_lock);
|
2009-04-24 07:32:25 +08:00
|
|
|
|
|
|
|
pos = buf;
|
|
|
|
totlen = 0;
|
2007-12-31 11:08:37 +08:00
|
|
|
list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
|
2009-04-24 07:32:25 +08:00
|
|
|
len = svc_one_xprt_name(xprt, pos, buflen - totlen);
|
|
|
|
if (len < 0) {
|
|
|
|
*buf = '\0';
|
|
|
|
totlen = len;
|
|
|
|
}
|
|
|
|
if (len <= 0)
|
2007-12-31 11:08:37 +08:00
|
|
|
break;
|
2009-04-24 07:32:25 +08:00
|
|
|
|
|
|
|
pos += len;
|
2007-12-31 11:08:37 +08:00
|
|
|
totlen += len;
|
|
|
|
}
|
2009-04-24 07:32:25 +08:00
|
|
|
|
2007-12-31 11:08:37 +08:00
|
|
|
spin_unlock_bh(&serv->sv_lock);
|
|
|
|
return totlen;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(svc_xprt_names);
|
2009-01-13 18:26:36 +08:00
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static void *svc_pool_stats_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
unsigned int pidx = (unsigned int)*pos;
|
|
|
|
struct svc_serv *serv = m->private;
|
|
|
|
|
|
|
|
dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
|
|
|
|
|
|
|
|
if (!pidx)
|
|
|
|
return SEQ_START_TOKEN;
|
|
|
|
return (pidx > serv->sv_nrpools ? NULL : &serv->sv_pools[pidx-1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *svc_pool_stats_next(struct seq_file *m, void *p, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct svc_pool *pool = p;
|
|
|
|
struct svc_serv *serv = m->private;
|
|
|
|
|
|
|
|
dprintk("svc_pool_stats_next, *pos=%llu\n", *pos);
|
|
|
|
|
|
|
|
if (p == SEQ_START_TOKEN) {
|
|
|
|
pool = &serv->sv_pools[0];
|
|
|
|
} else {
|
|
|
|
unsigned int pidx = (pool - &serv->sv_pools[0]);
|
|
|
|
if (pidx < serv->sv_nrpools-1)
|
|
|
|
pool = &serv->sv_pools[pidx+1];
|
|
|
|
else
|
|
|
|
pool = NULL;
|
|
|
|
}
|
|
|
|
++*pos;
|
|
|
|
return pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void svc_pool_stats_stop(struct seq_file *m, void *p)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int svc_pool_stats_show(struct seq_file *m, void *p)
|
|
|
|
{
|
|
|
|
struct svc_pool *pool = p;
|
|
|
|
|
|
|
|
if (p == SEQ_START_TOKEN) {
|
2009-08-07 03:41:34 +08:00
|
|
|
seq_puts(m, "# pool packets-arrived sockets-enqueued threads-woken threads-timedout\n");
|
2009-01-13 18:26:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-07 03:41:34 +08:00
|
|
|
seq_printf(m, "%u %lu %lu %lu %lu\n",
|
2009-01-13 18:26:36 +08:00
|
|
|
pool->sp_id,
|
2014-11-22 03:19:29 +08:00
|
|
|
(unsigned long)atomic_long_read(&pool->sp_stats.packets),
|
2009-01-13 18:26:36 +08:00
|
|
|
pool->sp_stats.sockets_queued,
|
2014-11-22 03:19:29 +08:00
|
|
|
(unsigned long)atomic_long_read(&pool->sp_stats.threads_woken),
|
|
|
|
(unsigned long)atomic_long_read(&pool->sp_stats.threads_timedout));
|
2009-01-13 18:26:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations svc_pool_stats_seq_ops = {
|
|
|
|
.start = svc_pool_stats_start,
|
|
|
|
.next = svc_pool_stats_next,
|
|
|
|
.stop = svc_pool_stats_stop,
|
|
|
|
.show = svc_pool_stats_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
int svc_pool_stats_open(struct svc_serv *serv, struct file *file)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = seq_open(file, &svc_pool_stats_seq_ops);
|
|
|
|
if (!err)
|
|
|
|
((struct seq_file *) file->private_data)->private = serv;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(svc_pool_stats_open);
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|