Output more error messages.

diff --git a/dapl/svc/mpxyd.c b/dapl/svc/mpxyd.c
index 172af1a7de8288187cae22e5a7b70585e2b797ec..9a5c410f03061ec9d260fd2a6a34810608b04996 100644 (file)
--- a/dapl/svc/mpxyd.c
+++ b/dapl/svc/mpxyd.c
@@ -552,7 +552,12 @@ static int mpxy_open_lock_file(void)
 
        rc = sprintf(pid, "%d", getpid());
 
-       return !(write(lock_fd, pid, strlen(pid)) == rc);
+       if (write(lock_fd, pid, strlen(pid)) != rc) {
+               perror(lock_file);
+               return -1;
+       }
+
+       return 0;
 }
 
 static void daemonize(void)
@@ -594,7 +599,7 @@ static int init_scif()
 
        scif_listen_ep = scif_open();
        if (scif_listen_ep < 0) {
-               mlog(0, "scif_open() failed with error %d\n", errno);
+               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);
@@ -610,7 +615,7 @@ static int init_scif()
        mlog(1,"Bound to reserved SCIF OFED port %d\n", (uint16_t)scif_id.port);
        ret = scif_listen(scif_listen_ep, scif_listen_qlen);
        if (ret < 0) {
-               mlog(0, "scif_listen() failed with error %d\n", errno);
+               mlog(0, "scif_listen() failed with error %s\n", strerror(errno));
                scif_close(scif_listen_ep);
                return -1;
        }
@@ -840,8 +845,11 @@ mcm_cm_t *m_cm_create(mcm_scif_dev_t *smd, mcm_qp_t *m_qp)
        mcm_cm_t *cm;
 
        /* Allocate CM, init lock, and initialize */
-       if ((cm = malloc(sizeof(*cm))) == NULL)
+       if ((cm = malloc(sizeof(*cm))) == NULL) {
+               mlog(0, "failed to allocate cm: %s\n", strerror(errno));
                return NULL;
+       }
+
        memset(cm, 0, sizeof(*cm));
 
        init_list(&cm->entry);
@@ -1222,8 +1230,11 @@ static mcm_scif_dev_t *mcm_create_smd(mcm_ib_dev_t *md, scif_epd_t op_ep, scif_e
 
        /* SCIF device object, allocate and init resources, one per MIC client */
        smd = malloc(sizeof(*smd));
-       if (!smd)
+       if (!smd) {
+               mlog(0, "failed to allocate smd: %s\n", strerror(errno));
                goto err;
+       }
+
        memset(smd, 0, sizeof(*smd));
        smd->md = md;
 
@@ -1235,14 +1246,16 @@ static mcm_scif_dev_t *mcm_create_smd(mcm_ib_dev_t *md, scif_epd_t op_ep, scif_e
                smd->m_shared_len = 0;
        smd->m_len = smd->m_shared_len + 8 * (1024 * 1024);
        ret = posix_memalign((void **)&smd->m_buf, 4096, smd->m_len);
-       if (ret)
+       if (ret) {
+               mlog(0, "failed to allocate smd m_buf, m_len=%d, ERR: %s\n", smd->m_len, strerror(errno));
                goto err;
+       }
        mlog(1, " Allocate/Register RDMA Proxy buffer %p, ln=%d\n", smd->m_buf, smd->m_len);
 
        smd->m_offset = scif_register(op_ep, smd->m_buf, smd->m_len,
                                      (off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
        if (smd->m_offset == (off_t)(-1)) {
-               mlog(1, " scif_register addr=%p,%d failed %s\n", smd->m_buf, smd->m_len, strerror(errno));
+               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);
@@ -1250,7 +1263,7 @@ static mcm_scif_dev_t *mcm_create_smd(mcm_ib_dev_t *md, scif_epd_t op_ep, scif_e
        smd->m_mr = ibv_reg_mr(smd->md->pd, smd->m_buf, smd->m_len,
                               IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_READ);
        if (smd->m_mr == NULL) {
-               mlog(1, " IB addr=%p,%d failed %s\n", smd->m_buf, smd->m_len, strerror(errno));
+               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",
@@ -1259,8 +1272,10 @@ static mcm_scif_dev_t *mcm_create_smd(mcm_ib_dev_t *md, scif_epd_t op_ep, scif_e
 
        /* SCIF device client port space */
        smd->ports = (uint64_t*) malloc(sizeof(uint64_t) * 0xffff);
-       if (!smd->ports)
+       if (!smd->ports) {
+               mlog(0, "failed to allocate smd ports: %s\n", strerror(errno));
                goto err;
+       }
        memset(smd->ports, 0, sizeof(uint64_t) * 0xffff);
 
        pthread_mutex_lock(&md->plock);
@@ -1327,8 +1342,11 @@ static mcm_scif_dev_t *mix_open_device(char *name, int port, scif_epd_t op_ep, s
 
        /* no IB device object, allocate and init, one per IB device */
        md = malloc(sizeof(*md));
-       if (md == NULL)
+       if (md == NULL) {
+               mlog(0, "failed to allocate md: %s\n", strerror(errno));
                goto err;
+       }
+
        memset(md, 0, sizeof(*md));
 
        init_list(&md->entry);
@@ -1618,15 +1636,17 @@ static int create_mbuf_pool(struct mcm_qp *m_qp)
                m_qp->m_len = 4096; /* allocate minimal per QP buffer to minimize code change */
        else
                m_qp->m_len = mix_buffer_mb * (1024 * 1024);
-       if (posix_memalign((void **)&m_qp->m_buf, 4096, m_qp->m_len))
+       if (posix_memalign((void **)&m_qp->m_buf, 4096, m_qp->m_len)) {
+               mlog(0, "failed to allocate mbuf. m_qp=%p, m_len=%d\n", m_qp, m_qp->m_len);
                goto err;
+       }
 
        mlog(1, " 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_ep, m_qp->m_buf, m_qp->m_len,
                                    (off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
        if (m_qp->m_off == (off_t)(-1)) {
-               mlog(1, " SCIF_register addr=%p,%d failed %s\n", m_qp->m_buf, m_qp->m_len, strerror(errno));
+               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);
@@ -1634,7 +1654,7 @@ static int create_mbuf_pool(struct mcm_qp *m_qp)
        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);
        if (m_qp->m_mr == NULL) {
-               mlog(1, " IB addr=%p,%d failed %s\n", m_qp->m_buf, m_qp->m_len, strerror(errno));
+               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",
@@ -1661,8 +1681,11 @@ static int create_wrbuf_pool(struct mcm_qp *m_qp, int entries)
        /* RDMA proxy pool, register with SCIF and IB, set pool and segm size with parameters */
        m_qp->wr_end = entries;
        m_qp->wr_len = DAT_MCM_WR * entries; /* 192 bytes to align signaling, ibv_qp + 7 SGE's */
-       if (posix_memalign((void **)&m_qp->wr_buf, 4096, ALIGN_PAGE(m_qp->wr_len)))
+       if (posix_memalign((void **)&m_qp->wr_buf, 4096, ALIGN_PAGE(m_qp->wr_len))) {
+               mlog(0, "failed to allocate wr_buf, m_qp=%p, wr_len=%d, entries=%d\n", m_qp, m_qp->wr_len, entries);
                goto err;
+       }
+
        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) );
@@ -1670,7 +1693,7 @@ static int create_wrbuf_pool(struct mcm_qp *m_qp, int entries)
        m_qp->wr_off = scif_register(m_qp->smd->scif_ep, m_qp->wr_buf, ALIGN_PAGE(m_qp->wr_len),
                                    (off_t)0, SCIF_PROT_READ | SCIF_PROT_WRITE, 0);
        if (m_qp->wr_off == (off_t)(-1)) {
-               mlog(1, " SCIF_register addr=%p,%d failed %s\n",
+               mlog(0, " SCIF_register addr=%p,%d failed %s\n",
                     m_qp->wr_buf, ALIGN_PAGE(m_qp->wr_len), strerror(errno));
                goto err;
        }
@@ -1953,8 +1976,10 @@ static int m_qp_create(mcm_scif_dev_t *smd,
        attr->send_cq = m_cq->ib_cq;
        attr->qp_context = (void *)m_qp;
        m_qp->ib_qp = ibv_create_qp(smd->md->pd, attr);
-       if (!m_qp->ib_qp)
+       if (!m_qp->ib_qp) {
+               mlog(0, "  ERR: ibv_create_qp, %s\n", strerror(errno));
                goto err;
+       }
 
        /* set to INIT state */
        ret = modify_qp(m_qp->ib_qp, IBV_QPS_INIT, 0, 0, NULL);