void
print_service(IB_SERVICE_RECORD *service, char *tag, int rc)
{
- char name[32];
+ char name[32];
+ lnet_nid_t nid;
if (service == NULL)
{
}
strncpy (name, service->ServiceName, sizeof(name)-1);
name[sizeof(name)-1] = 0;
+ nid = *kibnal_service_nid_field(service);
CWARN("tag : %s\n"
"status : %d\n"
"service id: "LPX64"\n"
"name : %s\n"
- "NID : "LPX64"\n", tag, rc,
+ "NID : %s\n", tag, rc,
service->RID.ServiceID, name,
- *kibnal_service_nid_field(service));
+ libcfs_nid2str(nid));
}
#endif
fill_fod(fod, FabOpSetServiceRecord);
svc = &fod->Value.ServiceRecordValue.ServiceRecord;
- CDEBUG(D_NET, "Advertising service id "LPX64" %s:"LPX64"\n",
+ CDEBUG(D_NET, "Advertising service id "LPX64" %s:%s\n",
svc->RID.ServiceID,
- svc->ServiceName, *kibnal_service_nid_field(svc));
+ svc->ServiceName,
+ libcfs_nid2str(*kibnal_service_nid_field(svc)));
frc = iibt_sd_port_fabric_operation(kibnal_data.kib_sd,
kibnal_data.kib_port_guid,
NULL, &frc2);
if (frc != FSUCCESS && frc != FPENDING) {
- CERROR ("Immediate error %d advertising NID "LPX64"\n",
- frc, kibnal_data.kib_ni->ni_nid);
+ CERROR ("Immediate error %d advertising NID %s\n",
+ frc, libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
goto out;
}
frc = frc2;
if (frc != FSUCCESS)
- CERROR ("Error %d advertising BUD "LPX64"\n",
- frc, kibnal_data.kib_ni->ni_nid);
+ CERROR ("Error %d advertising BUD %s\n",
+ frc, libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
out:
PORTAL_FREE(fod, sizeof(*fod));
return (frc == FSUCCESS) ? 0 : -EINVAL;
fill_fod(fod, FabOpDeleteServiceRecord);
svc = &fod->Value.ServiceRecordValue.ServiceRecord;
- CDEBUG(D_NET, "Unadvertising service %s:"LPX64"\n",
- svc->ServiceName, *kibnal_service_nid_field(svc));
+ CDEBUG(D_NET, "Unadvertising service %s:%s\n",
+ svc->ServiceName,
+ libcfs_nid2str(*kibnal_service_nid_field(svc)));
frc = iibt_sd_port_fabric_operation(kibnal_data.kib_sd,
kibnal_data.kib_port_guid,
NULL, &frc2);
if (frc != FSUCCESS && frc != FPENDING) {
- CERROR ("Immediate error %d unadvertising NID "LPX64"\n",
- frc, kibnal_data.kib_ni->ni_nid);
+ CERROR ("Immediate error %d unadvertising NID %s\n",
+ frc, libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
goto out;
}
goto out;
if (expect_success)
- CERROR("Error %d unadvertising NID "LPX64"\n",
- frc2, kibnal_data.kib_ni->ni_nid);
+ CERROR("Error %d unadvertising NID %s\n",
+ frc2, libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
else
- CWARN("Removed conflicting NID "LPX64"\n",
- kibnal_data.kib_ni->ni_nid);
+ CWARN("Removed conflicting NID %s\n",
+ libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
out:
PORTAL_FREE(fod, sizeof(*fod));
}
int rc;
FSTATUS frc;
- CDEBUG(D_IOCTL, "setting mynid to "LPX64" (old nid="LPX64")\n",
- nid, kibnal_data.kib_ni->ni_nid);
+ CDEBUG(D_IOCTL, "setting mynid to %s (old nid=%s)\n",
+ libcfs_nid2str(nid),
+ libcfs_nid2str(kibnal_data.kib_ni->ni_nid));
do_gettimeofday(&tv);
return (0);
}
- CDEBUG(D_NET, "NID "LPX64"("LPX64")\n",
- kibnal_data.kib_ni->ni_nid, nid);
+ CDEBUG(D_NET, "NID %s(%s)\n",
+ libcfs_nid2str(kibnal_data.kib_ni->ni_nid),
+ libcfs_nid2str(nid));
if (kibnal_data.kib_ni->ni_nid != LNET_NID_ANY) {
if (peer->ibp_nid != nid)
continue;
- CDEBUG(D_NET, "got peer [%p] -> "LPX64" (%d)\n",
- peer, nid, atomic_read (&peer->ibp_refcount));
+ CDEBUG(D_NET, "got peer [%p] -> %s (%d)\n",
+ peer, libcfs_nid2str(nid),
+ atomic_read (&peer->ibp_refcount));
return (peer);
}
return (NULL);
continue;
conn = list_entry (ctmp, kib_conn_t, ibc_list);
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
read_unlock_irqrestore(&kibnal_data.kib_global_lock,
{
unsigned long flags;
- CDEBUG (D_NET, "putting conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG (D_NET, "putting conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
LASSERT (atomic_read (&conn->ibc_refcount) > 0);
if (conn->ibc_incarnation == incarnation)
continue;
- CDEBUG(D_NET, "Closing stale conn nid:"LPX64" incarnation:"LPX64"("LPX64")\n",
- peer->ibp_nid, conn->ibc_incarnation, incarnation);
+ CDEBUG(D_NET, "Closing stale conn nid:%s incarnation:"LPX64"("LPX64")\n",
+ libcfs_nid2str(peer->ibp_nid),
+ conn->ibc_incarnation, incarnation);
count++;
kibnal_close_conn_locked (conn, -ESTALE);
/* these are purposely avoiding using local vars so they don't increase
* stack consumption. */
-#define kib_peer_addref(peer) do { \
- LASSERTF(atomic_read(&peer->ibp_refcount) > 0, "%d\n", \
- atomic_read(&peer->ibp_refcount)); \
- CDEBUG(D_NET, "++peer[%p] -> "LPX64" (%d)\n", \
- peer, peer->ibp_nid, atomic_read (&peer->ibp_refcount)); \
- atomic_inc(&peer->ibp_refcount); \
+#define kib_peer_addref(peer) do { \
+ LASSERTF(atomic_read(&peer->ibp_refcount) > 0, "%d\n", \
+ atomic_read(&peer->ibp_refcount)); \
+ CDEBUG(D_NET, "++peer[%p] -> %s (%d)\n", \
+ peer, libcfs_nid2str(peer->ibp_nid), \
+ atomic_read (&peer->ibp_refcount)); \
+ atomic_inc(&peer->ibp_refcount); \
} while (0)
-#define kib_peer_decref(peer) do { \
- LASSERTF(atomic_read(&peer->ibp_refcount) > 0, "%d\n", \
- atomic_read(&peer->ibp_refcount)); \
- CDEBUG(D_NET, "--peer[%p] -> "LPX64" (%d)\n", \
- peer, peer->ibp_nid, atomic_read (&peer->ibp_refcount)); \
- if (atomic_dec_and_test (&peer->ibp_refcount)) { \
- CDEBUG (D_NET, "destroying peer "LPX64" %p\n", \
- peer->ibp_nid, peer); \
- kibnal_destroy_peer (peer); \
- } \
+#define kib_peer_decref(peer) do { \
+ LASSERTF(atomic_read(&peer->ibp_refcount) > 0, "%d\n", \
+ atomic_read(&peer->ibp_refcount)); \
+ CDEBUG(D_NET, "--peer[%p] -> %s (%d)\n", \
+ peer, libcfs_nid2str(peer->ibp_nid), \
+ atomic_read (&peer->ibp_refcount)); \
+ if (atomic_dec_and_test (&peer->ibp_refcount)) { \
+ CDEBUG (D_NET, "destroying peer %s %p\n", \
+ libcfs_nid2str(peer->ibp_nid), peer); \
+ kibnal_destroy_peer (peer); \
+ } \
} while (0)
/******************************************************************************/
spin_unlock_irqrestore (&conn->ibc_lock, flags);
- CERROR ("Unmatched (late?) RDMA completion "LPX64" from "LPX64"\n",
- cookie, conn->ibc_peer->ibp_nid);
+ CERROR ("Unmatched (late?) RDMA completion "LPX64" from %s\n",
+ cookie, libcfs_nid2str(conn->ibc_peer->ibp_nid));
}
static __u32
}
if (conn->ibc_state == IBNAL_CONN_ESTABLISHED) {
- CERROR ("Error posting receive -> "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, rc);
+ CERROR ("Error posting receive -> %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
kibnal_close_conn (rx->rx_conn, rc);
} else {
- CDEBUG (D_NET, "Error posting receive -> "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, rc);
+ CDEBUG (D_NET, "Error posting receive -> %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
}
/* Drop rx's ref */
goto failed;
if (wc->Status != WRStatusSuccess) {
- CERROR("Rx from "LPX64" failed: %d\n",
- conn->ibc_peer->ibp_nid, wc->Status);
+ CERROR("Rx from %s failed: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), wc->Status);
goto failed;
}
if (nob < base_nob) {
- CERROR ("Short rx from "LPX64": %d < expected %d\n",
- conn->ibc_peer->ibp_nid, nob, base_nob);
+ CERROR ("Short rx from %s: %d < expected %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
+ nob, base_nob);
goto failed;
}
flipped = 0;
} else {
if (msg->ibm_magic != __swab32(IBNAL_MSG_MAGIC)) {
- CERROR ("Unrecognised magic: %08x from "LPX64"\n",
- msg->ibm_magic, conn->ibc_peer->ibp_nid);
+ CERROR ("Unrecognised magic: %08x from %s\n",
+ msg->ibm_magic,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
goto failed;
}
flipped = 1;
case IBNAL_MSG_IMMEDIATE:
if (nob < base_nob + sizeof (kib_immediate_msg_t)) {
- CERROR ("Short IMMEDIATE from "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, nob);
+ CERROR ("Short IMMEDIATE from %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
+ nob);
goto failed;
}
break;
case IBNAL_MSG_PUT_RDMA:
case IBNAL_MSG_GET_RDMA:
if (nob < base_nob + sizeof (kib_rdma_msg_t)) {
- CERROR ("Short RDMA msg from "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, nob);
+ CERROR ("Short RDMA msg from %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), nob);
goto failed;
}
if (flipped)
case IBNAL_MSG_PUT_DONE:
case IBNAL_MSG_GET_DONE:
if (nob < base_nob + sizeof (kib_completion_msg_t)) {
- CERROR ("Short COMPLETION msg from "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, nob);
+ CERROR ("Short COMPLETION msg from %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), nob);
goto failed;
}
if (flipped)
return;
default:
- CERROR ("Can't parse type from "LPX64": %d\n",
- conn->ibc_peer->ibp_nid, msg->ibm_type);
+ CERROR ("Can't parse type from %s: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), msg->ibm_type);
goto failed;
}
/* Otherwise, I'll send a failed completion now to prevent
* the peer's GET blocking for the full timeout. */
- CERROR ("Completing unmatched RDMA GET from "LPX64"\n",
- rx->rx_conn->ibc_peer->ibp_nid);
+ CERROR ("Completing unmatched RDMA GET from %s\n",
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
kibnal_start_active_rdma (IBNAL_MSG_GET_DONE, -EIO,
rx, NULL, 0, NULL, NULL, 0, 0);
break;
* inconsistent with this message type, so it's the
* sender's fault for sending garbage and she can time
* herself out... */
- CERROR ("Uncompleted RMDA PUT from "LPX64"\n",
- rx->rx_conn->ibc_peer->ibp_nid);
+ CERROR ("Uncompleted RMDA PUT from %s\n",
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
break;
case IBNAL_MSG_IMMEDIATE:
spin_unlock_irqrestore (&conn->ibc_lock, flags);
if (conn->ibc_state == IBNAL_CONN_ESTABLISHED)
- CERROR ("Error %d posting transmit to "LPX64"\n",
- rc, conn->ibc_peer->ibp_nid);
+ CERROR ("Error %d posting transmit to %s\n", rc,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
else
- CDEBUG (D_NET, "Error %d posting transmit to "
- LPX64"\n", rc, conn->ibc_peer->ibp_nid);
+ CDEBUG (D_NET, "Error %d posting transmit to %s\n",
+ rc, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_close_conn (conn, rc);
if (idle)
list_del(&tx->tx_list);
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
kibnal_tx_done (tx);
if (wc->Status != WRStatusSuccess) {
- CERROR ("Tx completion to "LPX64" failed: %d\n",
- conn->ibc_peer->ibp_nid, wc->Status);
+ CERROR ("Tx completion to %s failed: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
+ wc->Status);
kibnal_close_conn (conn, -ENETDOWN);
} else {
/* can I shovel some more sends out the door? */
conn = kibnal_find_conn_locked (peer);
if (conn != NULL) {
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount); /* 1 ref for the tx */
read_unlock_irqrestore(g_lock, flags);
conn = kibnal_find_conn_locked (peer);
if (conn != NULL) {
/* Connection exists; queue message on it */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount); /* 1 ref for the tx */
write_unlock_irqrestore (g_lock, flags);
0, nob, 0);
if (rc != 0) {
- CERROR ("Can't map RDMA for "LPX64": %d\n", nid, rc);
+ CERROR ("Can't map RDMA for %s: %d\n",
+ libcfs_nid2str(nid), rc);
goto failed;
}
tx->tx_ptlmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
nid, ptlmsg);
if (tx->tx_ptlmsg[1] == NULL) {
- CERROR ("Can't create reply for GET -> "LPX64"\n",
- nid);
+ CERROR ("Can't create reply for GET -> %s\n",
+ libcfs_nid2str(nid));
rc = -ENOMEM;
goto failed;
}
tx = kibnal_get_idle_tx (0); /* Mustn't block */
if (tx == NULL) {
- CERROR ("tx descs exhausted on RDMA from "LPX64
+ CERROR ("tx descs exhausted on RDMA from %s"
" completing locally with failure\n",
- rx->rx_conn->ibc_peer->ibp_nid);
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg, -ENOMEM);
return;
}
rc = kibnal_map_iov (tx, access, niov, iov, offset, nob, 1);
if (rc != 0) {
- CERROR ("Can't map RDMA -> "LPX64": %d\n",
- rx->rx_conn->ibc_peer->ibp_nid, rc);
+ CERROR ("Can't map RDMA -> %s: %d\n",
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid), rc);
/* We'll skip the RDMA and complete with failure. */
status = rc;
nob = 0;
}
/* +1 ref for this tx... */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
rx->rx_conn, rx->rx_conn->ibc_state,
- rx->rx_conn->ibc_peer->ibp_nid,
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid),
atomic_read (&rx->rx_conn->ibc_refcount));
atomic_inc (&rx->rx_conn->ibc_refcount);
/* ...and queue it up */
/* Incoming message consistent with immediate reply? */
if (rx->rx_msg->ibm_type != IBNAL_MSG_IMMEDIATE) {
- CERROR ("REPLY to "LPX64" bad opbm type %d!!!\n",
- target.nid, rx->rx_msg->ibm_type);
+ CERROR ("REPLY to %s bad ibm type %d!!!\n",
+ libcfs_nid2str(target.nid),
+ rx->rx_msg->ibm_type);
return (-EIO);
}
/* Will it fit in a message? */
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
if (nob >= IBNAL_MSG_SIZE) {
- CERROR("REPLY for "LPX64" too big (RDMA not requested): %d\n",
- target.nid, payload_nob);
+ CERROR("REPLY for %s too big (RDMA not requested): %d\n",
+ libcfs_nid2str(target.nid), payload_nob);
return (-EIO);
}
break;
type == PTL_MSG_REPLY ||
in_interrupt()));
if (tx == NULL) {
- CERROR ("Can't send %d to "LPX64": tx descs exhausted%s\n",
- type, target.nid, in_interrupt() ? " (intr)" : "");
+ CERROR ("Can't send %d to %s: tx descs exhausted%s\n",
+ type, libcfs_nid2str(target.nid),
+ in_interrupt() ? " (intr)" : "");
return (-ENOMEM);
}
case IBNAL_MSG_IMMEDIATE:
msg_nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
if (msg_nob > IBNAL_MSG_SIZE) {
- CERROR ("Immediate message from "LPX64" too big: %d\n",
- rxmsg->ibm_u.immediate.ibim_hdr.src_nid, rlen);
+ CERROR ("Immediate message from %s too big: %d\n",
+ libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
+ rlen);
return (-EIO);
}
return; /* already disconnecting */
CDEBUG (error == 0 ? D_NET : D_ERROR,
- "closing conn to "LPX64": error %d\n", peer->ibp_nid, error);
+ "closing conn to %s: error %d\n",
+ libcfs_nid2str(peer->ibp_nid), error);
if (conn->ibc_state == IBNAL_CONN_ESTABLISHED) {
/* kib_connd_conns takes ibc_list's ref */
list_del (&conn->ibc_list);
} else {
/* new ref for kib_connd_conns */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
}
write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
if (!list_empty (&zombies))
- CERROR ("Deleting messages for "LPX64": connection failed\n",
- peer->ibp_nid);
+ CERROR ("Deleting messages for %s: connection failed\n",
+ libcfs_nid2str(peer->ibp_nid));
while (!list_empty (&zombies)) {
tx = list_entry (zombies.next, kib_tx_t, tx_list);
/* +1 ref for ibc_list; caller(== CM)'s ref remains until
* the IB_CM_IDLE callback */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
list_add (&conn->ibc_list, &peer->ibp_conns);
list_del (&tx->tx_list);
/* +1 ref for each tx */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
kibnal_queue_tx_locked (tx, conn);
/* queue up all the receives */
for (i = 0; i < IBNAL_RX_MSGS; i++) {
/* +1 ref for rx desc */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
return (-ENOMEM);
if (queue_depth != IBNAL_MSG_QUEUE_SIZE) {
- CERROR("Can't accept "LPX64": bad queue depth %d (%d expected)\n",
- nid, queue_depth, IBNAL_MSG_QUEUE_SIZE);
+ CERROR("Can't accept %s: bad queue depth %d (%d expected)\n",
+ libcfs_nid2str(nid),
+ queue_depth, IBNAL_MSG_QUEUE_SIZE);
atomic_dec (&conn->ibc_refcount);
kibnal_destroy_conn(conn);
return (-EPROTO);
/* assume 'nid' is a new peer */
peer = kibnal_create_peer (nid);
if (peer == NULL) {
- CDEBUG(D_NET, "--conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "--conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_dec (&conn->ibc_refcount);
kibnal_destroy_conn(conn);
wcr = (kib_wire_connreq_t *)info->Info.Reply.PrivateData;
if (wcr->wcr_magic != cpu_to_le32(IBNAL_MSG_MAGIC)) {
- CERROR ("Can't connect "LPX64": bad magic %08x\n",
- conn->ibc_peer->ibp_nid, le32_to_cpu(wcr->wcr_magic));
+ CERROR ("Can't connect %s: bad magic %08x\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
+ le32_to_cpu(wcr->wcr_magic));
GOTO(reject, reason = RC_USER_REJ);
}
if (wcr->wcr_version != cpu_to_le16(IBNAL_MSG_VERSION)) {
- CERROR ("Can't connect "LPX64": bad version %d\n",
- conn->ibc_peer->ibp_nid, le16_to_cpu(wcr->wcr_magic));
+ CERROR ("Can't connect %s: bad version %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
+ le16_to_cpu(wcr->wcr_magic));
GOTO(reject, reason = RC_USER_REJ);
}
if (wcr->wcr_queue_depth != cpu_to_le16(IBNAL_MSG_QUEUE_SIZE)) {
- CERROR ("Can't connect "LPX64": bad queue depth %d\n",
- conn->ibc_peer->ibp_nid,
+ CERROR ("Can't connect %s: bad queue depth %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
le16_to_cpu(wcr->wcr_queue_depth));
GOTO(reject, reason = RC_USER_REJ);
}
if (le64_to_cpu(wcr->wcr_nid) != conn->ibc_peer->ibp_nid) {
- CERROR ("Unexpected NID "LPX64" from "LPX64"\n",
- le64_to_cpu(wcr->wcr_nid), conn->ibc_peer->ibp_nid);
+ CERROR ("Unexpected NID %s from %s\n",
+ libcfs_nid2str(le64_to_cpu(wcr->wcr_nid)),
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
GOTO(reject, reason = RC_USER_REJ);
}
- CDEBUG(D_NET, "Connection %p -> "LPX64" REP_RECEIVED.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_NET, "Connection %p -> %s REP_RECEIVED.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
conn->ibc_incarnation = le64_to_cpu(wcr->wcr_incarnation);
conn->ibc_credits = IBNAL_MSG_QUEUE_SIZE;
ca_attr->MaxQPInitiatorDepth),
rep->StartingPSN);
if (frc != FSUCCESS) {
- CERROR("Connection %p -> "LPX64" QP RTS/RTR failed: %d\n",
- conn, conn->ibc_peer->ibp_nid, frc);
+ CERROR("Connection %p -> %s QP RTS/RTR failed: %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), frc);
GOTO(reject, reason = RC_NO_QP);
}
frc = iibt_cm_accept(cep, &conn->ibc_connreq->cr_discarded,
NULL, NULL, NULL, NULL);
if (frc != FCM_CONNECT_ESTABLISHED) {
- CERROR("Connection %p -> "LPX64" CMAccept failed: %d\n",
- conn, conn->ibc_peer->ibp_nid, frc);
+ CERROR("Connection %p -> %s CMAccept failed: %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), frc);
kibnal_connreq_done (conn, 1, -ECONNABORTED);
/* XXX don't call reject after accept fails? */
return;
}
- CDEBUG(D_NET, "Connection %p -> "LPX64" Established\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_NET, "Connection %p -> %s Established\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done (conn, 1, 0);
return;
/* Established Connection Notifier */
switch (info->Status) {
default:
- CERROR("unknown status %d on Connection %p -> "LPX64"\n",
- info->Status, conn, conn->ibc_peer->ibp_nid);
+ CERROR("unknown status %d on Connection %p -> %s\n",
+ info->Status, conn,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
LBUG();
break;
/* these both guarantee that no more cm callbacks will occur */
case FCM_DISCONNECTED: /* aka FCM_DISCONNECT_TIMEOUT */
case FCM_DISCONNECT_REPLY:
- CDEBUG(D_NET, "Connection %p -> "LPX64" disconnect done.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_NET, "Connection %p -> %s disconnect done.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
conn->ibc_state = IBNAL_CONN_DISCONNECTED;
kibnal_flush_pending(conn);
req = &info->Info.Request;
wcr = (kib_wire_connreq_t *)req->PrivateData;
- CDEBUG(D_NET, "%d from "LPX64"\n", info->Status,
- le64_to_cpu(wcr->wcr_nid));
+ CDEBUG(D_NET, "%d from %s\n", info->Status,
+ libcfs_nid2str(le64_to_cpu(wcr->wcr_nid)));
if (info->Status == FCM_CONNECT_CANCEL)
return;
le64_to_cpu(wcr->wcr_incarnation),
le16_to_cpu(wcr->wcr_queue_depth));
if (rc != 0) {
- CERROR ("Can't accept "LPX64": %d\n",
- le64_to_cpu(wcr->wcr_nid), rc);
+ CERROR ("Can't accept %s: %d\n",
+ libcfs_nid2str(le64_to_cpu(wcr->wcr_nid)), rc);
GOTO(out, reason = RC_NO_RESOURCES);
}
req->CEPInfo.StartingPSN);
if (frc != FSUCCESS) {
- CERROR ("Can't mark QP RTS/RTR "LPX64": %d\n",
- le64_to_cpu(wcr->wcr_nid), frc);
+ CERROR ("Can't mark QP RTS/RTR %s: %d\n",
+ libcfs_nid2str(le64_to_cpu(wcr->wcr_nid)), frc);
GOTO(out, reason = RC_NO_QP);
}
frc = iibt_qp_query(conn->ibc_qp, &conn->ibc_qp_attrs, NULL);
if (frc != FSUCCESS) {
- CERROR ("Couldn't query qp attributes "LPX64": %d\n",
- le64_to_cpu(wcr->wcr_nid), frc);
+ CERROR ("Couldn't query qp attributes %s: %d\n",
+ libcfs_nid2str(le64_to_cpu(wcr->wcr_nid)), frc);
GOTO(out, reason = RC_NO_QP);
}
query = &conn->ibc_qp_attrs;
goto out;
}
- CDEBUG(D_WARNING, "Connection %p -> "LPX64" ESTABLISHED.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_WARNING, "Connection %p -> %s ESTABLISHED.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
out:
if (reason) {
kib_conn_t *conn = arg;
PATH_RESULTS *path;
FSTATUS frc;
+ lnet_nid_t nid;
if (query_res->Status != FSUCCESS || query_res->ResultDataSize == 0) {
CERROR ("status %d data size %d\n", query_res->Status,
/* Flag I'm getting involved with the CM... */
conn->ibc_state = IBNAL_CONN_CONNECTING;
- CDEBUG(D_NET, "Connecting to, service id "LPX64", on "LPX64"\n",
+ nid = *kibnal_service_nid_field(&conn->ibc_connreq->cr_service);
+
+ CDEBUG(D_NET, "Connecting to, service id "LPX64", on %s\n",
conn->ibc_connreq->cr_service.RID.ServiceID,
- *kibnal_service_nid_field(&conn->ibc_connreq->cr_service));
+ libcfs_nid2str(nid));
memset(conn->ibc_connreq->cr_cmreq.PrivateData, 0,
CM_REQUEST_INFO_USER_LEN);
COMMAND_CONTROL_PARAMETERS sd_params;
QUERY path_query;
FSTATUS frc;
+ lnet_nid_t nid;
if (query_res->Status != FSUCCESS || query_res->ResultDataSize == 0) {
CERROR ("status %d data size %d\n", query_res->Status,
dump_service_records(svc);
conn->ibc_connreq->cr_service = svc->ServiceRecords[0];
-
- CDEBUG(D_NET, "Got status %d, service id "LPX64", on "LPX64"\n",
+ nid = *kibnal_service_nid_field(&conn->ibc_connreq->cr_service);
+
+ CDEBUG(D_NET, "Got status %d, service id "LPX64", on %s\n",
query_res->Status , conn->ibc_connreq->cr_service.RID.ServiceID,
- *kibnal_service_nid_field(&conn->ibc_connreq->cr_service));
+ libcfs_nid2str(nid));
memset(&path_query, 0, sizeof(path_query));
path_query.InputType = InputTypePortGuidPair;
if (!kibnal_conn_timed_out(conn))
continue;
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
read_unlock_irqrestore(&kibnal_data.kib_global_lock,
flags);
- CERROR("Timed out RDMA with "LPX64"\n",
- peer->ibp_nid);
+ CERROR("Timed out RDMA with %s\n",
+ libcfs_nid2str(peer->ibp_nid));
kibnal_close_conn (conn, -ETIMEDOUT);
kibnal_put_conn (conn);
kibnal_tx_done (tx);
if (e->status != IB_COMPLETION_STATUS_SUCCESS) {
- CERROR ("Tx completion to "LPX64" failed: %d\n",
- conn->ibc_peer->ibp_nid, e->status);
+ CERROR ("Tx completion to %s failed: %d\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid), e->status);
kibnal_close_conn (conn, -ENETDOWN);
} else {
/* can I shovel some more sends out the door? */
conn = kibnal_find_conn_locked (peer);
if (conn != NULL) {
/* Connection exists; queue message on it */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount); /* 1 ref for the tx */
write_unlock_irqrestore (g_lock, flags);
0, nob);
if (rc != 0) {
- CERROR ("Can't map RDMA for "LPX64": %d\n", nid, rc);
+ CERROR ("Can't map RDMA for %s: %d\n",
+ libcfs_nid2str(nid), rc);
goto failed;
}
tx->tx_ptlmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
nid, ptlmsg);
if (tx->tx_ptlmsg[1] == NULL) {
- CERROR ("Can't create reply for GET -> "LPX64"\n",
- nid);
+ CERROR ("Can't create reply for GET -> %s\n",
+ libcfs_nid2str(nid));
rc = -ENOMEM;
goto failed;
}
tx = kibnal_get_idle_tx (0); /* Mustn't block */
if (tx == NULL) {
- CERROR ("tx descs exhausted on RDMA from "LPX64
+ CERROR ("tx descs exhausted on RDMA from %s"
" completing locally with failure\n",
- rx->rx_conn->ibc_peer->ibp_nid);
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg, -ENOMEM);
return;
}
niov, iov, offset, nob);
if (rc != 0) {
- CERROR ("Can't map RDMA -> "LPX64": %d\n",
- rx->rx_conn->ibc_peer->ibp_nid, rc);
+ CERROR ("Can't map RDMA -> %s: %d\n",
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid),
+ rc);
/* We'll skip the RDMA and complete with failure. */
status = rc;
nob = 0;
}
/* +1 ref for this tx... */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
rx->rx_conn, rx->rx_conn->ibc_state,
- rx->rx_conn->ibc_peer->ibp_nid,
+ libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid),
atomic_read (&rx->rx_conn->ibc_refcount));
atomic_inc (&rx->rx_conn->ibc_refcount);
/* ...and queue it up */
/* Incoming message consistent with immediate reply? */
if (rx->rx_msg->ibm_type != IBNAL_MSG_IMMEDIATE) {
- CERROR ("REPLY to "LPX64" bad opbm type %d!!!\n",
- target.nid, rx->rx_msg->ibm_type);
+ CERROR ("REPLY to %s bad opbm type %d!!!\n",
+ libcfs_nid2str(target.nid),
+ rx->rx_msg->ibm_type);
return (-EIO);
}
/* Will it fit in a message? */
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
if (nob > IBNAL_MSG_SIZE) {
- CERROR("REPLY for "LPX64" too big (RDMA not requested): %d\n",
- target.nid, payload_nob);
+ CERROR("REPLY for %s too big (RDMA not requested): %d\n",
+ libcfs_nid2str(target.nid), payload_nob);
return (-EIO);
}
break;
type == PTL_MSG_REPLY ||
in_interrupt()));
if (tx == NULL) {
- CERROR ("Can't send %d to "LPX64": tx descs exhausted%s\n",
- type, target.nid, in_interrupt() ? " (intr)" : "");
+ CERROR ("Can't send %d to %s: tx descs exhausted%s\n",
+ type, libcfs_nid2str(target.nid),
+ in_interrupt() ? " (intr)" : "");
return (-ENOMEM);
}
case IBNAL_MSG_IMMEDIATE:
msg_nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
if (msg_nob > IBNAL_MSG_SIZE) {
- CERROR ("Immediate message from "LPX64" too big: %d\n",
- rxmsg->ibm_u.immediate.ibim_hdr.src_nid, rlen);
+ CERROR ("Immediate message from %s too big: %d\n",
+ libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
+ rlen);
return (-EIO);
}
kib_peer_t *peer = conn->ibc_peer;
CDEBUG (error == 0 ? D_NET : D_ERROR,
- "closing conn to "LPX64": error %d\n", peer->ibp_nid, error);
+ "closing conn to %s: error %d\n",
+ libcfs_nid2str(peer->ibp_nid), error);
LASSERT (conn->ibc_state == IBNAL_CONN_ESTABLISHED ||
conn->ibc_state == IBNAL_CONN_CONNECTING);
list_del (&conn->ibc_list);
} else {
/* new ref for kib_reaper_conns */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
}
write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
if (!list_empty (&zombies))
- CERROR ("Deleting messages for "LPX64": connection failed\n",
- peer->ibp_nid);
+ CERROR ("Deleting messages for %s: connection failed\n",
+ libcfs_nid2str(peer->ibp_nid));
while (!list_empty (&zombies)) {
tx = list_entry (zombies.next, kib_tx_t, tx_list);
/* +1 ref for ibc_list; caller(== CM)'s ref remains until
* the IB_CM_IDLE callback */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
list_add (&conn->ibc_list, &peer->ibp_conns);
list_del (&tx->tx_list);
/* +1 ref for each tx */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
kibnal_queue_tx_locked (tx, conn);
/* queue up all the receives */
for (i = 0; i < IBNAL_RX_MSGS; i++) {
/* +1 ref for rx desc */
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
return -EPROTO;
}
- CDEBUG(D_NET, "connreq from "LPX64"\n", msg->ibm_srcnid);
+ CDEBUG(D_NET, "connreq from %s\n", libcfs_nid2str(msg->ibm_srcnid));
if (msg->ibm_type != IBNAL_MSG_CONNREQ) {
- CERROR("Unexpected connreq msg type: %x from "LPX64"\n",
- msg->ibm_type, msg->ibm_srcnid);
+ CERROR("Unexpected connreq msg type: %x from %s\n",
+ msg->ibm_type, libcfs_nid2str(msg->ibm_srcnid));
return -EPROTO;
}
if (msg->ibm_u.connparams.ibcp_queue_depth != IBNAL_MSG_QUEUE_SIZE) {
- CERROR("Can't accept "LPX64": bad queue depth %d (%d expected)\n",
- msg->ibm_srcnid, msg->ibm_u.connparams.ibcp_queue_depth,
+ CERROR("Can't accept %s: bad queue depth %d (%d expected)\n",
+ libcfs_nid2str(msg->ibm_srcnid),
+ msg->ibm_u.connparams.ibcp_queue_depth,
IBNAL_MSG_QUEUE_SIZE);
return (-EPROTO);
}
/* assume 'nid' is a new peer */
rc = kibnal_create_peer(&peer, msg->ibm_srcnid);
if (rc != 0) {
- CDEBUG(D_NET, "--conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, conn->ibc_peer->ibp_nid,
+ CDEBUG(D_NET, "--conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_dec (&conn->ibc_refcount);
kibnal_destroy_conn(conn);
msg->ibm_dststamp != kibnal_data.kib_incarnation) {
write_unlock_irqrestore (&kibnal_data.kib_global_lock, flags);
- CERROR("Stale connection params from "LPX64"\n",
- msg->ibm_srcnid);
+ CERROR("Stale connection params from %s\n",
+ libcfs_nid2str(msg->ibm_srcnid));
atomic_dec(&conn->ibc_refcount);
kibnal_destroy_conn(conn);
kibnal_put_peer(peer);
switch (event) {
default:
- CERROR("Connection %p -> "LPX64" ERROR %d\n",
- conn, conn->ibc_peer->ibp_nid, event);
+ CERROR("Connection %p -> %s ERROR %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), event);
kibnal_close_conn (conn, -ECONNABORTED);
break;
case TS_IB_CM_DISCONNECTED:
- CDEBUG(D_WARNING, "Connection %p -> "LPX64" DISCONNECTED.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_WARNING, "Connection %p -> %s DISCONNECTED.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_close_conn (conn, 0);
break;
case TS_IB_CM_IDLE:
- CDEBUG(D_NET, "Connection %p -> "LPX64" IDLE.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_NET, "Connection %p -> %s IDLE.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
/* LASSERT (no further callbacks) */
rc = tsIbCmCallbackModify(cid, kibnal_bad_conn_callback, conn);
return TS_IB_CM_CALLBACK_ABORT;
}
- CERROR ("%s event %p -> "LPX64": %d\n",
+ CERROR ("%s event %p -> %s: %d\n",
(event == TS_IB_CM_IDLE) ? "IDLE" : "Unexpected",
- conn, conn->ibc_peer->ibp_nid, event);
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), event);
kibnal_connreq_done(conn, -ECONNABORTED);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
LASSERT (conn == NULL);
/* Don't really know srcnid until successful unpack */
- CDEBUG(D_NET, "REQ from ?"LPX64"?\n", msg->ibm_srcnid);
+ CDEBUG(D_NET, "REQ from ?%s?\n", libcfs_nid2str(msg->ibm_srcnid));
rc = kibnal_accept_connreq(&conn, cid, msg,
req->remote_private_data_len);
if (rc != 0) {
- CERROR ("Can't accept ?"LPX64"?: %d\n",
- msg->ibm_srcnid, rc);
+ CERROR ("Can't accept ?%s?: %d\n",
+ libcfs_nid2str(msg->ibm_srcnid), rc);
return TS_IB_CM_CALLBACK_ABORT;
}
case TS_IB_CM_ESTABLISHED:
LASSERT (conn != NULL);
- CDEBUG(D_WARNING, "Connection %p -> "LPX64" ESTABLISHED.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_WARNING, "Connection %p -> %s ESTABLISHED.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, 0);
return TS_IB_CM_CALLBACK_PROCEED;
rc = kibnal_unpack_msg(msg, nob);
if (rc != 0) {
- CERROR ("Error %d unpacking conn ack from "LPX64"\n",
- rc, conn->ibc_peer->ibp_nid);
+ CERROR ("Error %d unpacking conn ack from %s\n",
+ rc, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, rc);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
}
if (msg->ibm_type != IBNAL_MSG_CONNACK) {
- CERROR ("Unexpected conn ack type %d from "LPX64"\n",
- msg->ibm_type, conn->ibc_peer->ibp_nid);
+ CERROR ("Unexpected conn ack type %d from %s\n",
+ msg->ibm_type,
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, -EPROTO);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
msg->ibm_dstnid) ||
msg->ibm_srcstamp != conn->ibc_incarnation ||
msg->ibm_dststamp != kibnal_data.kib_incarnation) {
- CERROR("Stale conn ack from "LPX64"\n",
- conn->ibc_peer->ibp_nid);
+ CERROR("Stale conn ack from %s\n",
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, -ESTALE);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
}
if (msg->ibm_u.connparams.ibcp_queue_depth != IBNAL_MSG_QUEUE_SIZE) {
- CERROR ("Bad queue depth %d from "LPX64"\n",
+ CERROR ("Bad queue depth %d from %s\n",
msg->ibm_u.connparams.ibcp_queue_depth,
- conn->ibc_peer->ibp_nid);
+ libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, -EPROTO);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
}
- CDEBUG(D_NET, "Connection %p -> "LPX64" REP_RECEIVED.\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_NET, "Connection %p -> %s REP_RECEIVED.\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
conn->ibc_credits = IBNAL_MSG_QUEUE_SIZE;
return TS_IB_CM_CALLBACK_PROCEED;
}
case TS_IB_CM_ESTABLISHED:
- CDEBUG(D_WARNING, "Connection %p -> "LPX64" ESTABLISHED\n",
- conn, conn->ibc_peer->ibp_nid);
+ CDEBUG(D_WARNING, "Connection %p -> %s ESTABLISHED\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
kibnal_connreq_done(conn, 0);
return TS_IB_CM_CALLBACK_PROCEED;
case TS_IB_CM_IDLE:
- CERROR("Connection %p -> "LPX64" IDLE\n",
- conn, conn->ibc_peer->ibp_nid);
+ CERROR("Connection %p -> %s IDLE\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
/* I assume this connection attempt was rejected because the
* peer found a stale QP; I'll just try again */
write_lock_irqsave(&kibnal_data.kib_global_lock, flags);
return TS_IB_CM_CALLBACK_ABORT;
default:
- CERROR("Connection %p -> "LPX64" ERROR %d\n",
- conn, conn->ibc_peer->ibp_nid, event);
+ CERROR("Connection %p -> %s ERROR %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), event);
kibnal_connreq_done(conn, -ECONNABORTED);
kibnal_put_conn(conn); /* drop CM's ref */
return TS_IB_CM_CALLBACK_ABORT;
kib_msg_t *msg = &conn->ibc_connreq->cr_msg;
if (status != 0) {
- CERROR ("Pathreq %p -> "LPX64" failed: %d\n",
- conn, conn->ibc_peer->ibp_nid, status);
+ CERROR ("Pathreq %p -> %s failed: %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), status);
kibnal_connreq_done(conn, status);
kibnal_put_conn(conn); /* drop callback's ref */
return 1; /* non-zero prevents further callbacks */
/* Flag I'm getting involved with the CM... */
conn->ibc_state = IBNAL_CONN_CONNECTING;
- CDEBUG(D_NET, "Connecting to, service id "LPX64", on "LPX64"\n",
- conn->ibc_connreq->cr_svcrsp.ibsr_svc_id, peer->ibp_nid);
+ CDEBUG(D_NET, "Connecting to, service id "LPX64", on %s\n",
+ conn->ibc_connreq->cr_svcrsp.ibsr_svc_id,
+ libcfs_nid2str(peer->ibp_nid));
/* kibnal_connect_callback gets my conn ref */
status = ib_cm_connect (&conn->ibc_connreq->cr_connparam,
kibnal_active_conn_callback, conn,
&conn->ibc_comm_id);
if (status != 0) {
- CERROR ("Connect %p -> "LPX64" failed: %d\n",
- conn, conn->ibc_peer->ibp_nid, status);
+ CERROR ("Connect %p -> %s failed: %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), status);
/* Back out state change: I've not got a CM comm_id yet... */
conn->ibc_state = IBNAL_CONN_INIT_QP;
kibnal_connreq_done(conn, status);
if (rc == 0)
return; /* callback now has my ref on conn */
- CERROR ("Path record request %p -> "LPX64" failed: %d\n",
- conn, conn->ibc_peer->ibp_nid, rc);
+ CERROR ("Path record request %p -> %s failed: %d\n",
+ conn, libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
kibnal_connreq_done(conn, rc);
kibnal_put_conn(conn); /* drop my ref */
}
if (!kibnal_conn_timed_out(conn))
continue;
- CDEBUG(D_NET, "++conn[%p] state %d -> "LPX64" (%d)\n",
- conn, conn->ibc_state, peer->ibp_nid,
+ CDEBUG(D_NET, "++conn[%p] state %d -> %s (%d)\n",
+ conn, conn->ibc_state,
+ libcfs_nid2str(peer->ibp_nid),
atomic_read (&conn->ibc_refcount));
atomic_inc (&conn->ibc_refcount);
read_unlock_irqrestore(&kibnal_data.kib_global_lock,
flags);
- CERROR("Timed out RDMA with "LPX64"\n",
- peer->ibp_nid);
+ CERROR("Timed out RDMA with %s\n",
+ libcfs_nid2str(peer->ibp_nid));
kibnal_close_conn (conn, -ETIMEDOUT);
kibnal_put_conn (conn);
rc = ib_cm_disconnect (conn->ibc_comm_id);
if (rc != 0)
- CERROR ("Error %d disconnecting conn %p -> "LPX64"\n",
- rc, conn, conn->ibc_peer->ibp_nid);
+ CERROR ("Error %d disconnecting conn %p -> %s\n",
+ rc, conn, libcfs_nid2str(conn->ibc_peer->ibp_nid));
}
int
static inline void
kranal_peer_addref(kra_peer_t *peer)
{
- CDEBUG(D_NET, "%p->"LPX64"\n", peer, peer->rap_nid);
+ CDEBUG(D_NET, "%p->%s\n", peer, libcfs_nid2str(peer->rap_nid));
LASSERT(atomic_read(&peer->rap_refcount) > 0);
atomic_inc(&peer->rap_refcount);
}
static inline void
kranal_peer_decref(kra_peer_t *peer)
{
- CDEBUG(D_NET, "%p->"LPX64"\n", peer, peer->rap_nid);
+ CDEBUG(D_NET, "%p->%s\n", peer, libcfs_nid2str(peer->rap_nid));
LASSERT(atomic_read(&peer->rap_refcount) > 0);
if (atomic_dec_and_test(&peer->rap_refcount))
kranal_destroy_peer(peer);
static inline void
kranal_conn_addref(kra_conn_t *conn)
{
- CDEBUG(D_NET, "%p->"LPX64"\n", conn, conn->rac_peer->rap_nid);
+ CDEBUG(D_NET, "%p->%s\n", conn,
+ libcfs_nid2str(conn->rac_peer->rap_nid));
LASSERT(atomic_read(&conn->rac_refcount) > 0);
atomic_inc(&conn->rac_refcount);
}
static inline void
kranal_conn_decref(kra_conn_t *conn)
{
- CDEBUG(D_NET, "%p->"LPX64"\n", conn, conn->rac_peer->rap_nid);
+ CDEBUG(D_NET, "%p->%s\n", conn,
+ libcfs_nid2str(conn->rac_peer->rap_nid));
LASSERT(atomic_read(&conn->rac_refcount) > 0);
if (atomic_dec_and_test(&conn->rac_refcount))
kranal_destroy_conn(conn);
#define kibnal_peer_addref(peer) \
do { \
- CDEBUG(D_NET, "peer[%p] -> "LPX64" (%d)++\n", \
- (peer), (peer)->ibp_nid, \
+ CDEBUG(D_NET, "peer[%p] -> %s (%d)++\n", \
+ (peer), libcfs_nid2str((peer)->ibp_nid), \
atomic_read (&(peer)->ibp_refcount)); \
LASSERT(atomic_read(&(peer)->ibp_refcount) > 0); \
atomic_inc(&(peer)->ibp_refcount); \
#define kibnal_peer_decref(peer) \
do { \
- CDEBUG(D_NET, "peer[%p] -> "LPX64" (%d)--\n", \
- (peer), (peer)->ibp_nid, \
+ CDEBUG(D_NET, "peer[%p] -> %s (%d)--\n", \
+ (peer), libcfs_nid2str((peer)->ibp_nid), \
atomic_read (&(peer)->ibp_refcount)); \
LASSERT(atomic_read(&(peer)->ibp_refcount) > 0); \
if (atomic_dec_and_test(&(peer)->ibp_refcount)) \
extern void (kping_client)(struct portal_ioctl_data *);
void (*ping)(struct portal_ioctl_data *);
- CDEBUG(D_IOCTL, "doing %d pings to nid "LPX64" (%s)\n",
- data->ioc_count, data->ioc_nid,
+ CDEBUG(D_IOCTL, "doing %d pings to nid %s (%s)\n",
+ data->ioc_count, libcfs_nid2str(data->ioc_nid),
libcfs_nid2str(data->ioc_nid));
ping = PORTAL_SYMBOL_GET(kping_client);
if (!ping)
msg->msg_ev.initiator, NULL, 0, 0);
if (rc != 0) {
/* send failed: there's nothing else to clean up. */
- CERROR("Error %d sending ACK to "LPX64"\n",
- rc, msg->msg_ev.initiator.nid);
+ CERROR("Error %d sending ACK to %s\n",
+ rc, libcfs_id2str(msg->msg_ev.initiator));
}
}
atomic_read (&ge2->kpge_weight)) & significant_bits;
int rc = (diff > (significant_bits >> 1));
- CDEBUG(D_NET, "[%p]"LPX64"=%d %s [%p]"LPX64"=%d\n",
- ge1, ge1->kpge_nid, atomic_read (&ge1->kpge_weight),
+ CDEBUG(D_NET, "[%p]%s=%d %s [%p]%s=%d\n",
+ ge1, libcfs_nid2str(ge1->kpge_nid),
+ atomic_read (&ge1->kpge_weight),
rc ? ">" : "<",
- ge2, ge2->kpge_nid, atomic_read (&ge2->kpge_weight));
+ ge2, libcfs_nid2str(ge2->kpge_nid),
+ atomic_read (&ge2->kpge_weight));
return (rc);
}
* rounded and scaled to the portals header size, so we get better
* use of the significant bits in kpge_weight. */
- CDEBUG(D_NET, "gateway [%p]"LPX64" += %d\n", ge,
- ge->kpge_nid, weight);
+ CDEBUG(D_NET, "gateway [%p]%s += %d\n", ge,
+ libcfs_nid2str(ge->kpge_nid), weight);
atomic_add (weight, &ge->kpge_weight);
}
/* Return the NID I must send to, to reach 'target_nid' */
- CDEBUG (D_NET, "lookup "LPX64" from %s\n", target_nid,
+ CDEBUG (D_NET, "lookup %s from %s\n", libcfs_nid2str(target_nid),
(ni == NULL) ? "<>" : libcfs_nid2str(ni->ni_nid));
if (ni == NULL) { /* ni not determined yet */
client->size = args->ioc_u32[0];
client->timeout = args->ioc_u32[1];
- CDEBUG (D_OTHER, "pingcli_setup args: nid "LPX64" (%s), \
+ CDEBUG (D_OTHER, "pingcli_setup args: nid %s (%s), \
size %u, count: %u, timeout: %u\n",
- client->nid,
+ libcfs_nid2str(client->nid),
libcfs_nid2str(client->nid),
client->size, client->count, client->timeout);
}
server->evnt = *ev;
- CWARN ("received ping from nid "LPX64" "
+ CWARN ("received ping from nid %s "
"(off=%u rlen=%u mlen=%u head=%x seq=%d size=%d)\n",
- ev->initiator.nid, ev->offset, ev->rlength, ev->mlength,
+ libcfs_nid2str(ev->initiator.nid),
+ ev->offset, ev->rlength, ev->mlength,
__le32_to_cpu(*((int *)(ev->md.start + ev->offset))),
__le32_to_cpu(*((int *)(ev->md.start + ev->offset + sizeof(unsigned)))),
__le32_to_cpu(*((int *)(ev->md.start + ev->offset + 2 *
client->size = args->ioc_u32[0];
client->timeout = args->ioc_u32[1];
- CDEBUG (D_OTHER, "pingcli_setup args: nid "LPX64" (%s), "
+ CDEBUG (D_OTHER, "pingcli_setup args: nid %s (%s), "
"size %u, count: %u, timeout: %u\n",
- client->nid,
+ libcfs_nid2str(client->nid),
libcfs_nid2str(client->nid),
client->size, client->count, client->timeout);
}
server->evnt = *ev;
- CWARN("Lustre: received ping from nid "LPX64" "
+ CWARN("Lustre: received ping from %s "
"(off=%u rlen=%u mlen=%u head=%x)\n",
- ev->initiator.nid, ev->offset, ev->rlength, ev->mlength,
+ libcfs_id2str(ev->initiator),
+ ev->offset, ev->rlength, ev->mlength,
*((int *)(ev->md.start + ev->offset)));
packets_valid++;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff