2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-08-11 14:25:47 -06:00
|
|
|
* linux/net/sunrpc/clnt.c
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This file contains the high-level RPC interface.
|
|
|
|
* It is modeled as a finite state machine to support both synchronous
|
|
|
|
* and asynchronous requests.
|
|
|
|
*
|
|
|
|
* - RPC header generation and argument serialization.
|
|
|
|
* - Credential refresh.
|
|
|
|
* - TCP connect handling.
|
|
|
|
* - Retry of operation when it is suspected the operation failed because
|
|
|
|
* of uid squashing on the server, or when the credentials were stale
|
|
|
|
* and need to be refreshed, or when a packet was damaged in transit.
|
|
|
|
* This may be have to be moved to the VFS layer.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
|
|
|
|
* Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
2008-05-21 15:09:41 -06:00
|
|
|
#include <linux/kallsyms.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/mm.h>
|
2009-08-09 13:14:25 -06:00
|
|
|
#include <linux/namei.h>
|
|
|
|
#include <linux/mount.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/slab.h>
|
2013-10-17 12:12:23 -06:00
|
|
|
#include <linux/rcupdate.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/utsname.h>
|
2006-03-20 11:44:22 -07:00
|
|
|
#include <linux/workqueue.h>
|
2011-05-09 13:22:44 -06:00
|
|
|
#include <linux/in.h>
|
2007-12-10 12:56:24 -07:00
|
|
|
#include <linux/in6.h>
|
2011-05-09 13:22:44 -06:00
|
|
|
#include <linux/un.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
2013-02-04 10:50:00 -07:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/sunrpc/rpc_pipe_fs.h>
|
2006-03-20 11:44:22 -07:00
|
|
|
#include <linux/sunrpc/metrics.h>
|
2009-04-01 07:23:03 -06:00
|
|
|
#include <linux/sunrpc/bc_xprt.h>
|
2012-02-06 08:08:08 -07:00
|
|
|
#include <trace/events/sunrpc.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-01 07:23:03 -06:00
|
|
|
#include "sunrpc.h"
|
2012-01-12 11:07:51 -07:00
|
|
|
#include "netns.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-17 14:58:04 -07:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
2005-04-16 16:20:36 -06:00
|
|
|
# define RPCDBG_FACILITY RPCDBG_CALL
|
|
|
|
#endif
|
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
#define dprint_status(t) \
|
|
|
|
dprintk("RPC: %5u %s (status %d)\n", t->tk_pid, \
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__, t->tk_status)
|
2007-01-31 10:14:08 -07:00
|
|
|
|
2007-06-16 12:18:40 -06:00
|
|
|
/*
|
|
|
|
* All RPC clients are linked into this list
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(destroy_wait);
|
|
|
|
|
|
|
|
|
|
|
|
static void call_start(struct rpc_task *task);
|
|
|
|
static void call_reserve(struct rpc_task *task);
|
|
|
|
static void call_reserveresult(struct rpc_task *task);
|
|
|
|
static void call_allocate(struct rpc_task *task);
|
|
|
|
static void call_decode(struct rpc_task *task);
|
|
|
|
static void call_bind(struct rpc_task *task);
|
2005-08-11 14:25:11 -06:00
|
|
|
static void call_bind_status(struct rpc_task *task);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void call_transmit(struct rpc_task *task);
|
2011-07-13 17:20:49 -06:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 07:23:03 -06:00
|
|
|
static void call_bc_transmit(struct rpc_task *task);
|
2011-07-13 17:20:49 -06:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2005-04-16 16:20:36 -06:00
|
|
|
static void call_status(struct rpc_task *task);
|
2005-11-09 19:45:24 -07:00
|
|
|
static void call_transmit_status(struct rpc_task *task);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void call_refresh(struct rpc_task *task);
|
|
|
|
static void call_refreshresult(struct rpc_task *task);
|
|
|
|
static void call_timeout(struct rpc_task *task);
|
|
|
|
static void call_connect(struct rpc_task *task);
|
|
|
|
static void call_connect_status(struct rpc_task *task);
|
|
|
|
|
2008-05-21 15:09:19 -06:00
|
|
|
static __be32 *rpc_encode_header(struct rpc_task *task);
|
|
|
|
static __be32 *rpc_verify_header(struct rpc_task *task);
|
2009-12-03 13:58:56 -07:00
|
|
|
static int rpc_ping(struct rpc_clnt *clnt);
|
2007-06-23 08:17:16 -06:00
|
|
|
|
2007-06-16 12:18:40 -06:00
|
|
|
static void rpc_register_client(struct rpc_clnt *clnt)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct net *net = rpc_net_ns(clnt);
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2012-01-12 11:07:51 -07:00
|
|
|
|
|
|
|
spin_lock(&sn->rpc_client_lock);
|
|
|
|
list_add(&clnt->cl_clients, &sn->all_clients);
|
|
|
|
spin_unlock(&sn->rpc_client_lock);
|
2007-06-16 12:18:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_unregister_client(struct rpc_clnt *clnt)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct net *net = rpc_net_ns(clnt);
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2012-01-12 11:07:51 -07:00
|
|
|
|
|
|
|
spin_lock(&sn->rpc_client_lock);
|
2007-06-16 12:18:40 -06:00
|
|
|
list_del(&clnt->cl_clients);
|
2012-01-12 11:07:51 -07:00
|
|
|
spin_unlock(&sn->rpc_client_lock);
|
2007-06-16 12:18:40 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-11 08:18:01 -07:00
|
|
|
static void __rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
|
|
|
|
{
|
2013-08-26 15:44:26 -06:00
|
|
|
rpc_remove_client_dir(clnt);
|
2012-01-11 08:18:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_clnt_remove_pipedir(struct rpc_clnt *clnt)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct net *net = rpc_net_ns(clnt);
|
2012-01-11 08:18:01 -07:00
|
|
|
struct super_block *pipefs_sb;
|
|
|
|
|
2012-03-01 15:00:56 -07:00
|
|
|
pipefs_sb = rpc_get_sb_net(net);
|
2012-01-11 08:18:01 -07:00
|
|
|
if (pipefs_sb) {
|
|
|
|
__rpc_clnt_remove_pipedir(clnt);
|
2012-03-01 15:00:56 -07:00
|
|
|
rpc_put_sb_net(net);
|
2012-01-11 08:18:01 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *rpc_setup_pipedir_sb(struct super_block *sb,
|
2013-08-23 11:03:50 -06:00
|
|
|
struct rpc_clnt *clnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-09-23 09:08:25 -06:00
|
|
|
static uint32_t clntid;
|
2013-08-23 11:03:50 -06:00
|
|
|
const char *dir_name = clnt->cl_program->pipe_dir_name;
|
2009-08-09 13:14:25 -06:00
|
|
|
char name[15];
|
2012-01-11 08:18:01 -07:00
|
|
|
struct dentry *dir, *dentry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-11 08:18:01 -07:00
|
|
|
dir = rpc_d_lookup_sb(sb, dir_name);
|
2012-10-23 08:43:25 -06:00
|
|
|
if (dir == NULL) {
|
|
|
|
pr_info("RPC: pipefs directory doesn't exist: %s\n", dir_name);
|
2012-01-11 08:18:01 -07:00
|
|
|
return dir;
|
2012-10-23 08:43:25 -06:00
|
|
|
}
|
2005-09-23 09:08:25 -06:00
|
|
|
for (;;) {
|
2013-07-14 06:43:54 -06:00
|
|
|
snprintf(name, sizeof(name), "clnt%x", (unsigned int)clntid++);
|
2009-08-09 13:14:25 -06:00
|
|
|
name[sizeof(name) - 1] = '\0';
|
2013-07-14 06:43:54 -06:00
|
|
|
dentry = rpc_create_client_dir(dir, name, clnt);
|
2012-01-11 08:18:01 -07:00
|
|
|
if (!IS_ERR(dentry))
|
2009-08-09 13:14:25 -06:00
|
|
|
break;
|
2013-07-14 06:43:54 -06:00
|
|
|
if (dentry == ERR_PTR(-EEXIST))
|
|
|
|
continue;
|
|
|
|
printk(KERN_INFO "RPC: Couldn't create pipefs entry"
|
|
|
|
" %s/%s, error %ld\n",
|
|
|
|
dir_name, name, PTR_ERR(dentry));
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-01-11 08:18:01 -07:00
|
|
|
dput(dir);
|
|
|
|
return dentry;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2013-08-23 11:03:50 -06:00
|
|
|
rpc_setup_pipedir(struct super_block *pipefs_sb, struct rpc_clnt *clnt)
|
2012-01-11 08:18:01 -07:00
|
|
|
{
|
2012-01-11 08:18:42 -07:00
|
|
|
struct dentry *dentry;
|
2012-01-11 08:18:01 -07:00
|
|
|
|
2013-08-26 15:44:26 -06:00
|
|
|
if (clnt->cl_program->pipe_dir_name != NULL) {
|
|
|
|
dentry = rpc_setup_pipedir_sb(pipefs_sb, clnt);
|
|
|
|
if (IS_ERR(dentry))
|
|
|
|
return PTR_ERR(dentry);
|
|
|
|
}
|
2009-08-09 13:14:25 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-08-23 11:03:50 -06:00
|
|
|
static int rpc_clnt_skip_event(struct rpc_clnt *clnt, unsigned long event)
|
2012-04-27 03:00:17 -06:00
|
|
|
{
|
2013-08-23 11:03:50 -06:00
|
|
|
if (clnt->cl_program->pipe_dir_name == NULL)
|
2013-06-24 01:52:59 -06:00
|
|
|
return 1;
|
2013-08-23 11:03:50 -06:00
|
|
|
|
2013-08-26 15:44:26 -06:00
|
|
|
switch (event) {
|
|
|
|
case RPC_PIPEFS_MOUNT:
|
|
|
|
if (clnt->cl_pipedir_objects.pdh_dentry != NULL)
|
|
|
|
return 1;
|
|
|
|
if (atomic_read(&clnt->cl_count) == 0)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
case RPC_PIPEFS_UMOUNT:
|
|
|
|
if (clnt->cl_pipedir_objects.pdh_dentry == NULL)
|
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-04-27 03:00:17 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __rpc_clnt_handle_event(struct rpc_clnt *clnt, unsigned long event,
|
|
|
|
struct super_block *sb)
|
2012-01-11 08:18:17 -07:00
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case RPC_PIPEFS_MOUNT:
|
2013-08-23 11:03:50 -06:00
|
|
|
dentry = rpc_setup_pipedir_sb(sb, clnt);
|
2012-10-23 08:43:25 -06:00
|
|
|
if (!dentry)
|
|
|
|
return -ENOENT;
|
2012-01-11 08:18:17 -07:00
|
|
|
if (IS_ERR(dentry))
|
|
|
|
return PTR_ERR(dentry);
|
|
|
|
break;
|
|
|
|
case RPC_PIPEFS_UMOUNT:
|
|
|
|
__rpc_clnt_remove_pipedir(clnt);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "%s: unknown event: %ld\n", __func__, event);
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-04-27 03:00:17 -06:00
|
|
|
static int __rpc_pipefs_event(struct rpc_clnt *clnt, unsigned long event,
|
|
|
|
struct super_block *sb)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
for (;; clnt = clnt->cl_parent) {
|
|
|
|
if (!rpc_clnt_skip_event(clnt, event))
|
|
|
|
error = __rpc_clnt_handle_event(clnt, event, sb);
|
|
|
|
if (error || clnt == clnt->cl_parent)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-02-27 11:05:29 -07:00
|
|
|
static struct rpc_clnt *rpc_get_client_for_event(struct net *net, int event)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
struct rpc_clnt *clnt;
|
|
|
|
|
|
|
|
spin_lock(&sn->rpc_client_lock);
|
|
|
|
list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
|
2012-04-27 03:00:17 -06:00
|
|
|
if (rpc_clnt_skip_event(clnt, event))
|
2012-02-27 11:05:29 -07:00
|
|
|
continue;
|
|
|
|
spin_unlock(&sn->rpc_client_lock);
|
|
|
|
return clnt;
|
|
|
|
}
|
|
|
|
spin_unlock(&sn->rpc_client_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-01-11 08:18:17 -07:00
|
|
|
static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
|
|
|
|
void *ptr)
|
|
|
|
{
|
|
|
|
struct super_block *sb = ptr;
|
|
|
|
struct rpc_clnt *clnt;
|
|
|
|
int error = 0;
|
|
|
|
|
2012-02-27 11:05:29 -07:00
|
|
|
while ((clnt = rpc_get_client_for_event(sb->s_fs_info, event))) {
|
2012-01-11 08:18:17 -07:00
|
|
|
error = __rpc_pipefs_event(clnt, event, sb);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block rpc_clients_block = {
|
|
|
|
.notifier_call = rpc_pipefs_event,
|
2012-01-10 05:13:19 -07:00
|
|
|
.priority = SUNRPC_PIPEFS_RPC_PRIO,
|
2012-01-11 08:18:17 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
int rpc_clients_notifier_register(void)
|
|
|
|
{
|
|
|
|
return rpc_pipefs_notifier_register(&rpc_clients_block);
|
|
|
|
}
|
|
|
|
|
|
|
|
void rpc_clients_notifier_unregister(void)
|
|
|
|
{
|
|
|
|
return rpc_pipefs_notifier_unregister(&rpc_clients_block);
|
|
|
|
}
|
|
|
|
|
2013-10-17 12:12:23 -06:00
|
|
|
static struct rpc_xprt *rpc_clnt_set_transport(struct rpc_clnt *clnt,
|
|
|
|
struct rpc_xprt *xprt,
|
|
|
|
const struct rpc_timeout *timeout)
|
|
|
|
{
|
|
|
|
struct rpc_xprt *old;
|
|
|
|
|
|
|
|
spin_lock(&clnt->cl_lock);
|
2013-10-28 14:42:44 -06:00
|
|
|
old = rcu_dereference_protected(clnt->cl_xprt,
|
|
|
|
lockdep_is_held(&clnt->cl_lock));
|
2013-10-17 12:12:23 -06:00
|
|
|
|
|
|
|
if (!xprt_bound(xprt))
|
|
|
|
clnt->cl_autobind = 1;
|
|
|
|
|
|
|
|
clnt->cl_timeout = timeout;
|
|
|
|
rcu_assign_pointer(clnt->cl_xprt, xprt);
|
|
|
|
spin_unlock(&clnt->cl_lock);
|
|
|
|
|
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
2012-04-30 09:52:40 -06:00
|
|
|
static void rpc_clnt_set_nodename(struct rpc_clnt *clnt, const char *nodename)
|
|
|
|
{
|
2015-01-30 16:12:28 -07:00
|
|
|
clnt->cl_nodelen = strlcpy(clnt->cl_nodename,
|
|
|
|
nodename, sizeof(clnt->cl_nodename));
|
2012-04-30 09:52:40 -06:00
|
|
|
}
|
|
|
|
|
2013-10-17 12:12:17 -06:00
|
|
|
static int rpc_client_register(struct rpc_clnt *clnt,
|
|
|
|
rpc_authflavor_t pseudoflavor,
|
|
|
|
const char *client_name)
|
2013-06-24 01:52:52 -06:00
|
|
|
{
|
2013-08-26 17:23:04 -06:00
|
|
|
struct rpc_auth_create_args auth_args = {
|
2013-10-17 12:12:17 -06:00
|
|
|
.pseudoflavor = pseudoflavor,
|
|
|
|
.target_name = client_name,
|
2013-08-26 17:23:04 -06:00
|
|
|
};
|
2013-06-24 01:52:52 -06:00
|
|
|
struct rpc_auth *auth;
|
|
|
|
struct net *net = rpc_net_ns(clnt);
|
|
|
|
struct super_block *pipefs_sb;
|
2013-07-10 13:33:01 -06:00
|
|
|
int err;
|
2013-06-24 01:52:52 -06:00
|
|
|
|
2014-11-26 12:44:43 -07:00
|
|
|
err = rpc_clnt_debugfs_register(clnt);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2013-06-24 01:52:52 -06:00
|
|
|
pipefs_sb = rpc_get_sb_net(net);
|
|
|
|
if (pipefs_sb) {
|
2013-08-23 11:03:50 -06:00
|
|
|
err = rpc_setup_pipedir(pipefs_sb, clnt);
|
2013-06-24 01:52:52 -06:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-07-10 13:33:01 -06:00
|
|
|
rpc_register_client(clnt);
|
|
|
|
if (pipefs_sb)
|
|
|
|
rpc_put_sb_net(net);
|
|
|
|
|
2013-08-26 17:23:04 -06:00
|
|
|
auth = rpcauth_create(&auth_args, clnt);
|
2013-06-24 01:52:52 -06:00
|
|
|
if (IS_ERR(auth)) {
|
|
|
|
dprintk("RPC: Couldn't create auth handle (flavor %u)\n",
|
2013-10-17 12:12:17 -06:00
|
|
|
pseudoflavor);
|
2013-06-24 01:52:52 -06:00
|
|
|
err = PTR_ERR(auth);
|
|
|
|
goto err_auth;
|
|
|
|
}
|
2013-07-10 13:33:01 -06:00
|
|
|
return 0;
|
|
|
|
err_auth:
|
|
|
|
pipefs_sb = rpc_get_sb_net(net);
|
2013-07-14 20:57:50 -06:00
|
|
|
rpc_unregister_client(clnt);
|
2013-07-10 13:33:01 -06:00
|
|
|
__rpc_clnt_remove_pipedir(clnt);
|
2013-06-24 01:52:52 -06:00
|
|
|
out:
|
|
|
|
if (pipefs_sb)
|
|
|
|
rpc_put_sb_net(net);
|
2014-11-26 12:44:43 -07:00
|
|
|
rpc_clnt_debugfs_unregister(clnt);
|
2013-06-24 01:52:52 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-09-04 19:51:44 -06:00
|
|
|
static DEFINE_IDA(rpc_clids);
|
|
|
|
|
|
|
|
static int rpc_alloc_clid(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
int clid;
|
|
|
|
|
|
|
|
clid = ida_simple_get(&rpc_clids, 0, 0, GFP_KERNEL);
|
|
|
|
if (clid < 0)
|
|
|
|
return clid;
|
|
|
|
clnt->cl_clid = clid;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_free_clid(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
ida_simple_remove(&rpc_clids, clnt->cl_clid);
|
|
|
|
}
|
|
|
|
|
2013-09-02 11:28:04 -06:00
|
|
|
static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
|
|
|
|
struct rpc_xprt *xprt,
|
|
|
|
struct rpc_clnt *parent)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-01-20 11:53:56 -07:00
|
|
|
const struct rpc_program *program = args->program;
|
|
|
|
const struct rpc_version *version;
|
2013-10-17 12:12:23 -06:00
|
|
|
struct rpc_clnt *clnt = NULL;
|
|
|
|
const struct rpc_timeout *timeout;
|
2015-01-30 16:12:28 -07:00
|
|
|
const char *nodename = args->nodename;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
2007-09-11 16:00:20 -06:00
|
|
|
|
|
|
|
/* sanity check the name before trying to print it */
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: creating %s client for %s (xprt %p)\n",
|
2007-12-20 14:03:53 -07:00
|
|
|
program->name, args->servername, xprt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-14 15:26:17 -06:00
|
|
|
err = rpciod_up();
|
|
|
|
if (err)
|
|
|
|
goto out_no_rpciod;
|
2007-12-20 14:03:53 -07:00
|
|
|
|
2013-04-05 12:13:21 -06:00
|
|
|
err = -EINVAL;
|
2007-12-20 14:03:53 -07:00
|
|
|
if (args->version >= program->nrvers)
|
|
|
|
goto out_err;
|
|
|
|
version = program->version[args->version];
|
|
|
|
if (version == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
err = -ENOMEM;
|
2006-07-21 15:51:30 -06:00
|
|
|
clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!clnt)
|
|
|
|
goto out_err;
|
2013-09-02 11:28:04 -06:00
|
|
|
clnt->cl_parent = parent ? : clnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-09-04 19:51:44 -06:00
|
|
|
err = rpc_alloc_clid(clnt);
|
|
|
|
if (err)
|
|
|
|
goto out_no_clid;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
clnt->cl_procinfo = version->procs;
|
|
|
|
clnt->cl_maxproc = version->nrprocs;
|
2008-09-28 00:21:26 -06:00
|
|
|
clnt->cl_prog = args->prognumber ? : program->number;
|
2005-04-16 16:20:36 -06:00
|
|
|
clnt->cl_vers = version->number;
|
|
|
|
clnt->cl_stats = program->stats;
|
2006-03-20 11:44:22 -07:00
|
|
|
clnt->cl_metrics = rpc_alloc_iostats(clnt);
|
2013-08-26 13:38:11 -06:00
|
|
|
rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects);
|
2006-11-21 08:40:23 -07:00
|
|
|
err = -ENOMEM;
|
|
|
|
if (clnt->cl_metrics == NULL)
|
|
|
|
goto out_no_stats;
|
2006-11-16 09:37:27 -07:00
|
|
|
clnt->cl_program = program;
|
2007-06-14 14:40:14 -06:00
|
|
|
INIT_LIST_HEAD(&clnt->cl_tasks);
|
2007-06-16 12:17:01 -06:00
|
|
|
spin_lock_init(&clnt->cl_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-10-17 12:12:23 -06:00
|
|
|
timeout = xprt->timeout;
|
2007-12-20 14:03:55 -07:00
|
|
|
if (args->timeout != NULL) {
|
|
|
|
memcpy(&clnt->cl_timeout_default, args->timeout,
|
|
|
|
sizeof(clnt->cl_timeout_default));
|
2013-10-17 12:12:23 -06:00
|
|
|
timeout = &clnt->cl_timeout_default;
|
2007-12-20 14:03:55 -07:00
|
|
|
}
|
|
|
|
|
2013-10-17 12:12:23 -06:00
|
|
|
rpc_clnt_set_transport(clnt, xprt, timeout);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
clnt->cl_rtt = &clnt->cl_rtt_default;
|
2007-12-20 14:03:55 -07:00
|
|
|
rpc_init_rtt(&clnt->cl_rtt_default, clnt->cl_timeout->to_initval);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-09-12 17:55:25 -06:00
|
|
|
atomic_set(&clnt->cl_count, 1);
|
2007-06-14 14:40:31 -06:00
|
|
|
|
2015-01-30 16:12:28 -07:00
|
|
|
if (nodename == NULL)
|
|
|
|
nodename = utsname()->nodename;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* save the nodename */
|
2015-01-30 16:12:28 -07:00
|
|
|
rpc_clnt_set_nodename(clnt, nodename);
|
2013-06-24 01:52:52 -06:00
|
|
|
|
2013-10-17 12:12:17 -06:00
|
|
|
err = rpc_client_register(clnt, args->authflavor, args->client_name);
|
2013-06-24 01:52:52 -06:00
|
|
|
if (err)
|
|
|
|
goto out_no_path;
|
2013-09-02 11:28:04 -06:00
|
|
|
if (parent)
|
|
|
|
atomic_inc(&parent->cl_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
return clnt;
|
|
|
|
|
|
|
|
out_no_path:
|
2006-11-21 08:40:23 -07:00
|
|
|
rpc_free_iostats(clnt->cl_metrics);
|
|
|
|
out_no_stats:
|
2013-09-04 19:51:44 -06:00
|
|
|
rpc_free_clid(clnt);
|
|
|
|
out_no_clid:
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(clnt);
|
|
|
|
out_err:
|
2007-06-14 15:26:17 -06:00
|
|
|
rpciod_down();
|
|
|
|
out_no_rpciod:
|
2013-04-05 12:13:21 -06:00
|
|
|
xprt_put(xprt);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
2014-03-23 21:58:59 -06:00
|
|
|
struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
|
|
|
|
struct rpc_xprt *xprt)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = NULL;
|
|
|
|
|
|
|
|
clnt = rpc_new_client(args, xprt, NULL);
|
|
|
|
if (IS_ERR(clnt))
|
|
|
|
return clnt;
|
|
|
|
|
|
|
|
if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
|
|
|
|
int err = rpc_ping(clnt);
|
|
|
|
if (err != 0) {
|
|
|
|
rpc_shutdown_client(clnt);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clnt->cl_softrtry = 1;
|
|
|
|
if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
|
|
|
|
clnt->cl_softrtry = 0;
|
|
|
|
|
|
|
|
if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
|
|
|
|
clnt->cl_autobind = 1;
|
2014-09-24 20:35:58 -06:00
|
|
|
if (args->flags & RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT)
|
|
|
|
clnt->cl_noretranstimeo = 1;
|
2014-03-23 21:58:59 -06:00
|
|
|
if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
|
|
|
|
clnt->cl_discrtry = 1;
|
|
|
|
if (!(args->flags & RPC_CLNT_CREATE_QUIET))
|
|
|
|
clnt->cl_chatty = 1;
|
|
|
|
|
|
|
|
return clnt;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_create_xprt);
|
|
|
|
|
2012-07-10 04:55:09 -06:00
|
|
|
/**
|
2006-08-22 18:06:20 -06:00
|
|
|
* rpc_create - create an RPC client and transport with one call
|
|
|
|
* @args: rpc_clnt create argument structure
|
|
|
|
*
|
|
|
|
* Creates and initializes an RPC transport and an RPC client.
|
|
|
|
*
|
|
|
|
* It can ping the server in order to determine if it is up, and to see if
|
|
|
|
* it supports this program and version. RPC_CLNT_CREATE_NOPING disables
|
|
|
|
* this behavior so asynchronous tasks can also use rpc_create.
|
|
|
|
*/
|
|
|
|
struct rpc_clnt *rpc_create(struct rpc_create_args *args)
|
|
|
|
{
|
|
|
|
struct rpc_xprt *xprt;
|
2007-09-10 11:47:07 -06:00
|
|
|
struct xprt_create xprtargs = {
|
2010-09-29 06:05:12 -06:00
|
|
|
.net = args->net,
|
2007-09-10 11:47:57 -06:00
|
|
|
.ident = args->protocol,
|
2007-07-09 14:23:35 -06:00
|
|
|
.srcaddr = args->saddress,
|
2007-07-08 05:08:54 -06:00
|
|
|
.dstaddr = args->address,
|
|
|
|
.addrlen = args->addrsize,
|
2012-03-01 15:01:05 -07:00
|
|
|
.servername = args->servername,
|
2009-09-10 08:33:30 -06:00
|
|
|
.bc_xprt = args->bc_xprt,
|
2007-07-08 05:08:54 -06:00
|
|
|
};
|
2007-12-10 12:56:24 -07:00
|
|
|
char servername[48];
|
2006-08-22 18:06:20 -06:00
|
|
|
|
2013-04-14 09:42:00 -06:00
|
|
|
if (args->flags & RPC_CLNT_CREATE_INFINITE_SLOTS)
|
|
|
|
xprtargs.flags |= XPRT_CREATE_INFINITE_SLOTS;
|
2013-04-11 13:06:36 -06:00
|
|
|
if (args->flags & RPC_CLNT_CREATE_NO_IDLE_TIMEOUT)
|
|
|
|
xprtargs.flags |= XPRT_CREATE_NO_IDLE_TIMEOUT;
|
2007-07-01 10:13:22 -06:00
|
|
|
/*
|
|
|
|
* If the caller chooses not to specify a hostname, whip
|
|
|
|
* up a string representation of the passed-in address.
|
|
|
|
*/
|
2012-03-01 15:01:05 -07:00
|
|
|
if (xprtargs.servername == NULL) {
|
2011-05-09 13:22:44 -06:00
|
|
|
struct sockaddr_un *sun =
|
|
|
|
(struct sockaddr_un *)args->address;
|
2011-05-09 13:22:25 -06:00
|
|
|
struct sockaddr_in *sin =
|
|
|
|
(struct sockaddr_in *)args->address;
|
|
|
|
struct sockaddr_in6 *sin6 =
|
|
|
|
(struct sockaddr_in6 *)args->address;
|
|
|
|
|
2007-12-10 12:56:24 -07:00
|
|
|
servername[0] = '\0';
|
|
|
|
switch (args->address->sa_family) {
|
2011-05-09 13:22:44 -06:00
|
|
|
case AF_LOCAL:
|
|
|
|
snprintf(servername, sizeof(servername), "%s",
|
|
|
|
sun->sun_path);
|
|
|
|
break;
|
2011-05-09 13:22:25 -06:00
|
|
|
case AF_INET:
|
2008-10-31 01:54:56 -06:00
|
|
|
snprintf(servername, sizeof(servername), "%pI4",
|
|
|
|
&sin->sin_addr.s_addr);
|
2007-12-10 12:56:24 -07:00
|
|
|
break;
|
2011-05-09 13:22:25 -06:00
|
|
|
case AF_INET6:
|
2008-10-29 13:52:50 -06:00
|
|
|
snprintf(servername, sizeof(servername), "%pI6",
|
2011-05-09 13:22:25 -06:00
|
|
|
&sin6->sin6_addr);
|
2007-12-10 12:56:24 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* caller wants default server name, but
|
|
|
|
* address family isn't recognized. */
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
2012-03-01 15:01:05 -07:00
|
|
|
xprtargs.servername = servername;
|
2007-07-01 10:13:22 -06:00
|
|
|
}
|
|
|
|
|
2007-12-10 12:56:24 -07:00
|
|
|
xprt = xprt_create_transport(&xprtargs);
|
|
|
|
if (IS_ERR(xprt))
|
|
|
|
return (struct rpc_clnt *)xprt;
|
|
|
|
|
2006-08-22 18:06:20 -06:00
|
|
|
/*
|
|
|
|
* By default, kernel RPC client connects from a reserved port.
|
|
|
|
* CAP_NET_BIND_SERVICE will not be set for unprivileged requesters,
|
|
|
|
* but it is always enabled for rpciod, which handles the connect
|
|
|
|
* operation.
|
|
|
|
*/
|
|
|
|
xprt->resvport = 1;
|
|
|
|
if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
|
|
|
|
xprt->resvport = 0;
|
|
|
|
|
2014-03-23 21:58:59 -06:00
|
|
|
return rpc_create_xprt(args, xprt);
|
2006-08-22 18:06:20 -06:00
|
|
|
}
|
2006-08-22 18:06:22 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_create);
|
2006-08-22 18:06:20 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This function clones the RPC client structure. It allows us to share the
|
|
|
|
* same transport while varying parameters such as the authentication
|
|
|
|
* flavour.
|
|
|
|
*/
|
2012-09-14 15:23:52 -06:00
|
|
|
static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,
|
|
|
|
struct rpc_clnt *clnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct rpc_xprt *xprt;
|
2012-09-14 15:23:52 -06:00
|
|
|
struct rpc_clnt *new;
|
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-09-14 15:23:52 -06:00
|
|
|
err = -ENOMEM;
|
2012-03-01 15:00:56 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (xprt == NULL)
|
2012-09-14 15:23:52 -06:00
|
|
|
goto out_err;
|
|
|
|
args->servername = xprt->servername;
|
2015-01-30 16:12:28 -07:00
|
|
|
args->nodename = clnt->cl_nodename;
|
2012-09-14 15:23:52 -06:00
|
|
|
|
2013-09-02 11:28:04 -06:00
|
|
|
new = rpc_new_client(args, xprt, clnt);
|
2012-09-14 15:23:52 -06:00
|
|
|
if (IS_ERR(new)) {
|
|
|
|
err = PTR_ERR(new);
|
2013-03-22 10:52:59 -06:00
|
|
|
goto out_err;
|
2012-09-14 15:23:52 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Turn off autobind on clones */
|
|
|
|
new->cl_autobind = 0;
|
|
|
|
new->cl_softrtry = clnt->cl_softrtry;
|
2014-09-24 20:35:58 -06:00
|
|
|
new->cl_noretranstimeo = clnt->cl_noretranstimeo;
|
2012-09-14 15:23:52 -06:00
|
|
|
new->cl_discrtry = clnt->cl_discrtry;
|
|
|
|
new->cl_chatty = clnt->cl_chatty;
|
2005-04-16 16:20:36 -06:00
|
|
|
return new;
|
2012-09-14 15:23:52 -06:00
|
|
|
|
|
|
|
out_err:
|
2008-03-05 21:47:47 -07:00
|
|
|
dprintk("RPC: %s: returned error %d\n", __func__, err);
|
2006-11-16 09:37:27 -07:00
|
|
|
return ERR_PTR(err);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-09-14 15:23:52 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_clone_client - Clone an RPC client structure
|
|
|
|
*
|
|
|
|
* @clnt: RPC client whose parameters are copied
|
|
|
|
*
|
|
|
|
* Returns a fresh RPC client or an ERR_PTR.
|
|
|
|
*/
|
|
|
|
struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
struct rpc_create_args args = {
|
|
|
|
.program = clnt->cl_program,
|
|
|
|
.prognumber = clnt->cl_prog,
|
|
|
|
.version = clnt->cl_vers,
|
|
|
|
.authflavor = clnt->cl_auth->au_flavor,
|
|
|
|
};
|
|
|
|
return __rpc_clone_client(&args, clnt);
|
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_clone_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-09-14 15:24:02 -06:00
|
|
|
/**
|
|
|
|
* rpc_clone_client_set_auth - Clone an RPC client structure and set its auth
|
|
|
|
*
|
|
|
|
* @clnt: RPC client whose parameters are copied
|
2013-01-09 18:12:35 -07:00
|
|
|
* @flavor: security flavor for new client
|
2012-09-14 15:24:02 -06:00
|
|
|
*
|
|
|
|
* Returns a fresh RPC client or an ERR_PTR.
|
|
|
|
*/
|
|
|
|
struct rpc_clnt *
|
|
|
|
rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
|
|
|
|
{
|
|
|
|
struct rpc_create_args args = {
|
|
|
|
.program = clnt->cl_program,
|
|
|
|
.prognumber = clnt->cl_prog,
|
|
|
|
.version = clnt->cl_vers,
|
|
|
|
.authflavor = flavor,
|
|
|
|
};
|
|
|
|
return __rpc_clone_client(&args, clnt);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_clone_client_set_auth);
|
|
|
|
|
2013-10-17 12:12:23 -06:00
|
|
|
/**
|
|
|
|
* rpc_switch_client_transport: switch the RPC transport on the fly
|
|
|
|
* @clnt: pointer to a struct rpc_clnt
|
|
|
|
* @args: pointer to the new transport arguments
|
|
|
|
* @timeout: pointer to the new timeout parameters
|
|
|
|
*
|
|
|
|
* This function allows the caller to switch the RPC transport for the
|
|
|
|
* rpc_clnt structure 'clnt' to allow it to connect to a mirrored NFS
|
|
|
|
* server, for instance. It assumes that the caller has ensured that
|
|
|
|
* there are no active RPC tasks by using some form of locking.
|
|
|
|
*
|
|
|
|
* Returns zero if "clnt" is now using the new xprt. Otherwise a
|
|
|
|
* negative errno is returned, and "clnt" continues to use the old
|
|
|
|
* xprt.
|
|
|
|
*/
|
|
|
|
int rpc_switch_client_transport(struct rpc_clnt *clnt,
|
|
|
|
struct xprt_create *args,
|
|
|
|
const struct rpc_timeout *timeout)
|
|
|
|
{
|
|
|
|
const struct rpc_timeout *old_timeo;
|
|
|
|
rpc_authflavor_t pseudoflavor;
|
|
|
|
struct rpc_xprt *xprt, *old;
|
|
|
|
struct rpc_clnt *parent;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
xprt = xprt_create_transport(args);
|
|
|
|
if (IS_ERR(xprt)) {
|
|
|
|
dprintk("RPC: failed to create new xprt for clnt %p\n",
|
|
|
|
clnt);
|
|
|
|
return PTR_ERR(xprt);
|
|
|
|
}
|
|
|
|
|
|
|
|
pseudoflavor = clnt->cl_auth->au_flavor;
|
|
|
|
|
|
|
|
old_timeo = clnt->cl_timeout;
|
|
|
|
old = rpc_clnt_set_transport(clnt, xprt, timeout);
|
|
|
|
|
|
|
|
rpc_unregister_client(clnt);
|
|
|
|
__rpc_clnt_remove_pipedir(clnt);
|
2014-11-26 12:44:43 -07:00
|
|
|
rpc_clnt_debugfs_unregister(clnt);
|
2013-10-17 12:12:23 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A new transport was created. "clnt" therefore
|
|
|
|
* becomes the root of a new cl_parent tree. clnt's
|
|
|
|
* children, if it has any, still point to the old xprt.
|
|
|
|
*/
|
|
|
|
parent = clnt->cl_parent;
|
|
|
|
clnt->cl_parent = clnt;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The old rpc_auth cache cannot be re-used. GSS
|
|
|
|
* contexts in particular are between a single
|
|
|
|
* client and server.
|
|
|
|
*/
|
|
|
|
err = rpc_client_register(clnt, pseudoflavor, NULL);
|
|
|
|
if (err)
|
|
|
|
goto out_revert;
|
|
|
|
|
|
|
|
synchronize_rcu();
|
|
|
|
if (parent != clnt)
|
|
|
|
rpc_release_client(parent);
|
|
|
|
xprt_put(old);
|
|
|
|
dprintk("RPC: replaced xprt for clnt %p\n", clnt);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_revert:
|
|
|
|
rpc_clnt_set_transport(clnt, old, old_timeo);
|
|
|
|
clnt->cl_parent = parent;
|
|
|
|
rpc_client_register(clnt, pseudoflavor, NULL);
|
|
|
|
xprt_put(xprt);
|
|
|
|
dprintk("RPC: failed to switch xprt for clnt %p\n", clnt);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_switch_client_transport);
|
|
|
|
|
2010-07-31 12:29:08 -06:00
|
|
|
/*
|
|
|
|
* Kill all tasks for the given client.
|
|
|
|
* XXX: kill their descendants as well?
|
|
|
|
*/
|
|
|
|
void rpc_killall_tasks(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
struct rpc_task *rovr;
|
|
|
|
|
|
|
|
|
|
|
|
if (list_empty(&clnt->cl_tasks))
|
|
|
|
return;
|
|
|
|
dprintk("RPC: killing all tasks for client %p\n", clnt);
|
|
|
|
/*
|
|
|
|
* Spin lock all_tasks to prevent changes...
|
|
|
|
*/
|
|
|
|
spin_lock(&clnt->cl_lock);
|
|
|
|
list_for_each_entry(rovr, &clnt->cl_tasks, tk_task) {
|
|
|
|
if (!RPC_IS_ACTIVATED(rovr))
|
|
|
|
continue;
|
|
|
|
if (!(rovr->tk_flags & RPC_TASK_KILLED)) {
|
|
|
|
rovr->tk_flags |= RPC_TASK_KILLED;
|
|
|
|
rpc_exit(rovr, -EIO);
|
2011-03-17 09:54:23 -06:00
|
|
|
if (RPC_IS_QUEUED(rovr))
|
|
|
|
rpc_wake_up_queued_task(rovr->tk_waitqueue,
|
|
|
|
rovr);
|
2010-07-31 12:29:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&clnt->cl_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_killall_tasks);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Properly shut down an RPC client, terminating all outstanding
|
2007-06-09 17:49:36 -06:00
|
|
|
* requests.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-06-14 14:40:32 -06:00
|
|
|
void rpc_shutdown_client(struct rpc_clnt *clnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-10-30 15:01:40 -06:00
|
|
|
might_sleep();
|
|
|
|
|
2012-03-01 15:01:05 -07:00
|
|
|
dprintk_rcu("RPC: shutting down %s client for %s\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name,
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-14 14:40:31 -06:00
|
|
|
while (!list_empty(&clnt->cl_tasks)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_killall_tasks(clnt);
|
2006-01-09 21:52:53 -07:00
|
|
|
wait_event_timeout(destroy_wait,
|
2007-06-14 14:40:31 -06:00
|
|
|
list_empty(&clnt->cl_tasks), 1*HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-06-14 14:40:32 -06:00
|
|
|
rpc_release_client(clnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_shutdown_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2007-06-14 14:40:31 -06:00
|
|
|
* Free an RPC client
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-11-12 15:24:36 -07:00
|
|
|
static struct rpc_clnt *
|
2010-09-12 17:55:25 -06:00
|
|
|
rpc_free_client(struct rpc_clnt *clnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-11-12 15:24:36 -07:00
|
|
|
struct rpc_clnt *parent = NULL;
|
|
|
|
|
2012-03-01 15:01:05 -07:00
|
|
|
dprintk_rcu("RPC: destroying %s client for %s\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name,
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2012-01-20 11:53:37 -07:00
|
|
|
if (clnt->cl_parent != clnt)
|
2013-11-12 15:24:36 -07:00
|
|
|
parent = clnt->cl_parent;
|
2014-11-26 12:44:43 -07:00
|
|
|
rpc_clnt_debugfs_unregister(clnt);
|
2012-01-11 08:18:26 -07:00
|
|
|
rpc_clnt_remove_pipedir(clnt);
|
2013-06-26 00:15:14 -06:00
|
|
|
rpc_unregister_client(clnt);
|
2006-03-20 11:44:22 -07:00
|
|
|
rpc_free_iostats(clnt->cl_metrics);
|
|
|
|
clnt->cl_metrics = NULL;
|
2012-03-01 15:00:56 -07:00
|
|
|
xprt_put(rcu_dereference_raw(clnt->cl_xprt));
|
2007-06-14 15:26:17 -06:00
|
|
|
rpciod_down();
|
2013-09-04 19:51:44 -06:00
|
|
|
rpc_free_clid(clnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(clnt);
|
2013-11-12 15:24:36 -07:00
|
|
|
return parent;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-06-26 14:57:41 -06:00
|
|
|
/*
|
|
|
|
* Free an RPC client
|
|
|
|
*/
|
2013-11-12 15:24:36 -07:00
|
|
|
static struct rpc_clnt *
|
2010-09-12 17:55:25 -06:00
|
|
|
rpc_free_auth(struct rpc_clnt *clnt)
|
2007-06-26 14:57:41 -06:00
|
|
|
{
|
2013-11-12 15:24:36 -07:00
|
|
|
if (clnt->cl_auth == NULL)
|
|
|
|
return rpc_free_client(clnt);
|
2007-06-26 14:57:41 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: RPCSEC_GSS may need to send NULL RPC calls in order to
|
|
|
|
* release remaining GSS contexts. This mechanism ensures
|
|
|
|
* that it can do so safely.
|
|
|
|
*/
|
2010-09-12 17:55:25 -06:00
|
|
|
atomic_inc(&clnt->cl_count);
|
2007-06-26 14:57:41 -06:00
|
|
|
rpcauth_release(clnt->cl_auth);
|
|
|
|
clnt->cl_auth = NULL;
|
2010-09-12 17:55:25 -06:00
|
|
|
if (atomic_dec_and_test(&clnt->cl_count))
|
2013-11-12 15:24:36 -07:00
|
|
|
return rpc_free_client(clnt);
|
|
|
|
return NULL;
|
2007-06-26 14:57:41 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2007-06-14 14:40:31 -06:00
|
|
|
* Release reference to the RPC client
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
rpc_release_client(struct rpc_clnt *clnt)
|
|
|
|
{
|
2007-06-14 14:40:31 -06:00
|
|
|
dprintk("RPC: rpc_release_client(%p)\n", clnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-11-12 15:24:36 -07:00
|
|
|
do {
|
|
|
|
if (list_empty(&clnt->cl_tasks))
|
|
|
|
wake_up(&destroy_wait);
|
|
|
|
if (!atomic_dec_and_test(&clnt->cl_count))
|
|
|
|
break;
|
|
|
|
clnt = rpc_free_auth(clnt);
|
|
|
|
} while (clnt != NULL);
|
2007-06-14 14:40:31 -06:00
|
|
|
}
|
2012-05-25 16:09:55 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_release_client);
|
2007-06-14 14:40:31 -06:00
|
|
|
|
2005-06-22 11:16:23 -06:00
|
|
|
/**
|
|
|
|
* rpc_bind_new_program - bind a new RPC program to an existing client
|
2008-02-13 16:03:23 -07:00
|
|
|
* @old: old rpc_client
|
|
|
|
* @program: rpc program to set
|
|
|
|
* @vers: rpc program version
|
2005-06-22 11:16:23 -06:00
|
|
|
*
|
|
|
|
* Clones the rpc client and sets up a new RPC program. This is mainly
|
|
|
|
* of use for enabling different RPC programs to share the same transport.
|
|
|
|
* The Sun NFSv2/v3 ACL protocol can do this.
|
|
|
|
*/
|
|
|
|
struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
|
2012-01-20 11:53:56 -07:00
|
|
|
const struct rpc_program *program,
|
2007-09-11 16:00:09 -06:00
|
|
|
u32 vers)
|
2005-06-22 11:16:23 -06:00
|
|
|
{
|
2012-11-01 10:14:14 -06:00
|
|
|
struct rpc_create_args args = {
|
|
|
|
.program = program,
|
|
|
|
.prognumber = program->number,
|
|
|
|
.version = vers,
|
|
|
|
.authflavor = old->cl_auth->au_flavor,
|
|
|
|
};
|
2005-06-22 11:16:23 -06:00
|
|
|
struct rpc_clnt *clnt;
|
|
|
|
int err;
|
|
|
|
|
2012-11-01 10:14:14 -06:00
|
|
|
clnt = __rpc_clone_client(&args, old);
|
2005-06-22 11:16:23 -06:00
|
|
|
if (IS_ERR(clnt))
|
|
|
|
goto out;
|
2009-12-03 13:58:56 -07:00
|
|
|
err = rpc_ping(clnt);
|
2005-06-22 11:16:23 -06:00
|
|
|
if (err != 0) {
|
|
|
|
rpc_shutdown_client(clnt);
|
|
|
|
clnt = ERR_PTR(err);
|
|
|
|
}
|
2007-02-09 16:38:13 -07:00
|
|
|
out:
|
2005-06-22 11:16:23 -06:00
|
|
|
return clnt;
|
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_bind_new_program);
|
2005-06-22 11:16:23 -06:00
|
|
|
|
2010-07-31 12:29:08 -06:00
|
|
|
void rpc_task_release_client(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
|
|
|
|
if (clnt != NULL) {
|
|
|
|
/* Remove from client task list */
|
|
|
|
spin_lock(&clnt->cl_lock);
|
|
|
|
list_del(&task->tk_task);
|
|
|
|
spin_unlock(&clnt->cl_lock);
|
|
|
|
task->tk_client = NULL;
|
|
|
|
|
|
|
|
rpc_release_client(clnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
if (clnt != NULL) {
|
|
|
|
rpc_task_release_client(task);
|
|
|
|
task->tk_client = clnt;
|
2010-09-12 17:55:25 -06:00
|
|
|
atomic_inc(&clnt->cl_count);
|
2010-07-31 12:29:08 -06:00
|
|
|
if (clnt->cl_softrtry)
|
|
|
|
task->tk_flags |= RPC_TASK_SOFT;
|
2013-09-24 10:00:27 -06:00
|
|
|
if (clnt->cl_noretranstimeo)
|
|
|
|
task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
|
2012-07-31 17:45:12 -06:00
|
|
|
if (sk_memalloc_socks()) {
|
|
|
|
struct rpc_xprt *xprt;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xprt = rcu_dereference(clnt->cl_xprt);
|
|
|
|
if (xprt->swapper)
|
|
|
|
task->tk_flags |= RPC_TASK_SWAPPER;
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2010-07-31 12:29:08 -06:00
|
|
|
/* Add to the client's list of all tasks */
|
|
|
|
spin_lock(&clnt->cl_lock);
|
|
|
|
list_add_tail(&task->tk_task, &clnt->cl_tasks);
|
|
|
|
spin_unlock(&clnt->cl_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-28 18:34:20 -07:00
|
|
|
void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
rpc_task_release_client(task);
|
|
|
|
rpc_task_set_client(task, clnt);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_task_reset_client);
|
|
|
|
|
|
|
|
|
2010-07-31 12:29:08 -06:00
|
|
|
static void
|
|
|
|
rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
|
|
|
|
{
|
|
|
|
if (msg != NULL) {
|
|
|
|
task->tk_msg.rpc_proc = msg->rpc_proc;
|
|
|
|
task->tk_msg.rpc_argp = msg->rpc_argp;
|
|
|
|
task->tk_msg.rpc_resp = msg->rpc_resp;
|
2010-07-31 12:29:08 -06:00
|
|
|
if (msg->rpc_cred != NULL)
|
|
|
|
task->tk_msg.rpc_cred = get_rpccred(msg->rpc_cred);
|
2010-07-31 12:29:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Default callback for async RPC calls
|
|
|
|
*/
|
|
|
|
static void
|
2006-01-03 01:55:04 -07:00
|
|
|
rpc_default_callback(struct rpc_task *task, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:04 -07:00
|
|
|
static const struct rpc_call_ops rpc_default_ops = {
|
|
|
|
.rpc_call_done = rpc_default_callback,
|
|
|
|
};
|
|
|
|
|
2007-07-14 13:39:59 -06:00
|
|
|
/**
|
|
|
|
* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
|
|
|
|
* @task_setup_data: pointer to task initialisation data
|
|
|
|
*/
|
|
|
|
struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)
|
2007-06-12 08:02:37 -06:00
|
|
|
{
|
2010-04-16 14:41:10 -06:00
|
|
|
struct rpc_task *task;
|
2007-06-12 08:02:37 -06:00
|
|
|
|
2007-07-14 13:39:59 -06:00
|
|
|
task = rpc_new_task(task_setup_data);
|
2010-04-16 14:41:10 -06:00
|
|
|
if (IS_ERR(task))
|
2007-10-25 16:19:37 -06:00
|
|
|
goto out;
|
2007-06-12 08:02:37 -06:00
|
|
|
|
2010-07-31 12:29:08 -06:00
|
|
|
rpc_task_set_client(task, task_setup_data->rpc_client);
|
|
|
|
rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
|
|
|
|
|
|
|
|
if (task->tk_action == NULL)
|
|
|
|
rpc_call_start(task);
|
|
|
|
|
2007-06-12 08:02:37 -06:00
|
|
|
atomic_inc(&task->tk_count);
|
|
|
|
rpc_execute(task);
|
|
|
|
out:
|
2010-04-16 14:41:10 -06:00
|
|
|
return task;
|
2007-06-12 08:02:37 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_run_task);
|
2007-06-12 08:02:37 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_call_sync - Perform a synchronous RPC call
|
|
|
|
* @clnt: pointer to RPC client
|
|
|
|
* @msg: RPC call parameters
|
|
|
|
* @flags: RPC call flags
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-14 09:11:30 -07:00
|
|
|
int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_task *task;
|
2007-07-14 13:39:59 -06:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.rpc_client = clnt,
|
|
|
|
.rpc_message = msg,
|
|
|
|
.callback_ops = &rpc_default_ops,
|
|
|
|
.flags = flags,
|
|
|
|
};
|
2007-06-12 08:02:37 -06:00
|
|
|
int status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-01 14:04:40 -06:00
|
|
|
WARN_ON_ONCE(flags & RPC_TASK_ASYNC);
|
|
|
|
if (flags & RPC_TASK_ASYNC) {
|
|
|
|
rpc_release_calldata(task_setup_data.callback_ops,
|
|
|
|
task_setup_data.callback_data);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-14 13:39:59 -06:00
|
|
|
task = rpc_run_task(&task_setup_data);
|
2007-06-12 08:02:37 -06:00
|
|
|
if (IS_ERR(task))
|
|
|
|
return PTR_ERR(task);
|
2006-01-03 01:55:10 -07:00
|
|
|
status = task->tk_status;
|
2007-01-24 12:54:53 -07:00
|
|
|
rpc_put_task(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
return status;
|
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_call_sync);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-12 08:02:37 -06:00
|
|
|
/**
|
|
|
|
* rpc_call_async - Perform an asynchronous RPC call
|
|
|
|
* @clnt: pointer to RPC client
|
|
|
|
* @msg: RPC call parameters
|
|
|
|
* @flags: RPC call flags
|
2008-02-13 16:03:23 -07:00
|
|
|
* @tk_ops: RPC call ops
|
2007-06-12 08:02:37 -06:00
|
|
|
* @data: user call data
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
2008-02-14 09:11:30 -07:00
|
|
|
rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags,
|
2006-01-03 01:55:04 -07:00
|
|
|
const struct rpc_call_ops *tk_ops, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_task *task;
|
2007-07-14 13:39:59 -06:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.rpc_client = clnt,
|
|
|
|
.rpc_message = msg,
|
|
|
|
.callback_ops = tk_ops,
|
|
|
|
.callback_data = data,
|
|
|
|
.flags = flags|RPC_TASK_ASYNC,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-14 13:39:59 -06:00
|
|
|
task = rpc_run_task(&task_setup_data);
|
2007-06-12 08:02:37 -06:00
|
|
|
if (IS_ERR(task))
|
|
|
|
return PTR_ERR(task);
|
|
|
|
rpc_put_task(task);
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_call_async);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-13 17:20:49 -06:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 07:23:03 -06:00
|
|
|
/**
|
|
|
|
* rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
|
|
|
|
* rpc_execute against it
|
2009-09-24 12:58:42 -06:00
|
|
|
* @req: RPC request
|
|
|
|
* @tk_ops: RPC call ops
|
2009-04-01 07:23:03 -06:00
|
|
|
*/
|
|
|
|
struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
|
2009-09-24 12:58:42 -06:00
|
|
|
const struct rpc_call_ops *tk_ops)
|
2009-04-01 07:23:03 -06:00
|
|
|
{
|
|
|
|
struct rpc_task *task;
|
|
|
|
struct xdr_buf *xbufp = &req->rq_snd_buf;
|
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.callback_ops = tk_ops,
|
|
|
|
};
|
|
|
|
|
|
|
|
dprintk("RPC: rpc_run_bc_task req= %p\n", req);
|
|
|
|
/*
|
|
|
|
* Create an rpc_task to send the data
|
|
|
|
*/
|
|
|
|
task = rpc_new_task(&task_setup_data);
|
2010-04-16 14:41:10 -06:00
|
|
|
if (IS_ERR(task)) {
|
2009-04-01 07:23:03 -06:00
|
|
|
xprt_free_bc_request(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
task->tk_rqstp = req;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the xdr_buf length.
|
|
|
|
* This also indicates that the buffer is XDR encoded already.
|
|
|
|
*/
|
|
|
|
xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
|
|
|
|
xbufp->tail[0].iov_len;
|
|
|
|
|
|
|
|
task->tk_action = call_bc_transmit;
|
|
|
|
atomic_inc(&task->tk_count);
|
2012-10-23 08:43:27 -06:00
|
|
|
WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
|
2009-04-01 07:23:03 -06:00
|
|
|
rpc_execute(task);
|
|
|
|
|
|
|
|
out:
|
|
|
|
dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
|
|
|
|
return task;
|
|
|
|
}
|
2011-07-13 17:20:49 -06:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2009-04-01 07:23:03 -06:00
|
|
|
|
2007-10-25 16:40:21 -06:00
|
|
|
void
|
|
|
|
rpc_call_start(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
task->tk_action = call_start;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_call_start);
|
|
|
|
|
2006-08-22 18:06:17 -06:00
|
|
|
/**
|
|
|
|
* rpc_peeraddr - extract remote peer address from clnt's xprt
|
|
|
|
* @clnt: RPC client structure
|
|
|
|
* @buf: target buffer
|
2008-02-13 16:03:23 -07:00
|
|
|
* @bufsize: length of target buffer
|
2006-08-22 18:06:17 -06:00
|
|
|
*
|
|
|
|
* Returns the number of bytes that are actually in the stored address.
|
|
|
|
*/
|
|
|
|
size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)
|
|
|
|
{
|
|
|
|
size_t bytes;
|
2012-03-01 15:00:56 -07:00
|
|
|
struct rpc_xprt *xprt;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xprt = rcu_dereference(clnt->cl_xprt);
|
2006-08-22 18:06:17 -06:00
|
|
|
|
2012-03-01 15:00:56 -07:00
|
|
|
bytes = xprt->addrlen;
|
2006-08-22 18:06:17 -06:00
|
|
|
if (bytes > bufsize)
|
|
|
|
bytes = bufsize;
|
2012-03-01 15:00:56 -07:00
|
|
|
memcpy(buf, &xprt->addr, bytes);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return bytes;
|
2006-08-22 18:06:17 -06:00
|
|
|
}
|
2006-08-22 18:06:22 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_peeraddr);
|
2006-08-22 18:06:17 -06:00
|
|
|
|
2006-08-22 18:06:18 -06:00
|
|
|
/**
|
|
|
|
* rpc_peeraddr2str - return remote peer address in printable format
|
|
|
|
* @clnt: RPC client structure
|
|
|
|
* @format: address format
|
|
|
|
*
|
2012-03-01 15:00:56 -07:00
|
|
|
* NB: the lifetime of the memory referenced by the returned pointer is
|
|
|
|
* the same as the rpc_xprt itself. As long as the caller uses this
|
|
|
|
* pointer, it must hold the RCU read lock.
|
2006-08-22 18:06:18 -06:00
|
|
|
*/
|
2008-01-07 16:34:48 -07:00
|
|
|
const char *rpc_peeraddr2str(struct rpc_clnt *clnt,
|
|
|
|
enum rpc_display_format_t format)
|
2006-08-22 18:06:18 -06:00
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct rpc_xprt *xprt;
|
|
|
|
|
|
|
|
xprt = rcu_dereference(clnt->cl_xprt);
|
2006-12-05 14:35:37 -07:00
|
|
|
|
|
|
|
if (xprt->address_strings[format] != NULL)
|
|
|
|
return xprt->address_strings[format];
|
|
|
|
else
|
|
|
|
return "unprintable";
|
2006-08-22 18:06:18 -06:00
|
|
|
}
|
2006-08-22 18:06:22 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_peeraddr2str);
|
2006-08-22 18:06:18 -06:00
|
|
|
|
2012-03-01 15:01:14 -07:00
|
|
|
static const struct sockaddr_in rpc_inaddr_loopback = {
|
|
|
|
.sin_family = AF_INET,
|
|
|
|
.sin_addr.s_addr = htonl(INADDR_ANY),
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sockaddr_in6 rpc_in6addr_loopback = {
|
|
|
|
.sin6_family = AF_INET6,
|
|
|
|
.sin6_addr = IN6ADDR_ANY_INIT,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try a getsockname() on a connected datagram socket. Using a
|
|
|
|
* connected datagram socket prevents leaving a socket in TIME_WAIT.
|
|
|
|
* This conserves the ephemeral port number space.
|
|
|
|
*
|
|
|
|
* Returns zero and fills in "buf" if successful; otherwise, a
|
|
|
|
* negative errno is returned.
|
|
|
|
*/
|
|
|
|
static int rpc_sockname(struct net *net, struct sockaddr *sap, size_t salen,
|
|
|
|
struct sockaddr *buf, int buflen)
|
|
|
|
{
|
|
|
|
struct socket *sock;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = __sock_create(net, sap->sa_family,
|
|
|
|
SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
|
|
|
|
if (err < 0) {
|
|
|
|
dprintk("RPC: can't create UDP socket (%d)\n", err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (sap->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
err = kernel_bind(sock,
|
|
|
|
(struct sockaddr *)&rpc_inaddr_loopback,
|
|
|
|
sizeof(rpc_inaddr_loopback));
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
err = kernel_bind(sock,
|
|
|
|
(struct sockaddr *)&rpc_in6addr_loopback,
|
|
|
|
sizeof(rpc_in6addr_loopback));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = -EAFNOSUPPORT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (err < 0) {
|
|
|
|
dprintk("RPC: can't bind UDP socket (%d)\n", err);
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = kernel_connect(sock, sap, salen, 0);
|
|
|
|
if (err < 0) {
|
|
|
|
dprintk("RPC: can't connect UDP socket (%d)\n", err);
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = kernel_getsockname(sock, buf, &buflen);
|
|
|
|
if (err < 0) {
|
|
|
|
dprintk("RPC: getsockname failed (%d)\n", err);
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
if (buf->sa_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
|
|
|
|
sin6->sin6_scope_id = 0;
|
|
|
|
}
|
|
|
|
dprintk("RPC: %s succeeded\n", __func__);
|
|
|
|
|
|
|
|
out_release:
|
|
|
|
sock_release(sock);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scraping a connected socket failed, so we don't have a useable
|
|
|
|
* local address. Fallback: generate an address that will prevent
|
|
|
|
* the server from calling us back.
|
|
|
|
*
|
|
|
|
* Returns zero and fills in "buf" if successful; otherwise, a
|
|
|
|
* negative errno is returned.
|
|
|
|
*/
|
|
|
|
static int rpc_anyaddr(int family, struct sockaddr *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
switch (family) {
|
|
|
|
case AF_INET:
|
|
|
|
if (buflen < sizeof(rpc_inaddr_loopback))
|
|
|
|
return -EINVAL;
|
|
|
|
memcpy(buf, &rpc_inaddr_loopback,
|
|
|
|
sizeof(rpc_inaddr_loopback));
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
if (buflen < sizeof(rpc_in6addr_loopback))
|
|
|
|
return -EINVAL;
|
|
|
|
memcpy(buf, &rpc_in6addr_loopback,
|
|
|
|
sizeof(rpc_in6addr_loopback));
|
|
|
|
default:
|
|
|
|
dprintk("RPC: %s: address family not supported\n",
|
|
|
|
__func__);
|
|
|
|
return -EAFNOSUPPORT;
|
|
|
|
}
|
|
|
|
dprintk("RPC: %s: succeeded\n", __func__);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_localaddr - discover local endpoint address for an RPC client
|
|
|
|
* @clnt: RPC client structure
|
|
|
|
* @buf: target buffer
|
|
|
|
* @buflen: size of target buffer, in bytes
|
|
|
|
*
|
|
|
|
* Returns zero and fills in "buf" and "buflen" if successful;
|
|
|
|
* otherwise, a negative errno is returned.
|
|
|
|
*
|
|
|
|
* This works even if the underlying transport is not currently connected,
|
|
|
|
* or if the upper layer never previously provided a source address.
|
|
|
|
*
|
|
|
|
* The result of this function call is transient: multiple calls in
|
|
|
|
* succession may give different results, depending on how local
|
|
|
|
* networking configuration changes over time.
|
|
|
|
*/
|
|
|
|
int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage address;
|
|
|
|
struct sockaddr *sap = (struct sockaddr *)&address;
|
|
|
|
struct rpc_xprt *xprt;
|
|
|
|
struct net *net;
|
|
|
|
size_t salen;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xprt = rcu_dereference(clnt->cl_xprt);
|
|
|
|
salen = xprt->addrlen;
|
|
|
|
memcpy(sap, &xprt->addr, salen);
|
|
|
|
net = get_net(xprt->xprt_net);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
rpc_set_port(sap, 0);
|
|
|
|
err = rpc_sockname(net, sap, salen, buf, buflen);
|
|
|
|
put_net(net);
|
|
|
|
if (err != 0)
|
|
|
|
/* Couldn't discover local address, return ANYADDR */
|
|
|
|
return rpc_anyaddr(sap->sa_family, buf, buflen);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_localaddr);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void
|
|
|
|
rpc_setbufsize(struct rpc_clnt *clnt, unsigned int sndsize, unsigned int rcvsize)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
struct rpc_xprt *xprt;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
xprt = rcu_dereference(clnt->cl_xprt);
|
2005-08-25 17:25:56 -06:00
|
|
|
if (xprt->ops->set_buffer_size)
|
|
|
|
xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
|
2012-03-01 15:00:56 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_setbufsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-01 15:00:56 -07:00
|
|
|
/**
|
|
|
|
* rpc_protocol - Get transport protocol number for an RPC client
|
|
|
|
* @clnt: RPC client to query
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int rpc_protocol(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
int protocol;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
protocol = rcu_dereference(clnt->cl_xprt)->prot;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return protocol;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_protocol);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_net_ns - Get the network namespace for this RPC client
|
|
|
|
* @clnt: RPC client to query
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct net *rpc_net_ns(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
struct net *ret;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
ret = rcu_dereference(clnt->cl_xprt)->xprt_net;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_net_ns);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_max_payload - Get maximum payload size for a transport, in bytes
|
|
|
|
* @clnt: RPC client to query
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* For stream transports, this is one RPC record fragment (see RFC
|
|
|
|
* 1831), as we don't support multi-record requests yet. For datagram
|
|
|
|
* transports, this is the size of an IP packet minus the IP, UDP, and
|
|
|
|
* RPC header sizes.
|
|
|
|
*/
|
|
|
|
size_t rpc_max_payload(struct rpc_clnt *clnt)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
size_t ret;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
ret = rcu_dereference(clnt->cl_xprt)->max_payload;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-08-22 18:06:22 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_max_payload);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-02-28 18:30:09 -07:00
|
|
|
/**
|
2013-03-02 16:54:11 -07:00
|
|
|
* rpc_get_timeout - Get timeout for transport in units of HZ
|
2013-02-28 18:30:09 -07:00
|
|
|
* @clnt: RPC client to query
|
|
|
|
*/
|
|
|
|
unsigned long rpc_get_timeout(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
unsigned long ret;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
ret = rcu_dereference(clnt->cl_xprt)->timeout->to_initval;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_get_timeout);
|
|
|
|
|
2006-01-03 01:55:50 -07:00
|
|
|
/**
|
|
|
|
* rpc_force_rebind - force transport to check that remote port is unchanged
|
|
|
|
* @clnt: client to rebind
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void rpc_force_rebind(struct rpc_clnt *clnt)
|
|
|
|
{
|
2012-03-01 15:00:56 -07:00
|
|
|
if (clnt->cl_autobind) {
|
|
|
|
rcu_read_lock();
|
|
|
|
xprt_clear_bound(rcu_dereference(clnt->cl_xprt));
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2006-01-03 01:55:50 -07:00
|
|
|
}
|
2006-08-22 18:06:22 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_force_rebind);
|
2006-01-03 01:55:50 -07:00
|
|
|
|
2009-04-01 07:22:40 -06:00
|
|
|
/*
|
|
|
|
* Restart an (async) RPC call from the call_prepare state.
|
|
|
|
* Usually called from within the exit handler.
|
|
|
|
*/
|
2010-07-31 12:29:07 -06:00
|
|
|
int
|
2009-04-01 07:22:40 -06:00
|
|
|
rpc_restart_call_prepare(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
if (RPC_ASSASSINATED(task))
|
2010-07-31 12:29:07 -06:00
|
|
|
return 0;
|
2011-10-19 13:17:29 -06:00
|
|
|
task->tk_action = call_start;
|
2014-03-20 10:59:09 -06:00
|
|
|
task->tk_status = 0;
|
2011-10-19 13:17:29 -06:00
|
|
|
if (task->tk_ops->rpc_call_prepare != NULL)
|
|
|
|
task->tk_action = rpc_prepare_task;
|
2010-07-31 12:29:07 -06:00
|
|
|
return 1;
|
2009-04-01 07:22:40 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_restart_call_prepare);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Restart an (async) RPC call. Usually called from within the
|
|
|
|
* exit handler.
|
|
|
|
*/
|
2010-07-31 12:29:07 -06:00
|
|
|
int
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_restart_call(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
if (RPC_ASSASSINATED(task))
|
2010-07-31 12:29:07 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_action = call_start;
|
2014-03-20 10:59:09 -06:00
|
|
|
task->tk_status = 0;
|
2010-07-31 12:29:07 -06:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_restart_call);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-17 14:58:04 -07:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
2014-11-26 12:44:43 -07:00
|
|
|
const char
|
|
|
|
*rpc_proc_name(const struct rpc_task *task)
|
2008-05-21 15:09:12 -06:00
|
|
|
{
|
|
|
|
const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
|
|
|
|
|
|
|
|
if (proc) {
|
|
|
|
if (proc->p_name)
|
|
|
|
return proc->p_name;
|
|
|
|
else
|
|
|
|
return "NULL";
|
|
|
|
} else
|
|
|
|
return "no proc";
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 0. Initial state
|
|
|
|
*
|
|
|
|
* Other FSM states can be visited zero or more times, but
|
|
|
|
* this state is visited exactly once for each RPC.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_start(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
|
2008-05-21 15:09:12 -06:00
|
|
|
dprintk("RPC: %5u call_start %s%d proc %s (%s)\n", task->tk_pid,
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name, clnt->cl_vers,
|
2008-05-21 15:09:12 -06:00
|
|
|
rpc_proc_name(task),
|
2007-01-31 10:14:08 -07:00
|
|
|
(RPC_IS_ASYNC(task) ? "async" : "sync"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Increment call count */
|
|
|
|
task->tk_msg.rpc_proc->p_count++;
|
|
|
|
clnt->cl_stats->rpccnt++;
|
|
|
|
task->tk_action = call_reserve;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 1. Reserve an RPC call slot
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_reserve(struct rpc_task *task)
|
|
|
|
{
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
task->tk_status = 0;
|
|
|
|
task->tk_action = call_reserveresult;
|
|
|
|
xprt_reserve(task);
|
|
|
|
}
|
|
|
|
|
2013-04-14 08:49:37 -06:00
|
|
|
static void call_retry_reserve(struct rpc_task *task);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 1b. Grok the result of xprt_reserve()
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_reserveresult(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
int status = task->tk_status;
|
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* After a call to xprt_reserve(), we must have either
|
|
|
|
* a request slot or else an error status.
|
|
|
|
*/
|
|
|
|
task->tk_status = 0;
|
|
|
|
if (status >= 0) {
|
|
|
|
if (task->tk_rqstp) {
|
2010-09-12 17:55:25 -06:00
|
|
|
task->tk_action = call_refresh;
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_ERR "%s: status=%d, but no request slot, exiting\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_exit(task, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Even though there was an error, we may have acquired
|
|
|
|
* a request slot somehow. Make sure not to leak it.
|
|
|
|
*/
|
|
|
|
if (task->tk_rqstp) {
|
|
|
|
printk(KERN_ERR "%s: status=%d, request allocated anyway\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
xprt_release(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (status) {
|
2012-05-19 10:12:53 -06:00
|
|
|
case -ENOMEM:
|
|
|
|
rpc_delay(task, HZ >> 2);
|
2005-04-16 16:20:36 -06:00
|
|
|
case -EAGAIN: /* woken up; retry */
|
2013-04-14 08:49:37 -06:00
|
|
|
task->tk_action = call_retry_reserve;
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
case -EIO: /* probably a shutdown */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "%s: unrecognized error %d, exiting\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
rpc_exit(task, status);
|
|
|
|
}
|
|
|
|
|
2013-04-14 08:49:37 -06:00
|
|
|
/*
|
|
|
|
* 1c. Retry reserving an RPC call slot
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_retry_reserve(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
dprint_status(task);
|
|
|
|
|
|
|
|
task->tk_status = 0;
|
|
|
|
task->tk_action = call_reserveresult;
|
|
|
|
xprt_retry_reserve(task);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-09-12 17:55:25 -06:00
|
|
|
* 2. Bind and/or refresh the credentials
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_refresh(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
dprint_status(task);
|
|
|
|
|
|
|
|
task->tk_action = call_refreshresult;
|
|
|
|
task->tk_status = 0;
|
|
|
|
task->tk_client->cl_stats->rpcauthrefresh++;
|
|
|
|
rpcauth_refreshcred(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2a. Process the results of a credential refresh
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_refreshresult(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
int status = task->tk_status;
|
|
|
|
|
|
|
|
dprint_status(task);
|
|
|
|
|
|
|
|
task->tk_status = 0;
|
2010-11-20 09:13:31 -07:00
|
|
|
task->tk_action = call_refresh;
|
2010-09-12 17:55:25 -06:00
|
|
|
switch (status) {
|
2010-11-20 09:13:31 -07:00
|
|
|
case 0:
|
2013-12-17 10:16:11 -07:00
|
|
|
if (rpcauth_uptodatecred(task)) {
|
2010-11-20 09:13:31 -07:00
|
|
|
task->tk_action = call_allocate;
|
2013-12-17 10:16:11 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Use rate-limiting and a max number of retries if refresh
|
|
|
|
* had status 0 but failed to update the cred.
|
|
|
|
*/
|
2010-09-12 17:55:25 -06:00
|
|
|
case -ETIMEDOUT:
|
|
|
|
rpc_delay(task, 3*HZ);
|
2010-11-20 09:13:31 -07:00
|
|
|
case -EAGAIN:
|
|
|
|
status = -EACCES;
|
2013-08-14 09:59:13 -06:00
|
|
|
case -EKEYEXPIRED:
|
2010-11-20 09:13:31 -07:00
|
|
|
if (!task->tk_cred_retry)
|
|
|
|
break;
|
|
|
|
task->tk_cred_retry--;
|
|
|
|
dprintk("RPC: %5u %s: retry refresh creds\n",
|
|
|
|
task->tk_pid, __func__);
|
|
|
|
return;
|
2010-09-12 17:55:25 -06:00
|
|
|
}
|
2010-11-20 09:13:31 -07:00
|
|
|
dprintk("RPC: %5u %s: refresh creds failed with error %d\n",
|
|
|
|
task->tk_pid, __func__, status);
|
|
|
|
rpc_exit(task, status);
|
2010-09-12 17:55:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2b. Allocate the buffer. For details, see sched.c:rpc_malloc.
|
2006-01-03 01:55:49 -07:00
|
|
|
* (Note: buffer memory is freed in xprt_release).
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_allocate(struct rpc_task *task)
|
|
|
|
{
|
2010-09-12 17:55:25 -06:00
|
|
|
unsigned int slack = task->tk_rqstp->rq_cred->cr_auth->au_cslack;
|
2006-01-03 01:55:49 -07:00
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
2013-01-08 07:10:21 -07:00
|
|
|
struct rpc_xprt *xprt = req->rq_xprt;
|
2007-03-29 14:47:53 -06:00
|
|
|
struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
|
|
|
|
2007-03-29 14:47:53 -06:00
|
|
|
task->tk_status = 0;
|
2010-09-12 17:55:25 -06:00
|
|
|
task->tk_action = call_bind;
|
2007-03-29 14:47:53 -06:00
|
|
|
|
2006-01-03 01:55:49 -07:00
|
|
|
if (req->rq_buffer)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
2007-03-29 14:47:53 -06:00
|
|
|
if (proc->p_proc != 0) {
|
|
|
|
BUG_ON(proc->p_arglen == 0);
|
|
|
|
if (proc->p_decode != NULL)
|
|
|
|
BUG_ON(proc->p_replen == 0);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-29 14:47:53 -06:00
|
|
|
/*
|
|
|
|
* Calculate the size (in quads) of the RPC call
|
|
|
|
* and reply headers, and convert both values
|
|
|
|
* to byte sizes.
|
|
|
|
*/
|
|
|
|
req->rq_callsize = RPC_CALLHDRSIZE + (slack << 1) + proc->p_arglen;
|
|
|
|
req->rq_callsize <<= 2;
|
|
|
|
req->rq_rcvsize = RPC_REPHDRSIZE + slack + proc->p_replen;
|
|
|
|
req->rq_rcvsize <<= 2;
|
|
|
|
|
2007-03-29 14:47:58 -06:00
|
|
|
req->rq_buffer = xprt->ops->buf_alloc(task,
|
|
|
|
req->rq_callsize + req->rq_rcvsize);
|
2007-03-29 14:47:53 -06:00
|
|
|
if (req->rq_buffer != NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2007-01-31 10:14:08 -07:00
|
|
|
|
|
|
|
dprintk("RPC: %5u rpc_buffer allocation failed\n", task->tk_pid);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-06-17 08:14:59 -06:00
|
|
|
if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
|
2007-10-01 10:06:44 -06:00
|
|
|
task->tk_action = call_allocate;
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_delay(task, HZ>>4);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rpc_exit(task, -ERESTARTSYS);
|
|
|
|
}
|
|
|
|
|
2005-11-09 19:45:24 -07:00
|
|
|
static inline int
|
|
|
|
rpc_task_need_encode(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
return task->tk_rqstp->rq_snd_buf.len == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rpc_task_force_reencode(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
task->tk_rqstp->rq_snd_buf.len = 0;
|
2009-08-28 09:12:12 -06:00
|
|
|
task->tk_rqstp->rq_bytes_sent = 0;
|
2005-11-09 19:45:24 -07:00
|
|
|
}
|
|
|
|
|
2007-03-29 14:47:53 -06:00
|
|
|
static inline void
|
|
|
|
rpc_xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
|
|
|
|
{
|
|
|
|
buf->head[0].iov_base = start;
|
|
|
|
buf->head[0].iov_len = len;
|
|
|
|
buf->tail[0].iov_len = 0;
|
|
|
|
buf->page_len = 0;
|
2007-09-10 11:44:58 -06:00
|
|
|
buf->flags = 0;
|
2007-03-29 14:47:53 -06:00
|
|
|
buf->len = 0;
|
|
|
|
buf->buflen = len;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 3. Encode arguments of an RPC call
|
|
|
|
*/
|
|
|
|
static void
|
2008-05-21 15:09:19 -06:00
|
|
|
rpc_xdr_encode(struct rpc_task *task)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
2010-12-14 07:59:18 -07:00
|
|
|
kxdreproc_t encode;
|
2006-09-26 23:29:38 -06:00
|
|
|
__be32 *p;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-29 14:47:53 -06:00
|
|
|
rpc_xdr_buf_init(&req->rq_snd_buf,
|
|
|
|
req->rq_buffer,
|
|
|
|
req->rq_callsize);
|
|
|
|
rpc_xdr_buf_init(&req->rq_rcv_buf,
|
|
|
|
(char *)req->rq_buffer + req->rq_callsize,
|
|
|
|
req->rq_rcvsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-21 15:09:19 -06:00
|
|
|
p = rpc_encode_header(task);
|
|
|
|
if (p == NULL) {
|
|
|
|
printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_exit(task, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
2008-05-21 15:09:19 -06:00
|
|
|
|
|
|
|
encode = task->tk_msg.rpc_proc->p_encode;
|
2005-10-13 14:54:48 -06:00
|
|
|
if (encode == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
task->tk_status = rpcauth_wrap_req(task, encode, req, p,
|
|
|
|
task->tk_msg.rpc_argp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 4. Get the server port number if not yet set
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_bind(struct rpc_task *task)
|
|
|
|
{
|
2013-01-08 08:08:33 -07:00
|
|
|
struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_action = call_connect;
|
2006-08-22 18:06:15 -06:00
|
|
|
if (!xprt_bound(xprt)) {
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_action = call_bind_status;
|
2006-08-22 18:06:15 -06:00
|
|
|
task->tk_timeout = xprt->bind_timeout;
|
2006-08-22 18:06:16 -06:00
|
|
|
xprt->ops->rpcbind(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-08-11 14:25:11 -06:00
|
|
|
* 4a. Sort out bind result
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_bind_status(struct rpc_task *task)
|
|
|
|
{
|
2007-09-11 16:00:47 -06:00
|
|
|
int status = -EIO;
|
2005-08-11 14:25:11 -06:00
|
|
|
|
|
|
|
if (task->tk_status >= 0) {
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_status = 0;
|
|
|
|
task->tk_action = call_connect;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-02-06 08:08:08 -07:00
|
|
|
trace_rpc_bind_status(task);
|
2005-08-11 14:25:11 -06:00
|
|
|
switch (task->tk_status) {
|
2008-07-07 10:18:53 -06:00
|
|
|
case -ENOMEM:
|
|
|
|
dprintk("RPC: %5u rpcbind out of memory\n", task->tk_pid);
|
|
|
|
rpc_delay(task, HZ >> 2);
|
2007-09-11 16:00:41 -06:00
|
|
|
goto retry_timeout;
|
2005-08-11 14:25:11 -06:00
|
|
|
case -EACCES:
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u remote rpcbind: RPC program/version "
|
|
|
|
"unavailable\n", task->tk_pid);
|
2007-09-11 16:00:52 -06:00
|
|
|
/* fail immediately if this is an RPC ping */
|
|
|
|
if (task->tk_msg.rpc_proc->p_proc == 0) {
|
|
|
|
status = -EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
2011-05-31 13:15:34 -06:00
|
|
|
if (task->tk_rebind_retry == 0)
|
|
|
|
break;
|
|
|
|
task->tk_rebind_retry--;
|
2005-10-06 21:12:58 -06:00
|
|
|
rpc_delay(task, 3*HZ);
|
2006-08-31 13:44:52 -06:00
|
|
|
goto retry_timeout;
|
2005-08-11 14:25:11 -06:00
|
|
|
case -ETIMEDOUT:
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u rpcbind request timed out\n",
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_pid);
|
2006-08-31 13:44:52 -06:00
|
|
|
goto retry_timeout;
|
2005-08-11 14:25:11 -06:00
|
|
|
case -EPFNOSUPPORT:
|
2007-09-11 16:00:47 -06:00
|
|
|
/* server doesn't support any rpcbind version we know of */
|
2009-12-03 13:58:56 -07:00
|
|
|
dprintk("RPC: %5u unrecognized remote rpcbind service\n",
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_pid);
|
|
|
|
break;
|
|
|
|
case -EPROTONOSUPPORT:
|
2007-03-29 14:48:33 -06:00
|
|
|
dprintk("RPC: %5u remote rpcbind version unavailable, retrying\n",
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_pid);
|
2014-03-17 10:57:31 -06:00
|
|
|
goto retry_timeout;
|
2009-12-03 13:58:56 -07:00
|
|
|
case -ECONNREFUSED: /* connection problems */
|
|
|
|
case -ECONNRESET:
|
2013-12-31 11:11:43 -07:00
|
|
|
case -ECONNABORTED:
|
2009-12-03 13:58:56 -07:00
|
|
|
case -ENOTCONN:
|
|
|
|
case -EHOSTDOWN:
|
|
|
|
case -EHOSTUNREACH:
|
|
|
|
case -ENETUNREACH:
|
2014-06-30 11:42:19 -06:00
|
|
|
case -ENOBUFS:
|
2009-12-03 13:58:56 -07:00
|
|
|
case -EPIPE:
|
|
|
|
dprintk("RPC: %5u remote rpcbind unreachable: %d\n",
|
|
|
|
task->tk_pid, task->tk_status);
|
|
|
|
if (!RPC_IS_SOFTCONN(task)) {
|
|
|
|
rpc_delay(task, 5*HZ);
|
|
|
|
goto retry_timeout;
|
|
|
|
}
|
|
|
|
status = task->tk_status;
|
|
|
|
break;
|
2005-08-11 14:25:11 -06:00
|
|
|
default:
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u unrecognized rpcbind error (%d)\n",
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_pid, -task->tk_status);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpc_exit(task, status);
|
|
|
|
return;
|
|
|
|
|
2006-08-31 13:44:52 -06:00
|
|
|
retry_timeout:
|
2014-03-17 10:57:31 -06:00
|
|
|
task->tk_status = 0;
|
2006-08-31 13:44:52 -06:00
|
|
|
task->tk_action = call_timeout;
|
2005-08-11 14:25:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 4b. Connect to the RPC server
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_connect(struct rpc_task *task)
|
|
|
|
{
|
2013-01-08 08:08:33 -07:00
|
|
|
struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u call_connect xprt %p %s connected\n",
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_pid, xprt,
|
|
|
|
(xprt_connected(xprt) ? "is" : "is not"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-11 14:25:11 -06:00
|
|
|
task->tk_action = call_transmit;
|
|
|
|
if (!xprt_connected(xprt)) {
|
|
|
|
task->tk_action = call_connect_status;
|
|
|
|
if (task->tk_status < 0)
|
|
|
|
return;
|
2013-08-05 14:04:47 -06:00
|
|
|
if (task->tk_flags & RPC_TASK_NOCONNECT) {
|
|
|
|
rpc_exit(task, -ENOTCONN);
|
|
|
|
return;
|
|
|
|
}
|
2005-08-11 14:25:11 -06:00
|
|
|
xprt_connect(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-08-11 14:25:11 -06:00
|
|
|
* 4c. Sort out connect result
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_connect_status(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
int status = task->tk_status;
|
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-08-11 14:25:11 -06:00
|
|
|
|
2012-02-06 08:08:08 -07:00
|
|
|
trace_rpc_connect_status(task, status);
|
2013-09-26 13:22:45 -06:00
|
|
|
task->tk_status = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (status) {
|
2013-03-04 15:29:33 -07:00
|
|
|
case -ECONNREFUSED:
|
|
|
|
case -ECONNRESET:
|
2013-12-31 11:11:43 -07:00
|
|
|
case -ECONNABORTED:
|
2013-03-04 15:29:33 -07:00
|
|
|
case -ENETUNREACH:
|
2013-12-31 11:11:43 -07:00
|
|
|
case -EHOSTUNREACH:
|
2015-02-08 19:44:04 -07:00
|
|
|
case -EADDRINUSE:
|
2014-06-30 11:42:19 -06:00
|
|
|
case -ENOBUFS:
|
2014-07-02 22:02:57 -06:00
|
|
|
case -EPIPE:
|
2013-03-04 15:29:33 -07:00
|
|
|
if (RPC_IS_SOFTCONN(task))
|
|
|
|
break;
|
2014-03-20 09:23:03 -06:00
|
|
|
/* retry with existing socket, after a delay */
|
|
|
|
rpc_delay(task, 3*HZ);
|
2013-03-04 15:29:33 -07:00
|
|
|
case -EAGAIN:
|
2014-03-17 10:51:44 -06:00
|
|
|
/* Check for timeouts before looping back to call_bind */
|
|
|
|
case -ETIMEDOUT:
|
|
|
|
task->tk_action = call_timeout;
|
2013-09-26 13:22:45 -06:00
|
|
|
return;
|
|
|
|
case 0:
|
2013-03-04 15:29:33 -07:00
|
|
|
clnt->cl_stats->netreconn++;
|
|
|
|
task->tk_action = call_transmit;
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-03-04 15:29:33 -07:00
|
|
|
rpc_exit(task, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 5. Transmit the RPC request, and wait for reply
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_transmit(struct rpc_task *task)
|
|
|
|
{
|
2013-09-25 11:39:45 -06:00
|
|
|
int is_retrans = RPC_WAS_SENT(task);
|
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
task->tk_action = call_status;
|
|
|
|
if (task->tk_status < 0)
|
|
|
|
return;
|
2013-09-25 10:17:18 -06:00
|
|
|
if (!xprt_prepare_transmit(task))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2006-07-27 15:22:50 -06:00
|
|
|
task->tk_action = call_transmit_status;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Encode here so that rpcsec_gss can use correct sequence number. */
|
2005-11-09 19:45:24 -07:00
|
|
|
if (rpc_task_need_encode(task)) {
|
2008-05-21 15:09:19 -06:00
|
|
|
rpc_xdr_encode(task);
|
2005-10-18 15:20:11 -06:00
|
|
|
/* Did the encode result in an error condition? */
|
2008-05-14 20:48:25 -06:00
|
|
|
if (task->tk_status != 0) {
|
|
|
|
/* Was the error nonfatal? */
|
|
|
|
if (task->tk_status == -EAGAIN)
|
|
|
|
rpc_delay(task, HZ >> 4);
|
|
|
|
else
|
|
|
|
rpc_exit(task, task->tk_status);
|
2006-07-27 15:22:50 -06:00
|
|
|
return;
|
2008-05-14 20:48:25 -06:00
|
|
|
}
|
2005-10-18 15:20:11 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
xprt_transmit(task);
|
|
|
|
if (task->tk_status < 0)
|
|
|
|
return;
|
2013-09-25 11:39:45 -06:00
|
|
|
if (is_retrans)
|
|
|
|
task->tk_client->cl_stats->rpcretrans++;
|
2006-07-27 15:22:50 -06:00
|
|
|
/*
|
|
|
|
* On success, ensure that we call xprt_end_transmit() before sleeping
|
|
|
|
* in order to allow access to the socket to other RPC requests.
|
|
|
|
*/
|
|
|
|
call_transmit_status(task);
|
2009-04-01 07:23:03 -06:00
|
|
|
if (rpc_reply_expected(task))
|
2006-07-27 15:22:50 -06:00
|
|
|
return;
|
|
|
|
task->tk_action = rpc_exit_task;
|
2013-01-08 07:10:21 -07:00
|
|
|
rpc_wake_up_queued_task(&task->tk_rqstp->rq_xprt->pending, task);
|
2006-07-27 15:22:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 5a. Handle cleanup after a transmission
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_transmit_status(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
task->tk_action = call_status;
|
2009-12-03 13:58:56 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Common case: success. Force the compiler to put this
|
|
|
|
* test first.
|
|
|
|
*/
|
|
|
|
if (task->tk_status == 0) {
|
|
|
|
xprt_end_transmit(task);
|
|
|
|
rpc_task_force_reencode(task);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-03-11 12:37:57 -06:00
|
|
|
switch (task->tk_status) {
|
|
|
|
case -EAGAIN:
|
|
|
|
break;
|
|
|
|
default:
|
2009-12-03 13:58:56 -07:00
|
|
|
dprint_status(task);
|
2009-03-11 12:37:57 -06:00
|
|
|
xprt_end_transmit(task);
|
SUNRPC: Allow RPCs to fail quickly if the server is unreachable
The kernel sometimes makes RPC calls to services that aren't running.
Because the kernel's RPC client always assumes the hard retry semantic
when reconnecting a connection-oriented RPC transport, the underlying
reconnect logic takes a long while to time out, even though the remote
may have responded immediately with ECONNREFUSED.
In certain cases, like upcalls to our local rpcbind daemon, or for NFS
mount requests, we'd like the kernel to fail immediately if the remote
service isn't reachable. This allows another transport to be tried
immediately, or the pending request can be abandoned quickly.
Introduce a per-request flag which controls how call_transmit_status()
behaves when request transmission fails because the server cannot be
reached.
We don't want soft connection semantics to apply to other errors. The
default case of the switch statement in call_transmit_status() no
longer falls through; the fall through code is copied to the default
case, and a "break;" is added.
The transport's connection re-establishment timeout is also ignored for
such requests. We want the request to fail immediately, so the
reconnect delay is skipped. Additionally, we don't want a connect
failure here to further increase the reconnect timeout value, since
this request will not be retried.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-12-03 13:58:56 -07:00
|
|
|
rpc_task_force_reencode(task);
|
|
|
|
break;
|
2009-03-11 12:37:57 -06:00
|
|
|
/*
|
|
|
|
* Special cases: if we've been waiting on the
|
|
|
|
* socket's write_space() callback, or if the
|
|
|
|
* socket just returned a connection error,
|
|
|
|
* then hold onto the transport lock.
|
|
|
|
*/
|
|
|
|
case -ECONNREFUSED:
|
|
|
|
case -EHOSTDOWN:
|
|
|
|
case -EHOSTUNREACH:
|
|
|
|
case -ENETUNREACH:
|
rpc: Add -EPERM processing for xs_udp_send_request()
If an iptables drop rule is added for an nfs server, the client can end up in
a softlockup. Because of the way that xs_sendpages() is structured, the -EPERM
is ignored since the prior bits of the packet may have been successfully queued
and thus xs_sendpages() returns a non-zero value. Then, xs_udp_send_request()
thinks that because some bits were queued it should return -EAGAIN. We then try
the request again and again, resulting in cpu spinning. Reproducer:
1) open a file on the nfs server '/nfs/foo' (mounted using udp)
2) iptables -A OUTPUT -d <nfs server ip> -j DROP
3) write to /nfs/foo
4) close /nfs/foo
5) iptables -D OUTPUT -d <nfs server ip> -j DROP
The softlockup occurs in step 4 above.
The previous patch, allows xs_sendpages() to return both a sent count and
any error values that may have occurred. Thus, if we get an -EPERM, return
that to the higher level code.
With this patch in place we can successfully abort the above sequence and
avoid the softlockup.
I also tried the above test case on an nfs mount on tcp and although the system
does not softlockup, I still ended up with the 'hung_task' firing after 120
seconds, due to the i/o being stuck. The tcp case appears a bit harder to fix,
since -EPERM appears to get ignored much lower down in the stack and does not
propogate up to xs_sendpages(). This case is not quite as insidious as the
softlockup and it is not addressed here.
Reported-by: Yigong Lou <ylou@akamai.com>
Signed-off-by: Jason Baron <jbaron@akamai.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2014-09-24 12:08:04 -06:00
|
|
|
case -EPERM:
|
SUNRPC: Allow RPCs to fail quickly if the server is unreachable
The kernel sometimes makes RPC calls to services that aren't running.
Because the kernel's RPC client always assumes the hard retry semantic
when reconnecting a connection-oriented RPC transport, the underlying
reconnect logic takes a long while to time out, even though the remote
may have responded immediately with ECONNREFUSED.
In certain cases, like upcalls to our local rpcbind daemon, or for NFS
mount requests, we'd like the kernel to fail immediately if the remote
service isn't reachable. This allows another transport to be tried
immediately, or the pending request can be abandoned quickly.
Introduce a per-request flag which controls how call_transmit_status()
behaves when request transmission fails because the server cannot be
reached.
We don't want soft connection semantics to apply to other errors. The
default case of the switch statement in call_transmit_status() no
longer falls through; the fall through code is copied to the default
case, and a "break;" is added.
The transport's connection re-establishment timeout is also ignored for
such requests. We want the request to fail immediately, so the
reconnect delay is skipped. Additionally, we don't want a connect
failure here to further increase the reconnect timeout value, since
this request will not be retried.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-12-03 13:58:56 -07:00
|
|
|
if (RPC_IS_SOFTCONN(task)) {
|
|
|
|
xprt_end_transmit(task);
|
|
|
|
rpc_exit(task, task->tk_status);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case -ECONNRESET:
|
2013-12-31 11:11:43 -07:00
|
|
|
case -ECONNABORTED:
|
2015-02-08 19:44:04 -07:00
|
|
|
case -EADDRINUSE:
|
SUNRPC: Allow RPCs to fail quickly if the server is unreachable
The kernel sometimes makes RPC calls to services that aren't running.
Because the kernel's RPC client always assumes the hard retry semantic
when reconnecting a connection-oriented RPC transport, the underlying
reconnect logic takes a long while to time out, even though the remote
may have responded immediately with ECONNREFUSED.
In certain cases, like upcalls to our local rpcbind daemon, or for NFS
mount requests, we'd like the kernel to fail immediately if the remote
service isn't reachable. This allows another transport to be tried
immediately, or the pending request can be abandoned quickly.
Introduce a per-request flag which controls how call_transmit_status()
behaves when request transmission fails because the server cannot be
reached.
We don't want soft connection semantics to apply to other errors. The
default case of the switch statement in call_transmit_status() no
longer falls through; the fall through code is copied to the default
case, and a "break;" is added.
The transport's connection re-establishment timeout is also ignored for
such requests. We want the request to fail immediately, so the
reconnect delay is skipped. Additionally, we don't want a connect
failure here to further increase the reconnect timeout value, since
this request will not be retried.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-12-03 13:58:56 -07:00
|
|
|
case -ENOTCONN:
|
2014-06-30 11:42:19 -06:00
|
|
|
case -ENOBUFS:
|
2009-03-11 12:37:59 -06:00
|
|
|
case -EPIPE:
|
2009-03-11 12:37:57 -06:00
|
|
|
rpc_task_force_reencode(task);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-07-13 17:20:49 -06:00
|
|
|
#if defined(CONFIG_SUNRPC_BACKCHANNEL)
|
2009-04-01 07:23:03 -06:00
|
|
|
/*
|
|
|
|
* 5b. Send the backchannel RPC reply. On error, drop the reply. In
|
|
|
|
* addition, disconnect on connectivity errors.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_bc_transmit(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
|
|
|
|
2013-09-25 10:17:18 -06:00
|
|
|
if (!xprt_prepare_transmit(task)) {
|
2009-04-01 07:23:03 -06:00
|
|
|
/*
|
|
|
|
* Could not reserve the transport. Try again after the
|
|
|
|
* transport is released.
|
|
|
|
*/
|
|
|
|
task->tk_status = 0;
|
|
|
|
task->tk_action = call_bc_transmit;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
task->tk_action = rpc_exit_task;
|
|
|
|
if (task->tk_status < 0) {
|
|
|
|
printk(KERN_NOTICE "RPC: Could not send backchannel reply "
|
|
|
|
"error: %d\n", task->tk_status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
xprt_transmit(task);
|
|
|
|
xprt_end_transmit(task);
|
|
|
|
dprint_status(task);
|
|
|
|
switch (task->tk_status) {
|
|
|
|
case 0:
|
|
|
|
/* Success */
|
|
|
|
break;
|
|
|
|
case -EHOSTDOWN:
|
|
|
|
case -EHOSTUNREACH:
|
|
|
|
case -ENETUNREACH:
|
|
|
|
case -ETIMEDOUT:
|
|
|
|
/*
|
|
|
|
* Problem reaching the server. Disconnect and let the
|
|
|
|
* forechannel reestablish the connection. The server will
|
|
|
|
* have to retransmit the backchannel request and we'll
|
|
|
|
* reprocess it. Since these ops are idempotent, there's no
|
|
|
|
* need to cache our reply at this time.
|
|
|
|
*/
|
|
|
|
printk(KERN_NOTICE "RPC: Could not send backchannel reply "
|
|
|
|
"error: %d\n", task->tk_status);
|
2013-01-08 07:10:21 -07:00
|
|
|
xprt_conditional_disconnect(req->rq_xprt,
|
2009-04-01 07:23:03 -06:00
|
|
|
req->rq_connect_cookie);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* We were unable to reply and will have to drop the
|
|
|
|
* request. The server should reconnect and retransmit.
|
|
|
|
*/
|
2012-10-23 08:43:30 -06:00
|
|
|
WARN_ON_ONCE(task->tk_status == -EAGAIN);
|
2009-04-01 07:23:03 -06:00
|
|
|
printk(KERN_NOTICE "RPC: Could not send backchannel reply "
|
|
|
|
"error: %d\n", task->tk_status);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
rpc_wake_up_queued_task(&req->rq_xprt->pending, task);
|
|
|
|
}
|
2011-07-13 17:20:49 -06:00
|
|
|
#endif /* CONFIG_SUNRPC_BACKCHANNEL */
|
2009-04-01 07:23:03 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 6. Sort out the RPC call status
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_status(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
|
|
|
int status;
|
|
|
|
|
2009-04-01 07:23:28 -06:00
|
|
|
if (req->rq_reply_bytes_recvd > 0 && !req->rq_bytes_sent)
|
|
|
|
task->tk_status = req->rq_reply_bytes_recvd;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
status = task->tk_status;
|
|
|
|
if (status >= 0) {
|
|
|
|
task->tk_action = call_decode;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-02-06 08:08:08 -07:00
|
|
|
trace_rpc_call_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_status = 0;
|
|
|
|
switch(status) {
|
2006-08-30 12:32:49 -06:00
|
|
|
case -EHOSTDOWN:
|
|
|
|
case -EHOSTUNREACH:
|
|
|
|
case -ENETUNREACH:
|
rpc: Add -EPERM processing for xs_udp_send_request()
If an iptables drop rule is added for an nfs server, the client can end up in
a softlockup. Because of the way that xs_sendpages() is structured, the -EPERM
is ignored since the prior bits of the packet may have been successfully queued
and thus xs_sendpages() returns a non-zero value. Then, xs_udp_send_request()
thinks that because some bits were queued it should return -EAGAIN. We then try
the request again and again, resulting in cpu spinning. Reproducer:
1) open a file on the nfs server '/nfs/foo' (mounted using udp)
2) iptables -A OUTPUT -d <nfs server ip> -j DROP
3) write to /nfs/foo
4) close /nfs/foo
5) iptables -D OUTPUT -d <nfs server ip> -j DROP
The softlockup occurs in step 4 above.
The previous patch, allows xs_sendpages() to return both a sent count and
any error values that may have occurred. Thus, if we get an -EPERM, return
that to the higher level code.
With this patch in place we can successfully abort the above sequence and
avoid the softlockup.
I also tried the above test case on an nfs mount on tcp and although the system
does not softlockup, I still ended up with the 'hung_task' firing after 120
seconds, due to the i/o being stuck. The tcp case appears a bit harder to fix,
since -EPERM appears to get ignored much lower down in the stack and does not
propogate up to xs_sendpages(). This case is not quite as insidious as the
softlockup and it is not addressed here.
Reported-by: Yigong Lou <ylou@akamai.com>
Signed-off-by: Jason Baron <jbaron@akamai.com>
Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
2014-09-24 12:08:04 -06:00
|
|
|
case -EPERM:
|
2014-03-19 11:25:43 -06:00
|
|
|
if (RPC_IS_SOFTCONN(task)) {
|
|
|
|
rpc_exit(task, status);
|
|
|
|
break;
|
|
|
|
}
|
2006-08-30 12:32:49 -06:00
|
|
|
/*
|
|
|
|
* Delay any retries for 3 seconds, then handle as if it
|
|
|
|
* were a timeout.
|
|
|
|
*/
|
|
|
|
rpc_delay(task, 3*HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
case -ETIMEDOUT:
|
|
|
|
task->tk_action = call_timeout;
|
2013-09-24 10:00:27 -06:00
|
|
|
if (!(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT)
|
|
|
|
&& task->tk_client->cl_discrtry)
|
2013-01-08 07:10:21 -07:00
|
|
|
xprt_conditional_disconnect(req->rq_xprt,
|
2008-04-17 14:52:57 -06:00
|
|
|
req->rq_connect_cookie);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case -ECONNREFUSED:
|
2013-12-31 11:11:43 -07:00
|
|
|
case -ECONNRESET:
|
|
|
|
case -ECONNABORTED:
|
2006-01-03 01:55:50 -07:00
|
|
|
rpc_force_rebind(clnt);
|
2015-02-08 19:44:04 -07:00
|
|
|
case -EADDRINUSE:
|
2014-06-30 11:42:19 -06:00
|
|
|
case -ENOBUFS:
|
2009-03-11 12:37:59 -06:00
|
|
|
rpc_delay(task, 3*HZ);
|
|
|
|
case -EPIPE:
|
|
|
|
case -ENOTCONN:
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_action = call_bind;
|
|
|
|
break;
|
|
|
|
case -EAGAIN:
|
|
|
|
task->tk_action = call_transmit;
|
|
|
|
break;
|
|
|
|
case -EIO:
|
|
|
|
/* shutdown or soft timeout */
|
|
|
|
rpc_exit(task, status);
|
|
|
|
break;
|
|
|
|
default:
|
2008-06-09 14:51:31 -06:00
|
|
|
if (clnt->cl_chatty)
|
|
|
|
printk("%s: RPC call returned error %d\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name, -status);
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_exit(task, status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-07-27 15:22:50 -06:00
|
|
|
* 6a. Handle RPC timeout
|
2005-04-16 16:20:36 -06:00
|
|
|
* We do not release the request slot, so we keep using the
|
|
|
|
* same XID for all retransmits.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_timeout(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
|
|
|
|
if (xprt_adjust_timeout(task->tk_rqstp) == 0) {
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u call_timeout (minor)\n", task->tk_pid);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u call_timeout (major)\n", task->tk_pid);
|
2006-03-20 11:44:17 -07:00
|
|
|
task->tk_timeouts++;
|
|
|
|
|
2009-12-03 13:58:56 -07:00
|
|
|
if (RPC_IS_SOFTCONN(task)) {
|
|
|
|
rpc_exit(task, -ETIMEDOUT);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (RPC_IS_SOFT(task)) {
|
2012-07-18 12:17:11 -06:00
|
|
|
if (clnt->cl_chatty) {
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_read_lock();
|
2008-06-09 14:51:31 -06:00
|
|
|
printk(KERN_NOTICE "%s: server %s not responding, timed out\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name,
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
|
|
|
rcu_read_unlock();
|
2012-07-18 12:17:11 -06:00
|
|
|
}
|
2011-04-24 12:28:45 -06:00
|
|
|
if (task->tk_flags & RPC_TASK_TIMEOUT)
|
|
|
|
rpc_exit(task, -ETIMEDOUT);
|
|
|
|
else
|
|
|
|
rpc_exit(task, -EIO);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:52 -07:00
|
|
|
if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_flags |= RPC_CALL_MAJORSEEN;
|
2012-03-01 15:01:05 -07:00
|
|
|
if (clnt->cl_chatty) {
|
|
|
|
rcu_read_lock();
|
2008-06-09 14:51:31 -06:00
|
|
|
printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name,
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-03 01:55:50 -07:00
|
|
|
rpc_force_rebind(clnt);
|
2008-04-22 14:47:55 -06:00
|
|
|
/*
|
|
|
|
* Did our request time out due to an RPCSEC_GSS out-of-sequence
|
|
|
|
* event? RFC2203 requires the server to drop all such requests.
|
|
|
|
*/
|
|
|
|
rpcauth_invalcred(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
retry:
|
|
|
|
task->tk_action = call_bind;
|
|
|
|
task->tk_status = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 7. Decode the RPC reply
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
call_decode(struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
2010-12-14 07:59:29 -07:00
|
|
|
kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;
|
2006-09-26 23:29:38 -06:00
|
|
|
__be32 *p;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-06-01 06:23:59 -06:00
|
|
|
dprint_status(task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-03 01:55:52 -07:00
|
|
|
if (task->tk_flags & RPC_CALL_MAJORSEEN) {
|
2012-03-01 15:01:05 -07:00
|
|
|
if (clnt->cl_chatty) {
|
|
|
|
rcu_read_lock();
|
2008-06-09 14:51:31 -06:00
|
|
|
printk(KERN_NOTICE "%s: server %s OK\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name,
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_flags &= ~RPC_CALL_MAJORSEEN;
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:51 -07:00
|
|
|
/*
|
|
|
|
* Ensure that we see all writes made by xprt_complete_rqst()
|
2009-04-01 07:23:28 -06:00
|
|
|
* before it changed req->rq_reply_bytes_recvd.
|
2006-03-20 11:44:51 -07:00
|
|
|
*/
|
|
|
|
smp_rmb();
|
2005-04-16 16:20:36 -06:00
|
|
|
req->rq_rcv_buf.len = req->rq_private_buf.len;
|
|
|
|
|
|
|
|
/* Check that the softirq receive buffer is valid */
|
|
|
|
WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,
|
|
|
|
sizeof(req->rq_rcv_buf)) != 0);
|
|
|
|
|
2008-03-21 14:19:41 -06:00
|
|
|
if (req->rq_rcv_buf.len < 12) {
|
|
|
|
if (!RPC_IS_SOFT(task)) {
|
|
|
|
task->tk_action = call_bind;
|
|
|
|
goto out_retry;
|
|
|
|
}
|
|
|
|
dprintk("RPC: %s: too small RPC reply size (%d bytes)\n",
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name, task->tk_status);
|
2008-03-21 14:19:41 -06:00
|
|
|
task->tk_action = call_timeout;
|
|
|
|
goto out_retry;
|
|
|
|
}
|
|
|
|
|
2008-05-21 15:09:19 -06:00
|
|
|
p = rpc_verify_header(task);
|
2006-01-03 01:55:03 -07:00
|
|
|
if (IS_ERR(p)) {
|
|
|
|
if (p == ERR_PTR(-EAGAIN))
|
|
|
|
goto out_retry;
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:03 -07:00
|
|
|
task->tk_action = rpc_exit_task;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-18 14:01:06 -06:00
|
|
|
if (decode) {
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
|
|
|
|
task->tk_msg.rpc_resp);
|
2006-10-18 14:01:06 -06:00
|
|
|
}
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
|
|
|
|
task->tk_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
out_retry:
|
|
|
|
task->tk_status = 0;
|
2008-05-21 15:09:19 -06:00
|
|
|
/* Note: rpc_verify_header() may have freed the RPC slot */
|
2008-04-19 11:15:47 -06:00
|
|
|
if (task->tk_rqstp == req) {
|
2009-04-01 07:23:28 -06:00
|
|
|
req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
|
2008-04-19 11:15:47 -06:00
|
|
|
if (task->tk_client->cl_discrtry)
|
2013-01-08 07:10:21 -07:00
|
|
|
xprt_conditional_disconnect(req->rq_xprt,
|
2008-04-17 14:52:57 -06:00
|
|
|
req->rq_connect_cookie);
|
2008-04-19 11:15:47 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 23:29:38 -06:00
|
|
|
static __be32 *
|
2008-05-21 15:09:19 -06:00
|
|
|
rpc_encode_header(struct rpc_task *task)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
|
|
|
struct rpc_rqst *req = task->tk_rqstp;
|
2006-09-26 23:29:38 -06:00
|
|
|
__be32 *p = req->rq_svec[0].iov_base;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* FIXME: check buffer size? */
|
2005-08-25 17:25:49 -06:00
|
|
|
|
2013-01-08 07:10:21 -07:00
|
|
|
p = xprt_skip_transport_header(req->rq_xprt, p);
|
2005-04-16 16:20:36 -06:00
|
|
|
*p++ = req->rq_xid; /* XID */
|
|
|
|
*p++ = htonl(RPC_CALL); /* CALL */
|
|
|
|
*p++ = htonl(RPC_VERSION); /* RPC version */
|
|
|
|
*p++ = htonl(clnt->cl_prog); /* program number */
|
|
|
|
*p++ = htonl(clnt->cl_vers); /* program version */
|
|
|
|
*p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */
|
2005-06-22 11:16:19 -06:00
|
|
|
p = rpcauth_marshcred(task, p);
|
|
|
|
req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
|
|
|
|
return p;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-26 23:29:38 -06:00
|
|
|
static __be32 *
|
2008-05-21 15:09:19 -06:00
|
|
|
rpc_verify_header(struct rpc_task *task)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-03-01 15:01:05 -07:00
|
|
|
struct rpc_clnt *clnt = task->tk_client;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
|
|
|
|
int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
|
2006-09-26 23:29:38 -06:00
|
|
|
__be32 *p = iov->iov_base;
|
|
|
|
u32 n;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error = -EACCES;
|
|
|
|
|
2006-08-24 13:44:19 -06:00
|
|
|
if ((task->tk_rqstp->rq_rcv_buf.len & 3) != 0) {
|
|
|
|
/* RFC-1014 says that the representation of XDR data must be a
|
|
|
|
* multiple of four bytes
|
|
|
|
* - if it isn't pointer subtraction in the NFS client may give
|
|
|
|
* undefined results
|
|
|
|
*/
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: XDR representation not a multiple of"
|
2008-03-05 21:47:47 -07:00
|
|
|
" 4 bytes: 0x%x\n", task->tk_pid, __func__,
|
2007-06-27 16:30:26 -06:00
|
|
|
task->tk_rqstp->rq_rcv_buf.len);
|
2013-08-14 09:59:17 -06:00
|
|
|
error = -EIO;
|
|
|
|
goto out_err;
|
2006-08-24 13:44:19 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((len -= 3) < 0)
|
|
|
|
goto out_overflow;
|
|
|
|
|
2009-04-01 07:22:54 -06:00
|
|
|
p += 1; /* skip XID */
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((n = ntohl(*p++)) != RPC_REPLY) {
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: not an RPC reply: %x\n",
|
2009-04-01 07:22:54 -06:00
|
|
|
task->tk_pid, __func__, n);
|
2013-08-14 09:59:17 -06:00
|
|
|
error = -EIO;
|
2006-01-03 01:55:03 -07:00
|
|
|
goto out_garbage;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-04-01 07:22:54 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((n = ntohl(*p++)) != RPC_MSG_ACCEPTED) {
|
|
|
|
if (--len < 0)
|
|
|
|
goto out_overflow;
|
|
|
|
switch ((n = ntohl(*p++))) {
|
2011-07-01 03:43:12 -06:00
|
|
|
case RPC_AUTH_ERROR:
|
|
|
|
break;
|
|
|
|
case RPC_MISMATCH:
|
|
|
|
dprintk("RPC: %5u %s: RPC call version mismatch!\n",
|
|
|
|
task->tk_pid, __func__);
|
|
|
|
error = -EPROTONOSUPPORT;
|
|
|
|
goto out_err;
|
|
|
|
default:
|
|
|
|
dprintk("RPC: %5u %s: RPC call rejected, "
|
|
|
|
"unknown error: %x\n",
|
|
|
|
task->tk_pid, __func__, n);
|
2013-08-14 09:59:17 -06:00
|
|
|
error = -EIO;
|
|
|
|
goto out_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (--len < 0)
|
|
|
|
goto out_overflow;
|
|
|
|
switch ((n = ntohl(*p++))) {
|
|
|
|
case RPC_AUTH_REJECTEDCRED:
|
|
|
|
case RPC_AUTH_REJECTEDVERF:
|
|
|
|
case RPCSEC_GSS_CREDPROBLEM:
|
|
|
|
case RPCSEC_GSS_CTXPROBLEM:
|
|
|
|
if (!task->tk_cred_retry)
|
|
|
|
break;
|
|
|
|
task->tk_cred_retry--;
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u %s: retry stale creds\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
rpcauth_invalcred(task);
|
2007-10-01 10:06:48 -06:00
|
|
|
/* Ensure we obtain a new XID! */
|
|
|
|
xprt_release(task);
|
2010-10-24 15:17:31 -06:00
|
|
|
task->tk_action = call_reserve;
|
2006-01-03 01:55:03 -07:00
|
|
|
goto out_retry;
|
2005-04-16 16:20:36 -06:00
|
|
|
case RPC_AUTH_BADCRED:
|
|
|
|
case RPC_AUTH_BADVERF:
|
|
|
|
/* possibly garbled cred/verf? */
|
|
|
|
if (!task->tk_garb_retry)
|
|
|
|
break;
|
|
|
|
task->tk_garb_retry--;
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u %s: retry garbled creds\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_action = call_bind;
|
2006-01-03 01:55:03 -07:00
|
|
|
goto out_retry;
|
2005-04-16 16:20:36 -06:00
|
|
|
case RPC_AUTH_TOOWEAK:
|
2012-03-01 15:01:05 -07:00
|
|
|
rcu_read_lock();
|
2008-05-21 15:09:19 -06:00
|
|
|
printk(KERN_NOTICE "RPC: server %s requires stronger "
|
2012-03-01 15:01:05 -07:00
|
|
|
"authentication.\n",
|
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: unknown auth error: %x\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__, n);
|
2005-04-16 16:20:36 -06:00
|
|
|
error = -EIO;
|
|
|
|
}
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u %s: call rejected %d\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__, n);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_err;
|
|
|
|
}
|
2013-08-14 09:59:17 -06:00
|
|
|
p = rpcauth_checkverf(task, p);
|
|
|
|
if (IS_ERR(p)) {
|
|
|
|
error = PTR_ERR(p);
|
|
|
|
dprintk("RPC: %5u %s: auth check failed with %d\n",
|
|
|
|
task->tk_pid, __func__, error);
|
2006-01-03 01:55:03 -07:00
|
|
|
goto out_garbage; /* bad verifier, retry */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-09-26 23:29:38 -06:00
|
|
|
len = p - (__be32 *)iov->iov_base - 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (len < 0)
|
|
|
|
goto out_overflow;
|
|
|
|
switch ((n = ntohl(*p++))) {
|
|
|
|
case RPC_SUCCESS:
|
|
|
|
return p;
|
|
|
|
case RPC_PROG_UNAVAIL:
|
2012-03-01 15:01:05 -07:00
|
|
|
dprintk_rcu("RPC: %5u %s: program %u is unsupported "
|
|
|
|
"by server %s\n", task->tk_pid, __func__,
|
|
|
|
(unsigned int)clnt->cl_prog,
|
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2005-06-22 11:16:23 -06:00
|
|
|
error = -EPFNOSUPPORT;
|
|
|
|
goto out_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
case RPC_PROG_MISMATCH:
|
2012-03-01 15:01:05 -07:00
|
|
|
dprintk_rcu("RPC: %5u %s: program %u, version %u unsupported "
|
|
|
|
"by server %s\n", task->tk_pid, __func__,
|
|
|
|
(unsigned int)clnt->cl_prog,
|
|
|
|
(unsigned int)clnt->cl_vers,
|
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2005-06-22 11:16:23 -06:00
|
|
|
error = -EPROTONOSUPPORT;
|
|
|
|
goto out_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
case RPC_PROC_UNAVAIL:
|
2012-03-01 15:01:05 -07:00
|
|
|
dprintk_rcu("RPC: %5u %s: proc %s unsupported by program %u, "
|
2007-01-31 10:14:08 -07:00
|
|
|
"version %u on server %s\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__,
|
2008-05-21 15:09:12 -06:00
|
|
|
rpc_proc_name(task),
|
2012-03-01 15:01:05 -07:00
|
|
|
clnt->cl_prog, clnt->cl_vers,
|
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2005-06-22 11:16:23 -06:00
|
|
|
error = -EOPNOTSUPP;
|
|
|
|
goto out_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
case RPC_GARBAGE_ARGS:
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u %s: server saw garbage\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
break; /* retry */
|
|
|
|
default:
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: server accept status: %x\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__, n);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Also retry */
|
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:03 -07:00
|
|
|
out_garbage:
|
2012-03-01 15:01:05 -07:00
|
|
|
clnt->cl_stats->rpcgarbage++;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (task->tk_garb_retry) {
|
|
|
|
task->tk_garb_retry--;
|
2007-01-31 10:14:08 -07:00
|
|
|
dprintk("RPC: %5u %s: retrying\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
task->tk_pid, __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
task->tk_action = call_bind;
|
2006-01-03 01:55:03 -07:00
|
|
|
out_retry:
|
|
|
|
return ERR_PTR(-EAGAIN);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
out_err:
|
|
|
|
rpc_exit(task, error);
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: call failed with error %d\n", task->tk_pid,
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__, error);
|
2006-01-03 01:55:03 -07:00
|
|
|
return ERR_PTR(error);
|
2005-04-16 16:20:36 -06:00
|
|
|
out_overflow:
|
2007-06-27 16:30:26 -06:00
|
|
|
dprintk("RPC: %5u %s: server reply was truncated.\n", task->tk_pid,
|
2008-03-05 21:47:47 -07:00
|
|
|
__func__);
|
2006-01-03 01:55:03 -07:00
|
|
|
goto out_garbage;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-06-22 11:16:20 -06:00
|
|
|
|
2010-12-14 07:59:18 -07:00
|
|
|
static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
|
2005-06-22 11:16:20 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-12-14 07:59:29 -07:00
|
|
|
static int rpcproc_decode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
|
2005-06-22 11:16:20 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct rpc_procinfo rpcproc_null = {
|
|
|
|
.p_encode = rpcproc_encode_null,
|
|
|
|
.p_decode = rpcproc_decode_null,
|
|
|
|
};
|
|
|
|
|
2009-12-03 13:58:56 -07:00
|
|
|
static int rpc_ping(struct rpc_clnt *clnt)
|
2005-06-22 11:16:20 -06:00
|
|
|
{
|
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_proc = &rpcproc_null,
|
|
|
|
};
|
|
|
|
int err;
|
|
|
|
msg.rpc_cred = authnull_ops.lookup_cred(NULL, NULL, 0);
|
2009-12-03 13:58:56 -07:00
|
|
|
err = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN);
|
2005-06-22 11:16:20 -06:00
|
|
|
put_rpccred(msg.rpc_cred);
|
|
|
|
return err;
|
|
|
|
}
|
2007-06-16 12:18:40 -06:00
|
|
|
|
2007-06-23 08:17:16 -06:00
|
|
|
struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred, int flags)
|
|
|
|
{
|
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_proc = &rpcproc_null,
|
|
|
|
.rpc_cred = cred,
|
|
|
|
};
|
2007-07-14 13:39:59 -06:00
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.rpc_client = clnt,
|
|
|
|
.rpc_message = &msg,
|
|
|
|
.callback_ops = &rpc_default_ops,
|
|
|
|
.flags = flags,
|
|
|
|
};
|
2007-07-14 13:39:59 -06:00
|
|
|
return rpc_run_task(&task_setup_data);
|
2007-06-23 08:17:16 -06:00
|
|
|
}
|
2007-07-14 13:39:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_call_null);
|
2007-06-23 08:17:16 -06:00
|
|
|
|
2014-11-17 14:58:04 -07:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
2008-05-21 15:09:26 -06:00
|
|
|
static void rpc_show_header(void)
|
|
|
|
{
|
2008-05-21 15:09:41 -06:00
|
|
|
printk(KERN_INFO "-pid- flgs status -client- --rqstp- "
|
|
|
|
"-timeout ---ops--\n");
|
2008-05-21 15:09:26 -06:00
|
|
|
}
|
|
|
|
|
2008-05-21 15:09:33 -06:00
|
|
|
static void rpc_show_task(const struct rpc_clnt *clnt,
|
|
|
|
const struct rpc_task *task)
|
|
|
|
{
|
|
|
|
const char *rpc_waitq = "none";
|
|
|
|
|
|
|
|
if (RPC_IS_QUEUED(task))
|
|
|
|
rpc_waitq = rpc_qname(task->tk_waitqueue);
|
|
|
|
|
2010-12-21 08:52:24 -07:00
|
|
|
printk(KERN_INFO "%5u %04x %6d %8p %8p %8ld %8p %sv%u %s a:%ps q:%s\n",
|
2008-05-21 15:09:41 -06:00
|
|
|
task->tk_pid, task->tk_flags, task->tk_status,
|
|
|
|
clnt, task->tk_rqstp, task->tk_timeout, task->tk_ops,
|
2013-08-23 09:48:15 -06:00
|
|
|
clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
|
2010-12-21 08:52:24 -07:00
|
|
|
task->tk_action, rpc_waitq);
|
2008-05-21 15:09:33 -06:00
|
|
|
}
|
|
|
|
|
2012-01-12 11:07:51 -07:00
|
|
|
void rpc_show_tasks(struct net *net)
|
2007-06-16 12:18:40 -06:00
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt;
|
2008-05-21 15:09:33 -06:00
|
|
|
struct rpc_task *task;
|
2008-05-21 15:09:26 -06:00
|
|
|
int header = 0;
|
2012-01-12 11:07:51 -07:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2007-06-16 12:18:40 -06:00
|
|
|
|
2012-01-12 11:07:51 -07:00
|
|
|
spin_lock(&sn->rpc_client_lock);
|
|
|
|
list_for_each_entry(clnt, &sn->all_clients, cl_clients) {
|
2007-06-16 12:18:40 -06:00
|
|
|
spin_lock(&clnt->cl_lock);
|
2008-05-21 15:09:33 -06:00
|
|
|
list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
|
2008-05-21 15:09:26 -06:00
|
|
|
if (!header) {
|
|
|
|
rpc_show_header();
|
|
|
|
header++;
|
|
|
|
}
|
2008-05-21 15:09:33 -06:00
|
|
|
rpc_show_task(clnt, task);
|
2007-06-16 12:18:40 -06:00
|
|
|
}
|
|
|
|
spin_unlock(&clnt->cl_lock);
|
|
|
|
}
|
2012-01-12 11:07:51 -07:00
|
|
|
spin_unlock(&sn->rpc_client_lock);
|
2007-06-16 12:18:40 -06:00
|
|
|
}
|
|
|
|
#endif
|