From: Håkon Bugge Date: Thu, 7 Mar 2019 11:35:54 +0000 (+0100) Subject: rds: Consolidate and align ftrace related to connection management X-Git-Tag: v4.1.12-124.31.3~115 X-Git-Url: https://www.infradead.org/git/?a=commitdiff_plain;h=39216a82c651538e16f1e153a3192783e1be08f4;p=users%2Fjedix%2Flinux-maple.git rds: Consolidate and align ftrace related to connection management Add some trace points, always include context in form of "conn" pointer and , and change some pr_warn/pr_debug to trace points. Add helper function conn_state_mnem() to display RDS connection states symbolically. Orabug: 29391909 Signed-off-by: Håkon Bugge Tested-by: Rosa Lopez Reviewed-by: Sudhakar Dindukurti --- v1 -> v2: Incorporated review comments from Dag and Sudhakar Signed-off-by: Brian Maly --- diff --git a/net/rds/connection.c b/net/rds/connection.c index be0dacd6cd77..6acc59ff6af0 100644 --- a/net/rds/connection.c +++ b/net/rds/connection.c @@ -281,10 +281,11 @@ static struct rds_connection *__rds_conn_create(struct net *net, goto out; } - rdsdebug("allocated conn %p for %pI6c -> %pI6c over %s %s\n", - conn, laddr, faddr, - trans->t_name ? trans->t_name : "[unknown]", - is_outgoing ? "(outgoing)" : ""); + rds_rtd_ptr(RDS_RTD_CM_EXT, + "allocated conn %p for <%pI6c,%pI6c,%d> over %s %s\n", + conn, laddr, faddr, tos, + trans->t_name ? trans->t_name : "[unknown]", + is_outgoing ? "(outgoing)" : ""); /* * Since we ran without holding the conn lock, someone could @@ -385,11 +386,11 @@ void rds_conn_shutdown(struct rds_conn_path *cp, int restart) /* shut it down unless it's down already */ if (!rds_conn_path_transition(cp, RDS_CONN_DOWN, RDS_CONN_DOWN)) { rds_rtd_ptr(RDS_RTD_CM_EXT, - "RDS/%s: shutdown init <%pI6c,%pI6c,%d>, cn %p, cn->c_p %p\n", - conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : - "IB", + "RDS/%s: shutdown init conn %p conn->c_passive %p <%pI6c,%pI6c,%d>\n", + conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : "IB", + conn, conn->c_passive, &conn->c_laddr, &conn->c_faddr, - conn->c_tos, conn, conn->c_passive); + conn->c_tos); /* * Quiesce the connection mgmt handlers before we start tearing * things down. We don't hold the mutex for the entire @@ -452,9 +453,15 @@ void rds_conn_shutdown(struct rds_conn_path *cp, int restart) rcu_read_lock(); if (!hlist_unhashed(&conn->c_hash_node) && restart) { rcu_read_unlock(); + rds_rtd(RDS_RTD_CM, + "calling rds_queue_reconnect conn %p restart: %d\n", + cp->cp_conn, restart); rds_queue_reconnect(cp); } else { rcu_read_unlock(); + rds_rtd(RDS_RTD_CM, + "NOT calling rds_queue_reconnect conn %p restart: %d\n", + cp->cp_conn, restart); } } @@ -988,16 +995,21 @@ void rds_conn_path_drop(struct rds_conn_path *cp, int reason) atomic_set(&cp->cp_state, RDS_CONN_ERROR); + if (reason != DR_CONN_DESTROY && test_bit(RDS_DESTROY_PENDING, &cp->cp_flags)) { + rds_rtd_ptr(RDS_RTD_CM_EXT, + "RDS/%s: NOT queueing shutdown work, conn %p <%pI6c,%pI6c,%d>\n", + conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : "IB", + conn, &conn->c_laddr, &conn->c_faddr, + conn->c_tos); + return; + } + rds_rtd_ptr(RDS_RTD_CM_EXT, - "RDS/%s: queueing shutdown work, conn %p, <%pI6c,%pI6c,%d>\n", + "RDS/%s: queueing shutdown work, conn %p <%pI6c,%pI6c,%d>\n", conn->c_trans->t_type == RDS_TRANS_TCP ? "TCP" : "IB", conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); - if (reason != DR_CONN_DESTROY && test_bit(RDS_DESTROY_PENDING, - &cp->cp_flags)) - return; - queue_work(cp->cp_wq, &cp->cp_down_w); } EXPORT_SYMBOL_GPL(rds_conn_path_drop); diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c index 5f28eb51aee6..b3137db27735 100644 --- a/net/rds/ib_cm.c +++ b/net/rds/ib_cm.c @@ -668,9 +668,9 @@ static void rds_ib_qp_event_handler(struct ib_event *event, void *data) break; default: rds_rtd_ptr(RDS_RTD_ERR, - "Fatal QP Event %u (%s) - connection %pI6c->%pI6c tos %d, reconnecting\n", + "Fatal QP Event %u (%s) - conn %p <%pI6c,%pI6c,%d>, reconnecting\n", event->event, rds_ib_event_str(event->event), - &conn->c_laddr, &conn->c_faddr, conn->c_tos); + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); rds_conn_drop(conn, DR_IB_QP_EVENT); break; } @@ -1032,13 +1032,12 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, } rds_rtd_ptr(RDS_RTD_CM, - "saddr %pI6c daddr %pI6c RDSv%u.%u lguid 0x%llx fguid 0x%llx tos %d\n", - saddr6, daddr6, + "<%pI6c,%pI6c,%d> RDSv%u.%u lguid 0x%llx fguid 0x%llx\n", + saddr6, daddr6, dp_cmn->ricpc_tos, RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version), (unsigned long long)be64_to_cpu(lguid), - (unsigned long long)be64_to_cpu(fguid), - dp_cmn->ricpc_tos); + (unsigned long long)be64_to_cpu(fguid)); acl_ret = rds_ib_match_acl(cm_id, saddr6); if (acl_ret < 0) { @@ -1076,13 +1075,13 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, if (conn->c_route && !rds_conn_self_loopback_passive(conn)) { rds_rtd_ptr(RDS_RTD_CM, - "no route resolution saddr %pI4 daddr %pI4 RDSv%u.%u lguid 0x%llx fguid 0x%llx tos %d\n", - saddr6, daddr6, + "no route resolution cm_id %p conn %p <%pI6c,%pI6c,%d> RDSv%u.%u lguid 0x%llx fguid 0x%llx\n", + cm_id, conn, + saddr6, daddr6, dp_cmn->ricpc_tos, RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version), (unsigned long long)be64_to_cpu(lguid), - (unsigned long long)be64_to_cpu(fguid), - dp_cmn->ricpc_tos); + (unsigned long long)be64_to_cpu(fguid)); goto out; } @@ -1109,7 +1108,8 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, destroy = 0; if (rds_conn_state(conn) == RDS_CONN_UP) { rds_rtd(RDS_RTD_CM_EXT_P, - "incoming connect while connecting\n"); + "conn %p <%pI6c,%pI6c,%d> incoming connect in UP state\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); 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) { @@ -1124,9 +1124,8 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, */ if (conn->c_reconnect_racing > 5) { rds_rtd_ptr(RDS_RTD_CM, - "RDS/IB: conn <%pI6c,%pI6c,%d> back-to-back REQ, reset\n", - &conn->c_laddr, &conn->c_faddr, - conn->c_tos); + "conn %p <%pI6c,%pI6c,%d> back-to-back REQ, reset\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); conn->c_reconnect_racing = 0; rds_conn_drop(conn, DR_IB_REQ_WHILE_CONNECTING); /* After 15 seconds, give up on existing connection @@ -1137,14 +1136,15 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, } else if (now > conn->c_connection_start && now - conn->c_connection_start > 15) { rds_rtd_ptr(RDS_RTD_CM, - "RDS/IB: connection <%pI6c,%pI6c,%d> racing for 15s, forcing reset", - &conn->c_laddr, - &conn->c_faddr, - conn->c_tos); + "conn %p <%pI6c,%pI6c,%d> racing for 15s, forcing reset\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); 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 */ + rds_rtd_ptr(RDS_RTD_CM, + "conn %p <%pI6c,%pI6c,%d> racing, wait and see\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); rds_ib_stats_inc(s_ib_connect_raced); } } @@ -1253,9 +1253,11 @@ int rds_ib_cm_initiate_connect(struct rdma_cm_id *cm_id, bool isv6) ret = rds_ib_match_acl(ic->i_cm_id, &conn->c_faddr); if (ret < 0) { - pr_err("RDS: IB: active conn=%p, <%pI6c,%pI6c,%d> destroyed due ACL violation\n", - conn, &conn->c_laddr, &conn->c_faddr, - conn->c_tos); + pr_err("RDS: IB: active conn %p <%pI6c,%pI6c,%d> destroyed due ACL violation\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); + rds_rtd_ptr(RDS_RTD_CM, + "active conn %p <%pI6c,%pI6c,%d> destroyed due ACL violation\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); rds_ib_conn_destroy_init(conn); return 0; } @@ -1272,13 +1274,14 @@ int rds_ib_cm_initiate_connect(struct rdma_cm_id *cm_id, bool isv6) */ atomic_set(&ic->i_credits, IB_SET_POST_CREDITS(ic->i_flowctl)); - pr_debug("RDS/IB: Initiate conn <%pI6c, %pI6c,%d> with Frags : {%d,%d}\n", - &conn->c_laddr, &conn->c_faddr, conn->c_tos, - ib_init_frag_size / SZ_1K, ic->i_frag_sz / SZ_1K); + rds_rtd_ptr(RDS_RTD_CM, + "RDS/IB: Initiate conn %p <%pI6c,%pI6c,%d> with Frags : {%d,%d}\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, + ib_init_frag_size / SZ_1K, ic->i_frag_sz / SZ_1K); ret = rds_ib_setup_qp(conn); if (ret) { - pr_warn("RDS/IB: rds_ib_setup_qp failed (%d)\n", ret); + rds_rtd(RDS_RTD_CM, "RDS/IB: rds_ib_setup_qp failed (%d)\n", ret); rds_conn_drop(conn, DR_IB_ACT_SETUP_QP_FAIL); goto out; } @@ -1290,7 +1293,7 @@ int rds_ib_cm_initiate_connect(struct rdma_cm_id *cm_id, bool isv6) frag, isv6, seq); ret = rdma_connect(cm_id, &conn_param); if (ret) { - pr_warn("RDS/IB: rdma_connect failed (%d)\n", ret); + rds_rtd(RDS_RTD_CM, "RDS/IB: rdma_connect failed (%d)\n", ret); rds_conn_drop(conn, DR_IB_RDMA_CONNECT_FAIL); } @@ -1391,13 +1394,13 @@ void rds_ib_conn_path_shutdown(struct rds_conn_path *cp) struct rds_ib_connection *ic = conn->c_transport_data; int err = 0; - rdsdebug("cm %p pd %p cq %p qp %p\n", ic->i_cm_id, - ic->i_pd, ic->i_rcq, ic->i_cm_id ? ic->i_cm_id->qp : NULL); + rds_rtd_ptr(RDS_RTD_CM_EXT, "conn %p cm_id %p pd %p cq %p qp %p\n", + conn, ic->i_cm_id, ic->i_pd, ic->i_rcq, ic->i_cm_id ? ic->i_cm_id->qp : NULL); if (ic->i_cm_id) { struct ib_device *dev = ic->i_cm_id->device; - rdsdebug("disconnecting cm %p\n", ic->i_cm_id); + rds_rtd_ptr(RDS_RTD_CM_EXT, "disconnecting conn %p cm_id %p\n", conn, ic->i_cm_id); err = rdma_disconnect(ic->i_cm_id); if (err) { /* Actually this may happen quite frequently, when diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c index 65a209d9df1c..d7a68a21b4ac 100644 --- a/net/rds/rdma_transport.c +++ b/net/rds/rdma_transport.c @@ -92,8 +92,20 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, int ret = 0; int *err; - rdsdebug("conn %p id %p handling event %u (%s)\n", conn, cm_id, - event->event, rds_cm_event_str(event->event)); + if (conn) + rds_rtd_ptr(RDS_RTD_CM, + "conn %p state %s cm_id %p <%pI6c,%pI6c,%d> handling event %u (%s) priv_dta_len %d\n", + conn, conn_state_mnem(rds_conn_state(conn)), cm_id, + &conn->c_laddr, &conn->c_faddr, conn->c_tos, + event->event, rds_cm_event_str(event->event), + event->param.conn.private_data_len); + else + rds_rtd(RDS_RTD_CM, + "conn %p cm_id %p handling event %u (%s) priv_dta_len %d\n", + conn, cm_id, + event->event, rds_cm_event_str(event->event), + event->param.conn.private_data_len); + if (cm_id->device->node_type == RDMA_NODE_IB_CA) trans = &rds_ib_transport; @@ -110,6 +122,8 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, * down an existing one. */ if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) ret = 1; + rds_rtd(RDS_RTD_CM, "Bailing, conn %p being shut down, ret: %d\n", + conn, ret); goto out; } } @@ -120,6 +134,11 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, break; case RDMA_CM_EVENT_ADDR_RESOLVED: + rds_rtd_ptr(RDS_RTD_CM, + "conn %p <%pI6c,%pI6c,%d> daddr resolved. dmac %pI6c\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, + cm_id->route.addr.dev_addr.dst_dev_addr + + rdma_addr_gid_offset(&cm_id->route.addr.dev_addr)); rdma_set_service_type(cm_id, conn->c_tos); /* XXX do we need to clean up if this fails? */ @@ -133,8 +152,9 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, if (conn) { struct rds_ib_connection *ibic; - printk(KERN_CRIT "rds dropping connection after rdma_resolve_route failure connection %pI6c->%pI6c\n", - &conn->c_laddr, &conn->c_faddr); + rds_rtd_ptr(RDS_RTD_CM, + "conn %p <%pI6c,%pI6c,%d> dropping connection after rdma_resolve_route failure %d\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, ret); ibic = conn->c_transport_data; if (ibic && ibic->i_cm_id == cm_id) ibic->i_cm_id = NULL; @@ -161,9 +181,15 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, * needs to update the sl manually. As for now, RDS is assuming * that it is a 1:1 in tos to sl mapping. */ + rds_rtd(RDS_RTD_CM, "ibic: %p cm_id: %p\n", ibic->i_cm_id->context, cm_id->context); conn->c_route = 0; cm_id->route.path_rec[0].sl = TOS_TO_SL(conn->c_tos); cm_id->route.path_rec[0].qos_class = conn->c_tos; + rds_rtd_ptr(RDS_RTD_CM, + "conn %p <%pI6c,%pI6c,%d> initiate connect, smac %pI6c dmac %pI6c\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, + cm_id->route.path_rec[0].sgid.raw, + cm_id->route.path_rec[0].dgid.raw); ret = trans->cm_initiate_connect(cm_id, isv6); } else { rds_rtd_ptr(RDS_RTD_CM, @@ -244,10 +270,12 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, } else if (event->status == RDS_REJ_CONSUMER_DEFINED && (*err) == RDS_ACL_FAILURE) { /* Rejection due to ACL violation */ - pr_err("RDS: IB: conn=%p, <%pI6c,%pI6c,%d> destroyed due to ACL violation\n", - conn, &conn->c_laddr, - &conn->c_faddr, - conn->c_tos); + pr_err("RDS: IB: conn %p <%pI6c,%pI6c,%d> destroyed due to ACL violation\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); + + rds_rtd_ptr(RDS_RTD_CM, + "Rejected: active conn %p <%pI6c,%pI6c,%d> destroyed due to ACL violation\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); rds_ib_conn_destroy_init(conn); } else { rds_rtd_ptr(RDS_RTD_ERR, @@ -268,9 +296,8 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, &conn->c_faddr); if (conn) { rds_rtd_ptr(RDS_RTD_CM, - "ADDR_CHANGE: calling rds_conn_drop <%pI6c,%pI6c,%d>\n", - &conn->c_laddr, &conn->c_faddr, - conn->c_tos); + "ADDR_CHANGE: calling rds_conn_drop conn %p <%pI6c,%pI6c,%d>\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); conn->c_reconnect_racing = 0; /* reset route resolution flag */ conn->c_route = 1; @@ -281,8 +308,8 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, case RDMA_CM_EVENT_DISCONNECTED: rds_rtd_ptr(RDS_RTD_CM, - "DISCONNECT event - dropping connection %pI6c->%pI6c tos %d\n", - &conn->c_laddr, &conn->c_faddr, conn->c_tos); + "DISCONNECT event - dropping conn %p <%pI6c,%pI6c,%d>\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); conn->c_reconnect_racing = 0; /* reset route resolution flag */ conn->c_route = 1; @@ -291,8 +318,9 @@ int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id, case RDMA_CM_EVENT_TIMEWAIT_EXIT: if (conn) { - printk(KERN_INFO "TIMEWAIT_EXIT event - dropping connection %pI6c->%pI6c\n", - &conn->c_laddr, &conn->c_faddr); + rds_rtd_ptr(RDS_RTD_CM, + "TIMEWAIT_EXIT event - dropping conn %p <%pI6c,%pI6c,%d>\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); rds_conn_drop(conn, DR_IB_TIMEWAIT_EXIT); } else printk(KERN_INFO "TIMEWAIT_EXIT event - conn=NULL\n"); diff --git a/net/rds/rds.h b/net/rds/rds.h index de7243427ac1..ff2b07850dca 100644 --- a/net/rds/rds.h +++ b/net/rds/rds.h @@ -137,6 +137,22 @@ enum { RDS_CONN_ERROR, }; +static inline const char *conn_state_mnem(int state) +{ +#define CASE_RET(s) case (s): return #s + switch (state) { + CASE_RET(RDS_CONN_DOWN); + CASE_RET(RDS_CONN_CONNECTING); + CASE_RET(RDS_CONN_DISCONNECTING); + CASE_RET(RDS_CONN_UP); + CASE_RET(RDS_CONN_RESETTING); + CASE_RET(RDS_CONN_ERROR); + default: + return "RDS_CONN_UNKNOWN"; + } +#undef CASE_RET +} + /* Bits for c_flags */ #define RDS_LL_SEND_FULL 0 #define RDS_RECONNECT_PENDING 1 diff --git a/net/rds/threads.c b/net/rds/threads.c index 42b1f46b2ea5..3acc78146328 100644 --- a/net/rds/threads.c +++ b/net/rds/threads.c @@ -82,15 +82,16 @@ void rds_connect_path_complete(struct rds_conn_path *cp, int curr) struct rds_connection *conn = cp->cp_conn; if (!rds_conn_path_transition(cp, curr, RDS_CONN_UP)) { - pr_warn("RDS: Cannot transition conn <%pI6c,%pI6c,%d> to state UP, current state is %d\n", - &conn->c_laddr, &conn->c_faddr, conn->c_tos, - atomic_read(&cp->cp_state)); + rds_rtd_ptr(RDS_RTD_CM, + "conn %p <%pI6c,%pI6c,%d> cannot transition to state UP, current state is %s\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, + conn_state_mnem(atomic_read(&cp->cp_state))); rds_conn_path_drop(cp, DR_IB_NOT_CONNECTING_STATE); return; } rds_rtd_ptr(RDS_RTD_CM_EXT, - "conn %p for %pI6c to %pI6c tos %d complete\n", + "conn %p <%pI6c,%pI6c,%d> complete\n", conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); cp->cp_reconnect_jiffies = 0; @@ -138,8 +139,8 @@ void rds_queue_reconnect(struct rds_conn_path *cp) bool is_tcp = conn->c_trans->t_type == RDS_TRANS_TCP; rds_rtd_ptr(RDS_RTD_CM_EXT, - "conn %p for %pI6c to %pI6c tos %d reconnect jiffies %lu\n", - conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, + "conn %p:%d <%pI6c,%pI6c,%d> reconnect jiffies %lu\n", + conn, !!conn->c_passive, &conn->c_laddr, &conn->c_faddr, conn->c_tos, cp->cp_reconnect_jiffies); /* let peer with smaller addr initiate reconnect, to avoid duels */ @@ -154,7 +155,7 @@ void rds_queue_reconnect(struct rds_conn_path *cp) } rds_rtd_ptr(RDS_RTD_CM_EXT, - "delay %lu conn %p for %pI6c -> %pI6c tos %d\n", + "delay %lu conn %p <%pI6c,%pI6c,%d>\n", cp->cp_reconnect_jiffies, conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos); @@ -192,7 +193,7 @@ void rds_connect_worker(struct work_struct *work) ret = conn->c_trans->conn_path_connect(cp); rds_rtd_ptr(RDS_RTD_CM_EXT, - "conn %p for %pI6c to %pI6c tos %d dispatched, ret %d\n", + "conn %p for <%pI6c,%pI6c,%d> dispatched, ret %d\n", conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, ret); @@ -209,8 +210,8 @@ void rds_connect_worker(struct work_struct *work) } } else { rds_rtd(RDS_RTD_CM, - "conn %p cannot trans from DOWN to CONNECTING state.\n", - conn); + "conn %p cannot transition from allegedly DOWN(act %s) to CONNECTING state\n", + conn, conn_state_mnem(atomic_read(&cp->cp_state))); } } @@ -308,8 +309,8 @@ void rds_reconnect_timeout(struct work_struct *work) if (!rds_conn_path_up(cp)) { rds_rtd_ptr(RDS_RTD_CM, - "conn <%pI6c,%pI6c,%d> not up, retry(%d)\n", - &conn->c_laddr, &conn->c_faddr, conn->c_tos, + "conn %p <%pI6c,%pI6c,%d> not up, retry(%d)\n", + conn, &conn->c_laddr, &conn->c_faddr, conn->c_tos, cp->cp_reconnect_retry_count); cp->cp_reconnect_racing = 0; rds_conn_path_drop(cp, DR_RECONNECT_TIMEOUT);