}
#define mcm_time_ms() (mcm_time_us() / 1000)
+/* logging levels:
+ * 0=errors
+ * 1=warnings
+ * 2=cm
+ * 4=data
+ * 8=info
+ */
#define mlog(level, format, ...) \
mpxy_write(level, "%s: "format, __func__, ## __VA_ARGS__)
va_list args;
struct timeval tv;
- if (level > log_level)
+ if (level && !(level & log_level))
return;
gettimeofday(&tv, NULL);
{
int ret, i;
- mlog(1, " sleep, fds=%d\n", set->index);
+ mlog(8, " sleep, fds=%d\n", set->index);
ret = poll(set->set, set->index, time_ms);
if (ret > 0) {
for (i=0;i<set->index;i++) {
- mlog(1, " wakeup, set[%d].fd %d = %d\n", i, set->set[i].fd, set->set[i].revents);
+ mlog(8, " wakeup, set[%d].fd %d = %d\n", i, set->set[i].fd, set->set[i].revents);
}
}
return ret;
opts = fcntl(fd, F_GETFL);
if (opts < 0 || fcntl(fd, F_SETFL, opts | O_NONBLOCK) < 0) {
- mlog(1, "fcntl on fd %d ERR %d %s\n", fd, opts, strerror(errno));
+ mlog(8, "fcntl on fd %d ERR %d %s\n", fd, opts, strerror(errno));
return errno;
}
return 0;
if (!strcasecmp("log_file", opt))
strcpy(log_file, value);
else if (!strcasecmp("log_level", opt))
- log_level = atoi(value);
+ log_level = strtol(value,NULL,0);
else if (!strcasecmp("lock_file", opt))
strcpy(lock_file, value);
else if (!strcasecmp("max_message_mb", opt))
int ret;
while (len) {
- mlog(2, " scif_send - ep %d, len=%d \n", ep, len);
+ mlog(8, " scif_send - ep %d, len=%d \n", ep, len);
ret = scif_send(ep, msg, len, SCIF_SEND_BLOCK);
- mlog(2, " scif_sent - ep %d, len=%d \n", ep, len);
+ mlog(8, " scif_sent - ep %d, len=%d \n", ep, len);
if (ret == -1) {
- mlog(0, " ERR: scif_send - ep %d, %s, len=%d \n",
- ep, strerror(errno), len);
+ mlog(0, " %s ERR: scif_send - ep %d, %s, len=%d \n",
+ __func__, ep, strerror(errno), len);
return -1;
}
if (ret < len) {
ret = scif_get_nodeIDs(NULL, 0, &scif_id.node);
if (ret < 0) {
- mlog(1, "scif_get_nodeIDs() failed with error %d\n", strerror(errno));
+ mlog(0, "scif_get_nodeIDs() failed with error %d\n", strerror(errno));
return -1;
}
- mlog(1," SCIF node_id: %d, scif node count =%d\n", (uint16_t)scif_id.node, ret);
+ mlog(8," SCIF node_id: %d, scif node count =%d\n", (uint16_t)scif_id.node, ret);
if (scif_id.node != 0) {
- mlog(1,"ERROR scif node_id must be 0, get_nodeID = %d\n", (uint16_t)scif_id.node);
+ mlog(0,"ERROR scif node_id must be 0, get_nodeID = %d\n", (uint16_t)scif_id.node);
return -1;
}
mlog(0, "scif_open() failed with error %s\n", strerror(errno));
return -1;
}
- mlog(1,"Opened SCIF endpoint for OPERATIONS listening, ep = %d\n", scif_listen_ep);
+ mlog(8,"Opened SCIF endpoint for OPERATIONS listening, ep = %d\n", scif_listen_ep);
ret = scif_bind(scif_listen_ep, scif_sport);
if (ret < 0) {
qp_attr.qp_state = IBV_QP_STATE;
qp_attr.ah_attr.dlid = lid;
if (gid != NULL) {
- mlog(2, "create_ah: with GID\n");
+ mlog(8, "create_ah: with GID\n");
qp_attr.ah_attr.is_global = 1;
qp_attr.ah_attr.grh.dgid.global.subnet_prefix =
ntohll(gid->global.subnet_prefix);
qp_attr.ah_attr.src_path_bits = 0;
qp_attr.ah_attr.port_num = md->port;
- mlog(1, "create_ah: port %x lid %x pd %p ctx %p handle 0x%x\n",
+ mlog(8, "create_ah: port %x lid %x pd %p ctx %p handle 0x%x\n",
md->port, qp_attr.ah_attr.dlid, pd, pd->context, pd->handle);
/* UD: create AH for remote side */
return NULL;
}
- mlog(1, "create_ah: AH %p for lid %x\n", ah, qp_attr.ah_attr.dlid);
+ mlog(8, "create_ah: AH %p for lid %x\n", ah, qp_attr.ah_attr.dlid);
return ah;
}
switch (qp_state) {
case IBV_QPS_RTR:
- mlog(1, " QPS_RTR: l_qpn %x type %d r_qpn 0x%x gid %p (%d) lid 0x%x"
+ mlog(8, " QPS_RTR: l_qpn %x type %d r_qpn 0x%x gid %p (%d) lid 0x%x"
" port %d ep %p qp_state %d \n",
qp_handle->qp_num, qp_handle->qp_type,
ntohl(qpn), gid, m_qp->smd->md->dev_attr.global,
qp_attr.rnr_retry = m_qp->smd->md->dev_attr.rnr_retry;
qp_attr.max_rd_atomic = 4;
- mlog(1, " QPS_RTS: psn %x rd_atomic %d ack %d "
+ mlog(8, " QPS_RTS: psn %x rd_atomic %d ack %d "
" retry %d rnr_retry %d qpn %x qp_state %d\n",
qp_attr.sq_psn, qp_attr.max_rd_atomic,
qp_attr.timeout, qp_attr.retry_cnt,
qp_attr.port_num = m_qp->smd->md->port;
qp_attr.qkey = 0;
- mlog(1, " QPS_INIT: pi %x port %x acc %x qkey 0x%x\n",
+ mlog(8, " QPS_INIT: pi %x port %x acc %x qkey 0x%x\n",
qp_attr.pkey_index, qp_attr.port_num,
qp_attr.qp_access_flags, qp_attr.qkey);
break;
cm->msg.saddr.lid = smd->md->addr.lid;
memcpy(&cm->msg.saddr.gid[0], &smd->md->addr.gid, 16);
- mlog(1, " SRC: QPt qpn 0x%x, lid 0x%x, QPr qpn 0x%x,"
+ mlog(8, " SRC: QPt qpn 0x%x, lid 0x%x, QPr qpn 0x%x,"
" lid 0x%x UCM: qpn 0x%x port=0x%x\n",
cm->m_qp->qp_t.qp_num, ntohs(cm->msg.saddr2.lid),
cm->m_qp->qp_r.qp_num, ntohs(cm->msg.saddr.lid),
struct ibv_sge sge;
int i, mlen = 256; /* overhead for mcm_msg & ibv_grh */
- mlog(1, " create CM services.. %p\n", md);
+ mlog(8, " create CM services.. %p\n", md);
/* setup CM msg attributes and timers */
md->retries = mcm_retry;
/* get gid for this hca-port, in network order */
if (ibv_query_gid(md->ibctx, md->port, 0, (union ibv_gid *)&md->addr.gid)) {
- mlog(1, " query GID ERR for %s, err=%s\n",
+ mlog(0, " query GID ERR for %s, err=%s\n",
ibv_get_device_name(md->ibdev),
strerror(errno));
goto bail;
}
- mlog(1, " IB LID 0x%x GID %s\n", ntohs(md->addr.lid),
+ mlog(8, " IB LID 0x%x GID %s\n", ntohs(md->addr.lid),
inet_ntop(AF_INET6, md->addr.gid, gid_str, sizeof(gid_str)));
/* setup CM timers and queue sizes */
if (!md->pd)
goto bail;
- mlog(1, " allocated PD\n");
+ mlog(8, " allocated PD\n");
md->rch = ibv_create_comp_channel(md->ibctx);
if (!md->rch)
goto bail;
config_fd(md->rch->fd);
- mlog(1, " allocated rx completion channel\n");
+ mlog(8, " allocated rx completion channel\n");
md->scq = ibv_create_cq(md->ibctx, md->cqe, md, NULL, 0);
if (!md->scq)
if (!md->rcq)
goto bail;
- mlog(1, " created CQ\n");
+ mlog(8, " created CQ\n");
if(ibv_req_notify_cq(md->rcq, 0))
goto bail;
if (!md->qp)
goto bail;
- mlog(1, " created QP, qp_num = 0x%x\n", md->qp->qp_num);
+ mlog(8, " created QP, qp_num = 0x%x\n", md->qp->qp_num);
/* local addr info in network order */
md->addr.port = htons(md->port);
if (!md->mr_rbuf)
goto bail;
- mlog(1, " registered TX and RX CM message pools \n");
+ mlog(8, " registered TX and RX CM message pools \n");
/* modify UD QP: init, rtr, rts */
if ((modify_ud_qp(md, md->qp)) != DAT_SUCCESS)
return 0;
bail:
- mlog(1, " ERR: MCM UD-CM services: %s\n",strerror(errno));
+ mlog(0, " ERR: MCM UD-CM services: %s\n",strerror(errno));
mcm_destroy_md(md);
return -1;
}
}
init_list(&smd->llist);
pthread_mutex_unlock(&smd->llock);
- mlog(1, " cm listen list destroyed \n");
+ mlog(8, " cm listen list destroyed \n");
/* free all CM, QP, CQ objects and then port space */
pthread_mutex_lock(&smd->clock);
}
init_list(&smd->clist);
pthread_mutex_unlock(&smd->clock);
- mlog(1, " cm connection list destroyed \n");
+ mlog(8, " cm connection list destroyed \n");
pthread_mutex_lock(&smd->cqlock);
m_cq = get_head_entry(&smd->cqlist);
}
init_list(&smd->cqlist);
pthread_mutex_unlock(&smd->cqlock);
- mlog(1, " cq_list destroyed \n");
+ mlog(8, " cq_list destroyed \n");
pthread_mutex_lock(&smd->qplock);
m_qp = get_head_entry(&smd->qplist);
}
init_list(&smd->qplist);
pthread_mutex_unlock(&smd->qplock);
- mlog(1, " qp_list destroyed \n");
+ mlog(8, " qp_list destroyed \n");
pthread_mutex_lock(&smd->plock);
if (smd->ports) {
smd->ports = NULL;
}
pthread_mutex_unlock(&smd->plock);
- mlog(1, " port space destroyed \n");
+ mlog(8, " port space destroyed \n");
/* unregister scif window, ib mr, and free m_buf*/
if (smd->m_offset)
free (smd->m_buf);
free (smd->cmd_buf);
- mlog(1, " m_buf, cmd_buf unregistered and freed\n");
+ mlog(8, " m_buf, cmd_buf unregistered and freed\n");
if (smd->ref_cnt) {
mlog(0, " WARNING: ref_cnt not 0, = %d \n", smd->ref_cnt);
ALIGN_64(DAT_MIX_MSG_MAX + DAT_MIX_INLINE_MAX), ret);
goto err;
}
- mlog(1, "Allocated smd cmd_buf = %p len %d\n",
+ mlog(8, "Allocated smd cmd_buf = %p len %d\n",
smd->cmd_buf, ALIGN_64(DAT_MIX_MSG_MAX + DAT_MIX_INLINE_MAX));
/* small shared SEND message pool */
mlog(0, "failed to allocate smd m_buf, m_len=%d, ERR: %d\n", smd->m_len, ret);
goto err;
}
- mlog(1, " Allocate/Register RDMA Proxy buffer %p-%p, ln=%d\n", smd->m_buf, (char*)smd->m_buf + smd->m_len, smd->m_len);
+ mlog(8, " Allocate/Register RDMA Proxy buffer %p-%p, ln=%d\n", smd->m_buf, (char*)smd->m_buf + smd->m_len, smd->m_len);
smd->m_offset = scif_register(tx_ep, smd->m_buf, smd->m_len,
(off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
mlog(0, " scif_register addr=%p,%d failed %s\n", smd->m_buf, smd->m_len, strerror(errno));
goto err;
}
- mlog(1, " SCIF addr=%p, offset=0x%llx, len %d\n", smd->m_buf, smd->m_offset, smd->m_len);
+ mlog(8, " SCIF addr=%p, offset=0x%llx, len %d\n", smd->m_buf, smd->m_offset, smd->m_len);
smd->m_mr = ibv_reg_mr(smd->md->pd, smd->m_buf, smd->m_len,
IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_READ);
mlog(0, " IB addr=%p,%d failed %s\n", smd->m_buf, smd->m_len, strerror(errno));
goto err;
}
- mlog(1, " IB registered addr=%p,%d, mr_addr=%p handle=0x%x, lkey=0x%x rkey=0x%x \n",
+ mlog(8, " IB registered addr=%p,%d, mr_addr=%p handle=0x%x, lkey=0x%x rkey=0x%x \n",
smd->m_buf, smd->m_len, smd->m_mr->addr, smd->m_mr->handle, smd->m_mr->lkey, smd->m_mr->rkey);
mcm_scif_dev_t *smd = NULL;
int i;
- mlog(1, " Open IB device - %s, IB port %d, scif_node %d\n", name, port, node);
+ mlog(8, " Open IB device - %s, IB port %d, scif_node %d\n", name, port, node);
mc = &mcm_client_list[node];
if (!new_md)
goto err;
- mlog(1, " new Device open on md %p -> %s port %d\n", new_md, name, port);
+ mlog(8, " new Device open on md %p -> %s port %d\n", new_md, name, port);
/* This IB device is not yet open for SCIF node. Allocate and init */
md = new_md;
/* close MCM device, MIC client, md->slock held */
static void mix_close_device(mcm_ib_dev_t *md, mcm_scif_dev_t *smd)
{
- mlog(1, " md %p smd %p\n", md, smd);
+ mlog(8, " md %p smd %p\n", md, smd);
/* close and remove scif MIX client, leave parent mcm_ib_dev open */
if (smd->scif_op_ep) {
}
mcm_destroy_smd(smd);
- mlog(1, " freed smd %p\n", md, smd);
+ mlog(8, " freed smd %p\n", md, smd);
return;
}
int len;
mcm_cm_t *cm;
- mlog(1, " MIX_LISTEN_FREE: sid 0x%x \n", pmsg->req_id);
+ mlog(8, " MIX_LISTEN_FREE: sid 0x%x \n", pmsg->req_id);
pthread_mutex_lock(&smd->llock);
cm = get_head_entry(&smd->llist);
goto err;
}
- mlog(1, " RDMA Proxy buffer %p, len %d\n", m_qp->m_buf, m_qp->m_len);
+ mlog(8, " RDMA Proxy buffer %p, len %d\n", m_qp->m_buf, m_qp->m_len);
m_qp->m_off = scif_register(m_qp->smd->scif_tx_ep, m_qp->m_buf, m_qp->m_len,
(off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
mlog(0, " SCIF_register addr=%p,%d failed %s\n", m_qp->m_buf, m_qp->m_len, strerror(errno));
goto err;
}
- mlog(1, " SCIF_mr addr %p, off 0x%llx, len %d\n", m_qp->m_buf, m_qp->m_off, m_qp->m_len);
+ mlog(8, " SCIF_mr addr %p, off 0x%llx, len %d\n", m_qp->m_buf, m_qp->m_off, m_qp->m_len);
m_qp->m_mr = ibv_reg_mr(m_qp->smd->md->pd, m_qp->m_buf, m_qp->m_len,
IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_READ);
mlog(0, " IB addr=%p,%d failed %s\n", m_qp->m_buf, m_qp->m_len, strerror(errno));
goto err;
}
- mlog(1, " IB_mr addr=%p,%d, mr_addr %p handle 0x%x lkey 0x%x rkey 0x%x \n",
+ mlog(8, " IB_mr addr=%p,%d, mr_addr %p handle 0x%x lkey 0x%x rkey 0x%x \n",
m_qp->m_buf, m_qp->m_len, m_qp->m_mr->addr, m_qp->m_mr->handle, m_qp->m_mr->lkey, m_qp->m_mr->rkey);
return 0;
}
memset(m_qp->wr_buf, 0, ALIGN_PAGE(m_qp->wr_len));
- mlog(1, " WR buf pool %p, LEN req=%d, act=%d\n", m_qp->wr_buf, m_qp->wr_len, ALIGN_PAGE(m_qp->wr_len) );
+ mlog(8, " WR buf pool %p, LEN req=%d, act=%d\n", m_qp->wr_buf, m_qp->wr_len, ALIGN_PAGE(m_qp->wr_len) );
m_qp->wr_off = scif_register(m_qp->smd->scif_tx_ep, m_qp->wr_buf, ALIGN_PAGE(m_qp->wr_len),
(off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
m_qp->wr_buf, ALIGN_PAGE(m_qp->wr_len), strerror(errno));
goto err;
}
- mlog(1, " SCIF_mr for wr_buf addr %p, off 0x%llx, len %d, entries %d\n",
+ mlog(8, " SCIF_mr for wr_buf addr %p, off 0x%llx, len %d, entries %d\n",
m_qp->wr_buf, m_qp->wr_off, ALIGN_PAGE(m_qp->wr_len), entries);
return 0;
int len;
struct mcm_cq *m_cq;
- mlog(1, " MIX_CQ_DESTROY: cq_id 0x%x\n", pmsg->req_id);
+ mlog(8, " MIX_CQ_DESTROY: cq_id 0x%x\n", pmsg->req_id);
/* Find the CQ */
m_cq = mix_get_cq(smd, pmsg->req_id);
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CQ_CREATE: cq_len = %d, mic_ctx = %Lx\n", pmsg->cq_len, pmsg->cq_ctx);
+ mlog(8, " MIX_CQ_CREATE: cq_len = %d, mic_ctx = %Lx\n", pmsg->cq_len, pmsg->cq_ctx);
if (m_cq_create(smd, pmsg->cq_len, &new_mcq))
goto err;
pmsg->cq_id = new_mcq->cq_id = new_mcq->entry.tid;
pmsg->cq_ctx = (uint64_t)new_mcq;
pmsg->hdr.status = MIX_SUCCESS;
- mlog(1, " new cq_id %d, mpxyd_ctx=%p\n", pmsg->cq_id, pmsg->cq_ctx);
+ mlog(8, " new cq_id %d, mpxyd_ctx=%p\n", pmsg->cq_id, pmsg->cq_ctx);
goto resp;
err:
mlog(0, " ERR: %s\n", strerror(errno));
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CQ_POLL: cq_id 0x%x, cq_ctx %p\n", pmsg->cq_id, pmsg->cq_ctx);
+ mlog(8, " MIX_CQ_POLL: cq_id 0x%x, cq_ctx %p\n", pmsg->cq_id, pmsg->cq_ctx);
/* get CQ object, set WC polling count */
m_cq = (struct mcm_cq *)pmsg->cq_ctx;
pcnt = pmsg->wc_cnt;
pmsg->wc_cnt = ibv_poll_cq(m_cq->ib_cq, pcnt, local_wc);
- mlog(1," completions = %d \n", pmsg->wc_cnt);
+ mlog(8," completions = %d \n", pmsg->wc_cnt);
if (pmsg->wc_cnt < 0) {
mlog(0, " ibv_poll_cq ERR %s on cq_id 0x%x, cq_ctx %p\n", strerror(errno), pmsg->cq_id, pmsg->cq_ctx);
pmsg->hdr.status = MIX_EFAULT; /* todo: add a errno convert to MIX */
const_mix_wc(pmsg->wc, local_wc, pmsg->wc_cnt);
if (pmsg->wc_cnt) {
- mlog(1, " (ep=%d) cq %p id %d ctx %p stat %d op %d ln %d wr_id %p wc's %d verr 0x%x\n",
+ mlog(8, " (ep=%d) cq %p id %d ctx %p stat %d op %d ln %d wr_id %p wc's %d verr 0x%x\n",
m_cq->smd->scif_op_ep, m_cq, m_cq->cq_id, m_cq->cq_ctx,
pmsg->wc[0].status, pmsg->wc[0].opcode, pmsg->wc[0].byte_len,
pmsg->wc[0].wr_id, pmsg->wc_cnt, pmsg->wc[0].vendor_err);
int len;
struct mcm_qp *m_qp;
- mlog(1, " MIX_QP_DESTROY: QP_t - id 0x%x\n", pmsg->req_id );
+ mlog(8, " MIX_QP_DESTROY: QP_t - id 0x%x\n", pmsg->req_id );
/* Find the QP */
m_qp = mix_get_qp(smd, pmsg->req_id, 0);
if (scif_send_msg(smd->scif_op_ep, (void*)pmsg, len))
return -1;
- mlog(1, " MIX_QP_DESTROY: QP %p response sent to MIC client\n", m_qp);
+ mlog(8, " MIX_QP_DESTROY: QP %p response sent to MIC client\n", m_qp);
return 0;
}
return -1;
}
- mlog(1, " QP_r - qpn 0x%x, ctx %p, rq %d,%d sq %d,%d rcq_id %d\n",
+ mlog(8, " QP_r - qpn 0x%x, ctx %p, rq %d,%d sq %d,%d rcq_id %d\n",
pmsg->qp_r.qp_num, pmsg->qp_r.ctx, pmsg->qp_r.max_recv_wr,
pmsg->qp_r.max_recv_sge, pmsg->qp_r.max_send_wr,
pmsg->qp_r.max_send_sge, pmsg->qp_r.rcq_id);
- mlog(1, " QP_t - wr %d sge %d inline %d\n",
+ mlog(8, " QP_t - wr %d sge %d inline %d\n",
pmsg->qp_t.max_send_wr, pmsg->qp_t.max_send_sge,
pmsg->qp_t.max_inline_data);
qp_create.cap.max_inline_data = mcm_ib_inline;
qp_create.qp_type = IBV_QPT_RC;
- mlog(1, " QP_t - max_wr %d adjusted up to %d for segmentation \n",
+ mlog(8, " QP_t - max_wr %d adjusted up to %d for segmentation \n",
pmsg->qp_t.max_send_wr, qp_create.cap.max_send_wr);
pmsg->hdr.status = m_qp_create(smd, &qp_create, pmsg->qp_t.scq_id, &new_mqp);
pmsg->wr_len = new_mqp->wr_end;
pmsg->m_inline = mix_inline_threshold;
- mlog(1, " QP_t - qpn %x, q_id %d, q_ctx %p sq %d,%d rq %d,%d, il %d\n",
+ mlog(8, " QP_t - qpn %x, q_id %d, q_ctx %p sq %d,%d rq %d,%d, il %d\n",
pmsg->qp_t.qp_num, pmsg->qp_t.qp_id, new_mqp,
pmsg->qp_t.max_send_wr,
pmsg->qp_t.max_send_sge, pmsg->qp_t.max_recv_wr,
msg.wc[i].status, msg.wc[i].opcode, msg.wc[i].byte_len,
msg.wc[i].wr_id, msg.wc_cnt, msg.wc[i].vendor_err);
} else {
- mlog(1, " SUCCESS (ep=%d): cq %p id %d ctx %p stat %d"
+ mlog(4, " SUCCESS (ep=%d): cq %p id %d ctx %p stat %d"
" op %d ln %d wr_id %p wc's %d verr 0x%x\n",
m_cq->smd->scif_op_ep, m_cq, msg.cq_id, msg.cq_ctx,
msg.wc[i].status, msg.wc[i].opcode, msg.wc[i].byte_len,
pthread_mutex_unlock(&m_cm->lock);
}
- mlog(1, " MIX_CM_EVENT: cm %p cm_id %d, ctx %p, event 0x%x\n",
+ mlog(2, " MIX_CM_EVENT: cm %p cm_id %d, ctx %p, event 0x%x\n",
m_cm, m_cm->entry.tid, msg.cm_ctx, event);
len = sizeof(dat_mix_cm_event_t);
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CM_REQ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
+ mlog(8, " MIX_CM_REQ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
pmsg->cm_id, (void*)pmsg->cm_ctx, pmsg->qp_id);
/* Find the QP for linking */
memcpy(m_cm->msg.p_data, pmsg->msg.p_data, htons(m_cm->msg.p_size));
memcpy(&m_cm->msg.daddr, &pmsg->msg.daddr, sizeof(dat_mcm_addr_t));
- mlog(1," QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
+ mlog(2," QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
m_cm->m_qp->qp_t.qp_num, m_cm->m_qp->qp_r.qp_num,
ntohs(m_cm->msg.dport), ntohl(m_cm->msg.dqpn),
ntohs(m_cm->msg.daddr.lid), ntohs(m_cm->msg.p_size));
pmsg->hdr.status = MIX_EINVAL;
resp:
- mlog(1, " MIX_CM_REQ_OUT: MPXYD id 0x%x, ctx %p - MIC id 0x%x, ctx %p\n",
+ mlog(8, " MIX_CM_REQ_OUT: MPXYD id 0x%x, ctx %p - MIC id 0x%x, ctx %p\n",
pmsg->cm_id, pmsg->cm_ctx, m_cm->cm_id, m_cm->cm_ctx);
/* send back response */
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CM_DREQ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
+ mlog(8, " MIX_CM_DREQ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
pmsg->cm_id, (void*)pmsg->cm_ctx, pmsg->qp_id);
/* Find the CM for linking */
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CM_RTU_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
+ mlog(8, " MIX_CM_RTU_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
pmsg->cm_id, (void*)pmsg->cm_ctx, pmsg->qp_id);
/* Find the CM for linking */
return -1;
}
- mlog(1," QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
+ mlog(2," CONNECTED: QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
m_cm->m_qp?m_cm->m_qp->qp_t.qp_num:0, m_cm->m_qp?m_cm->m_qp->qp_r.qp_num:0,
ntohs(m_cm->msg.dport), ntohl(m_cm->msg.dqpn),
ntohs(m_cm->msg.daddr.lid), ntohs(m_cm->msg.p_size));
dat_mix_cm_t msg;
int ret, len;
- mlog(1, " cm_id %d, ctx %p, m_cm %p pkt %p pln %d psz %d\n",
+ mlog(2, " cm_id %d, ctx %p, m_cm %p pkt %p pln %d psz %d\n",
m_cm->cm_id, m_cm->cm_ctx, m_cm, pkt,
pkt_len, ntohs(pkt->p_size));
if (scif_send_msg(m_cm->smd->scif_ev_ep, (void*)&msg, len))
goto err;
- mlog(1, " success cm_id %d\n", msg.cm_id);
+ mlog(2, " success cm_id %d\n", msg.cm_id);
pthread_mutex_lock(&m_cm->lock);
m_cm->state = MCM_REP_RCV;
pthread_mutex_unlock(&m_cm->lock);
memcpy(&acm->msg.daddr, &pkt->saddr, sizeof(dat_mcm_addr_t));
memcpy(&acm->msg.daddr2, &pkt->saddr2, sizeof(dat_mcm_addr_t));
- mlog(1, " DST port=%x lid=%x, QPr=%x, QPt=%x, psize=%d\n",
+ mlog(2, " DST port=%x lid=%x, QPr=%x, QPt=%x, psize=%d\n",
ntohs(acm->msg.dport), ntohs(acm->msg.daddr.lid),
htonl(acm->msg.daddr.qpn), htonl(acm->msg.daddr2.qpn),
htons(acm->msg.p_size));
dat_mix_cm_t msg;
int len;
- mlog(1, " CONN ESTABLISHED cm_id %d, ctx %p\n", m_cm->cm_id, m_cm->cm_ctx);
+ mlog(2, " CONNECTED: cm_id %d, ctx %p\n", m_cm->cm_id, m_cm->cm_ctx);
/* Forward, as is, conn_reply message to MIC client, with remote QP info */
msg.hdr.ver = DAT_MIX_VER;
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " REP: mic_ctx %p my_id %d, my_ctx %p, qp_id %d, pmsg_sz=%d \n",
+ mlog(8, " REP: mic_ctx %p my_id %d, my_ctx %p, qp_id %d, pmsg_sz=%d \n",
pmsg->sp_ctx, pmsg->cm_id, (void*)pmsg->cm_ctx, pmsg->qp_id, sizeof(dat_mix_cm_t));
/* Find the CM for this reply */
}
m_cm->m_qp->cm = m_cm;
- mlog(1, " REP: found cm_id %d = %p qp_id %d = %p \n",
+ mlog(8, " REP: found cm_id %d = %p qp_id %d = %p \n",
pmsg->cm_id, m_cm, pmsg->qp_id, m_cm->m_qp);
- mlog(1," QPt 0x%x -> d_port 0x%x, cqpn %x QPr %x lid 0x%x psize %d\n",
+ mlog(2," QPt 0x%x -> d_port 0x%x, cqpn %x QPr %x lid 0x%x psize %d\n",
m_cm->m_qp->qp_t.qp_num,
ntohs(m_cm->msg.dport), ntohl(m_cm->msg.dqpn),
ntohl(m_cm->msg.daddr.qpn), ntohs(m_cm->msg.daddr.lid),
ntohs(m_cm->msg.p_size));
- mlog(1," QPr 0x%x -> d_port 0x%x, cqpn %x QPt %x lid 0x%x\n",
+ mlog(2," QPr 0x%x -> d_port 0x%x, cqpn %x QPt %x lid 0x%x\n",
m_cm->m_qp->qp_r.qp_num,
ntohs(m_cm->msg.dport), ntohl(m_cm->msg.dqpn),
ntohl(m_cm->msg.daddr2.qpn), ntohs(m_cm->msg.daddr2.lid));
mlog(0, " ERR: ret %d, exp %d\n", ret, len);
return ret;
}
- mlog(1, " MIX_CM_REJ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
+ mlog(8, " MIX_CM_REJ_OUT: cm_id %d, cm_ctx %p, qp_id %d \n",
pmsg->cm_id, (void*)pmsg->cm_ctx, pmsg->qp_id);
/* Find the CM for linking */
return -1;
}
- mlog(1," QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
+ mlog(2," QPt 0x%x QPr 0x%x -> dport 0x%x, dqpn 0x%x dlid 0x%x psize %d\n",
m_cm->m_qp?m_cm->m_qp->qp_t.qp_num:0, m_cm->m_qp?m_cm->m_qp->qp_r.qp_num:0,
ntohs(m_cm->msg.dport), ntohl(m_cm->msg.dqpn),
ntohs(m_cm->msg.daddr.lid), ntohs(m_cm->msg.p_size));
/* inline, OP thread posted */
if (m_wr->flags & M_SEND_POSTED) {
- mlog(2, " POSTED: qp %p hd %d tl %d idx %d wr %p wr_id %p, addr %p sz %d sflg 0x%x mflg 0x%x\n",
+ mlog(4, " POSTED: qp %p hd %d tl %d idx %d wr %p wr_id %p, addr %p sz %d sflg 0x%x mflg 0x%x\n",
m_qp, m_qp->wr_hd, m_qp->wr_tl, wr_idx, m_wr,
m_wr->org_id, m_wr->wr.sg_list->addr, m_wr->sg->length,
m_wr->wr.send_flags, m_wr->flags);
}
wr_max--;
while ((m_wr->wr.wr_id != m_wr->org_id) && (--poll_cnt));
- mlog(1, " qp %p hd %d tl %d idx %d wr %p wr_id %Lx poll_cnt %d\n",
+ mlog(4, " qp %p hd %d tl %d idx %d wr %p wr_id %Lx poll_cnt %d\n",
m_qp, m_qp->wr_hd, m_qp->wr_tl, wr_idx, m_wr, m_wr->org_id, poll_cnt);
if (m_wr->wr.wr_id == m_wr->org_id) {
char *sbuf = (char*)m_wr->wr.sg_list->addr;
- mlog(1, " m_wr %p ready for ibv_post addr=%p ln=%d, lkey=%x\n",
+ mlog(4, " m_wr %p ready for ibv_post addr=%p ln=%d, lkey=%x\n",
m_wr, sbuf, m_wr->sg->length, m_wr->sg->lkey);
- mlog(1, " wr_id %Lx next %p sglist %p sge %d op %d flgs"
+ mlog(4, " wr_id %Lx next %p sglist %p sge %d op %d flgs"
" %d idata 0x%x raddr %p rkey %x \n",
m_wr->wr.wr_id, m_wr->wr.next, m_wr->wr.sg_list, m_wr->wr.num_sge, m_wr->wr.opcode,
m_wr->wr.send_flags, m_wr->wr.imm_data, m_wr->wr.wr.rdma.remote_addr, m_wr->wr.wr.rdma.rkey);
else
m_wr->m_idx = (sbuf + (m_wr->wr.sg_list->length - 1)) - m_qp->m_buf;
- mlog(1, " signaled, qp %p wr %p wr_id %p flgs 0x%x,"
+ mlog(4, " signaled, qp %p wr %p wr_id %p flgs 0x%x,"
" pcnt %d sg_rate %d sqe_cnt %d, hd %d tl %d sz %d\n",
m_qp, m_wr, m_wr->wr.wr_id, m_wr->wr.send_flags,
m_qp->post_cnt, mcm_ib_signal_rate,
ret = ibv_post_send(m_qp->ib_qp, &m_wr->wr, &bad_wr);
if (ret || (cn_signal && mix_eager_completion)) {
struct dat_mix_wc wc;
- mlog(1, " dto_event: sig %d ret %d, %s - m_wr %p, wr_id %p\n",
+ mlog(4, " dto_event: sig %d ret %d, %s - m_wr %p, wr_id %p\n",
cn_signal, ret, strerror(errno),
m_wr->wr.wr_id, m_wr->org_id);
else
MCNTR(smd->md, MCM_QP_WRITE_SEG);
}
- mlog(1, " qp %p wr %p wr_id %Lx posted tl=%d"
+ mlog(4, " qp %p wr %p wr_id %Lx posted tl=%d"
" hd=%d idx=%d pst=%d,%d cmp %d\n",
m_qp, m_wr, m_wr->org_id, m_qp->wr_tl,
m_qp->wr_hd, wr_idx, m_qp->post_cnt,
posted++;
}
if (!posted) {
- mlog(1, " qp %p wr %p wr_id %Lx still not ready\n", m_qp, m_wr, m_wr->org_id);
+ mlog(4, " qp %p wr %p wr_id %Lx still not ready\n", m_qp, m_wr, m_wr->org_id);
break;
}
if (++wr_idx == m_qp->wr_end) /* posted WR, move to next */
struct mcm_wr *m_wr;
struct ibv_sge *m_sge;
- mlog(1, " q_id %d, q_ctx %p, len %d, wr_id %p, sge %d, op %x flgs %x wr_idx %d\n",
+ mlog(4, " q_id %d, q_ctx %p, len %d, wr_id %p, sge %d, op %x flgs %x wr_idx %d\n",
pmsg->qp_id, (void*)pmsg->qp_ctx, pmsg->len, pmsg->wr.wr_id,
pmsg->wr.num_sge, pmsg->wr.opcode, pmsg->wr.send_flags, pmsg->sge[0].lkey);
m_wr = (struct mcm_wr *)(m_qp->wr_buf + (m_qp->wr_sz * m_qp->wr_hd));
m_sge = m_wr->sg;
- mlog(1, " m_wr %p m_sge %p \n", m_wr, m_sge);
+ mlog(4, " m_wr %p m_sge %p \n", m_wr, m_sge);
m_wr->org_id = pmsg->wr.wr_id;
m_wr->w_idx = m_qp->wr_hd;
m_wr->context = (uint64_t)m_qp;
const_ib_wr(&m_wr->wr, &pmsg->wr, m_sge);
- mlog(1, " m_wr (%p)raddr %Lx rkey 0x%x, ib_wr raddr %Lx rkey 0x%x \n",
+ mlog(4, " m_wr (%p)raddr %Lx rkey 0x%x, ib_wr raddr %Lx rkey 0x%x \n",
&pmsg->wr.wr.rdma.remote_addr, pmsg->wr.wr.rdma.remote_addr, pmsg->wr.wr.rdma.rkey,
&m_wr->wr.wr.rdma.remote_addr, m_wr->wr.wr.rdma.remote_addr, m_wr->wr.wr.rdma.rkey);
l_off = m_qp->m_off + l_start;
}
- mlog(1, " SCIF_readfrom[%d] l_off %p, r_off %p, l_start 0x%x l_end 0x%x seg_len %d, len %d cacheln_off %d \n",
+ mlog(4, " SCIF_readfrom[%d] l_off %p, r_off %p, l_start 0x%x l_end 0x%x seg_len %d, len %d cacheln_off %d \n",
i, l_off, r_off, l_start, l_end, seg_len, len, cacheln_off);
ret = scif_readfrom(smd->scif_tx_ep, l_off, seg_len, r_off, 0);
m_sge->length = seg_len - cacheln_off;
if (m_sge->length > len)
m_sge->length = len;
- mlog(1, " local sge[%d] addr %p len %d lkey 0x%x\n",
+ mlog(4, " local sge[%d] addr %p len %d lkey 0x%x\n",
i, m_sge->addr, m_sge->length, m_sge->lkey);
l_len -= seg_len;
if (seg_len == m_qp->m_seg || i == pmsg->wr.num_sge - 1) {
l_off = m_qp->wr_off + (m_qp->wr_hd * m_qp->wr_sz);
- mlog(1, " SCIF_fence_signal[%d] l_off %p, wr_id %p, new wr_hd 0x%x wr_len %d\n",
+ mlog(4, " SCIF_fence_signal[%d] l_off %p, wr_id %p, new wr_hd 0x%x wr_len %d\n",
i, l_off, pmsg->wr.wr_id, m_qp->wr_hd, m_qp->wr_len);
ret = scif_fence_signal(smd->scif_tx_ep, l_off, pmsg->wr.wr_id, 0, 0,
m_wr = (struct mcm_wr *)(m_qp->wr_buf + (m_qp->wr_sz * m_qp->wr_hd));
m_sge = m_wr->sg;
- mlog(1, " next m_wr %p m_sge %p \n", m_wr, m_wr->sg);
+ mlog(4, " next m_wr %p m_sge %p \n", m_wr, m_wr->sg);
m_wr->org_id = pmsg->wr.wr_id;
m_wr->w_idx = m_qp->wr_hd;
l_off = m_qp->wr_off + (m_qp->wr_hd * m_qp->wr_sz);
- mlog(1, " SCIF_fence_signal[%d] l_off %p, wr_id %p, new wr_hd 0x%x wr_len %d\n",
+ mlog(4, " SCIF_fence_signal[%d] l_off %p, wr_id %p, new wr_hd 0x%x wr_len %d\n",
i, l_off, pmsg->wr.wr_id, m_qp->wr_hd, m_qp->wr_len);
ret = scif_fence_signal(smd->scif_tx_ep, l_off, pmsg->wr.wr_id, 0, 0,
mix_dto_event(m_qp->ib_qp->send_cq->cq_context, &wc, 1);
}
- mlog(1, " exit: q_id %d, q_ctx %p, len %d, wr_hd = %d\n",
+ mlog(4, " exit: q_id %d, q_ctx %p, len %d, wr_hd = %d\n",
pmsg->qp_id, (void*)pmsg->qp_ctx, pmsg->len, m_qp->wr_hd);
return ret;
}
m_qp = (struct mcm_qp*)pmsg->qp_ctx;
- mlog(1, " q_id %d, q_num %x data %d pkt %d wr_id %p, sge %d, op %x flgs %x pst %d,%d cmp %d, inl %d, %s\n",
+ mlog(4, " q_id %d, q_num %x data %d pkt %d wr_id %p, sge %d, op %x flgs %x pst %d,%d cmp %d, inl %d, %s\n",
pmsg->qp_id, m_qp->ib_qp->qp_num, pmsg->len, sizeof(dat_mix_send_t) + pmsg->len, pmsg->wr.wr_id,
pmsg->wr.num_sge, pmsg->wr.opcode, pmsg->wr.send_flags, m_qp->post_cnt,
m_qp->post_sig_cnt, m_qp->comp_cnt, pmsg->hdr.flags & MIX_OP_INLINE ? 1:0,
len = pmsg->len;
- mlog(1, " inline, m_wr %p m_wr_prev %p m_sge %p len %d hd %d tl %d\n",
+ mlog(4, " inline, m_wr %p m_wr_prev %p m_sge %p len %d hd %d tl %d\n",
m_wr, m_wr_prev, m_wr->sg, len, m_qp->wr_hd, m_qp->wr_tl);
/* IB_WR */
m_wr->wr.sg_list = m_wr->sg;
m_wr->wr.num_sge = len ? 1:0;
- mlog(1, " INLINE m_wr (%p)raddr %p rkey 0x%llx, ib_wr raddr %p rkey 0x%llx \n",
+ mlog(4, " INLINE m_wr (%p)raddr %p rkey 0x%llx, ib_wr raddr %p rkey 0x%llx \n",
&pmsg->wr.wr.rdma.remote_addr, pmsg->wr.wr.rdma.remote_addr, pmsg->wr.wr.rdma.rkey,
&m_wr->wr.wr.rdma.remote_addr, m_wr->wr.wr.rdma.remote_addr, m_wr->wr.wr.rdma.rkey);
m_qp->post_cnt++;
if (m_wr->wr.send_flags & IBV_SEND_SIGNALED) {
m_qp->post_sig_cnt++;
- mlog(1, " INLINE signaled, qp %p wr %p wr_id %p cn_flgs %x wr_flgs %x,"
+ mlog(4, " INLINE signaled, qp %p wr %p wr_id %p cn_flgs %x wr_flgs %x,"
" pcnt %d sg_rate %d sqe_cnt %d, hd %d tl %d sz %d\n",
m_qp, m_wr, m_wr->wr.wr_id, pmsg->wr.send_flags,
m_wr->wr.send_flags,
int ret, len;
len = sizeof(*phdr);
- mlog(1, " -> scif_ep %d len %d ...\n", scif_ep, len);
+ mlog(8, " -> scif_ep %d len %d ...\n", scif_ep, len);
ret = scif_recv(scif_ep, phdr, len, SCIF_RECV_BLOCK);
if ((ret != len) || (phdr->ver != DAT_MIX_VER)) {
mlog(0, " ERR: smd %p ep %d ret %d exp %d ver %d op %d flgs %d last_op %s\n",
}
last_op = phdr->op;
- mlog(1, " <- %d bytes: ver %d, op %d, flags %d scif_ep %d\n",
+ mlog(8, " <- %d bytes: ver %d, op %d, flags %d scif_ep %d\n",
len, phdr->ver, phdr->op, phdr->flags, scif_ep);
switch (phdr->op) {
/* process completions, based on UCM_TX_BURST */
ret = ibv_poll_cq(md->scq, 1, &wc);
if (ret < 0) {
- mlog(1, " get_smsg: cq %p %s\n", md->scq, strerror(errno));
+ mlog(8, " get_smsg: cq %p %s\n", md->scq, strerror(errno));
return NULL;
}
/* free up completed sends, update tail */
sge.lkey = md->mr_sbuf->lkey;
sge.addr = (uintptr_t)smsg;
- mlog(1," mcm_send: op %s ln %d lid %x c_qpn %x rport %x, p_size %d\n",
+ mlog(8," cm_send: op %s ln %d lid %x c_qpn %x rport %x, p_size %d\n",
mcm_op_str(ntohs(smsg->op)), sge.length, ntohs(smsg->daddr.lid),
ntohl(smsg->dqpn), ntohs(smsg->dport), p_size);
int finalize = 1;
pthread_mutex_lock(&cm->lock);
- mlog(1," enter: state = %s \n", mcm_state_str(cm->state));
+ mlog(2," enter: state = %s \n", mcm_state_str(cm->state));
switch (cm->state) {
case MCM_CONNECTED:
/* CONSUMER: move to err state to flush */
cm->msg.op = htons(MCM_DREQ);
cm->retries = 0;
finalize = 0; /* wait for DREP */
- mlog(1, " DREQ_out (%d): cm_id %d %x %x %x -> %x %x %x\n",
+ mlog(2, " DREQ_out (%d): cm_id %d %x %x %x -> %x %x %x\n",
cm->retries+1, cm->entry.tid,
htons(cm->msg.saddr.lid),htonl(cm->msg.saddr.qpn),
htons(cm->msg.sport),htons(cm->msg.daddr.lid),
}
cm->msg.op = htons(MCM_DREQ);
finalize = 0; /* wait for DREP */
- mlog(1, " DREQ_out (%d): cm_id %d %x %x %x -> %x %x %x\n",
+ mlog(2, " DREQ_out (%d): cm_id %d %x %x %x -> %x %x %x\n",
cm->retries+1, cm->entry.tid,
htons(cm->msg.saddr.lid),htonl(cm->msg.saddr.qpn),
htons(cm->msg.sport),htons(cm->msg.daddr.lid),
/* DREQ received, send DREP and schedule event, finalize */
cm->msg.op = htons(MCM_DREP);
cm->state = MCM_DISCONNECTED;
- mlog(1, " DREQ_in: cm_id %d send DREP %x %x %x -> %x %x %x\n",
+ mlog(2, " DREQ_in: cm_id %d send DREP %x %x %x -> %x %x %x\n",
cm->entry.tid, htons(cm->msg.saddr.lid),htonl(cm->msg.saddr.qpn),
htons(cm->msg.sport),htons(cm->msg.daddr.lid),
htonl(cm->msg.dqpn), htons(cm->msg.dport));
MCNTR(cm->md, MCM_CM_DREP_OUT);
break;
case MCM_DISCONNECTED:
- mlog(1," state = %s already disconnected\n", mcm_state_str(cm->state) );
+ mlog(2," state = %s already disconnected\n", mcm_state_str(cm->state) );
pthread_mutex_unlock(&cm->lock);
MCNTR(cm->md, MCM_CM_DREQ_DUP);
return;
static void mcm_process_recv(mcm_ib_dev_t *md, dat_mcm_msg_t *msg, mcm_cm_t *cm, int len)
{
- mlog(1, " cm %p cm_id %d state %s \n", cm, cm->entry.tid, mcm_state_str(cm->state));
+ mlog(2, " cm %p cm_id %d state %s \n", cm, cm->entry.tid, mcm_state_str(cm->state));
pthread_mutex_lock(&cm->lock);
switch (cm->state) {
case MCM_LISTEN: /* passive */
- mlog(1, "LISTEN: req_in: l_cm %p, sid %d\n", cm, cm->sid);
+ mlog(2, "LISTEN: req_in: l_cm %p, sid %d\n", cm, cm->sid);
pthread_mutex_unlock(&cm->lock);
mix_cm_req_in(cm, msg, len);
MCNTR(md, MCM_CM_REQ_IN);
break;
case MCM_RTU_PENDING: /* passive */
- mlog(1, "RTU_PENDING: cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
+ mlog(2, "RTU_PENDING: cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
pthread_mutex_unlock(&cm->lock);
mix_cm_rtu_in(cm, msg, len);
MCNTR(md, MCM_CM_RTU_IN);
break;
case MCM_REP_PENDING: /* active */
- mlog(1, "REP_PENDING: cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
+ mlog(2, "REP_PENDING: cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
pthread_mutex_unlock(&cm->lock);
mix_cm_reply_in(cm, msg, len);
MCNTR(md, MCM_CM_REP_IN);
break;
case MCM_REP_RCV: /* active */
if (ntohs(msg->op) == MCM_REP) {
- mlog(1, "REP_RCV: DUPLICATE cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
+ mlog(2, "REP_RCV: DUPLICATE cm %p, my_id %d, cm_id %d\n", cm, cm->entry.tid, cm->cm_id);
MCNTR(md, MCM_CM_ERR_REP_DUP);
}
pthread_mutex_unlock(&cm->lock);
case MCM_CONNECTED: /* active and passive */
/* DREQ, change state and process */
if (ntohs(msg->op) == MCM_DREQ) {
- mlog(1, "DREQ_in: cm %p, cm_id %d\n", cm, cm->entry.tid);
+ mlog(2, "DREQ_in: cm %p, cm_id %d\n", cm, cm->entry.tid);
cm->state = MCM_DISC_RECV;
pthread_mutex_unlock(&cm->lock);
mcm_cm_disc(cm);
}
/* active: RTU was dropped, resend */
if (ntohs(msg->op) == MCM_REP) {
- mlog(1, " REP_in resend RTU: op %s st %s [lid, port, cqp, iqp]:"
+ mlog(2, " REP_in resend RTU: op %s st %s [lid, port, cqp, iqp]:"
" %x %x %x %x -> %x %x %x %x r_pid %x\n",
mcm_op_str(ntohs(cm->msg.op)),
mcm_state_str(cm->state),
/* DREQ dropped, resend */
if (ntohs(msg->op) == MCM_DREQ) {
MCNTR(md, MCM_CM_DREQ_DUP);
- mlog(1, " DREQ_in resend DREP: cm_id %d op %s st %s [lid, port, qpn]:"
+ mlog(2, " DREQ_in resend DREP: cm_id %d op %s st %s [lid, port, qpn]:"
" %x %x %x -> %x %x %x\n",
cm->entry.tid, mcm_op_str(ntohs(msg->op)),
mcm_state_str(cm->state),
} else if (ntohs(msg->op) != MCM_DREP){
/* DREP ok to ignore, any other print warning */
- mlog(1, " mcm_recv: UNEXPECTED MSG on cm %p"
+ mlog(2, " mcm_recv: UNEXPECTED MSG on cm %p"
" <- op %s, st %s spsp %x sqpn %x\n",
cm, mcm_op_str(ntohs(msg->op)),
mcm_state_str(cm->state),
break;
}
default:
- mlog(1, " mcm_recv: Warning, UNKNOWN state"
+ mlog(8, " mcm_recv: Warning, UNKNOWN state"
" <- op %s, %s spsp %x sqpn %x slid %x\n",
mcm_op_str(ntohs(msg->op)), mcm_state_str(cm->state),
ntohs(msg->sport), ntohl(msg->sqpn), ntohs(msg->saddr.lid));
pthread_mutex_t *lock;
int listenq = 0;
- mlog(1, " <- rmsg: op %s [lid, sid, cQP, QPr, QPt, pid]: "
+ mlog(8, " <- rmsg: op %s [lid, sid, cQP, QPr, QPt, pid]: "
"%x %x %x %x %x <- %x %x %x %x %x l_pid %x r_pid %x\n",
mcm_op_str(ntohs(msg->op)),
ntohs(msg->daddr.lid), ntohs(msg->dport), ntohl(msg->dqpn),
if (cm->state == MCM_DESTROY || cm->state == MCM_FREE)
continue;
- mlog(2, " CM %s [lid, port, cqp, iqp, pid]: SRC %x %x %x %x %x DST %x %x %x %x %x\n",
+ mlog(8, " CM %s [lid, port, cqp, iqp, pid]: SRC %x %x %x %x %x DST %x %x %x %x %x\n",
mcm_state_str(cm->state),
ntohs(cm->msg.saddr.lid), ntohs(cm->msg.sport),
ntohl(cm->msg.sqpn), ntohl(cm->msg.saddr.qpn), ntohl(cm->msg.s_id),
pthread_mutex_unlock(&md->slock);
if (!cm && !dup) {
- mlog(0, " %s - op %s [lid, port, cqp, iqp, pid]:"
+ mlog(1, " %s - op %s [lid, port, cqp, iqp, pid]:"
" %x %x %x %x %x <- %x %x %x %x lpid %x rpid %x\n",
ntohs(msg->op) == MCM_REQ ? "NO LISTENER":"NO MATCH",
mcm_op_str(ntohs(msg->op)),
for (i = 0; i < ret; i++) {
msg = (dat_mcm_msg_t*) (uintptr_t) wc[i].wr_id;
- mlog(1, " mcm_recv: stat=%d op=%s ln=%d id=%p sqp=%x\n",
+ mlog(8, " mcm_recv: stat=%d op=%s ln=%d id=%p sqp=%x\n",
wc[i].status, mcm_op_str(ntohs(msg->op)),
wc[i].byte_len,
(void*)wc[i].wr_id, wc[i].src_qp);
continue;
}
if (!(cm = mcm_get_cm(md, msg))) {
- mlog(1, " mcm_recv: ERR no match in cm_q\n");
+ mlog(8, " mcm_recv: ERR no match in cm_q\n");
mcm_post_rmsg(md, msg);
continue;
}
static int mcm_cm_req_out(mcm_cm_t *m_cm)
{
- mlog(1, " %s 0x%x %x 0x%x -> 0x%x %x 0x%x\n",
+ mlog(8, " %s 0x%x %x 0x%x -> 0x%x %x 0x%x\n",
mcm_state_str(m_cm->state),
htons(m_cm->msg.saddr.lid), htonl(m_cm->msg.saddr.qpn),
htons(m_cm->msg.sport), htons(m_cm->msg.daddr.lid),
return -1;
}
- mlog(1, " m_cm %p, state = %d, retries =%d\n", m_cm, m_cm->state,m_cm->md->retries);
+ mlog(8, " m_cm %p, state = %d, retries =%d\n", m_cm, m_cm->state,m_cm->md->retries);
m_cm->state = MCM_REP_PENDING;
m_cm->msg.op = htons(MCM_REQ);
static int mcm_cm_rtu_out(mcm_cm_t *m_cm)
{
- mlog(1, " CONN ESTABLISHED 0x%x %x 0x%x -> 0x%x %x 0x%x\n",
+ mlog(8, " CONN ESTABLISHED 0x%x %x 0x%x -> 0x%x %x 0x%x\n",
htons(m_cm->msg.saddr.lid), htonl(m_cm->msg.saddr.qpn),
htons(m_cm->msg.sport), htons(m_cm->msg.daddr.lid),
htonl(m_cm->msg.dqpn), htons(m_cm->msg.dport));
struct ibv_wc wc[DAT_MIX_WC_MAX];
struct dat_mix_wc wc_ev[DAT_MIX_WC_MAX];
- mlog(2," m_cq(%p) \n", m_cq);
+ mlog(8," m_cq(%p) \n", m_cq);
ret = ibv_get_cq_event(m_cq->ib_ch, &ib_cq, (void *)&cq_ctx);
if (ret == 0)
notify = 1;
goto retry;
}
- mlog(2," m_cq(%p) empty, armed... \n", m_cq);
+ mlog(8," m_cq(%p) empty, armed... \n", m_cq);
return;
} else
notify = 0;
m_wr = (struct mcm_wr *)wc[i].wr_id;
m_qp = (struct mcm_qp *)m_wr->context;
- mlog(1," wr_id[%d of %d] m_wr %p m_qp %p\n", i, ret, m_wr, m_qp);
+ mlog(8," wr_id[%d of %d] m_wr %p m_qp %p\n", i, ret, m_wr, m_qp);
m_qp->comp_cnt++;
}
}
if (mix_shared_buffer) {
- mlog(1," smd->mbuf_tl %p to %p, wr_tl %d to %d, pst %d,%d cmp %d\n",
+ mlog(8," smd->mbuf_tl %p to %p, wr_tl %d to %d, pst %d,%d cmp %d\n",
m_qp->smd->m_tl, m_wr->m_idx, m_qp->wr_tl,
m_wr->w_idx, m_qp->post_cnt, m_qp->post_sig_cnt,
m_qp->comp_cnt);
pthread_mutex_unlock(&m_qp->smd->qplock);
}
else {
- mlog(1," qp->mbuf_tl %p to %p, wr_tl %p to %d\n",
+ mlog(8," qp->mbuf_tl %p to %p, wr_tl %p to %d\n",
m_qp->m_tl, m_wr->m_idx);
pthread_mutex_lock(&m_qp->smd->qplock);
m_qp->m_tl = m_wr->m_idx;
set.fd = mc->tx_pipe[0];
set.events = POLLIN;
set.revents = 0;
- mlog(1, " waiting, no data\n");
+ mlog(8, " waiting, no data\n");
poll(&set, 1, -1); /* no more pending, next scif_readfrom will signal */
- mlog(1, " signaled\n");
+ mlog(8, " signaled\n");
while (mcm_poll(mc->tx_pipe[0], POLLIN) == POLLIN)
read(mc->tx_pipe[0], rbuf, 2);
pthread_mutex_unlock(&mc->cmlock);
for (i=0;i<fds;i++)
- mlog(1, " sleep, set[%d].fd %d event %d\n", i, set[i].fd, set[i].events);
+ mlog(8, " sleep, set[%d].fd %d event %d\n", i, set[i].fd, set[i].events);
poll(set, fds, -1);
for (i=0;i<fds;i++)
- mlog(1, " wake, set[%d].fd %d = %d\n", i, set[i].fd, set[i].revents);
+ mlog(8, " wake, set[%d].fd %d = %d\n", i, set[i].fd, set[i].revents);
pthread_mutex_lock(&mc->cmlock);
for (i=0;i<MCM_IB_MAX;i++) {
projects / ~ardavis / dapl.git / commitdiff