2009-02-24 15:30:27 +00:00
|
|
|
/*
|
2018-04-11 07:57:25 +00:00
|
|
|
* Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
|
2009-02-24 15:30:27 +00:00
|
|
|
*
|
|
|
|
* This software is available to you under a choice of one of two
|
|
|
|
* licenses. You may choose to be licensed under the terms of the GNU
|
|
|
|
* General Public License (GPL) Version 2, available from the file
|
|
|
|
* COPYING in the main directory of this source tree, or the
|
|
|
|
* OpenIB.org BSD license below:
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or
|
|
|
|
* without modification, are permitted provided that the following
|
|
|
|
* conditions are met:
|
|
|
|
*
|
|
|
|
* - Redistributions of source code must retain the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer.
|
|
|
|
*
|
|
|
|
* - Redistributions in binary form must reproduce the above
|
|
|
|
* copyright notice, this list of conditions and the following
|
|
|
|
* disclaimer in the documentation and/or other materials
|
|
|
|
* provided with the distribution.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
2011-09-18 17:21:27 +00:00
|
|
|
#include <linux/moduleparam.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/gfp.h>
|
2009-02-24 15:30:27 +00:00
|
|
|
#include <net/sock.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/list.h>
|
2011-06-16 02:09:57 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2011-07-15 15:47:34 +00:00
|
|
|
#include <linux/export.h>
|
2015-09-10 18:57:14 +00:00
|
|
|
#include <linux/sizes.h>
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
#include "rds.h"
|
|
|
|
|
|
|
|
/* When transmitting messages in rds_send_xmit, we need to emerge from
|
|
|
|
* time to time and briefly release the CPU. Otherwise the softlock watchdog
|
|
|
|
* will kick our shin.
|
|
|
|
* Also, it seems fairer to not let one busy connection stall all the
|
|
|
|
* others.
|
|
|
|
*
|
|
|
|
* send_batch_count is the number of times we'll loop in send_xmit. Setting
|
|
|
|
* it to 0 will restore the old behavior (where we looped until we had
|
|
|
|
* drained the queue).
|
|
|
|
*/
|
2015-09-10 18:57:14 +00:00
|
|
|
static int send_batch_count = SZ_1K;
|
2009-02-24 15:30:27 +00:00
|
|
|
module_param(send_batch_count, int, 0444);
|
|
|
|
MODULE_PARM_DESC(send_batch_count, " batch factor when working the send queue");
|
|
|
|
|
2010-10-19 08:08:33 +00:00
|
|
|
static void rds_send_remove_from_sock(struct list_head *messages, int status);
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/*
|
2010-06-04 21:41:41 +00:00
|
|
|
* Reset the send state. Callers must ensure that this doesn't race with
|
|
|
|
* rds_send_xmit().
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
2016-06-13 16:44:41 +00:00
|
|
|
void rds_send_path_reset(struct rds_conn_path *cp)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct rds_message *rm, *tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2016-06-13 16:44:30 +00:00
|
|
|
if (cp->cp_xmit_rm) {
|
|
|
|
rm = cp->cp_xmit_rm;
|
|
|
|
cp->cp_xmit_rm = NULL;
|
2009-02-24 15:30:27 +00:00
|
|
|
/* Tell the user the RDMA op is no longer mapped by the
|
|
|
|
* transport. This isn't entirely true (it's flushed out
|
|
|
|
* independently) but as the connection is down, there's
|
|
|
|
* no ongoing RDMA to/from that memory */
|
2010-05-11 22:11:11 +00:00
|
|
|
rds_message_unmapped(rm);
|
|
|
|
rds_message_put(rm);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
2010-05-11 22:11:11 +00:00
|
|
|
|
2016-06-13 16:44:30 +00:00
|
|
|
cp->cp_xmit_sg = 0;
|
|
|
|
cp->cp_xmit_hdr_off = 0;
|
|
|
|
cp->cp_xmit_data_off = 0;
|
|
|
|
cp->cp_xmit_atomic_sent = 0;
|
|
|
|
cp->cp_xmit_rdma_sent = 0;
|
|
|
|
cp->cp_xmit_data_sent = 0;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:30 +00:00
|
|
|
cp->cp_conn->c_map_queued = 0;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:30 +00:00
|
|
|
cp->cp_unacked_packets = rds_sysctl_max_unacked_packets;
|
|
|
|
cp->cp_unacked_bytes = rds_sysctl_max_unacked_bytes;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
/* Mark messages as retransmissions, and move them to the send q */
|
2016-06-13 16:44:30 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
|
|
|
list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
|
2009-02-24 15:30:27 +00:00
|
|
|
set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);
|
|
|
|
set_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags);
|
|
|
|
}
|
2016-06-13 16:44:30 +00:00
|
|
|
list_splice_init(&cp->cp_retrans, &cp->cp_send_queue);
|
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
|
|
|
}
|
2016-06-13 16:44:41 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_send_path_reset);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
static int acquire_in_xmit(struct rds_conn_path *cp)
|
2010-06-04 21:41:41 +00:00
|
|
|
{
|
2016-06-13 16:44:34 +00:00
|
|
|
return test_and_set_bit(RDS_IN_XMIT, &cp->cp_flags) == 0;
|
2010-06-04 21:41:41 +00:00
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
static void release_in_xmit(struct rds_conn_path *cp)
|
2010-06-04 21:41:41 +00:00
|
|
|
{
|
2016-06-13 16:44:34 +00:00
|
|
|
clear_bit(RDS_IN_XMIT, &cp->cp_flags);
|
2014-03-17 17:06:10 +00:00
|
|
|
smp_mb__after_atomic();
|
2010-06-04 21:41:41 +00:00
|
|
|
/*
|
|
|
|
* We don't use wait_on_bit()/wake_up_bit() because our waking is in a
|
|
|
|
* hot path and finding waiters is very rare. We don't want to walk
|
|
|
|
* the system-wide hashed waitqueue buckets in the fast path only to
|
|
|
|
* almost never find waiters.
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
if (waitqueue_active(&cp->cp_waitq))
|
|
|
|
wake_up_all(&cp->cp_waitq);
|
2010-06-04 21:41:41 +00:00
|
|
|
}
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/*
|
2011-03-31 01:57:33 +00:00
|
|
|
* We're making the conscious trade-off here to only send one message
|
2009-02-24 15:30:27 +00:00
|
|
|
* down the connection at a time.
|
|
|
|
* Pro:
|
|
|
|
* - tx queueing is a simple fifo list
|
|
|
|
* - reassembly is optional and easily done by transports per conn
|
|
|
|
* - no per flow rx lookup at all, straight to the socket
|
|
|
|
* - less per-frag memory and wire overhead
|
|
|
|
* Con:
|
|
|
|
* - queued acks can be delayed behind large messages
|
|
|
|
* Depends:
|
|
|
|
* - small message latency is higher behind queued large messages
|
|
|
|
* - large message latency isn't starved by intervening small sends
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
int rds_send_xmit(struct rds_conn_path *cp)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
2016-06-13 16:44:34 +00:00
|
|
|
struct rds_connection *conn = cp->cp_conn;
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_message *rm;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int tmp;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
int ret = 0;
|
|
|
|
LIST_HEAD(to_be_dropped);
|
2015-04-08 16:33:47 +00:00
|
|
|
int batch_count;
|
|
|
|
unsigned long send_gen = 0;
|
2011-01-13 19:40:31 +00:00
|
|
|
int same_rm = 0;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-30 00:08:49 +00:00
|
|
|
restart:
|
2015-04-08 16:33:47 +00:00
|
|
|
batch_count = 0;
|
2010-03-24 00:39:07 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/*
|
|
|
|
* sendmsg calls here after having queued its message on the send
|
|
|
|
* queue. We only have one task feeding the connection at a time. If
|
|
|
|
* another thread is already feeding the queue then we back off. This
|
|
|
|
* avoids blocking the caller and trading per-connection data between
|
|
|
|
* caches per message.
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
if (!acquire_in_xmit(cp)) {
|
2010-03-24 00:39:07 +00:00
|
|
|
rds_stats_inc(s_send_lock_contention);
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-06-04 21:41:41 +00:00
|
|
|
|
2018-02-03 12:26:51 +00:00
|
|
|
if (rds_destroy_pending(cp->cp_conn)) {
|
2018-01-04 14:53:00 +00:00
|
|
|
release_in_xmit(cp);
|
|
|
|
ret = -ENETUNREACH; /* dont requeue send work */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-04-08 16:33:47 +00:00
|
|
|
/*
|
|
|
|
* we record the send generation after doing the xmit acquire.
|
|
|
|
* if someone else manages to jump in and do some work, we'll use
|
|
|
|
* this to avoid a goto restart farther down.
|
|
|
|
*
|
|
|
|
* The acquire_in_xmit() check above ensures that only one
|
|
|
|
* caller can increment c_send_gen at any time.
|
|
|
|
*/
|
2017-07-20 10:28:55 +00:00
|
|
|
send_gen = READ_ONCE(cp->cp_send_gen) + 1;
|
|
|
|
WRITE_ONCE(cp->cp_send_gen, send_gen);
|
2015-04-08 16:33:47 +00:00
|
|
|
|
2010-06-04 21:41:41 +00:00
|
|
|
/*
|
|
|
|
* rds_conn_shutdown() sets the conn state and then tests RDS_IN_XMIT,
|
|
|
|
* we do the opposite to avoid races.
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
if (!rds_conn_path_up(cp)) {
|
|
|
|
release_in_xmit(cp);
|
2010-06-04 21:41:41 +00:00
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-30 23:11:10 +00:00
|
|
|
if (conn->c_trans->xmit_path_prepare)
|
|
|
|
conn->c_trans->xmit_path_prepare(cp);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* spin trying to push headers and data down the connection until
|
2010-02-04 03:36:44 +00:00
|
|
|
* the connection doesn't make forward progress.
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
2010-03-30 00:08:49 +00:00
|
|
|
while (1) {
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
rm = cp->cp_xmit_rm;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2011-01-13 19:40:31 +00:00
|
|
|
if (!rm) {
|
|
|
|
same_rm = 0;
|
|
|
|
} else {
|
|
|
|
same_rm++;
|
|
|
|
if (same_rm >= 4096) {
|
|
|
|
rds_stats_inc(s_send_stuck_rm);
|
|
|
|
ret = -EAGAIN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-04 03:36:44 +00:00
|
|
|
/*
|
|
|
|
* If between sending messages, we can send a pending congestion
|
|
|
|
* map update.
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
2010-01-12 19:56:44 +00:00
|
|
|
if (!rm && test_and_clear_bit(0, &conn->c_map_queued)) {
|
2010-03-22 22:22:04 +00:00
|
|
|
rm = rds_cong_update_alloc(conn);
|
|
|
|
if (IS_ERR(rm)) {
|
|
|
|
ret = PTR_ERR(rm);
|
|
|
|
break;
|
2010-02-04 03:36:44 +00:00
|
|
|
}
|
2010-03-22 22:22:04 +00:00
|
|
|
rm->data.op_active = 1;
|
2016-06-13 16:44:34 +00:00
|
|
|
rm->m_inc.i_conn_path = cp;
|
|
|
|
rm->m_inc.i_conn = cp->cp_conn;
|
2010-03-22 22:22:04 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_rm = rm;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-02-04 03:36:44 +00:00
|
|
|
* If not already working on one, grab the next message.
|
2009-02-24 15:30:27 +00:00
|
|
|
*
|
2016-06-13 16:44:34 +00:00
|
|
|
* cp_xmit_rm holds a ref while we're sending this message down
|
2009-02-24 15:30:27 +00:00
|
|
|
* the connction. We can use this ref while holding the
|
|
|
|
* send_sem.. rds_send_reset() is serialized with it.
|
|
|
|
*/
|
2010-01-12 19:56:44 +00:00
|
|
|
if (!rm) {
|
2009-02-24 15:30:27 +00:00
|
|
|
unsigned int len;
|
|
|
|
|
2015-04-08 16:33:47 +00:00
|
|
|
batch_count++;
|
|
|
|
|
|
|
|
/* we want to process as big a batch as we can, but
|
|
|
|
* we also want to avoid softlockups. If we've been
|
|
|
|
* through a lot of messages, lets back off and see
|
|
|
|
* if anyone else jumps in
|
|
|
|
*/
|
2015-09-10 18:57:14 +00:00
|
|
|
if (batch_count >= send_batch_count)
|
2015-04-08 16:33:47 +00:00
|
|
|
goto over_batch;
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
if (!list_empty(&cp->cp_send_queue)) {
|
|
|
|
rm = list_entry(cp->cp_send_queue.next,
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_message,
|
|
|
|
m_conn_item);
|
|
|
|
rds_message_addref(rm);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move the message from the send queue to the retransmit
|
|
|
|
* list right away.
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
list_move_tail(&rm->m_conn_item,
|
|
|
|
&cp->cp_retrans);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-30 00:08:49 +00:00
|
|
|
if (!rm)
|
2009-02-24 15:30:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Unfortunately, the way Infiniband deals with
|
|
|
|
* RDMA to a bad MR key is by moving the entire
|
|
|
|
* queue pair to error state. We cold possibly
|
|
|
|
* recover from that, but right now we drop the
|
|
|
|
* connection.
|
|
|
|
* Therefore, we never retransmit messages with RDMA ops.
|
|
|
|
*/
|
2016-11-16 21:29:49 +00:00
|
|
|
if (test_bit(RDS_MSG_FLUSH, &rm->m_flags) ||
|
|
|
|
(rm->rdma.op_active &&
|
|
|
|
test_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags))) {
|
2016-06-13 16:44:34 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
if (test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags))
|
|
|
|
list_move(&rm->m_conn_item, &to_be_dropped);
|
2016-06-13 16:44:34 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Require an ACK every once in a while */
|
|
|
|
len = ntohl(rm->m_inc.i_hdr.h_len);
|
2016-06-13 16:44:34 +00:00
|
|
|
if (cp->cp_unacked_packets == 0 ||
|
|
|
|
cp->cp_unacked_bytes < len) {
|
2017-09-05 15:42:01 +00:00
|
|
|
set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_unacked_packets =
|
|
|
|
rds_sysctl_max_unacked_packets;
|
|
|
|
cp->cp_unacked_bytes =
|
|
|
|
rds_sysctl_max_unacked_bytes;
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_stats_inc(s_send_ack_required);
|
|
|
|
} else {
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_unacked_bytes -= len;
|
|
|
|
cp->cp_unacked_packets--;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_rm = rm;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2010-03-02 00:10:40 +00:00
|
|
|
/* The transport either sends the whole rdma or none of it */
|
2016-06-13 16:44:34 +00:00
|
|
|
if (rm->rdma.op_active && !cp->cp_xmit_rdma_sent) {
|
2010-03-01 22:03:09 +00:00
|
|
|
rm->m_final_op = &rm->rdma;
|
2015-08-22 22:45:29 +00:00
|
|
|
/* The transport owns the mapped memory for now.
|
|
|
|
* You can't unmap it while it's on the send queue
|
|
|
|
*/
|
|
|
|
set_bit(RDS_MSG_MAPPED, &rm->m_flags);
|
2010-03-02 00:10:40 +00:00
|
|
|
ret = conn->c_trans->xmit_rdma(conn, &rm->rdma);
|
2015-08-22 22:45:29 +00:00
|
|
|
if (ret) {
|
|
|
|
clear_bit(RDS_MSG_MAPPED, &rm->m_flags);
|
|
|
|
wake_up_interruptible(&rm->m_flush_wait);
|
2010-01-12 22:33:38 +00:00
|
|
|
break;
|
2015-08-22 22:45:29 +00:00
|
|
|
}
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_rdma_sent = 1;
|
2010-03-02 00:10:40 +00:00
|
|
|
|
2010-01-12 22:33:38 +00:00
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
if (rm->atomic.op_active && !cp->cp_xmit_atomic_sent) {
|
2010-03-01 22:03:09 +00:00
|
|
|
rm->m_final_op = &rm->atomic;
|
2015-08-22 22:45:29 +00:00
|
|
|
/* The transport owns the mapped memory for now.
|
|
|
|
* You can't unmap it while it's on the send queue
|
|
|
|
*/
|
|
|
|
set_bit(RDS_MSG_MAPPED, &rm->m_flags);
|
2010-03-01 22:03:09 +00:00
|
|
|
ret = conn->c_trans->xmit_atomic(conn, &rm->atomic);
|
2015-08-22 22:45:29 +00:00
|
|
|
if (ret) {
|
|
|
|
clear_bit(RDS_MSG_MAPPED, &rm->m_flags);
|
|
|
|
wake_up_interruptible(&rm->m_flush_wait);
|
2009-02-24 15:30:27 +00:00
|
|
|
break;
|
2015-08-22 22:45:29 +00:00
|
|
|
}
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_atomic_sent = 1;
|
2010-03-01 22:03:09 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2010-03-02 00:10:40 +00:00
|
|
|
/*
|
|
|
|
* A number of cases require an RDS header to be sent
|
|
|
|
* even if there is no data.
|
|
|
|
* We permit 0-byte sends; rds-ping depends on this.
|
|
|
|
* However, if there are exclusively attached silent ops,
|
|
|
|
* we skip the hdr/data send, to enable silent operation.
|
|
|
|
*/
|
|
|
|
if (rm->data.op_nents == 0) {
|
|
|
|
int ops_present;
|
|
|
|
int all_ops_are_silent = 1;
|
|
|
|
|
|
|
|
ops_present = (rm->atomic.op_active || rm->rdma.op_active);
|
|
|
|
if (rm->atomic.op_active && !rm->atomic.op_silent)
|
|
|
|
all_ops_are_silent = 0;
|
|
|
|
if (rm->rdma.op_active && !rm->rdma.op_silent)
|
|
|
|
all_ops_are_silent = 0;
|
|
|
|
|
|
|
|
if (ops_present && all_ops_are_silent
|
|
|
|
&& !rm->m_rdma_cookie)
|
|
|
|
rm->data.op_active = 0;
|
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
if (rm->data.op_active && !cp->cp_xmit_data_sent) {
|
2010-03-01 22:03:09 +00:00
|
|
|
rm->m_final_op = &rm->data;
|
2016-06-13 16:44:34 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = conn->c_trans->xmit(conn, rm,
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_hdr_off,
|
|
|
|
cp->cp_xmit_sg,
|
|
|
|
cp->cp_xmit_data_off);
|
2009-02-24 15:30:27 +00:00
|
|
|
if (ret <= 0)
|
|
|
|
break;
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
if (cp->cp_xmit_hdr_off < sizeof(struct rds_header)) {
|
2009-02-24 15:30:27 +00:00
|
|
|
tmp = min_t(int, ret,
|
|
|
|
sizeof(struct rds_header) -
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_hdr_off);
|
|
|
|
cp->cp_xmit_hdr_off += tmp;
|
2009-02-24 15:30:27 +00:00
|
|
|
ret -= tmp;
|
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
sg = &rm->data.op_sg[cp->cp_xmit_sg];
|
2009-02-24 15:30:27 +00:00
|
|
|
while (ret) {
|
|
|
|
tmp = min_t(int, ret, sg->length -
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_data_off);
|
|
|
|
cp->cp_xmit_data_off += tmp;
|
2009-02-24 15:30:27 +00:00
|
|
|
ret -= tmp;
|
2016-06-13 16:44:34 +00:00
|
|
|
if (cp->cp_xmit_data_off == sg->length) {
|
|
|
|
cp->cp_xmit_data_off = 0;
|
2009-02-24 15:30:27 +00:00
|
|
|
sg++;
|
2016-06-13 16:44:34 +00:00
|
|
|
cp->cp_xmit_sg++;
|
|
|
|
BUG_ON(ret != 0 && cp->cp_xmit_sg ==
|
|
|
|
rm->data.op_nents);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-04 03:36:44 +00:00
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
if (cp->cp_xmit_hdr_off == sizeof(struct rds_header) &&
|
|
|
|
(cp->cp_xmit_sg == rm->data.op_nents))
|
|
|
|
cp->cp_xmit_data_sent = 1;
|
2010-02-04 03:36:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A rm will only take multiple times through this loop
|
|
|
|
* if there is a data op. Thus, if the data is sent (or there was
|
|
|
|
* none), then we're done with the rm.
|
|
|
|
*/
|
2016-06-13 16:44:34 +00:00
|
|
|
if (!rm->data.op_active || cp->cp_xmit_data_sent) {
|
|
|
|
cp->cp_xmit_rm = NULL;
|
|
|
|
cp->cp_xmit_sg = 0;
|
|
|
|
cp->cp_xmit_hdr_off = 0;
|
|
|
|
cp->cp_xmit_data_off = 0;
|
|
|
|
cp->cp_xmit_rdma_sent = 0;
|
|
|
|
cp->cp_xmit_atomic_sent = 0;
|
|
|
|
cp->cp_xmit_data_sent = 0;
|
2010-02-04 03:36:44 +00:00
|
|
|
|
|
|
|
rds_message_put(rm);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-08 16:33:47 +00:00
|
|
|
over_batch:
|
2016-06-30 23:11:10 +00:00
|
|
|
if (conn->c_trans->xmit_path_complete)
|
|
|
|
conn->c_trans->xmit_path_complete(cp);
|
2016-06-13 16:44:34 +00:00
|
|
|
release_in_xmit(cp);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-24 00:48:04 +00:00
|
|
|
/* Nuke any messages we decided not to retransmit. */
|
|
|
|
if (!list_empty(&to_be_dropped)) {
|
|
|
|
/* irqs on here, so we can put(), unlike above */
|
|
|
|
list_for_each_entry(rm, &to_be_dropped, m_conn_item)
|
|
|
|
rds_message_put(rm);
|
|
|
|
rds_send_remove_from_sock(&to_be_dropped, RDS_RDMA_DROPPED);
|
|
|
|
}
|
|
|
|
|
2010-03-30 00:08:49 +00:00
|
|
|
/*
|
2010-06-04 21:41:41 +00:00
|
|
|
* Other senders can queue a message after we last test the send queue
|
|
|
|
* but before we clear RDS_IN_XMIT. In that case they'd back off and
|
|
|
|
* not try and send their newly queued message. We need to check the
|
|
|
|
* send queue after having cleared RDS_IN_XMIT so that their message
|
|
|
|
* doesn't get stuck on the send queue.
|
2010-03-30 00:08:49 +00:00
|
|
|
*
|
|
|
|
* If the transport cannot continue (i.e ret != 0), then it must
|
|
|
|
* call us when more room is available, such as from the tx
|
|
|
|
* completion handler.
|
2015-04-08 16:33:47 +00:00
|
|
|
*
|
|
|
|
* We have an extra generation check here so that if someone manages
|
|
|
|
* to jump in after our release_in_xmit, we'll see that they have done
|
|
|
|
* some work and we will skip our goto
|
2010-03-30 00:08:49 +00:00
|
|
|
*/
|
|
|
|
if (ret == 0) {
|
2017-09-06 16:35:51 +00:00
|
|
|
bool raced;
|
|
|
|
|
2010-04-15 20:38:14 +00:00
|
|
|
smp_mb();
|
2017-09-06 16:35:51 +00:00
|
|
|
raced = send_gen != READ_ONCE(cp->cp_send_gen);
|
|
|
|
|
2015-08-22 22:45:27 +00:00
|
|
|
if ((test_bit(0, &conn->c_map_queued) ||
|
2017-09-06 16:35:51 +00:00
|
|
|
!list_empty(&cp->cp_send_queue)) && !raced) {
|
2015-09-10 18:57:14 +00:00
|
|
|
if (batch_count < send_batch_count)
|
|
|
|
goto restart;
|
2018-01-04 14:53:00 +00:00
|
|
|
rcu_read_lock();
|
2018-02-03 12:26:51 +00:00
|
|
|
if (rds_destroy_pending(cp->cp_conn))
|
2018-01-04 14:53:00 +00:00
|
|
|
ret = -ENETUNREACH;
|
|
|
|
else
|
|
|
|
queue_delayed_work(rds_wq, &cp->cp_send_w, 1);
|
|
|
|
rcu_read_unlock();
|
2017-09-06 16:35:51 +00:00
|
|
|
} else if (raced) {
|
|
|
|
rds_stats_inc(s_send_lock_queue_raced);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
2015-09-06 06:18:51 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_send_xmit);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
static void rds_send_sndbuf_remove(struct rds_sock *rs, struct rds_message *rm)
|
|
|
|
{
|
|
|
|
u32 len = be32_to_cpu(rm->m_inc.i_hdr.h_len);
|
|
|
|
|
|
|
|
assert_spin_locked(&rs->rs_lock);
|
|
|
|
|
|
|
|
BUG_ON(rs->rs_snd_bytes < len);
|
|
|
|
rs->rs_snd_bytes -= len;
|
|
|
|
|
|
|
|
if (rs->rs_snd_bytes == 0)
|
|
|
|
rds_stats_inc(s_send_queue_empty);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int rds_send_is_acked(struct rds_message *rm, u64 ack,
|
|
|
|
is_acked_func is_acked)
|
|
|
|
{
|
|
|
|
if (is_acked)
|
|
|
|
return is_acked(rm, ack);
|
|
|
|
return be64_to_cpu(rm->m_inc.i_hdr.h_sequence) <= ack;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is pretty similar to what happens below in the ACK
|
|
|
|
* handling code - except that we call here as soon as we get
|
|
|
|
* the IB send completion on the RDMA op and the accompanying
|
|
|
|
* message.
|
|
|
|
*/
|
|
|
|
void rds_rdma_send_complete(struct rds_message *rm, int status)
|
|
|
|
{
|
|
|
|
struct rds_sock *rs = NULL;
|
2010-03-01 22:11:53 +00:00
|
|
|
struct rm_rdma_op *ro;
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_notifier *notifier;
|
2010-03-29 23:50:54 +00:00
|
|
|
unsigned long flags;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_lock_irqsave(&rm->m_rs_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-01 22:11:53 +00:00
|
|
|
ro = &rm->rdma;
|
2009-11-30 00:55:45 +00:00
|
|
|
if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags) &&
|
2019-06-19 05:12:05 +00:00
|
|
|
ro->op_active && ro->op_notify && ro->op_notifier) {
|
2010-03-01 22:11:53 +00:00
|
|
|
notifier = ro->op_notifier;
|
2009-02-24 15:30:27 +00:00
|
|
|
rs = rm->m_rs;
|
|
|
|
sock_hold(rds_rs_to_sk(rs));
|
|
|
|
|
|
|
|
notifier->n_status = status;
|
|
|
|
spin_lock(&rs->rs_lock);
|
|
|
|
list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
|
|
|
|
spin_unlock(&rs->rs_lock);
|
|
|
|
|
2010-03-01 22:11:53 +00:00
|
|
|
ro->op_notifier = NULL;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_unlock_irqrestore(&rm->m_rs_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
if (rs) {
|
|
|
|
rds_wake_sk_sleep(rs);
|
|
|
|
sock_put(rds_rs_to_sk(rs));
|
|
|
|
}
|
|
|
|
}
|
2009-08-21 12:28:32 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_rdma_send_complete);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-01-12 22:33:38 +00:00
|
|
|
/*
|
|
|
|
* Just like above, except looks at atomic op
|
|
|
|
*/
|
|
|
|
void rds_atomic_send_complete(struct rds_message *rm, int status)
|
|
|
|
{
|
|
|
|
struct rds_sock *rs = NULL;
|
|
|
|
struct rm_atomic_op *ao;
|
|
|
|
struct rds_notifier *notifier;
|
2010-03-29 23:50:54 +00:00
|
|
|
unsigned long flags;
|
2010-01-12 22:33:38 +00:00
|
|
|
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_lock_irqsave(&rm->m_rs_lock, flags);
|
2010-01-12 22:33:38 +00:00
|
|
|
|
|
|
|
ao = &rm->atomic;
|
|
|
|
if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags)
|
|
|
|
&& ao->op_active && ao->op_notify && ao->op_notifier) {
|
|
|
|
notifier = ao->op_notifier;
|
|
|
|
rs = rm->m_rs;
|
|
|
|
sock_hold(rds_rs_to_sk(rs));
|
|
|
|
|
|
|
|
notifier->n_status = status;
|
|
|
|
spin_lock(&rs->rs_lock);
|
|
|
|
list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
|
|
|
|
spin_unlock(&rs->rs_lock);
|
|
|
|
|
|
|
|
ao->op_notifier = NULL;
|
|
|
|
}
|
|
|
|
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_unlock_irqrestore(&rm->m_rs_lock, flags);
|
2010-01-12 22:33:38 +00:00
|
|
|
|
|
|
|
if (rs) {
|
|
|
|
rds_wake_sk_sleep(rs);
|
|
|
|
sock_put(rds_rs_to_sk(rs));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rds_atomic_send_complete);
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/*
|
|
|
|
* This is the same as rds_rdma_send_complete except we
|
|
|
|
* don't do any locking - we have all the ingredients (message,
|
|
|
|
* socket, socket lock) and can just move the notifier.
|
|
|
|
*/
|
|
|
|
static inline void
|
2010-02-20 02:04:58 +00:00
|
|
|
__rds_send_complete(struct rds_sock *rs, struct rds_message *rm, int status)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
2010-03-01 22:11:53 +00:00
|
|
|
struct rm_rdma_op *ro;
|
2010-02-20 02:04:58 +00:00
|
|
|
struct rm_atomic_op *ao;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-03-01 22:11:53 +00:00
|
|
|
ro = &rm->rdma;
|
|
|
|
if (ro->op_active && ro->op_notify && ro->op_notifier) {
|
|
|
|
ro->op_notifier->n_status = status;
|
|
|
|
list_add_tail(&ro->op_notifier->n_list, &rs->rs_notify_queue);
|
|
|
|
ro->op_notifier = NULL;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
2010-02-20 02:04:58 +00:00
|
|
|
ao = &rm->atomic;
|
|
|
|
if (ao->op_active && ao->op_notify && ao->op_notifier) {
|
|
|
|
ao->op_notifier->n_status = status;
|
|
|
|
list_add_tail(&ao->op_notifier->n_list, &rs->rs_notify_queue);
|
|
|
|
ao->op_notifier = NULL;
|
|
|
|
}
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/* No need to wake the app - caller does this */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This removes messages from the socket's list if they're on it. The list
|
|
|
|
* argument must be private to the caller, we must be able to modify it
|
|
|
|
* without locks. The messages must have a reference held for their
|
|
|
|
* position on the list. This function will drop that reference after
|
|
|
|
* removing the messages from the 'messages' list regardless of if it found
|
|
|
|
* the messages on the socket list or not.
|
|
|
|
*/
|
2010-10-19 08:08:33 +00:00
|
|
|
static void rds_send_remove_from_sock(struct list_head *messages, int status)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
2010-03-11 13:50:06 +00:00
|
|
|
unsigned long flags;
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_sock *rs = NULL;
|
|
|
|
struct rds_message *rm;
|
|
|
|
|
|
|
|
while (!list_empty(messages)) {
|
2010-03-11 13:50:06 +00:00
|
|
|
int was_on_sock = 0;
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
rm = list_entry(messages->next, struct rds_message,
|
|
|
|
m_conn_item);
|
|
|
|
list_del_init(&rm->m_conn_item);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we see this flag cleared then we're *sure* that someone
|
|
|
|
* else beat us to removing it from the sock. If we race
|
|
|
|
* with their flag update we'll get the lock and then really
|
|
|
|
* see that the flag has been cleared.
|
|
|
|
*
|
|
|
|
* The message spinlock makes sure nobody clears rm->m_rs
|
|
|
|
* while we're messing with it. It does not prevent the
|
|
|
|
* message from being removed from the socket, though.
|
|
|
|
*/
|
2010-03-11 13:50:06 +00:00
|
|
|
spin_lock_irqsave(&rm->m_rs_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
if (!test_bit(RDS_MSG_ON_SOCK, &rm->m_flags))
|
|
|
|
goto unlock_and_drop;
|
|
|
|
|
|
|
|
if (rs != rm->m_rs) {
|
|
|
|
if (rs) {
|
|
|
|
rds_wake_sk_sleep(rs);
|
|
|
|
sock_put(rds_rs_to_sk(rs));
|
|
|
|
}
|
|
|
|
rs = rm->m_rs;
|
net/rds: fix possible double free on sock tear down
I got a report of a double free happening at RDS slab cache. One
suspicion was that may be somewhere we were doing a sock_hold/sock_put
on an already freed sock. Thus after providing a kernel with the
following change:
static inline void sock_hold(struct sock *sk)
{
- atomic_inc(&sk->sk_refcnt);
+ if (!atomic_inc_not_zero(&sk->sk_refcnt))
+ WARN(1, "Trying to hold sock already gone: %p (family: %hd)\n",
+ sk, sk->sk_family);
}
The warning successfuly triggered:
Trying to hold sock already gone: ffff81f6dda61280 (family: 21)
WARNING: at include/net/sock.h:350 sock_hold()
Call Trace:
<IRQ> [<ffffffff8adac135>] :rds:rds_send_remove_from_sock+0xf0/0x21b
[<ffffffff8adad35c>] :rds:rds_send_drop_acked+0xbf/0xcf
[<ffffffff8addf546>] :rds_rdma:rds_ib_recv_tasklet_fn+0x256/0x2dc
[<ffffffff8009899a>] tasklet_action+0x8f/0x12b
[<ffffffff800125a2>] __do_softirq+0x89/0x133
[<ffffffff8005f30c>] call_softirq+0x1c/0x28
[<ffffffff8006e644>] do_softirq+0x2c/0x7d
[<ffffffff8006e4d4>] do_IRQ+0xee/0xf7
[<ffffffff8005e625>] ret_from_intr+0x0/0xa
<EOI>
Looking at the call chain above, the only way I think this would be
possible is if somewhere we already released the same socket->sock which
is assigned to the rds_message at rds_send_remove_from_sock. Which seems
only possible to happen after the tear down done on rds_release.
rds_release properly calls rds_send_drop_to to drop the socket from any
rds_message, and some proper synchronization is in place to avoid race
with rds_send_drop_acked/rds_send_remove_from_sock. However, I still see
a very narrow window where it may be possible we touch a sock already
released: when rds_release races with rds_send_drop_acked, we check
RDS_MSG_ON_CONN to avoid cleanup on the same rds_message, but in this
specific case we don't clear rm->m_rs. In this case, it seems we could
then go on at rds_send_drop_to and after it returns, the sock is freed
by last sock_put on rds_release, with concurrently we being at
rds_send_remove_from_sock; then at some point in the loop at
rds_send_remove_from_sock we process an rds_message which didn't have
rm->m_rs unset for a freed sock, and a possible sock_hold on an sock
already gone at rds_release happens.
This hopefully address the described condition above and avoids a double
free on "second last" sock_put. In addition, I removed the comment about
socket destruction on top of rds_send_drop_acked: we call rds_send_drop_to
in rds_release and we should have things properly serialized there, thus
I can't see the comment being accurate there.
Signed-off-by: Herton R. Krzesinski <herton@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-10-01 21:49:54 +00:00
|
|
|
if (rs)
|
|
|
|
sock_hold(rds_rs_to_sk(rs));
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
net/rds: fix possible double free on sock tear down
I got a report of a double free happening at RDS slab cache. One
suspicion was that may be somewhere we were doing a sock_hold/sock_put
on an already freed sock. Thus after providing a kernel with the
following change:
static inline void sock_hold(struct sock *sk)
{
- atomic_inc(&sk->sk_refcnt);
+ if (!atomic_inc_not_zero(&sk->sk_refcnt))
+ WARN(1, "Trying to hold sock already gone: %p (family: %hd)\n",
+ sk, sk->sk_family);
}
The warning successfuly triggered:
Trying to hold sock already gone: ffff81f6dda61280 (family: 21)
WARNING: at include/net/sock.h:350 sock_hold()
Call Trace:
<IRQ> [<ffffffff8adac135>] :rds:rds_send_remove_from_sock+0xf0/0x21b
[<ffffffff8adad35c>] :rds:rds_send_drop_acked+0xbf/0xcf
[<ffffffff8addf546>] :rds_rdma:rds_ib_recv_tasklet_fn+0x256/0x2dc
[<ffffffff8009899a>] tasklet_action+0x8f/0x12b
[<ffffffff800125a2>] __do_softirq+0x89/0x133
[<ffffffff8005f30c>] call_softirq+0x1c/0x28
[<ffffffff8006e644>] do_softirq+0x2c/0x7d
[<ffffffff8006e4d4>] do_IRQ+0xee/0xf7
[<ffffffff8005e625>] ret_from_intr+0x0/0xa
<EOI>
Looking at the call chain above, the only way I think this would be
possible is if somewhere we already released the same socket->sock which
is assigned to the rds_message at rds_send_remove_from_sock. Which seems
only possible to happen after the tear down done on rds_release.
rds_release properly calls rds_send_drop_to to drop the socket from any
rds_message, and some proper synchronization is in place to avoid race
with rds_send_drop_acked/rds_send_remove_from_sock. However, I still see
a very narrow window where it may be possible we touch a sock already
released: when rds_release races with rds_send_drop_acked, we check
RDS_MSG_ON_CONN to avoid cleanup on the same rds_message, but in this
specific case we don't clear rm->m_rs. In this case, it seems we could
then go on at rds_send_drop_to and after it returns, the sock is freed
by last sock_put on rds_release, with concurrently we being at
rds_send_remove_from_sock; then at some point in the loop at
rds_send_remove_from_sock we process an rds_message which didn't have
rm->m_rs unset for a freed sock, and a possible sock_hold on an sock
already gone at rds_release happens.
This hopefully address the described condition above and avoids a double
free on "second last" sock_put. In addition, I removed the comment about
socket destruction on top of rds_send_drop_acked: we call rds_send_drop_to
in rds_release and we should have things properly serialized there, thus
I can't see the comment being accurate there.
Signed-off-by: Herton R. Krzesinski <herton@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-10-01 21:49:54 +00:00
|
|
|
if (!rs)
|
|
|
|
goto unlock_and_drop;
|
2010-03-11 13:50:00 +00:00
|
|
|
spin_lock(&rs->rs_lock);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
if (test_and_clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags)) {
|
2010-03-01 22:11:53 +00:00
|
|
|
struct rm_rdma_op *ro = &rm->rdma;
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_notifier *notifier;
|
|
|
|
|
|
|
|
list_del_init(&rm->m_sock_item);
|
|
|
|
rds_send_sndbuf_remove(rs, rm);
|
|
|
|
|
2010-03-01 22:11:53 +00:00
|
|
|
if (ro->op_active && ro->op_notifier &&
|
|
|
|
(ro->op_notify || (ro->op_recverr && status))) {
|
|
|
|
notifier = ro->op_notifier;
|
2009-02-24 15:30:27 +00:00
|
|
|
list_add_tail(¬ifier->n_list,
|
|
|
|
&rs->rs_notify_queue);
|
|
|
|
if (!notifier->n_status)
|
|
|
|
notifier->n_status = status;
|
2010-03-01 22:11:53 +00:00
|
|
|
rm->rdma.op_notifier = NULL;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
2010-03-11 13:50:06 +00:00
|
|
|
was_on_sock = 1;
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
2010-03-11 13:50:00 +00:00
|
|
|
spin_unlock(&rs->rs_lock);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
unlock_and_drop:
|
2010-03-11 13:50:06 +00:00
|
|
|
spin_unlock_irqrestore(&rm->m_rs_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_message_put(rm);
|
2010-03-11 13:50:06 +00:00
|
|
|
if (was_on_sock)
|
|
|
|
rds_message_put(rm);
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rs) {
|
|
|
|
rds_wake_sk_sleep(rs);
|
|
|
|
sock_put(rds_rs_to_sk(rs));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Transports call here when they've determined that the receiver queued
|
|
|
|
* messages up to, and including, the given sequence number. Messages are
|
|
|
|
* moved to the retrans queue when rds_send_xmit picks them off the send
|
|
|
|
* queue. This means that in the TCP case, the message may not have been
|
|
|
|
* assigned the m_ack_seq yet - but that's fine as long as tcp_is_acked
|
|
|
|
* checks the RDS_MSG_HAS_ACK_SEQ bit.
|
|
|
|
*/
|
2016-06-13 16:44:31 +00:00
|
|
|
void rds_send_path_drop_acked(struct rds_conn_path *cp, u64 ack,
|
|
|
|
is_acked_func is_acked)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct rds_message *rm, *tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
2016-06-13 16:44:31 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:31 +00:00
|
|
|
list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
|
2009-02-24 15:30:27 +00:00
|
|
|
if (!rds_send_is_acked(rm, ack, is_acked))
|
|
|
|
break;
|
|
|
|
|
|
|
|
list_move(&rm->m_conn_item, &list);
|
|
|
|
clear_bit(RDS_MSG_ON_CONN, &rm->m_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* order flag updates with spin locks */
|
|
|
|
if (!list_empty(&list))
|
2014-03-17 17:06:10 +00:00
|
|
|
smp_mb__after_atomic();
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:31 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
/* now remove the messages from the sock list as needed */
|
|
|
|
rds_send_remove_from_sock(&list, RDS_RDMA_SUCCESS);
|
|
|
|
}
|
2016-06-13 16:44:31 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_send_path_drop_acked);
|
|
|
|
|
|
|
|
void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
|
|
|
|
is_acked_func is_acked)
|
|
|
|
{
|
|
|
|
WARN_ON(conn->c_trans->t_mp_capable);
|
|
|
|
rds_send_path_drop_acked(&conn->c_path[0], ack, is_acked);
|
|
|
|
}
|
2009-08-21 12:28:32 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_send_drop_acked);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2018-07-24 03:51:21 +00:00
|
|
|
void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in6 *dest)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct rds_message *rm, *tmp;
|
|
|
|
struct rds_connection *conn;
|
2016-06-13 16:44:35 +00:00
|
|
|
struct rds_conn_path *cp;
|
2010-02-20 02:01:41 +00:00
|
|
|
unsigned long flags;
|
2009-02-24 15:30:27 +00:00
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
/* get all the messages we're dropping under the rs lock */
|
|
|
|
spin_lock_irqsave(&rs->rs_lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(rm, tmp, &rs->rs_send_queue, m_sock_item) {
|
2018-07-24 03:51:21 +00:00
|
|
|
if (dest &&
|
|
|
|
(!ipv6_addr_equal(&dest->sin6_addr, &rm->m_daddr) ||
|
|
|
|
dest->sin6_port != rm->m_inc.i_hdr.h_dport))
|
2009-02-24 15:30:27 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
list_move(&rm->m_sock_item, &list);
|
|
|
|
rds_send_sndbuf_remove(rs, rm);
|
|
|
|
clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* order flag updates with the rs lock */
|
2014-03-17 17:06:10 +00:00
|
|
|
smp_mb__after_atomic();
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&rs->rs_lock, flags);
|
|
|
|
|
2010-02-20 02:01:41 +00:00
|
|
|
if (list_empty(&list))
|
|
|
|
return;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-02-20 02:01:41 +00:00
|
|
|
/* Remove the messages from the conn */
|
2009-02-24 15:30:27 +00:00
|
|
|
list_for_each_entry(rm, &list, m_sock_item) {
|
2010-02-20 02:01:41 +00:00
|
|
|
|
|
|
|
conn = rm->m_inc.i_conn;
|
2016-06-13 16:44:35 +00:00
|
|
|
if (conn->c_trans->t_mp_capable)
|
|
|
|
cp = rm->m_inc.i_conn_path;
|
|
|
|
else
|
|
|
|
cp = &conn->c_path[0];
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:35 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
/*
|
2010-02-20 02:01:41 +00:00
|
|
|
* Maybe someone else beat us to removing rm from the conn.
|
|
|
|
* If we race with their flag update we'll get the lock and
|
|
|
|
* then really see that the flag has been cleared.
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
2010-02-20 02:01:41 +00:00
|
|
|
if (!test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags)) {
|
2016-06-13 16:44:35 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-03-29 23:50:54 +00:00
|
|
|
list_del_init(&rm->m_conn_item);
|
2016-06-13 16:44:35 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-02-20 02:01:41 +00:00
|
|
|
/*
|
|
|
|
* Couldn't grab m_rs_lock in top loop (lock ordering),
|
|
|
|
* but we can now.
|
|
|
|
*/
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_lock_irqsave(&rm->m_rs_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-02-20 02:01:41 +00:00
|
|
|
spin_lock(&rs->rs_lock);
|
2010-02-20 02:04:58 +00:00
|
|
|
__rds_send_complete(rs, rm, RDS_RDMA_CANCELED);
|
2010-02-20 02:01:41 +00:00
|
|
|
spin_unlock(&rs->rs_lock);
|
|
|
|
|
2010-03-29 23:50:54 +00:00
|
|
|
spin_unlock_irqrestore(&rm->m_rs_lock, flags);
|
2010-02-20 02:01:41 +00:00
|
|
|
|
|
|
|
rds_message_put(rm);
|
|
|
|
}
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2010-02-20 02:01:41 +00:00
|
|
|
rds_wake_sk_sleep(rs);
|
2010-03-11 13:50:03 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
while (!list_empty(&list)) {
|
|
|
|
rm = list_entry(list.next, struct rds_message, m_sock_item);
|
|
|
|
list_del_init(&rm->m_sock_item);
|
|
|
|
rds_message_wait(rm);
|
2015-08-22 22:45:33 +00:00
|
|
|
|
|
|
|
/* just in case the code above skipped this message
|
|
|
|
* because RDS_MSG_ON_CONN wasn't set, run it again here
|
|
|
|
* taking m_rs_lock is the only thing that keeps us
|
|
|
|
* from racing with ack processing.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&rm->m_rs_lock, flags);
|
|
|
|
|
|
|
|
spin_lock(&rs->rs_lock);
|
|
|
|
__rds_send_complete(rs, rm, RDS_RDMA_CANCELED);
|
|
|
|
spin_unlock(&rs->rs_lock);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&rm->m_rs_lock, flags);
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_message_put(rm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we only want this to fire once so we use the callers 'queued'. It's
|
|
|
|
* possible that another thread can race with us and remove the
|
|
|
|
* message from the flow with RDS_CANCEL_SENT_TO.
|
|
|
|
*/
|
|
|
|
static int rds_send_queue_rm(struct rds_sock *rs, struct rds_connection *conn,
|
2016-06-13 16:44:33 +00:00
|
|
|
struct rds_conn_path *cp,
|
2009-02-24 15:30:27 +00:00
|
|
|
struct rds_message *rm, __be16 sport,
|
|
|
|
__be16 dport, int *queued)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
u32 len;
|
|
|
|
|
|
|
|
if (*queued)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
len = be32_to_cpu(rm->m_inc.i_hdr.h_len);
|
|
|
|
|
|
|
|
/* this is the only place which holds both the socket's rs_lock
|
|
|
|
* and the connection's c_lock */
|
|
|
|
spin_lock_irqsave(&rs->rs_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a little space in sndbuf, we don't queue anything,
|
|
|
|
* and userspace gets -EAGAIN. But poll() indicates there's send
|
|
|
|
* room. This can lead to bad behavior (spinning) if snd_bytes isn't
|
|
|
|
* freed up by incoming acks. So we check the *old* value of
|
|
|
|
* rs_snd_bytes here to allow the last msg to exceed the buffer,
|
|
|
|
* and poll() now knows no more data can be sent.
|
|
|
|
*/
|
|
|
|
if (rs->rs_snd_bytes < rds_sk_sndbuf(rs)) {
|
|
|
|
rs->rs_snd_bytes += len;
|
|
|
|
|
|
|
|
/* let recv side know we are close to send space exhaustion.
|
|
|
|
* This is probably not the optimal way to do it, as this
|
|
|
|
* means we set the flag on *all* messages as soon as our
|
|
|
|
* throughput hits a certain threshold.
|
|
|
|
*/
|
|
|
|
if (rs->rs_snd_bytes >= rds_sk_sndbuf(rs) / 2)
|
2017-09-05 15:42:01 +00:00
|
|
|
set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
list_add_tail(&rm->m_sock_item, &rs->rs_send_queue);
|
|
|
|
set_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
|
|
|
|
rds_message_addref(rm);
|
2018-02-15 18:49:33 +00:00
|
|
|
sock_hold(rds_rs_to_sk(rs));
|
2009-02-24 15:30:27 +00:00
|
|
|
rm->m_rs = rs;
|
|
|
|
|
|
|
|
/* The code ordering is a little weird, but we're
|
|
|
|
trying to minimize the time we hold c_lock */
|
|
|
|
rds_message_populate_header(&rm->m_inc.i_hdr, sport, dport, 0);
|
|
|
|
rm->m_inc.i_conn = conn;
|
2016-06-13 16:44:33 +00:00
|
|
|
rm->m_inc.i_conn_path = cp;
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_message_addref(rm);
|
|
|
|
|
2016-06-13 16:44:33 +00:00
|
|
|
spin_lock(&cp->cp_lock);
|
|
|
|
rm->m_inc.i_hdr.h_sequence = cpu_to_be64(cp->cp_next_tx_seq++);
|
|
|
|
list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
|
2009-02-24 15:30:27 +00:00
|
|
|
set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
|
2016-06-13 16:44:33 +00:00
|
|
|
spin_unlock(&cp->cp_lock);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
rdsdebug("queued msg %p len %d, rs %p bytes %d seq %llu\n",
|
|
|
|
rm, len, rs, rs->rs_snd_bytes,
|
|
|
|
(unsigned long long)be64_to_cpu(rm->m_inc.i_hdr.h_sequence));
|
|
|
|
|
|
|
|
*queued = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&rs->rs_lock, flags);
|
|
|
|
out:
|
|
|
|
return *queued;
|
|
|
|
}
|
|
|
|
|
2010-01-12 20:56:06 +00:00
|
|
|
/*
|
|
|
|
* rds_message is getting to be quite complicated, and we'd like to allocate
|
|
|
|
* it all in one go. This figures out how big it needs to be up front.
|
|
|
|
*/
|
2018-12-16 07:01:08 +00:00
|
|
|
static int rds_rm_size(struct msghdr *msg, int num_sgs,
|
|
|
|
struct rds_iov_vector_arr *vct)
|
2010-01-12 20:56:06 +00:00
|
|
|
{
|
2010-01-12 22:13:15 +00:00
|
|
|
struct cmsghdr *cmsg;
|
2010-01-12 20:56:06 +00:00
|
|
|
int size = 0;
|
2010-04-13 19:00:35 +00:00
|
|
|
int cmsg_groups = 0;
|
2010-01-12 22:13:15 +00:00
|
|
|
int retval;
|
2018-02-15 18:49:36 +00:00
|
|
|
bool zcopy_cookie = false;
|
2018-12-16 07:01:08 +00:00
|
|
|
struct rds_iov_vector *iov, *tmp_iov;
|
2010-01-12 22:13:15 +00:00
|
|
|
|
2018-12-16 07:01:09 +00:00
|
|
|
if (num_sgs < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-12-11 03:22:04 +00:00
|
|
|
for_each_cmsghdr(cmsg, msg) {
|
2010-01-12 22:13:15 +00:00
|
|
|
if (!CMSG_OK(msg, cmsg))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (cmsg->cmsg_level != SOL_RDS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (cmsg->cmsg_type) {
|
|
|
|
case RDS_CMSG_RDMA_ARGS:
|
2018-12-16 07:01:08 +00:00
|
|
|
if (vct->indx >= vct->len) {
|
|
|
|
vct->len += vct->incr;
|
|
|
|
tmp_iov =
|
|
|
|
krealloc(vct->vec,
|
|
|
|
vct->len *
|
|
|
|
sizeof(struct rds_iov_vector),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!tmp_iov) {
|
|
|
|
vct->len -= vct->incr;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
vct->vec = tmp_iov;
|
|
|
|
}
|
|
|
|
iov = &vct->vec[vct->indx];
|
|
|
|
memset(iov, 0, sizeof(struct rds_iov_vector));
|
|
|
|
vct->indx++;
|
2010-04-13 19:00:35 +00:00
|
|
|
cmsg_groups |= 1;
|
2018-12-16 07:01:08 +00:00
|
|
|
retval = rds_rdma_extra_size(CMSG_DATA(cmsg), iov);
|
2010-01-12 22:13:15 +00:00
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
|
|
|
size += retval;
|
2010-04-13 19:00:35 +00:00
|
|
|
|
2010-01-12 22:13:15 +00:00
|
|
|
break;
|
|
|
|
|
2018-02-15 18:49:36 +00:00
|
|
|
case RDS_CMSG_ZCOPY_COOKIE:
|
|
|
|
zcopy_cookie = true;
|
2018-02-19 18:10:20 +00:00
|
|
|
/* fall through */
|
|
|
|
|
2010-01-12 22:13:15 +00:00
|
|
|
case RDS_CMSG_RDMA_DEST:
|
|
|
|
case RDS_CMSG_RDMA_MAP:
|
2010-04-13 19:00:35 +00:00
|
|
|
cmsg_groups |= 2;
|
2010-01-12 22:13:15 +00:00
|
|
|
/* these are valid but do no add any size */
|
|
|
|
break;
|
|
|
|
|
2010-01-12 22:33:38 +00:00
|
|
|
case RDS_CMSG_ATOMIC_CSWP:
|
|
|
|
case RDS_CMSG_ATOMIC_FADD:
|
2010-08-25 12:51:28 +00:00
|
|
|
case RDS_CMSG_MASKED_ATOMIC_CSWP:
|
|
|
|
case RDS_CMSG_MASKED_ATOMIC_FADD:
|
2010-04-13 19:00:35 +00:00
|
|
|
cmsg_groups |= 1;
|
2010-01-12 22:33:38 +00:00
|
|
|
size += sizeof(struct scatterlist);
|
|
|
|
break;
|
|
|
|
|
2010-01-12 22:13:15 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2010-01-12 20:56:06 +00:00
|
|
|
|
2018-02-15 18:49:36 +00:00
|
|
|
if ((msg->msg_flags & MSG_ZEROCOPY) && !zcopy_cookie)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
size += num_sgs * sizeof(struct scatterlist);
|
2010-01-12 20:56:06 +00:00
|
|
|
|
2010-04-13 19:00:35 +00:00
|
|
|
/* Ensure (DEST, MAP) are never used with (ARGS, ATOMIC) */
|
|
|
|
if (cmsg_groups == 3)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-01-12 20:56:06 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2018-02-15 18:49:36 +00:00
|
|
|
static int rds_cmsg_zcopy(struct rds_sock *rs, struct rds_message *rm,
|
|
|
|
struct cmsghdr *cmsg)
|
|
|
|
{
|
|
|
|
u32 *cookie;
|
|
|
|
|
2018-02-22 21:40:27 +00:00
|
|
|
if (cmsg->cmsg_len < CMSG_LEN(sizeof(*cookie)) ||
|
|
|
|
!rm->data.op_mmp_znotifier)
|
2018-02-15 18:49:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
cookie = CMSG_DATA(cmsg);
|
|
|
|
rm->data.op_mmp_znotifier->z_cookie = *cookie;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
static int rds_cmsg_send(struct rds_sock *rs, struct rds_message *rm,
|
2018-12-16 07:01:08 +00:00
|
|
|
struct msghdr *msg, int *allocated_mr,
|
|
|
|
struct rds_iov_vector_arr *vct)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct cmsghdr *cmsg;
|
2018-12-16 07:01:08 +00:00
|
|
|
int ret = 0, ind = 0;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2014-12-11 03:22:04 +00:00
|
|
|
for_each_cmsghdr(cmsg, msg) {
|
2009-02-24 15:30:27 +00:00
|
|
|
if (!CMSG_OK(msg, cmsg))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (cmsg->cmsg_level != SOL_RDS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* As a side effect, RDMA_DEST and RDMA_MAP will set
|
2010-01-12 22:33:38 +00:00
|
|
|
* rm->rdma.m_rdma_cookie and rm->rdma.m_rdma_mr.
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
|
|
|
switch (cmsg->cmsg_type) {
|
|
|
|
case RDS_CMSG_RDMA_ARGS:
|
2018-12-16 07:01:08 +00:00
|
|
|
if (ind >= vct->indx)
|
|
|
|
return -ENOMEM;
|
|
|
|
ret = rds_cmsg_rdma_args(rs, rm, cmsg, &vct->vec[ind]);
|
|
|
|
ind++;
|
2009-02-24 15:30:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RDS_CMSG_RDMA_DEST:
|
|
|
|
ret = rds_cmsg_rdma_dest(rs, rm, cmsg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RDS_CMSG_RDMA_MAP:
|
|
|
|
ret = rds_cmsg_rdma_map(rs, rm, cmsg);
|
|
|
|
if (!ret)
|
|
|
|
*allocated_mr = 1;
|
2016-07-05 00:04:37 +00:00
|
|
|
else if (ret == -ENODEV)
|
|
|
|
/* Accommodate the get_mr() case which can fail
|
|
|
|
* if connection isn't established yet.
|
|
|
|
*/
|
|
|
|
ret = -EAGAIN;
|
2009-02-24 15:30:27 +00:00
|
|
|
break;
|
2010-01-12 22:33:38 +00:00
|
|
|
case RDS_CMSG_ATOMIC_CSWP:
|
|
|
|
case RDS_CMSG_ATOMIC_FADD:
|
2010-08-25 12:51:28 +00:00
|
|
|
case RDS_CMSG_MASKED_ATOMIC_CSWP:
|
|
|
|
case RDS_CMSG_MASKED_ATOMIC_FADD:
|
2010-01-12 22:33:38 +00:00
|
|
|
ret = rds_cmsg_atomic(rs, rm, cmsg);
|
|
|
|
break;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2018-02-15 18:49:36 +00:00
|
|
|
case RDS_CMSG_ZCOPY_COOKIE:
|
|
|
|
ret = rds_cmsg_zcopy(rs, rm, cmsg);
|
|
|
|
break;
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-10-08 16:17:11 +00:00
|
|
|
static int rds_send_mprds_hash(struct rds_sock *rs,
|
|
|
|
struct rds_connection *conn, int nonblock)
|
2016-07-14 10:51:03 +00:00
|
|
|
{
|
|
|
|
int hash;
|
|
|
|
|
|
|
|
if (conn->c_npaths == 0)
|
|
|
|
hash = RDS_MPATH_HASH(rs, RDS_MPATH_WORKERS);
|
|
|
|
else
|
|
|
|
hash = RDS_MPATH_HASH(rs, conn->c_npaths);
|
|
|
|
if (conn->c_npaths == 0 && hash != 0) {
|
2017-06-21 20:40:12 +00:00
|
|
|
rds_send_ping(conn, 0);
|
2016-07-14 10:51:03 +00:00
|
|
|
|
2018-04-11 07:57:25 +00:00
|
|
|
/* The underlying connection is not up yet. Need to wait
|
|
|
|
* until it is up to be sure that the non-zero c_path can be
|
|
|
|
* used. But if we are interrupted, we have to use the zero
|
|
|
|
* c_path in case the connection ends up being non-MP capable.
|
|
|
|
*/
|
2018-10-08 16:17:11 +00:00
|
|
|
if (conn->c_npaths == 0) {
|
|
|
|
/* Cannot wait for the connection be made, so just use
|
|
|
|
* the base c_path.
|
|
|
|
*/
|
|
|
|
if (nonblock)
|
|
|
|
return 0;
|
2018-04-11 07:57:25 +00:00
|
|
|
if (wait_event_interruptible(conn->c_hs_waitq,
|
|
|
|
conn->c_npaths != 0))
|
|
|
|
hash = 0;
|
2018-10-08 16:17:11 +00:00
|
|
|
}
|
2016-07-14 10:51:03 +00:00
|
|
|
if (conn->c_npaths == 1)
|
|
|
|
hash = 0;
|
|
|
|
}
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
2016-02-29 23:30:57 +00:00
|
|
|
static int rds_rdma_bytes(struct msghdr *msg, size_t *rdma_bytes)
|
|
|
|
{
|
|
|
|
struct rds_rdma_args *args;
|
|
|
|
struct cmsghdr *cmsg;
|
|
|
|
|
|
|
|
for_each_cmsghdr(cmsg, msg) {
|
|
|
|
if (!CMSG_OK(msg, cmsg))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (cmsg->cmsg_level != SOL_RDS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (cmsg->cmsg_type == RDS_CMSG_RDMA_ARGS) {
|
2017-12-22 04:17:04 +00:00
|
|
|
if (cmsg->cmsg_len <
|
|
|
|
CMSG_LEN(sizeof(struct rds_rdma_args)))
|
|
|
|
return -EINVAL;
|
2016-02-29 23:30:57 +00:00
|
|
|
args = CMSG_DATA(cmsg);
|
|
|
|
*rdma_bytes += args->remote_vec.bytes;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-02 07:37:48 +00:00
|
|
|
int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct rds_sock *rs = rds_sk_to_rs(sk);
|
2018-07-24 03:51:21 +00:00
|
|
|
DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
|
2014-01-17 21:53:15 +00:00
|
|
|
DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
|
2009-02-24 15:30:27 +00:00
|
|
|
__be16 dport;
|
|
|
|
struct rds_message *rm = NULL;
|
|
|
|
struct rds_connection *conn;
|
|
|
|
int ret = 0;
|
|
|
|
int queued = 0, allocated_mr = 0;
|
|
|
|
int nonblock = msg->msg_flags & MSG_DONTWAIT;
|
2010-03-11 13:49:56 +00:00
|
|
|
long timeo = sock_sndtimeo(sk, nonblock);
|
2016-06-13 16:44:33 +00:00
|
|
|
struct rds_conn_path *cpath;
|
2018-07-24 03:51:21 +00:00
|
|
|
struct in6_addr daddr;
|
|
|
|
__u32 scope_id = 0;
|
2016-02-29 23:30:57 +00:00
|
|
|
size_t total_payload_len = payload_len, rdma_payload_len = 0;
|
2018-02-15 18:49:36 +00:00
|
|
|
bool zcopy = ((msg->msg_flags & MSG_ZEROCOPY) &&
|
|
|
|
sock_flag(rds_rs_to_sk(rs), SOCK_ZEROCOPY));
|
2019-01-07 01:59:59 +00:00
|
|
|
int num_sgs = DIV_ROUND_UP(payload_len, PAGE_SIZE);
|
2018-07-24 03:51:21 +00:00
|
|
|
int namelen;
|
2018-12-20 04:53:18 +00:00
|
|
|
struct rds_iov_vector_arr vct;
|
2018-12-16 07:01:08 +00:00
|
|
|
int ind;
|
|
|
|
|
2018-12-20 04:53:18 +00:00
|
|
|
memset(&vct, 0, sizeof(vct));
|
|
|
|
|
2018-12-16 07:01:08 +00:00
|
|
|
/* expect 1 RDMA CMSG per rds_sendmsg. can still grow if more needed. */
|
|
|
|
vct.incr = 1;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
/* Mirror Linux UDP mirror of BSD error message compatibility */
|
|
|
|
/* XXX: Perhaps MSG_MORE someday */
|
2018-02-15 18:49:36 +00:00
|
|
|
if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_CMSG_COMPAT | MSG_ZEROCOPY)) {
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-07-24 03:51:21 +00:00
|
|
|
namelen = msg->msg_namelen;
|
|
|
|
if (namelen != 0) {
|
|
|
|
if (namelen < sizeof(*usin)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-07-24 03:51:22 +00:00
|
|
|
switch (usin->sin_family) {
|
|
|
|
case AF_INET:
|
|
|
|
if (usin->sin_addr.s_addr == htonl(INADDR_ANY) ||
|
2018-07-24 03:51:21 +00:00
|
|
|
usin->sin_addr.s_addr == htonl(INADDR_BROADCAST) ||
|
2019-09-02 23:29:36 +00:00
|
|
|
ipv4_is_multicast(usin->sin_addr.s_addr)) {
|
2018-07-24 03:51:21 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ipv6_addr_set_v4mapped(usin->sin_addr.s_addr, &daddr);
|
|
|
|
dport = usin->sin_port;
|
|
|
|
break;
|
|
|
|
|
2018-07-31 05:48:42 +00:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2018-07-24 03:51:22 +00:00
|
|
|
case AF_INET6: {
|
|
|
|
int addr_type;
|
|
|
|
|
|
|
|
if (namelen < sizeof(*sin6)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
addr_type = ipv6_addr_type(&sin6->sin6_addr);
|
|
|
|
if (!(addr_type & IPV6_ADDR_UNICAST)) {
|
|
|
|
__be32 addr4;
|
|
|
|
|
|
|
|
if (!(addr_type & IPV6_ADDR_MAPPED)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* It is a mapped address. Need to do some
|
|
|
|
* sanity checks.
|
|
|
|
*/
|
|
|
|
addr4 = sin6->sin6_addr.s6_addr32[3];
|
|
|
|
if (addr4 == htonl(INADDR_ANY) ||
|
|
|
|
addr4 == htonl(INADDR_BROADCAST) ||
|
2019-09-02 23:29:36 +00:00
|
|
|
ipv4_is_multicast(addr4)) {
|
2018-07-25 15:22:27 +00:00
|
|
|
ret = -EINVAL;
|
2018-07-24 03:51:22 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (addr_type & IPV6_ADDR_LINKLOCAL) {
|
|
|
|
if (sin6->sin6_scope_id == 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
scope_id = sin6->sin6_scope_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
daddr = sin6->sin6_addr;
|
|
|
|
dport = sin6->sin6_port;
|
|
|
|
break;
|
2018-07-24 03:51:21 +00:00
|
|
|
}
|
2018-07-31 05:48:42 +00:00
|
|
|
#endif
|
2018-07-24 03:51:21 +00:00
|
|
|
|
|
|
|
default:
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* We only care about consistency with ->connect() */
|
|
|
|
lock_sock(sk);
|
|
|
|
daddr = rs->rs_conn_addr;
|
|
|
|
dport = rs->rs_conn_port;
|
2018-07-24 03:51:21 +00:00
|
|
|
scope_id = rs->rs_bound_scope_id;
|
2009-02-24 15:30:27 +00:00
|
|
|
release_sock(sk);
|
|
|
|
}
|
|
|
|
|
2015-11-24 22:13:21 +00:00
|
|
|
lock_sock(sk);
|
2018-07-24 03:51:21 +00:00
|
|
|
if (ipv6_addr_any(&rs->rs_bound_addr) || ipv6_addr_any(&daddr)) {
|
2015-11-24 22:13:21 +00:00
|
|
|
release_sock(sk);
|
2018-07-24 03:51:21 +00:00
|
|
|
ret = -ENOTCONN;
|
2009-02-24 15:30:27 +00:00
|
|
|
goto out;
|
2018-07-24 03:51:21 +00:00
|
|
|
} else if (namelen != 0) {
|
|
|
|
/* Cannot send to an IPv4 address using an IPv6 source
|
|
|
|
* address and cannot send to an IPv6 address using an
|
|
|
|
* IPv4 source address.
|
|
|
|
*/
|
|
|
|
if (ipv6_addr_v4mapped(&daddr) ^
|
|
|
|
ipv6_addr_v4mapped(&rs->rs_bound_addr)) {
|
|
|
|
release_sock(sk);
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-07-24 03:51:22 +00:00
|
|
|
/* If the socket is already bound to a link local address,
|
|
|
|
* it can only send to peers on the same link. But allow
|
|
|
|
* communicating beween link local and non-link local address.
|
|
|
|
*/
|
|
|
|
if (scope_id != rs->rs_bound_scope_id) {
|
|
|
|
if (!scope_id) {
|
|
|
|
scope_id = rs->rs_bound_scope_id;
|
|
|
|
} else if (rs->rs_bound_scope_id) {
|
|
|
|
release_sock(sk);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2009-02-24 15:30:27 +00:00
|
|
|
}
|
2015-11-24 22:13:21 +00:00
|
|
|
release_sock(sk);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-02-29 23:30:57 +00:00
|
|
|
ret = rds_rdma_bytes(msg, &rdma_payload_len);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
total_payload_len += rdma_payload_len;
|
|
|
|
if (max_t(size_t, payload_len, rdma_payload_len) > RDS_MAX_MSG_SIZE) {
|
|
|
|
ret = -EMSGSIZE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-08-22 22:45:34 +00:00
|
|
|
if (payload_len > rds_sk_sndbuf(rs)) {
|
|
|
|
ret = -EMSGSIZE;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-02-15 18:49:36 +00:00
|
|
|
if (zcopy) {
|
|
|
|
if (rs->rs_transport->t_type != RDS_TRANS_TCP) {
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
num_sgs = iov_iter_npages(&msg->msg_iter, INT_MAX);
|
|
|
|
}
|
2010-01-12 20:56:06 +00:00
|
|
|
/* size of rm including all sgs */
|
2018-12-16 07:01:08 +00:00
|
|
|
ret = rds_rm_size(msg, num_sgs, &vct);
|
2010-01-12 20:56:06 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
rm = rds_message_alloc(ret, GFP_KERNEL);
|
|
|
|
if (!rm) {
|
|
|
|
ret = -ENOMEM;
|
2009-02-24 15:30:27 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-02-04 03:40:32 +00:00
|
|
|
/* Attach data to the rm */
|
|
|
|
if (payload_len) {
|
2018-12-16 07:01:09 +00:00
|
|
|
rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs, &ret);
|
|
|
|
if (!rm->data.op_sg)
|
2010-10-28 15:40:59 +00:00
|
|
|
goto out;
|
2018-02-15 18:49:36 +00:00
|
|
|
ret = rds_message_copy_from_user(rm, &msg->msg_iter, zcopy);
|
2010-02-04 03:40:32 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
rm->data.op_active = 1;
|
2010-01-12 20:56:06 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
rm->m_daddr = daddr;
|
|
|
|
|
|
|
|
/* rds_conn_create has a spinlock that runs with IRQ off.
|
|
|
|
* Caching the conn in the socket helps a lot. */
|
2018-10-13 14:13:23 +00:00
|
|
|
if (rs->rs_conn && ipv6_addr_equal(&rs->rs_conn->c_faddr, &daddr) &&
|
|
|
|
rs->rs_tos == rs->rs_conn->c_tos) {
|
2009-02-24 15:30:27 +00:00
|
|
|
conn = rs->rs_conn;
|
2018-10-24 03:21:14 +00:00
|
|
|
} else {
|
2015-08-05 05:43:25 +00:00
|
|
|
conn = rds_conn_create_outgoing(sock_net(sock->sk),
|
2018-07-24 03:51:21 +00:00
|
|
|
&rs->rs_bound_addr, &daddr,
|
2018-10-13 14:13:23 +00:00
|
|
|
rs->rs_transport, rs->rs_tos,
|
2018-07-24 03:51:21 +00:00
|
|
|
sock->sk->sk_allocation,
|
|
|
|
scope_id);
|
2009-02-24 15:30:27 +00:00
|
|
|
if (IS_ERR(conn)) {
|
|
|
|
ret = PTR_ERR(conn);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
rs->rs_conn = conn;
|
|
|
|
}
|
|
|
|
|
2018-07-25 03:31:58 +00:00
|
|
|
if (conn->c_trans->t_mp_capable)
|
2018-10-08 16:17:11 +00:00
|
|
|
cpath = &conn->c_path[rds_send_mprds_hash(rs, conn, nonblock)];
|
2018-07-25 03:31:58 +00:00
|
|
|
else
|
|
|
|
cpath = &conn->c_path[0];
|
|
|
|
|
|
|
|
rm->m_conn_path = cpath;
|
|
|
|
|
2009-04-09 14:09:41 +00:00
|
|
|
/* Parse any control messages the user may have included. */
|
2018-12-16 07:01:08 +00:00
|
|
|
ret = rds_cmsg_send(rs, rm, msg, &allocated_mr, &vct);
|
2016-07-05 00:04:37 +00:00
|
|
|
if (ret) {
|
|
|
|
/* Trigger connection so that its ready for the next retry */
|
|
|
|
if (ret == -EAGAIN)
|
|
|
|
rds_conn_connect_if_down(conn);
|
2009-04-09 14:09:41 +00:00
|
|
|
goto out;
|
2016-07-05 00:04:37 +00:00
|
|
|
}
|
2009-04-09 14:09:41 +00:00
|
|
|
|
2010-03-02 00:10:40 +00:00
|
|
|
if (rm->rdma.op_active && !conn->c_trans->xmit_rdma) {
|
2011-06-16 02:09:57 +00:00
|
|
|
printk_ratelimited(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n",
|
2010-03-01 22:11:53 +00:00
|
|
|
&rm->rdma, conn->c_trans->xmit_rdma);
|
2010-01-12 22:33:38 +00:00
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rm->atomic.op_active && !conn->c_trans->xmit_atomic) {
|
2011-06-16 02:09:57 +00:00
|
|
|
printk_ratelimited(KERN_NOTICE "atomic_op %p conn xmit_atomic %p\n",
|
2010-01-12 22:33:38 +00:00
|
|
|
&rm->atomic, conn->c_trans->xmit_atomic);
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-02-03 12:26:51 +00:00
|
|
|
if (rds_destroy_pending(conn)) {
|
2018-01-04 14:53:00 +00:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:37 +00:00
|
|
|
rds_conn_path_connect_if_down(cpath);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs);
|
2010-03-11 13:50:04 +00:00
|
|
|
if (ret) {
|
|
|
|
rs->rs_seen_congestion = 1;
|
2009-02-24 15:30:27 +00:00
|
|
|
goto out;
|
2010-03-11 13:50:04 +00:00
|
|
|
}
|
2016-06-13 16:44:33 +00:00
|
|
|
while (!rds_send_queue_rm(rs, conn, cpath, rm, rs->rs_bound_port,
|
2009-02-24 15:30:27 +00:00
|
|
|
dport, &queued)) {
|
|
|
|
rds_stats_inc(s_send_queue_full);
|
2015-08-22 22:45:34 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
if (nonblock) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-04-20 13:03:51 +00:00
|
|
|
timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
|
2016-06-13 16:44:33 +00:00
|
|
|
rds_send_queue_rm(rs, conn, cpath, rm,
|
2009-02-24 15:30:27 +00:00
|
|
|
rs->rs_bound_port,
|
|
|
|
dport,
|
|
|
|
&queued),
|
|
|
|
timeo);
|
|
|
|
rdsdebug("sendmsg woke queued %d timeo %ld\n", queued, timeo);
|
|
|
|
if (timeo > 0 || timeo == MAX_SCHEDULE_TIMEOUT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = timeo;
|
|
|
|
if (ret == 0)
|
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* By now we've committed to the send. We reuse rds_send_worker()
|
|
|
|
* to retry sends in the rds thread if the transport asks us to.
|
|
|
|
*/
|
|
|
|
rds_stats_inc(s_send_queued);
|
|
|
|
|
2016-06-13 16:44:34 +00:00
|
|
|
ret = rds_send_xmit(cpath);
|
2018-01-04 14:53:00 +00:00
|
|
|
if (ret == -ENOMEM || ret == -EAGAIN) {
|
|
|
|
ret = 0;
|
|
|
|
rcu_read_lock();
|
2018-02-03 12:26:51 +00:00
|
|
|
if (rds_destroy_pending(cpath->cp_conn))
|
2018-01-04 14:53:00 +00:00
|
|
|
ret = -ENETUNREACH;
|
|
|
|
else
|
|
|
|
queue_delayed_work(rds_wq, &cpath->cp_send_w, 1);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_message_put(rm);
|
2018-12-16 07:01:08 +00:00
|
|
|
|
|
|
|
for (ind = 0; ind < vct.indx; ind++)
|
|
|
|
kfree(vct.vec[ind].iov);
|
|
|
|
kfree(vct.vec);
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
return payload_len;
|
|
|
|
|
|
|
|
out:
|
2018-12-16 07:01:08 +00:00
|
|
|
for (ind = 0; ind < vct.indx; ind++)
|
|
|
|
kfree(vct.vec[ind].iov);
|
|
|
|
kfree(vct.vec);
|
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
/* If the user included a RDMA_MAP cmsg, we allocated a MR on the fly.
|
|
|
|
* If the sendmsg goes through, we keep the MR. If it fails with EAGAIN
|
|
|
|
* or in any other way, we need to destroy the MR again */
|
|
|
|
if (allocated_mr)
|
|
|
|
rds_rdma_unuse(rs, rds_rdma_cookie_key(rm->m_rdma_cookie), 1);
|
|
|
|
|
|
|
|
if (rm)
|
|
|
|
rds_message_put(rm);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-07-14 10:51:03 +00:00
|
|
|
* send out a probe. Can be shared by rds_send_ping,
|
|
|
|
* rds_send_pong, rds_send_hb.
|
|
|
|
* rds_send_hb should use h_flags
|
|
|
|
* RDS_FLAG_HB_PING|RDS_FLAG_ACK_REQUIRED
|
|
|
|
* or
|
|
|
|
* RDS_FLAG_HB_PONG|RDS_FLAG_ACK_REQUIRED
|
2009-02-24 15:30:27 +00:00
|
|
|
*/
|
2016-12-05 00:41:29 +00:00
|
|
|
static int
|
2016-07-14 10:51:03 +00:00
|
|
|
rds_send_probe(struct rds_conn_path *cp, __be16 sport,
|
|
|
|
__be16 dport, u8 h_flags)
|
2009-02-24 15:30:27 +00:00
|
|
|
{
|
|
|
|
struct rds_message *rm;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
rm = rds_message_alloc(0, GFP_ATOMIC);
|
2010-01-12 19:56:44 +00:00
|
|
|
if (!rm) {
|
2009-02-24 15:30:27 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-06-13 16:44:36 +00:00
|
|
|
rm->m_daddr = cp->cp_conn->c_faddr;
|
2010-04-01 01:56:25 +00:00
|
|
|
rm->data.op_active = 1;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:37 +00:00
|
|
|
rds_conn_path_connect_if_down(cp);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-06-13 16:44:36 +00:00
|
|
|
ret = rds_cong_wait(cp->cp_conn->c_fcong, dport, 1, NULL);
|
2009-02-24 15:30:27 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2016-06-13 16:44:36 +00:00
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
|
|
|
list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
|
2009-02-24 15:30:27 +00:00
|
|
|
set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
|
|
|
|
rds_message_addref(rm);
|
2016-06-13 16:44:36 +00:00
|
|
|
rm->m_inc.i_conn = cp->cp_conn;
|
|
|
|
rm->m_inc.i_conn_path = cp;
|
2009-02-24 15:30:27 +00:00
|
|
|
|
2016-07-14 10:51:03 +00:00
|
|
|
rds_message_populate_header(&rm->m_inc.i_hdr, sport, dport,
|
2016-06-13 16:44:36 +00:00
|
|
|
cp->cp_next_tx_seq);
|
2016-07-14 10:51:03 +00:00
|
|
|
rm->m_inc.i_hdr.h_flags |= h_flags;
|
2016-06-13 16:44:36 +00:00
|
|
|
cp->cp_next_tx_seq++;
|
2016-07-14 10:51:03 +00:00
|
|
|
|
2017-06-15 18:28:54 +00:00
|
|
|
if (RDS_HS_PROBE(be16_to_cpu(sport), be16_to_cpu(dport)) &&
|
|
|
|
cp->cp_conn->c_trans->t_mp_capable) {
|
|
|
|
u16 npaths = cpu_to_be16(RDS_MPATH_WORKERS);
|
|
|
|
u32 my_gen_num = cpu_to_be32(cp->cp_conn->c_my_gen_num);
|
2016-07-14 10:51:03 +00:00
|
|
|
|
|
|
|
rds_message_add_extension(&rm->m_inc.i_hdr,
|
|
|
|
RDS_EXTHDR_NPATHS, &npaths,
|
|
|
|
sizeof(npaths));
|
2016-11-16 21:29:49 +00:00
|
|
|
rds_message_add_extension(&rm->m_inc.i_hdr,
|
|
|
|
RDS_EXTHDR_GEN_NUM,
|
2017-06-15 18:28:54 +00:00
|
|
|
&my_gen_num,
|
2016-11-16 21:29:49 +00:00
|
|
|
sizeof(u32));
|
2016-07-14 10:51:03 +00:00
|
|
|
}
|
2016-06-13 16:44:36 +00:00
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2009-02-24 15:30:27 +00:00
|
|
|
|
|
|
|
rds_stats_inc(s_send_queued);
|
|
|
|
rds_stats_inc(s_send_pong);
|
|
|
|
|
2015-10-17 02:13:21 +00:00
|
|
|
/* schedule the send work on rds_wq */
|
2018-01-04 14:53:00 +00:00
|
|
|
rcu_read_lock();
|
2018-02-03 12:26:51 +00:00
|
|
|
if (!rds_destroy_pending(cp->cp_conn))
|
2018-01-04 14:53:00 +00:00
|
|
|
queue_delayed_work(rds_wq, &cp->cp_send_w, 1);
|
|
|
|
rcu_read_unlock();
|
2010-04-01 01:56:25 +00:00
|
|
|
|
2009-02-24 15:30:27 +00:00
|
|
|
rds_message_put(rm);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (rm)
|
|
|
|
rds_message_put(rm);
|
|
|
|
return ret;
|
|
|
|
}
|
2016-07-14 10:51:03 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
rds_send_pong(struct rds_conn_path *cp, __be16 dport)
|
|
|
|
{
|
|
|
|
return rds_send_probe(cp, 0, dport, 0);
|
|
|
|
}
|
|
|
|
|
2017-06-21 20:40:12 +00:00
|
|
|
void
|
|
|
|
rds_send_ping(struct rds_connection *conn, int cp_index)
|
2016-07-14 10:51:03 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2017-06-21 20:40:12 +00:00
|
|
|
struct rds_conn_path *cp = &conn->c_path[cp_index];
|
2016-07-14 10:51:03 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&cp->cp_lock, flags);
|
|
|
|
if (conn->c_ping_triggered) {
|
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
conn->c_ping_triggered = 1;
|
|
|
|
spin_unlock_irqrestore(&cp->cp_lock, flags);
|
2017-06-21 20:40:12 +00:00
|
|
|
rds_send_probe(cp, cpu_to_be16(RDS_FLAG_PROBE_PORT), 0, 0);
|
2016-07-14 10:51:03 +00:00
|
|
|
}
|
2017-06-21 20:40:12 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rds_send_ping);
|