mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 19:51:31 -04:00
The nfsd update this round is mainly a lot of miscellaneous cleanups and
bugfixes.
A couple changes could theoretically break working setups on upgrade. I
don't expect complaints in practice, but they seem worth calling out
just in case:
- NFS security labels are now off by default; a new
security_label export flag reenables it per export. But,
having them on by default is a disaster, as it generally only
makes sense if all your clients and servers have similar
enough selinux policies. Thanks to Jason Tibbitts for
pointing this out.
- NFSv4/UDP support is off. It was never really supported, and
the spec explicitly forbids it. We only ever left it on out
of laziness; thanks to Jeff Layton for finally fixing that.
-----BEGIN PGP SIGNATURE-----
iQIcBAABAgAGBQJYtejbAAoJECebzXlCjuG+JhEQAK3YTYYNrPY26Pfiu0FghLFV
4qOHK4DOkJzrWIom5uWyBo7yOwH6WnQtTe/gCx/voOEW3lsJO7F3IfTnTVp+Smp6
GJeVtsr1vI9EBnwhMlyoJ5hZ2Ju5kX3MBVnew6+momt6620ZO7a+EtT+74ePaY8Y
jxLzWVA1UqbWYoMabNQpqgKypKvNrhwst72iYyBhNuL/qtGeBDQWwcrA+TFeE9tv
Ad7qB53xL1mr0Wn1CNIOR/IzVAj4o2H0vdjqrPjAdvbfwf8YYLNpJXt5k591wx/j
1TpiWIPqnwLjMT3X5NkQN3agZKeD+2ZWPrClr35TgRRe62CK6JblK9/Wwc5BRSzV
paMP3hOm6/dQOBA5C+mqPaHdEI8VqcHyZpxU4VC/ttsVEGTgaLhGwHGzSn+5lYiM
Qx9Sh50yFV3oiBW/sb/y8lBDwYm/Cq0OyqAU277idbdzjcFerMg1qt06tjEQhYMY
K2V7rS8NuADUF6F1BwOONZzvg7Rr7iWHmLh+iSM9TeQoEmz2jIHSaLIFaYOET5Jr
PIZS3rOYoa0FaKOYVYnZMC74n/LqP/Aou8B+1rRcLy5YEdUIIIVpFvqpg1nGv6PI
sA3zx/f13IRte3g0CuQiY0/2cx7uXk/gXJ7s5+ejEzljF/aYWiomx3mr6HqPQETn
CWEtXlfyJCyX+A8hbO+U
=iLLz
-----END PGP SIGNATURE-----
Merge tag 'nfsd-4.11' of git://linux-nfs.org/~bfields/linux
Pull nfsd updates from Bruce Fields:
"The nfsd update this round is mainly a lot of miscellaneous cleanups
and bugfixes.
A couple changes could theoretically break working setups on upgrade.
I don't expect complaints in practice, but they seem worth calling out
just in case:
- NFS security labels are now off by default; a new security_label
export flag reenables it per export. But, having them on by default
is a disaster, as it generally only makes sense if all your clients
and servers have similar enough selinux policies. Thanks to Jason
Tibbitts for pointing this out.
- NFSv4/UDP support is off. It was never really supported, and the
spec explicitly forbids it. We only ever left it on out of
laziness; thanks to Jeff Layton for finally fixing that"
* tag 'nfsd-4.11' of git://linux-nfs.org/~bfields/linux: (34 commits)
nfsd: Fix display of the version string
nfsd: fix configuration of supported minor versions
sunrpc: don't register UDP port with rpcbind when version needs congestion control
nfs/nfsd/sunrpc: enforce transport requirements for NFSv4
sunrpc: flag transports as having congestion control
sunrpc: turn bitfield flags in svc_version into bools
nfsd: remove superfluous KERN_INFO
nfsd: special case truncates some more
nfsd: minor nfsd_setattr cleanup
NFSD: Reserve adequate space for LOCKT operation
NFSD: Get response size before operation for all RPCs
nfsd/callback: Drop a useless data copy when comparing sessionid
nfsd/callback: skip the callback tag
nfsd/callback: Cleanup callback cred on shutdown
nfsd/idmap: return nfserr_inval for 0-length names
SUNRPC/Cache: Always treat the invalid cache as unexpired
SUNRPC: Drop all entries from cache_detail when cache_purge()
svcrdma: Poll CQs in "workqueue" mode
svcrdma: Combine list fields in struct svc_rdma_op_ctxt
svcrdma: Remove unused sc_dto_q field
...
This commit is contained in:
Linus Torvalds
commit
8313064c2e
33 changed files with 510 additions and 431 deletions
|
|
@ -1489,8 +1489,8 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
|
|||
case RPC_GSS_PROC_DESTROY:
|
||||
if (gss_write_verf(rqstp, rsci->mechctx, gc->gc_seq))
|
||||
goto auth_err;
|
||||
rsci->h.expiry_time = seconds_since_boot();
|
||||
set_bit(CACHE_NEGATIVE, &rsci->h.flags);
|
||||
/* Delete the entry from the cache_list and call cache_put */
|
||||
sunrpc_cache_unhash(sn->rsc_cache, &rsci->h);
|
||||
if (resv->iov_len + 4 > PAGE_SIZE)
|
||||
goto drop;
|
||||
svc_putnl(resv, RPC_SUCCESS);
|
||||
|
|
|
|||
|
|
@ -362,11 +362,6 @@ void sunrpc_destroy_cache_detail(struct cache_detail *cd)
|
|||
cache_purge(cd);
|
||||
spin_lock(&cache_list_lock);
|
||||
write_lock(&cd->hash_lock);
|
||||
if (cd->entries) {
|
||||
write_unlock(&cd->hash_lock);
|
||||
spin_unlock(&cache_list_lock);
|
||||
goto out;
|
||||
}
|
||||
if (current_detail == cd)
|
||||
current_detail = NULL;
|
||||
list_del_init(&cd->others);
|
||||
|
|
@ -376,9 +371,6 @@ void sunrpc_destroy_cache_detail(struct cache_detail *cd)
|
|||
/* module must be being unloaded so its safe to kill the worker */
|
||||
cancel_delayed_work_sync(&cache_cleaner);
|
||||
}
|
||||
return;
|
||||
out:
|
||||
printk(KERN_ERR "RPC: failed to unregister %s cache\n", cd->name);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sunrpc_destroy_cache_detail);
|
||||
|
||||
|
|
@ -497,13 +489,32 @@ EXPORT_SYMBOL_GPL(cache_flush);
|
|||
|
||||
void cache_purge(struct cache_detail *detail)
|
||||
{
|
||||
time_t now = seconds_since_boot();
|
||||
if (detail->flush_time >= now)
|
||||
now = detail->flush_time + 1;
|
||||
/* 'now' is the maximum value any 'last_refresh' can have */
|
||||
detail->flush_time = now;
|
||||
detail->nextcheck = seconds_since_boot();
|
||||
cache_flush();
|
||||
struct cache_head *ch = NULL;
|
||||
struct hlist_head *head = NULL;
|
||||
struct hlist_node *tmp = NULL;
|
||||
int i = 0;
|
||||
|
||||
write_lock(&detail->hash_lock);
|
||||
if (!detail->entries) {
|
||||
write_unlock(&detail->hash_lock);
|
||||
return;
|
||||
}
|
||||
|
||||
dprintk("RPC: %d entries in %s cache\n", detail->entries, detail->name);
|
||||
for (i = 0; i < detail->hash_size; i++) {
|
||||
head = &detail->hash_table[i];
|
||||
hlist_for_each_entry_safe(ch, tmp, head, cache_list) {
|
||||
hlist_del_init(&ch->cache_list);
|
||||
detail->entries--;
|
||||
|
||||
set_bit(CACHE_CLEANED, &ch->flags);
|
||||
write_unlock(&detail->hash_lock);
|
||||
cache_fresh_unlocked(ch, detail);
|
||||
cache_put(ch, detail);
|
||||
write_lock(&detail->hash_lock);
|
||||
}
|
||||
}
|
||||
write_unlock(&detail->hash_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(cache_purge);
|
||||
|
||||
|
|
@ -1855,3 +1866,15 @@ void sunrpc_cache_unregister_pipefs(struct cache_detail *cd)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs);
|
||||
|
||||
void sunrpc_cache_unhash(struct cache_detail *cd, struct cache_head *h)
|
||||
{
|
||||
write_lock(&cd->hash_lock);
|
||||
if (!hlist_unhashed(&h->cache_list)){
|
||||
hlist_del_init(&h->cache_list);
|
||||
cd->entries--;
|
||||
write_unlock(&cd->hash_lock);
|
||||
cache_put(h, cd);
|
||||
} else
|
||||
write_unlock(&cd->hash_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sunrpc_cache_unhash);
|
||||
|
|
|
|||
|
|
@ -385,7 +385,7 @@ static int svc_uses_rpcbind(struct svc_serv *serv)
|
|||
for (i = 0; i < progp->pg_nvers; i++) {
|
||||
if (progp->pg_vers[i] == NULL)
|
||||
continue;
|
||||
if (progp->pg_vers[i]->vs_hidden == 0)
|
||||
if (!progp->pg_vers[i]->vs_hidden)
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -976,6 +976,13 @@ int svc_register(const struct svc_serv *serv, struct net *net,
|
|||
if (vers->vs_hidden)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Don't register a UDP port if we need congestion
|
||||
* control.
|
||||
*/
|
||||
if (vers->vs_need_cong_ctrl && proto == IPPROTO_UDP)
|
||||
continue;
|
||||
|
||||
error = __svc_register(net, progp->pg_name, progp->pg_prog,
|
||||
i, family, proto, port);
|
||||
|
||||
|
|
@ -1169,6 +1176,21 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
|
|||
!(versp = progp->pg_vers[vers]))
|
||||
goto err_bad_vers;
|
||||
|
||||
/*
|
||||
* Some protocol versions (namely NFSv4) require some form of
|
||||
* congestion control. (See RFC 7530 section 3.1 paragraph 2)
|
||||
* In other words, UDP is not allowed. We mark those when setting
|
||||
* up the svc_xprt, and verify that here.
|
||||
*
|
||||
* The spec is not very clear about what error should be returned
|
||||
* when someone tries to access a server that is listening on UDP
|
||||
* for lower versions. RPC_PROG_MISMATCH seems to be the closest
|
||||
* fit.
|
||||
*/
|
||||
if (versp->vs_need_cong_ctrl &&
|
||||
!test_bit(XPT_CONG_CTRL, &rqstp->rq_xprt->xpt_flags))
|
||||
goto err_bad_vers;
|
||||
|
||||
procp = versp->vs_proc + proc;
|
||||
if (proc >= versp->vs_nproc || !procp->pc_func)
|
||||
goto err_bad_proc;
|
||||
|
|
|
|||
|
|
@ -1306,6 +1306,7 @@ static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
|
|||
svc_xprt_init(sock_net(svsk->sk_sock->sk), &svc_tcp_class,
|
||||
&svsk->sk_xprt, serv);
|
||||
set_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags);
|
||||
set_bit(XPT_CONG_CTRL, &svsk->sk_xprt.xpt_flags);
|
||||
if (sk->sk_state == TCP_LISTEN) {
|
||||
dprintk("setting up TCP socket for listening\n");
|
||||
set_bit(XPT_LISTENER, &svsk->sk_xprt.xpt_flags);
|
||||
|
|
|
|||
|
|
@ -201,19 +201,20 @@ rpcrdma_bc_send_request(struct svcxprt_rdma *rdma, struct rpc_rqst *rqst)
|
|||
{
|
||||
struct rpc_xprt *xprt = rqst->rq_xprt;
|
||||
struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
|
||||
struct rpcrdma_msg *headerp = (struct rpcrdma_msg *)rqst->rq_buffer;
|
||||
__be32 *p;
|
||||
int rc;
|
||||
|
||||
/* Space in the send buffer for an RPC/RDMA header is reserved
|
||||
* via xprt->tsh_size.
|
||||
*/
|
||||
headerp->rm_xid = rqst->rq_xid;
|
||||
headerp->rm_vers = rpcrdma_version;
|
||||
headerp->rm_credit = cpu_to_be32(r_xprt->rx_buf.rb_bc_max_requests);
|
||||
headerp->rm_type = rdma_msg;
|
||||
headerp->rm_body.rm_chunks[0] = xdr_zero;
|
||||
headerp->rm_body.rm_chunks[1] = xdr_zero;
|
||||
headerp->rm_body.rm_chunks[2] = xdr_zero;
|
||||
p = rqst->rq_buffer;
|
||||
*p++ = rqst->rq_xid;
|
||||
*p++ = rpcrdma_version;
|
||||
*p++ = cpu_to_be32(r_xprt->rx_buf.rb_bc_max_requests);
|
||||
*p++ = rdma_msg;
|
||||
*p++ = xdr_zero;
|
||||
*p++ = xdr_zero;
|
||||
*p = xdr_zero;
|
||||
|
||||
#ifdef SVCRDMA_BACKCHANNEL_DEBUG
|
||||
pr_info("%s: %*ph\n", __func__, 64, rqst->rq_buffer);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2016 Oracle. All rights reserved.
|
||||
* Copyright (c) 2005-2006 Network Appliance, Inc. All rights reserved.
|
||||
*
|
||||
* This software is available to you under a choice of one of two
|
||||
|
|
@ -47,102 +48,43 @@
|
|||
|
||||
#define RPCDBG_FACILITY RPCDBG_SVCXPRT
|
||||
|
||||
/*
|
||||
* Decodes a read chunk list. The expected format is as follows:
|
||||
* descrim : xdr_one
|
||||
* position : __be32 offset into XDR stream
|
||||
* handle : __be32 RKEY
|
||||
* . . .
|
||||
* end-of-list: xdr_zero
|
||||
*/
|
||||
static __be32 *decode_read_list(__be32 *va, __be32 *vaend)
|
||||
static __be32 *xdr_check_read_list(__be32 *p, __be32 *end)
|
||||
{
|
||||
struct rpcrdma_read_chunk *ch = (struct rpcrdma_read_chunk *)va;
|
||||
__be32 *next;
|
||||
|
||||
while (ch->rc_discrim != xdr_zero) {
|
||||
if (((unsigned long)ch + sizeof(struct rpcrdma_read_chunk)) >
|
||||
(unsigned long)vaend) {
|
||||
dprintk("svcrdma: vaend=%p, ch=%p\n", vaend, ch);
|
||||
while (*p++ != xdr_zero) {
|
||||
next = p + rpcrdma_readchunk_maxsz - 1;
|
||||
if (next > end)
|
||||
return NULL;
|
||||
}
|
||||
ch++;
|
||||
p = next;
|
||||
}
|
||||
return &ch->rc_position;
|
||||
return p;
|
||||
}
|
||||
|
||||
/*
|
||||
* Decodes a write chunk list. The expected format is as follows:
|
||||
* descrim : xdr_one
|
||||
* nchunks : <count>
|
||||
* handle : __be32 RKEY ---+
|
||||
* length : __be32 <len of segment> |
|
||||
* offset : remove va + <count>
|
||||
* . . . |
|
||||
* ---+
|
||||
*/
|
||||
static __be32 *decode_write_list(__be32 *va, __be32 *vaend)
|
||||
static __be32 *xdr_check_write_list(__be32 *p, __be32 *end)
|
||||
{
|
||||
unsigned long start, end;
|
||||
int nchunks;
|
||||
__be32 *next;
|
||||
|
||||
struct rpcrdma_write_array *ary =
|
||||
(struct rpcrdma_write_array *)va;
|
||||
|
||||
/* Check for not write-array */
|
||||
if (ary->wc_discrim == xdr_zero)
|
||||
return &ary->wc_nchunks;
|
||||
|
||||
if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
|
||||
(unsigned long)vaend) {
|
||||
dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
|
||||
return NULL;
|
||||
while (*p++ != xdr_zero) {
|
||||
next = p + 1 + be32_to_cpup(p) * rpcrdma_segment_maxsz;
|
||||
if (next > end)
|
||||
return NULL;
|
||||
p = next;
|
||||
}
|
||||
nchunks = be32_to_cpu(ary->wc_nchunks);
|
||||
|
||||
start = (unsigned long)&ary->wc_array[0];
|
||||
end = (unsigned long)vaend;
|
||||
if (nchunks < 0 ||
|
||||
nchunks > (SIZE_MAX - start) / sizeof(struct rpcrdma_write_chunk) ||
|
||||
(start + (sizeof(struct rpcrdma_write_chunk) * nchunks)) > end) {
|
||||
dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n",
|
||||
ary, nchunks, vaend);
|
||||
return NULL;
|
||||
}
|
||||
/*
|
||||
* rs_length is the 2nd 4B field in wc_target and taking its
|
||||
* address skips the list terminator
|
||||
*/
|
||||
return &ary->wc_array[nchunks].wc_target.rs_length;
|
||||
return p;
|
||||
}
|
||||
|
||||
static __be32 *decode_reply_array(__be32 *va, __be32 *vaend)
|
||||
static __be32 *xdr_check_reply_chunk(__be32 *p, __be32 *end)
|
||||
{
|
||||
unsigned long start, end;
|
||||
int nchunks;
|
||||
struct rpcrdma_write_array *ary =
|
||||
(struct rpcrdma_write_array *)va;
|
||||
__be32 *next;
|
||||
|
||||
/* Check for no reply-array */
|
||||
if (ary->wc_discrim == xdr_zero)
|
||||
return &ary->wc_nchunks;
|
||||
|
||||
if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
|
||||
(unsigned long)vaend) {
|
||||
dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
|
||||
return NULL;
|
||||
if (*p++ != xdr_zero) {
|
||||
next = p + 1 + be32_to_cpup(p) * rpcrdma_segment_maxsz;
|
||||
if (next > end)
|
||||
return NULL;
|
||||
p = next;
|
||||
}
|
||||
nchunks = be32_to_cpu(ary->wc_nchunks);
|
||||
|
||||
start = (unsigned long)&ary->wc_array[0];
|
||||
end = (unsigned long)vaend;
|
||||
if (nchunks < 0 ||
|
||||
nchunks > (SIZE_MAX - start) / sizeof(struct rpcrdma_write_chunk) ||
|
||||
(start + (sizeof(struct rpcrdma_write_chunk) * nchunks)) > end) {
|
||||
dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n",
|
||||
ary, nchunks, vaend);
|
||||
return NULL;
|
||||
}
|
||||
return (__be32 *)&ary->wc_array[nchunks];
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -158,87 +100,71 @@ static __be32 *decode_reply_array(__be32 *va, __be32 *vaend)
|
|||
*/
|
||||
int svc_rdma_xdr_decode_req(struct xdr_buf *rq_arg)
|
||||
{
|
||||
struct rpcrdma_msg *rmsgp;
|
||||
__be32 *va, *vaend;
|
||||
unsigned int len;
|
||||
u32 hdr_len;
|
||||
__be32 *p, *end, *rdma_argp;
|
||||
unsigned int hdr_len;
|
||||
|
||||
/* Verify that there's enough bytes for header + something */
|
||||
if (rq_arg->len <= RPCRDMA_HDRLEN_ERR) {
|
||||
dprintk("svcrdma: header too short = %d\n",
|
||||
rq_arg->len);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (rq_arg->len <= RPCRDMA_HDRLEN_ERR)
|
||||
goto out_short;
|
||||
|
||||
rmsgp = (struct rpcrdma_msg *)rq_arg->head[0].iov_base;
|
||||
if (rmsgp->rm_vers != rpcrdma_version) {
|
||||
dprintk("%s: bad version %u\n", __func__,
|
||||
be32_to_cpu(rmsgp->rm_vers));
|
||||
return -EPROTONOSUPPORT;
|
||||
}
|
||||
rdma_argp = rq_arg->head[0].iov_base;
|
||||
if (*(rdma_argp + 1) != rpcrdma_version)
|
||||
goto out_version;
|
||||
|
||||
switch (be32_to_cpu(rmsgp->rm_type)) {
|
||||
case RDMA_MSG:
|
||||
case RDMA_NOMSG:
|
||||
switch (*(rdma_argp + 3)) {
|
||||
case rdma_msg:
|
||||
case rdma_nomsg:
|
||||
break;
|
||||
|
||||
case RDMA_DONE:
|
||||
/* Just drop it */
|
||||
dprintk("svcrdma: dropping RDMA_DONE message\n");
|
||||
return 0;
|
||||
case rdma_done:
|
||||
goto out_drop;
|
||||
|
||||
case RDMA_ERROR:
|
||||
/* Possible if this is a backchannel reply.
|
||||
* XXX: We should cancel this XID, though.
|
||||
*/
|
||||
dprintk("svcrdma: dropping RDMA_ERROR message\n");
|
||||
return 0;
|
||||
case rdma_error:
|
||||
goto out_drop;
|
||||
|
||||
case RDMA_MSGP:
|
||||
/* Pull in the extra for the padded case, bump our pointer */
|
||||
rmsgp->rm_body.rm_padded.rm_align =
|
||||
be32_to_cpu(rmsgp->rm_body.rm_padded.rm_align);
|
||||
rmsgp->rm_body.rm_padded.rm_thresh =
|
||||
be32_to_cpu(rmsgp->rm_body.rm_padded.rm_thresh);
|
||||
|
||||
va = &rmsgp->rm_body.rm_padded.rm_pempty[4];
|
||||
rq_arg->head[0].iov_base = va;
|
||||
len = (u32)((unsigned long)va - (unsigned long)rmsgp);
|
||||
rq_arg->head[0].iov_len -= len;
|
||||
if (len > rq_arg->len)
|
||||
return -EINVAL;
|
||||
return len;
|
||||
default:
|
||||
dprintk("svcrdma: bad rdma procedure (%u)\n",
|
||||
be32_to_cpu(rmsgp->rm_type));
|
||||
return -EINVAL;
|
||||
goto out_proc;
|
||||
}
|
||||
|
||||
/* The chunk list may contain either a read chunk list or a write
|
||||
* chunk list and a reply chunk list.
|
||||
*/
|
||||
va = &rmsgp->rm_body.rm_chunks[0];
|
||||
vaend = (__be32 *)((unsigned long)rmsgp + rq_arg->len);
|
||||
va = decode_read_list(va, vaend);
|
||||
if (!va) {
|
||||
dprintk("svcrdma: failed to decode read list\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
va = decode_write_list(va, vaend);
|
||||
if (!va) {
|
||||
dprintk("svcrdma: failed to decode write list\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
va = decode_reply_array(va, vaend);
|
||||
if (!va) {
|
||||
dprintk("svcrdma: failed to decode reply chunk\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
end = (__be32 *)((unsigned long)rdma_argp + rq_arg->len);
|
||||
p = xdr_check_read_list(rdma_argp + 4, end);
|
||||
if (!p)
|
||||
goto out_inval;
|
||||
p = xdr_check_write_list(p, end);
|
||||
if (!p)
|
||||
goto out_inval;
|
||||
p = xdr_check_reply_chunk(p, end);
|
||||
if (!p)
|
||||
goto out_inval;
|
||||
if (p > end)
|
||||
goto out_inval;
|
||||
|
||||
rq_arg->head[0].iov_base = va;
|
||||
hdr_len = (unsigned long)va - (unsigned long)rmsgp;
|
||||
rq_arg->head[0].iov_base = p;
|
||||
hdr_len = (unsigned long)p - (unsigned long)rdma_argp;
|
||||
rq_arg->head[0].iov_len -= hdr_len;
|
||||
return hdr_len;
|
||||
|
||||
out_short:
|
||||
dprintk("svcrdma: header too short = %d\n", rq_arg->len);
|
||||
return -EINVAL;
|
||||
|
||||
out_version:
|
||||
dprintk("svcrdma: bad xprt version: %u\n",
|
||||
be32_to_cpup(rdma_argp + 1));
|
||||
return -EPROTONOSUPPORT;
|
||||
|
||||
out_drop:
|
||||
dprintk("svcrdma: dropping RDMA_DONE/ERROR message\n");
|
||||
return 0;
|
||||
|
||||
out_proc:
|
||||
dprintk("svcrdma: bad rdma procedure (%u)\n",
|
||||
be32_to_cpup(rdma_argp + 3));
|
||||
return -EINVAL;
|
||||
|
||||
out_inval:
|
||||
dprintk("svcrdma: failed to parse transport header\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt,
|
||||
|
|
@ -249,7 +175,7 @@ int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt,
|
|||
|
||||
*va++ = rmsgp->rm_xid;
|
||||
*va++ = rmsgp->rm_vers;
|
||||
*va++ = cpu_to_be32(xprt->sc_max_requests);
|
||||
*va++ = xprt->sc_fc_credits;
|
||||
*va++ = rdma_error;
|
||||
*va++ = cpu_to_be32(err);
|
||||
if (err == ERR_VERS) {
|
||||
|
|
@ -260,32 +186,35 @@ int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt,
|
|||
return (int)((unsigned long)va - (unsigned long)startp);
|
||||
}
|
||||
|
||||
int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *rmsgp)
|
||||
/**
|
||||
* svc_rdma_xdr_get_reply_hdr_length - Get length of Reply transport header
|
||||
* @rdma_resp: buffer containing Reply transport header
|
||||
*
|
||||
* Returns length of transport header, in bytes.
|
||||
*/
|
||||
unsigned int svc_rdma_xdr_get_reply_hdr_len(__be32 *rdma_resp)
|
||||
{
|
||||
struct rpcrdma_write_array *wr_ary;
|
||||
unsigned int nsegs;
|
||||
__be32 *p;
|
||||
|
||||
/* There is no read-list in a reply */
|
||||
p = rdma_resp;
|
||||
|
||||
/* skip write list */
|
||||
wr_ary = (struct rpcrdma_write_array *)
|
||||
&rmsgp->rm_body.rm_chunks[1];
|
||||
if (wr_ary->wc_discrim)
|
||||
wr_ary = (struct rpcrdma_write_array *)
|
||||
&wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)].
|
||||
wc_target.rs_length;
|
||||
else
|
||||
wr_ary = (struct rpcrdma_write_array *)
|
||||
&wr_ary->wc_nchunks;
|
||||
/* RPC-over-RDMA V1 replies never have a Read list. */
|
||||
p += rpcrdma_fixed_maxsz + 1;
|
||||
|
||||
/* skip reply array */
|
||||
if (wr_ary->wc_discrim)
|
||||
wr_ary = (struct rpcrdma_write_array *)
|
||||
&wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)];
|
||||
else
|
||||
wr_ary = (struct rpcrdma_write_array *)
|
||||
&wr_ary->wc_nchunks;
|
||||
/* Skip Write list. */
|
||||
while (*p++ != xdr_zero) {
|
||||
nsegs = be32_to_cpup(p++);
|
||||
p += nsegs * rpcrdma_segment_maxsz;
|
||||
}
|
||||
|
||||
return (unsigned long) wr_ary - (unsigned long) rmsgp;
|
||||
/* Skip Reply chunk. */
|
||||
if (*p++ != xdr_zero) {
|
||||
nsegs = be32_to_cpup(p++);
|
||||
p += nsegs * rpcrdma_segment_maxsz;
|
||||
}
|
||||
|
||||
return (unsigned long)p - (unsigned long)rdma_resp;
|
||||
}
|
||||
|
||||
void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *rmsgp, int chunks)
|
||||
|
|
@ -326,19 +255,3 @@ void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary,
|
|||
seg->rs_offset = rs_offset;
|
||||
seg->rs_length = cpu_to_be32(write_len);
|
||||
}
|
||||
|
||||
void svc_rdma_xdr_encode_reply_header(struct svcxprt_rdma *xprt,
|
||||
struct rpcrdma_msg *rdma_argp,
|
||||
struct rpcrdma_msg *rdma_resp,
|
||||
enum rpcrdma_proc rdma_type)
|
||||
{
|
||||
rdma_resp->rm_xid = rdma_argp->rm_xid;
|
||||
rdma_resp->rm_vers = rdma_argp->rm_vers;
|
||||
rdma_resp->rm_credit = cpu_to_be32(xprt->sc_max_requests);
|
||||
rdma_resp->rm_type = cpu_to_be32(rdma_type);
|
||||
|
||||
/* Encode <nul> chunks lists */
|
||||
rdma_resp->rm_body.rm_chunks[0] = xdr_zero;
|
||||
rdma_resp->rm_body.rm_chunks[1] = xdr_zero;
|
||||
rdma_resp->rm_body.rm_chunks[2] = xdr_zero;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -606,26 +606,24 @@ int svc_rdma_recvfrom(struct svc_rqst *rqstp)
|
|||
|
||||
dprintk("svcrdma: rqstp=%p\n", rqstp);
|
||||
|
||||
spin_lock_bh(&rdma_xprt->sc_rq_dto_lock);
|
||||
spin_lock(&rdma_xprt->sc_rq_dto_lock);
|
||||
if (!list_empty(&rdma_xprt->sc_read_complete_q)) {
|
||||
ctxt = list_entry(rdma_xprt->sc_read_complete_q.next,
|
||||
struct svc_rdma_op_ctxt,
|
||||
dto_q);
|
||||
list_del_init(&ctxt->dto_q);
|
||||
spin_unlock_bh(&rdma_xprt->sc_rq_dto_lock);
|
||||
ctxt = list_first_entry(&rdma_xprt->sc_read_complete_q,
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
spin_unlock(&rdma_xprt->sc_rq_dto_lock);
|
||||
rdma_read_complete(rqstp, ctxt);
|
||||
goto complete;
|
||||
} else if (!list_empty(&rdma_xprt->sc_rq_dto_q)) {
|
||||
ctxt = list_entry(rdma_xprt->sc_rq_dto_q.next,
|
||||
struct svc_rdma_op_ctxt,
|
||||
dto_q);
|
||||
list_del_init(&ctxt->dto_q);
|
||||
ctxt = list_first_entry(&rdma_xprt->sc_rq_dto_q,
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
} else {
|
||||
atomic_inc(&rdma_stat_rq_starve);
|
||||
clear_bit(XPT_DATA, &xprt->xpt_flags);
|
||||
ctxt = NULL;
|
||||
}
|
||||
spin_unlock_bh(&rdma_xprt->sc_rq_dto_lock);
|
||||
spin_unlock(&rdma_xprt->sc_rq_dto_lock);
|
||||
if (!ctxt) {
|
||||
/* This is the EAGAIN path. The svc_recv routine will
|
||||
* return -EAGAIN, the nfsd thread will go to call into
|
||||
|
|
|
|||
|
|
@ -476,7 +476,8 @@ static int send_reply(struct svcxprt_rdma *rdma,
|
|||
|
||||
/* Prepare the SGE for the RPCRDMA Header */
|
||||
ctxt->sge[0].lkey = rdma->sc_pd->local_dma_lkey;
|
||||
ctxt->sge[0].length = svc_rdma_xdr_get_reply_hdr_len(rdma_resp);
|
||||
ctxt->sge[0].length =
|
||||
svc_rdma_xdr_get_reply_hdr_len((__be32 *)rdma_resp);
|
||||
ctxt->sge[0].addr =
|
||||
ib_dma_map_page(rdma->sc_cm_id->device, page, 0,
|
||||
ctxt->sge[0].length, DMA_TO_DEVICE);
|
||||
|
|
@ -559,12 +560,12 @@ int svc_rdma_sendto(struct svc_rqst *rqstp)
|
|||
struct rpcrdma_msg *rdma_argp;
|
||||
struct rpcrdma_msg *rdma_resp;
|
||||
struct rpcrdma_write_array *wr_ary, *rp_ary;
|
||||
enum rpcrdma_proc reply_type;
|
||||
int ret;
|
||||
int inline_bytes;
|
||||
struct page *res_page;
|
||||
struct svc_rdma_req_map *vec;
|
||||
u32 inv_rkey;
|
||||
__be32 *p;
|
||||
|
||||
dprintk("svcrdma: sending response for rqstp=%p\n", rqstp);
|
||||
|
||||
|
|
@ -596,12 +597,17 @@ int svc_rdma_sendto(struct svc_rqst *rqstp)
|
|||
if (!res_page)
|
||||
goto err0;
|
||||
rdma_resp = page_address(res_page);
|
||||
if (rp_ary)
|
||||
reply_type = RDMA_NOMSG;
|
||||
else
|
||||
reply_type = RDMA_MSG;
|
||||
svc_rdma_xdr_encode_reply_header(rdma, rdma_argp,
|
||||
rdma_resp, reply_type);
|
||||
|
||||
p = &rdma_resp->rm_xid;
|
||||
*p++ = rdma_argp->rm_xid;
|
||||
*p++ = rdma_argp->rm_vers;
|
||||
*p++ = rdma->sc_fc_credits;
|
||||
*p++ = rp_ary ? rdma_nomsg : rdma_msg;
|
||||
|
||||
/* Start with empty chunks */
|
||||
*p++ = xdr_zero;
|
||||
*p++ = xdr_zero;
|
||||
*p = xdr_zero;
|
||||
|
||||
/* Send any write-chunk data and build resp write-list */
|
||||
if (wr_ary) {
|
||||
|
|
|
|||
|
|
@ -157,8 +157,7 @@ static struct svc_rdma_op_ctxt *alloc_ctxt(struct svcxprt_rdma *xprt,
|
|||
ctxt = kmalloc(sizeof(*ctxt), flags);
|
||||
if (ctxt) {
|
||||
ctxt->xprt = xprt;
|
||||
INIT_LIST_HEAD(&ctxt->free);
|
||||
INIT_LIST_HEAD(&ctxt->dto_q);
|
||||
INIT_LIST_HEAD(&ctxt->list);
|
||||
}
|
||||
return ctxt;
|
||||
}
|
||||
|
|
@ -180,7 +179,7 @@ static bool svc_rdma_prealloc_ctxts(struct svcxprt_rdma *xprt)
|
|||
dprintk("svcrdma: No memory for RDMA ctxt\n");
|
||||
return false;
|
||||
}
|
||||
list_add(&ctxt->free, &xprt->sc_ctxts);
|
||||
list_add(&ctxt->list, &xprt->sc_ctxts);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -189,15 +188,15 @@ struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *xprt)
|
|||
{
|
||||
struct svc_rdma_op_ctxt *ctxt = NULL;
|
||||
|
||||
spin_lock_bh(&xprt->sc_ctxt_lock);
|
||||
spin_lock(&xprt->sc_ctxt_lock);
|
||||
xprt->sc_ctxt_used++;
|
||||
if (list_empty(&xprt->sc_ctxts))
|
||||
goto out_empty;
|
||||
|
||||
ctxt = list_first_entry(&xprt->sc_ctxts,
|
||||
struct svc_rdma_op_ctxt, free);
|
||||
list_del_init(&ctxt->free);
|
||||
spin_unlock_bh(&xprt->sc_ctxt_lock);
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
spin_unlock(&xprt->sc_ctxt_lock);
|
||||
|
||||
out:
|
||||
ctxt->count = 0;
|
||||
|
|
@ -209,15 +208,15 @@ out_empty:
|
|||
/* Either pre-allocation missed the mark, or send
|
||||
* queue accounting is broken.
|
||||
*/
|
||||
spin_unlock_bh(&xprt->sc_ctxt_lock);
|
||||
spin_unlock(&xprt->sc_ctxt_lock);
|
||||
|
||||
ctxt = alloc_ctxt(xprt, GFP_NOIO);
|
||||
if (ctxt)
|
||||
goto out;
|
||||
|
||||
spin_lock_bh(&xprt->sc_ctxt_lock);
|
||||
spin_lock(&xprt->sc_ctxt_lock);
|
||||
xprt->sc_ctxt_used--;
|
||||
spin_unlock_bh(&xprt->sc_ctxt_lock);
|
||||
spin_unlock(&xprt->sc_ctxt_lock);
|
||||
WARN_ONCE(1, "svcrdma: empty RDMA ctxt list?\n");
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -254,10 +253,10 @@ void svc_rdma_put_context(struct svc_rdma_op_ctxt *ctxt, int free_pages)
|
|||
for (i = 0; i < ctxt->count; i++)
|
||||
put_page(ctxt->pages[i]);
|
||||
|
||||
spin_lock_bh(&xprt->sc_ctxt_lock);
|
||||
spin_lock(&xprt->sc_ctxt_lock);
|
||||
xprt->sc_ctxt_used--;
|
||||
list_add(&ctxt->free, &xprt->sc_ctxts);
|
||||
spin_unlock_bh(&xprt->sc_ctxt_lock);
|
||||
list_add(&ctxt->list, &xprt->sc_ctxts);
|
||||
spin_unlock(&xprt->sc_ctxt_lock);
|
||||
}
|
||||
|
||||
static void svc_rdma_destroy_ctxts(struct svcxprt_rdma *xprt)
|
||||
|
|
@ -266,8 +265,8 @@ static void svc_rdma_destroy_ctxts(struct svcxprt_rdma *xprt)
|
|||
struct svc_rdma_op_ctxt *ctxt;
|
||||
|
||||
ctxt = list_first_entry(&xprt->sc_ctxts,
|
||||
struct svc_rdma_op_ctxt, free);
|
||||
list_del(&ctxt->free);
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
kfree(ctxt);
|
||||
}
|
||||
}
|
||||
|
|
@ -404,7 +403,7 @@ static void svc_rdma_wc_receive(struct ib_cq *cq, struct ib_wc *wc)
|
|||
/* All wc fields are now known to be valid */
|
||||
ctxt->byte_len = wc->byte_len;
|
||||
spin_lock(&xprt->sc_rq_dto_lock);
|
||||
list_add_tail(&ctxt->dto_q, &xprt->sc_rq_dto_q);
|
||||
list_add_tail(&ctxt->list, &xprt->sc_rq_dto_q);
|
||||
spin_unlock(&xprt->sc_rq_dto_lock);
|
||||
|
||||
set_bit(XPT_DATA, &xprt->sc_xprt.xpt_flags);
|
||||
|
|
@ -525,7 +524,7 @@ void svc_rdma_wc_read(struct ib_cq *cq, struct ib_wc *wc)
|
|||
|
||||
read_hdr = ctxt->read_hdr;
|
||||
spin_lock(&xprt->sc_rq_dto_lock);
|
||||
list_add_tail(&read_hdr->dto_q,
|
||||
list_add_tail(&read_hdr->list,
|
||||
&xprt->sc_read_complete_q);
|
||||
spin_unlock(&xprt->sc_rq_dto_lock);
|
||||
|
||||
|
|
@ -557,7 +556,6 @@ static struct svcxprt_rdma *rdma_create_xprt(struct svc_serv *serv,
|
|||
return NULL;
|
||||
svc_xprt_init(&init_net, &svc_rdma_class, &cma_xprt->sc_xprt, serv);
|
||||
INIT_LIST_HEAD(&cma_xprt->sc_accept_q);
|
||||
INIT_LIST_HEAD(&cma_xprt->sc_dto_q);
|
||||
INIT_LIST_HEAD(&cma_xprt->sc_rq_dto_q);
|
||||
INIT_LIST_HEAD(&cma_xprt->sc_read_complete_q);
|
||||
INIT_LIST_HEAD(&cma_xprt->sc_frmr_q);
|
||||
|
|
@ -571,6 +569,14 @@ static struct svcxprt_rdma *rdma_create_xprt(struct svc_serv *serv,
|
|||
spin_lock_init(&cma_xprt->sc_ctxt_lock);
|
||||
spin_lock_init(&cma_xprt->sc_map_lock);
|
||||
|
||||
/*
|
||||
* Note that this implies that the underlying transport support
|
||||
* has some form of congestion control (see RFC 7530 section 3.1
|
||||
* paragraph 2). For now, we assume that all supported RDMA
|
||||
* transports are suitable here.
|
||||
*/
|
||||
set_bit(XPT_CONG_CTRL, &cma_xprt->sc_xprt.xpt_flags);
|
||||
|
||||
if (listener)
|
||||
set_bit(XPT_LISTENER, &cma_xprt->sc_xprt.xpt_flags);
|
||||
|
||||
|
|
@ -923,14 +929,14 @@ struct svc_rdma_fastreg_mr *svc_rdma_get_frmr(struct svcxprt_rdma *rdma)
|
|||
{
|
||||
struct svc_rdma_fastreg_mr *frmr = NULL;
|
||||
|
||||
spin_lock_bh(&rdma->sc_frmr_q_lock);
|
||||
spin_lock(&rdma->sc_frmr_q_lock);
|
||||
if (!list_empty(&rdma->sc_frmr_q)) {
|
||||
frmr = list_entry(rdma->sc_frmr_q.next,
|
||||
struct svc_rdma_fastreg_mr, frmr_list);
|
||||
list_del_init(&frmr->frmr_list);
|
||||
frmr->sg_nents = 0;
|
||||
}
|
||||
spin_unlock_bh(&rdma->sc_frmr_q_lock);
|
||||
spin_unlock(&rdma->sc_frmr_q_lock);
|
||||
if (frmr)
|
||||
return frmr;
|
||||
|
||||
|
|
@ -943,10 +949,10 @@ void svc_rdma_put_frmr(struct svcxprt_rdma *rdma,
|
|||
if (frmr) {
|
||||
ib_dma_unmap_sg(rdma->sc_cm_id->device,
|
||||
frmr->sg, frmr->sg_nents, frmr->direction);
|
||||
spin_lock_bh(&rdma->sc_frmr_q_lock);
|
||||
spin_lock(&rdma->sc_frmr_q_lock);
|
||||
WARN_ON_ONCE(!list_empty(&frmr->frmr_list));
|
||||
list_add(&frmr->frmr_list, &rdma->sc_frmr_q);
|
||||
spin_unlock_bh(&rdma->sc_frmr_q_lock);
|
||||
spin_unlock(&rdma->sc_frmr_q_lock);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1002,6 +1008,7 @@ static struct svc_xprt *svc_rdma_accept(struct svc_xprt *xprt)
|
|||
newxprt->sc_max_req_size = svcrdma_max_req_size;
|
||||
newxprt->sc_max_requests = min_t(u32, dev->attrs.max_qp_wr,
|
||||
svcrdma_max_requests);
|
||||
newxprt->sc_fc_credits = cpu_to_be32(newxprt->sc_max_requests);
|
||||
newxprt->sc_max_bc_requests = min_t(u32, dev->attrs.max_qp_wr,
|
||||
svcrdma_max_bc_requests);
|
||||
newxprt->sc_rq_depth = newxprt->sc_max_requests +
|
||||
|
|
@ -1027,13 +1034,13 @@ static struct svc_xprt *svc_rdma_accept(struct svc_xprt *xprt)
|
|||
goto errout;
|
||||
}
|
||||
newxprt->sc_sq_cq = ib_alloc_cq(dev, newxprt, newxprt->sc_sq_depth,
|
||||
0, IB_POLL_SOFTIRQ);
|
||||
0, IB_POLL_WORKQUEUE);
|
||||
if (IS_ERR(newxprt->sc_sq_cq)) {
|
||||
dprintk("svcrdma: error creating SQ CQ for connect request\n");
|
||||
goto errout;
|
||||
}
|
||||
newxprt->sc_rq_cq = ib_alloc_cq(dev, newxprt, newxprt->sc_rq_depth,
|
||||
0, IB_POLL_SOFTIRQ);
|
||||
0, IB_POLL_WORKQUEUE);
|
||||
if (IS_ERR(newxprt->sc_rq_cq)) {
|
||||
dprintk("svcrdma: error creating RQ CQ for connect request\n");
|
||||
goto errout;
|
||||
|
|
@ -1213,20 +1220,18 @@ static void __svc_rdma_free(struct work_struct *work)
|
|||
*/
|
||||
while (!list_empty(&rdma->sc_read_complete_q)) {
|
||||
struct svc_rdma_op_ctxt *ctxt;
|
||||
ctxt = list_entry(rdma->sc_read_complete_q.next,
|
||||
struct svc_rdma_op_ctxt,
|
||||
dto_q);
|
||||
list_del_init(&ctxt->dto_q);
|
||||
ctxt = list_first_entry(&rdma->sc_read_complete_q,
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
svc_rdma_put_context(ctxt, 1);
|
||||
}
|
||||
|
||||
/* Destroy queued, but not processed recv completions */
|
||||
while (!list_empty(&rdma->sc_rq_dto_q)) {
|
||||
struct svc_rdma_op_ctxt *ctxt;
|
||||
ctxt = list_entry(rdma->sc_rq_dto_q.next,
|
||||
struct svc_rdma_op_ctxt,
|
||||
dto_q);
|
||||
list_del_init(&ctxt->dto_q);
|
||||
ctxt = list_first_entry(&rdma->sc_rq_dto_q,
|
||||
struct svc_rdma_op_ctxt, list);
|
||||
list_del(&ctxt->list);
|
||||
svc_rdma_put_context(ctxt, 1);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue