list_for_each_entry(conn, &s_addr_conns, c_laddr_node)
if (conn) {
conn->c_drop_source = 1;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_USER_RESET);
}
goto done;
}
"<%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
NIPQUAD(reset.src.s_addr),
NIPQUAD(reset.dst.s_addr), conn->c_tos);
- conn->c_drop_source = DR_USER_RESET;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_USER_RESET);
}
done:
return 0;
mutex_lock(&conn->c_cm_lock);
if (!rds_conn_transition(conn, RDS_CONN_UP, RDS_CONN_DISCONNECTING)
&& !rds_conn_transition(conn, RDS_CONN_ERROR, RDS_CONN_DISCONNECTING)) {
- conn->c_drop_source = DR_INV_CONN_STATE;
- rds_conn_error(conn, "shutdown called in state %d\n",
- atomic_read(&conn->c_state));
+ pr_warn("RDS: shutdown called in state %d\n",
+ atomic_read(&conn->c_state));
+ rds_conn_drop(conn, DR_INV_CONN_STATE);
mutex_unlock(&conn->c_cm_lock);
return;
}
* Quite reproduceable with loopback connections.
* Mostly harmless.
*/
- conn->c_drop_source = DR_DOWN_TRANSITION_FAIL;
- rds_conn_error(conn,
- "%s: failed to transition to state DOWN, "
- "current state is %d\n",
- __func__,
- atomic_read(&conn->c_state));
+ pr_warn("RDS: %s: failed to transition to state DOWN, current state is %d\n",
+ __func__, atomic_read(&conn->c_state));
+ rds_conn_drop(conn, DR_DOWN_TRANSITION_FAIL);
return;
}
}
synchronize_rcu();
/* shut the connection down */
- conn->c_drop_source = DR_CONN_DESTROY;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_CONN_DESTROY);
flush_work(&conn->c_down_w);
/* now that conn down worker is flushed; there cannot be any
else if (rds_conn_connecting(tmp) && (tmp->c_route_resolved == 0)) {
printk(KERN_INFO "RDS/IB: connection "
"<%u.%u.%u.%u,%u.%u.%u.%u,%d> "
- "connecting, force reset ",
+ "connecting, force reset\n",
NIPQUAD(tmp->c_laddr),
NIPQUAD(tmp->c_faddr),
tmp->c_tos);
- conn->c_drop_source = DR_ZERO_LANE_DOWN;
- rds_conn_drop(tmp);
+ rds_conn_drop(tmp, DR_ZERO_LANE_DOWN);
}
}
}
/*
* Force a disconnect
*/
-void rds_conn_drop(struct rds_connection *conn)
+void rds_conn_drop(struct rds_connection *conn, int reason)
{
unsigned long now = get_seconds();
+ conn->c_drop_source = reason;
if (rds_conn_state(conn) == RDS_CONN_UP) {
conn->c_reconnect_start = now;
conn->c_reconnect_warn = 1;
NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr),
conn->c_tos,
- conn_drop_reason_str(conn->c_drop_source));
+ conn_drop_reason_str(reason));
if (conn->c_tos == 0)
rds_conn_probe_lanes(conn);
}
}
EXPORT_SYMBOL_GPL(rds_conn_connect_if_down);
-
-/*
- * An error occurred on the connection
- */
-void
-__rds_conn_error(struct rds_connection *conn, const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- vprintk(fmt, ap);
- va_end(ap);
-
- rds_conn_drop(conn);
-}
spin_lock_irqsave(&rds_ibdev->spinlock, flags);
list_for_each_entry(ic, &rds_ibdev->conn_list, ib_node) {
- ic->conn->c_drop_source = DR_IB_UMMOD;
- rds_conn_drop(ic->conn);
+ rds_conn_drop(ic->conn, DR_IB_UMMOD);
}
spin_unlock_irqrestore(&rds_ibdev->spinlock, flags);
}
void rds_ib_state_change(struct sock *sk);
int rds_ib_listen_init(void);
void rds_ib_listen_stop(void);
-void __rds_ib_conn_error(struct rds_connection *conn, const char *, ...);
int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
struct rdma_cm_event *event);
int rds_ib_cm_initiate_connect(struct rdma_cm_id *cm_id);
void rds_ib_init_frag(unsigned int version);
void rds_ib_conn_destroy_init(struct rds_connection *conn);
-#define rds_ib_conn_error(conn, fmt...) \
- __rds_ib_conn_error(conn, KERN_WARNING "RDS/IB: " fmt)
-
/* ib_rdma.c */
int rds_ib_update_ipaddr(struct rds_ib_device *rds_ibdev, __be32 ipaddr);
void rds_ib_add_conn(struct rds_ib_device *rds_ibdev, struct rds_connection *conn);
rds_rtd(RDS_RTD_CM,
"ic->i_cm_id is NULL, ic: %p, calling rds_conn_drop\n",
ic);
- conn->c_drop_source = DR_IB_CONN_DROP_RACE;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_CONN_DROP_RACE);
return;
}
rds_rtd(RDS_RTD_CM,
"conn is in connecting state, conn: %p, calling rds_conn_drop\n",
conn);
- conn->c_drop_source = DR_IB_NOT_CONNECTING_STATE;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_NOT_CONNECTING_STATE);
return;
}
"Fatal QP Event %u (%s) - connection %pI4->%pI4 tos %d, reconnecting\n",
event->event, rds_ib_event_str(event->event),
&conn->c_laddr, &conn->c_faddr, conn->c_tos);
- conn->c_drop_source = DR_IB_QP_EVENT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_QP_EVENT);
break;
}
}
NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr),
conn->c_tos);
- conn->c_drop_source = DR_IB_BASE_CONN_DOWN;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_BASE_CONN_DOWN);
}
/*
if (rds_conn_state(conn) == RDS_CONN_UP) {
rds_rtd(RDS_RTD_CM_EXT_P,
"incoming connect while connecting\n");
- conn->c_drop_source = DR_IB_REQ_WHILE_CONN_UP;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_REQ_WHILE_CONN_UP);
rds_ib_stats_inc(s_ib_listen_closed_stale);
} else if (rds_conn_state(conn) == RDS_CONN_CONNECTING) {
unsigned long now = get_seconds();
NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr),
conn->c_tos);
- conn->c_drop_source = DR_IB_REQ_WHILE_CONNECTING;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_REQ_WHILE_CONNECTING);
rds_ib_stats_inc(s_ib_listen_closed_stale);
} else {
/* Wait and see - our connect may still be succeeding */
err = rds_ib_setup_qp(conn);
if (err) {
- conn->c_drop_source = DR_IB_PAS_SETUP_QP_FAIL;
- rds_ib_conn_error(conn, "rds_ib_setup_qp failed (%d)\n", err);
+ pr_warn("RDS/IB: rds_ib_setup_qp failed (%d)\n", err);
+ rds_conn_drop(conn, DR_IB_PAS_SETUP_QP_FAIL);
goto out;
}
/* rdma_accept() calls rdma_reject() internally if it fails */
err = rdma_accept(cm_id, &conn_param);
if (err) {
- conn->c_drop_source = DR_IB_RDMA_ACCEPT_FAIL;
- rds_ib_conn_error(conn, "rdma_accept failed (%d)\n", err);
+ pr_warn("RDS/IB: rdma_accept failed (%d)\n", err);
+ rds_conn_drop(conn, DR_IB_RDMA_ACCEPT_FAIL);
}
out:
ret = rds_ib_setup_qp(conn);
if (ret) {
- conn->c_drop_source = DR_IB_ACT_SETUP_QP_FAIL;
- rds_ib_conn_error(conn, "rds_ib_setup_qp failed (%d)\n", ret);
+ pr_warn("RDS/IB: rds_ib_setup_qp failed (%d)\n", ret);
+ rds_conn_drop(conn, DR_IB_ACT_SETUP_QP_FAIL);
goto out;
}
ib_init_frag_size);
ret = rdma_connect(cm_id, &conn_param);
if (ret) {
- conn->c_drop_source = DR_IB_RDMA_CONNECT_FAIL;
- rds_ib_conn_error(conn, "rdma_connect failed (%d)\n", ret);
+ pr_warn("RDS/IB: rdma_connect failed (%d)\n", ret);
+ rds_conn_drop(conn, DR_IB_RDMA_CONNECT_FAIL);
}
out:
kfree(ic);
}
-
-
-/*
- * An error occurred on the connection
- */
-void
-__rds_ib_conn_error(struct rds_connection *conn, const char *fmt, ...)
-{
- va_list ap;
-
- rds_conn_drop(conn);
-
- va_start(ap, fmt);
- vprintk(fmt, ap);
- va_end(ap);
-}
recv->r_ibinc, sg_page(&recv->r_frag->f_sg),
(long) sg_dma_address(&recv->r_frag->f_sg), ret);
if (ret) {
- conn->c_drop_source = DR_IB_POST_RECV_FAIL;
- rds_ib_conn_error(conn, "recv post on "
- "%pI4 returned %d, disconnecting and "
- "reconnecting\n", &conn->c_faddr,
- ret);
+ rds_conn_drop(conn, DR_IB_POST_RECV_FAIL);
+ pr_warn("RDS/IB: recv post on %pI4 returned %d, disconnecting and reconnecting\n",
+ &conn->c_faddr, ret);
break;
}
set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
rds_ib_stats_inc(s_ib_ack_send_failure);
-
- ic->conn->c_drop_source = DR_IB_SEND_ACK_FAIL;
- rds_ib_conn_error(ic->conn, "sending ack failed\n");
+ rds_conn_drop(ic->conn, DR_IB_SEND_ACK_FAIL);
} else
rds_ib_stats_inc(s_ib_ack_sent);
}
data_len);
if (data_len < sizeof(struct rds_header)) {
- conn->c_drop_source = DR_IB_HEADER_MISSING;
- rds_ib_conn_error(conn, "incoming message "
- "from %pI4 didn't inclue a "
- "header, disconnecting and "
- "reconnecting\n",
- &conn->c_faddr);
+ rds_conn_drop(conn, DR_IB_HEADER_MISSING);
+ pr_warn("RDS/IB: incoming message from %pI4 didn't inclue a header, disconnecting and reconnecting\n",
+ &conn->c_faddr);
return;
}
data_len -= sizeof(struct rds_header);
/* Validate the checksum. */
if (!rds_message_verify_checksum(ihdr)) {
- conn->c_drop_source = DR_IB_HEADER_CORRUPTED;
- rds_ib_conn_error(conn, "incoming message "
- "from %pI4 has corrupted header - "
- "forcing a reconnect\n",
- &conn->c_faddr);
+ rds_conn_drop(conn, DR_IB_HEADER_CORRUPTED);
+ pr_warn("RDS/IB: incoming message from %pI4 has corrupted header - forcing a reconnect\n",
+ &conn->c_faddr);
rds_stats_inc(s_recv_drop_bad_checksum);
return;
}
|| hdr->h_len != ihdr->h_len
|| hdr->h_sport != ihdr->h_sport
|| hdr->h_dport != ihdr->h_dport) {
- conn->c_drop_source = DR_IB_FRAG_HEADER_MISMATCH;
- rds_ib_conn_error(conn,
- "fragment header mismatch; forcing reconnect\n");
+ rds_conn_drop(conn, DR_IB_FRAG_HEADER_MISMATCH);
return;
}
}
} else {
/* We expect errors as the qp is drained during shutdown */
if (rds_conn_up(conn) || rds_conn_connecting(conn)) {
- conn->c_drop_source = DR_IB_RECV_COMP_ERR;
- rds_ib_conn_error(conn, "recv completion "
- "<%pI4,%pI4,%d> had status %u "
- "vendor_err 0x%x, disconnecting and "
- "reconnecting\n",
- &conn->c_laddr,
- &conn->c_faddr,
- conn->c_tos,
- wc->status, wc->vendor_err);
+ pr_warn("RDS/IB: recv completion <%pI4,%pI4,%d> had status %u vendor_err 0x%x, disconnecting and reconnecting\n",
+ &conn->c_laddr, &conn->c_faddr, conn->c_tos,
+ wc->status, wc->vendor_err);
+ rds_conn_drop(conn, DR_IB_RECV_COMP_ERR);
rds_rtd(RDS_RTD_ERR, "status %u => %s\n", wc->status,
rds_ib_wc_status_str(wc->status));
}
/* We expect errors as the qp is drained during shutdown */
if (wc->status != IB_WC_SUCCESS && rds_conn_up(conn)) {
- conn->c_drop_source = DR_IB_SEND_COMP_ERR;
- rds_ib_conn_error(conn,
- "send completion <%u.%u.%u.%u,%u.%u.%u.%u,%d> status "
- "%u vendor_err 0x%x, disconnecting and reconnecting\n",
- NIPQUAD(conn->c_laddr),
- NIPQUAD(conn->c_faddr),
- conn->c_tos, wc->status, wc->vendor_err);
+ pr_warn("RDS/IB: send completion <%pI4,%pI4,%d> status %u vendor_err 0x%x, disconnecting and reconnecting\n",
+ &conn->c_laddr, &conn->c_faddr, conn->c_tos,
+ wc->status, wc->vendor_err);
+ rds_conn_drop(conn, DR_IB_SEND_COMP_ERR);
rds_rtd(RDS_RTD_ERR, "status %u => %s\n", wc->status,
rds_ib_wc_status_str(wc->status));
}
prev->s_op = NULL;
}
- ic->conn->c_drop_source = DR_IB_POST_SEND_FAIL;
- rds_ib_conn_error(ic->conn, "ib_post_send failed\n");
+ rds_conn_drop(ic->conn, DR_IB_POST_SEND_FAIL);
goto out;
}
"ADDR_RESOLVED: ret %d, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
ret, NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr), conn->c_tos);
- conn->c_drop_source = DR_IB_SET_IB_PATH_FAIL;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_SET_IB_PATH_FAIL);
ret = 0;
}
ibic = conn->c_transport_data;
if (ibic && ibic->i_cm_id == cm_id)
ibic->i_cm_id = NULL;
- conn->c_drop_source = DR_IB_RESOLVE_ROUTE_FAIL;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_RESOLVE_ROUTE_FAIL);
}
} else if (conn->c_to_index < (RDS_RDMA_RESOLVE_TO_MAX_INDEX-1))
conn->c_to_index++;
"ROUTE_RESOLVED: calling rds_conn_drop, conn %p <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
conn, NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr), conn->c_tos);
- conn->c_drop_source = DR_IB_RDMA_CM_ID_MISMATCH;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_RDMA_CM_ID_MISMATCH);
}
}
break;
"ROUTE_ERROR: conn %p, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
conn, NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr), conn->c_tos);
- conn->c_drop_source = DR_IB_ROUTE_ERR;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_ROUTE_ERR);
}
break;
"ADDR_ERROR: conn %p, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
conn, NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr), conn->c_tos);
- conn->c_drop_source = DR_IB_ADDR_ERR;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_ADDR_ERR);
}
break;
"CONN/UNREACHABLE/RMVAL ERR: conn %p, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
conn, NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr), conn->c_tos);
- conn->c_drop_source = DR_IB_CONNECT_ERR;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_CONNECT_ERR);
}
break;
if (!conn->c_tos) {
conn->c_proposed_version =
RDS_PROTOCOL_COMPAT_VERSION;
- conn->c_drop_source = DR_IB_CONSUMER_DEFINED_REJ;
- rds_conn_drop(conn);
+ rds_conn_drop(conn,
+ DR_IB_CONSUMER_DEFINED_REJ);
} else {
if (conn->c_loopback)
queue_delayed_work(rds_local_wq,
NIPQUAD(conn->c_laddr),
NIPQUAD(conn->c_faddr),
conn->c_tos);
- conn->c_drop_source = DR_IB_REJECTED_EVENT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_REJECTED_EVENT);
}
}
break;
"ADDR_CHANGE: calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
conn->c_tos);
- conn->c_drop_source = DR_IB_ADDR_CHANGE;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_ADDR_CHANGE);
}
break;
rds_rtd(RDS_RTD_CM,
"DISCONNECT event - dropping connection %pI4->%pI4 tos %d\n",
&conn->c_laddr, &conn->c_faddr, conn->c_tos);
- conn->c_drop_source = DR_IB_DISCONNECTED_EVENT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_DISCONNECTED_EVENT);
break;
case RDMA_CM_EVENT_TIMEWAIT_EXIT:
"dropping connection "
"%pI4->%pI4\n", &conn->c_laddr,
&conn->c_faddr);
- conn->c_drop_source = DR_IB_TIMEWAIT_EXIT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_IB_TIMEWAIT_EXIT);
} else
printk(KERN_INFO "TIMEWAIT_EXIT event - conn=NULL\n");
break;
void rds_conn_shutdown(struct rds_connection *conn, int restart);
void rds_conn_destroy(struct rds_connection *conn, int shutdown);
void rds_conn_reset(struct rds_connection *conn);
-void rds_conn_drop(struct rds_connection *conn);
+void rds_conn_drop(struct rds_connection *conn, int reason);
void rds_conn_laddr_list(__be32 laddr, struct list_head *laddr_conns);
void rds_conn_connect_if_down(struct rds_connection *conn);
void rds_for_each_conn_info(struct socket *sock, unsigned int len,
int (*visitor)(struct rds_connection *, void *),
size_t item_len);
char *conn_drop_reason_str(enum rds_conn_drop_src reason);
-void __rds_conn_error(struct rds_connection *conn, const char *, ...)
- __attribute__ ((format (printf, 2, 3)));
-#define rds_conn_error(conn, fmt...) \
- __rds_conn_error(conn, KERN_WARNING "RDS: " fmt)
static inline int
rds_conn_transition(struct rds_connection *conn, int old, int new)
if (net != c_net || !tc->t_sock)
continue;
- rds_conn_drop(tc->conn); /* reconnect with new parameters */
+ /* reconnect with new parameters */
+ rds_conn_drop(tc->conn, DR_USER_RESET);
}
spin_unlock_irq(&rds_tcp_conn_lock);
}
break;
case TCP_CLOSE_WAIT:
case TCP_CLOSE:
- conn->c_drop_source = DR_TCP_STATE_CLOSE;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_TCP_STATE_CLOSE);
default:
break;
}
printk(KERN_WARNING "RDS/tcp: send to %u.%u.%u.%u "
"returned %d, disconnecting and reconnecting\n",
NIPQUAD(conn->c_faddr), ret);
- conn->c_drop_source = DR_TCP_SEND_FAIL;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_TCP_SEND_FAIL);
}
}
if (done == 0)
"reconnecting..., conn %p\n", conn);
rds_queue_reconnect(conn);
} else {
- conn->c_drop_source = DR_CONN_CONNECT_FAIL;
- rds_conn_error(conn, "RDS: connect failed\n");
+ rds_conn_drop(conn, DR_CONN_CONNECT_FAIL);
}
}
} else {
"RDS/IB: connection <%u.%u.%u.%u,%u.%u.%u.%u,%d> timed out (0x%lx,0x%lx)..discon and recon\n",
NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
conn->c_tos, conn->c_hb_start, now);
- conn->c_drop_source = DR_HB_TIMEOUT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_HB_TIMEOUT);
return;
}
queue_delayed_work(rds_wq, &conn->c_hb_w, HZ);
"conn not up, calling rds_conn_drop <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
conn->c_tos);
- conn->c_drop_source = DR_RECONNECT_TIMEOUT;
- rds_conn_drop(conn);
+ rds_conn_drop(conn, DR_RECONNECT_TIMEOUT);
conn->c_reconnect_racing = 0;
}
}
projects / users / jedix / linux-maple.git / commitdiff