RDMA/rtrs: Add error description to the logs

Print error description instead of the error number.

Signed-off-by: Kim Zhu <zhu.yanjun@ionos.com>
Signed-off-by: Jack Wang <jinpu.wang@ionos.com>
Signed-off-by: Grzegorz Prajsner <grzegorz.prajsner@ionos.com>
Link: https://patch.msgid.link/20260107161517.56357-3-haris.iqbal@ionos.com
Signed-off-by: Leon Romanovsky <leon@kernel.org>

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-clt-sysfs.c b/drivers/infiniband/ulp/rtrs/rtrs-clt-sysfs.c
index 4aa80c9388f058b745fca05b86f532d6a2b3339a..287e0ea43287f2cc286e1bcfecc17bb510b1019e 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-clt-sysfs.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-clt-sysfs.c
@@ -439,19 +439,19 @@ int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path)
                                   clt->kobj_paths,
                                   "%s", str);
        if (err) {
-               pr_err("kobject_init_and_add: %d\n", err);
+               pr_err("kobject_init_and_add: %pe\n", ERR_PTR(err));
                kobject_put(&clt_path->kobj);
                return err;
        }
        err = sysfs_create_group(&clt_path->kobj, &rtrs_clt_path_attr_group);
        if (err) {
-               pr_err("sysfs_create_group(): %d\n", err);
+               pr_err("sysfs_create_group(): %pe\n", ERR_PTR(err));
                goto put_kobj;
        }
        err = kobject_init_and_add(&clt_path->stats->kobj_stats, &ktype_stats,
                                   &clt_path->kobj, "stats");
        if (err) {
-               pr_err("kobject_init_and_add: %d\n", err);
+               pr_err("kobject_init_and_add: %pe\n", ERR_PTR(err));
                kobject_put(&clt_path->stats->kobj_stats);
                goto remove_group;
        }
@@ -459,7 +459,7 @@ int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path)
        err = sysfs_create_group(&clt_path->stats->kobj_stats,
                                 &rtrs_clt_stats_attr_group);
        if (err) {
-               pr_err("failed to create stats sysfs group, err: %d\n", err);
+               pr_err("failed to create stats sysfs group, err: %pe\n", ERR_PTR(err));
                goto put_kobj_stats;
        }
 

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-clt.c b/drivers/infiniband/ulp/rtrs/rtrs-clt.c
index 71387811b2815822f1bea5c9f2ab0e4bc39aa2d9..ee7d505ff016ce06f5848f527d982a68cae6fbd5 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-clt.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-clt.c
@@ -422,8 +422,8 @@ static void complete_rdma_req(struct rtrs_clt_io_req *req, int errno,
                        refcount_inc(&req->ref);
                        err = rtrs_inv_rkey(req);
                        if (err) {
-                               rtrs_err_rl(con->c.path, "Send INV WR key=%#x: %d\n",
-                                         req->mr->rkey, err);
+                               rtrs_err_rl(con->c.path, "Send INV WR key=%#x: %pe\n",
+                                           req->mr->rkey, ERR_PTR(err));
                        } else if (can_wait) {
                                wait_for_completion(&req->inv_comp);
                        }
@@ -443,8 +443,8 @@ static void complete_rdma_req(struct rtrs_clt_io_req *req, int errno,
 
        if (errno) {
                rtrs_err_rl(con->c.path,
-                           "IO %s request failed: error=%d path=%s [%s:%u] notify=%d\n",
-                           req->dir == DMA_TO_DEVICE ? "write" : "read", errno,
+                           "IO %s request failed: error=%pe path=%s [%s:%u] notify=%d\n",
+                           req->dir == DMA_TO_DEVICE ? "write" : "read", ERR_PTR(errno),
                            kobject_name(&clt_path->kobj), clt_path->hca_name,
                            clt_path->hca_port, notify);
        }
@@ -514,7 +514,7 @@ static void rtrs_clt_recv_done(struct rtrs_clt_con *con, struct ib_wc *wc)
                          cqe);
        err = rtrs_iu_post_recv(&con->c, iu);
        if (err) {
-               rtrs_err(con->c.path, "post iu failed %d\n", err);
+               rtrs_err(con->c.path, "post iu failed %pe\n", ERR_PTR(err));
                rtrs_rdma_error_recovery(con);
        }
 }
@@ -659,8 +659,8 @@ static void rtrs_clt_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                else
                        err = rtrs_post_recv_empty(&con->c, &io_comp_cqe);
                if (err) {
-                       rtrs_err(con->c.path, "rtrs_post_recv_empty(): %d\n",
-                                 err);
+                       rtrs_err(con->c.path, "rtrs_post_recv_empty(): %pe\n",
+                                ERR_PTR(err));
                        rtrs_rdma_error_recovery(con);
                }
                break;
@@ -731,8 +731,8 @@ static int post_recv_path(struct rtrs_clt_path *clt_path)
 
                err = post_recv_io(to_clt_con(clt_path->s.con[cid]), q_size);
                if (err) {
-                       rtrs_err(clt_path->clt, "post_recv_io(), err: %d\n",
-                                err);
+                       rtrs_err(clt_path->clt, "post_recv_io(), err: %pe\n",
+                                ERR_PTR(err));
                        return err;
                }
        }
@@ -1122,8 +1122,8 @@ static int rtrs_clt_write_req(struct rtrs_clt_io_req *req)
                ret = rtrs_map_sg_fr(req, count);
                if (ret < 0) {
                        rtrs_err_rl(s,
-                                   "Write request failed, failed to map fast reg. data, err: %d\n",
-                                   ret);
+                                   "Write request failed, failed to map fast reg. data, err: %pe\n",
+                                   ERR_PTR(ret));
                        ib_dma_unmap_sg(clt_path->s.dev->ib_dev, req->sglist,
                                        req->sg_cnt, req->dir);
                        return ret;
@@ -1150,9 +1150,9 @@ static int rtrs_clt_write_req(struct rtrs_clt_io_req *req)
                                      imm, wr, NULL);
        if (ret) {
                rtrs_err_rl(s,
-                           "Write request failed: error=%d path=%s [%s:%u]\n",
-                           ret, kobject_name(&clt_path->kobj), clt_path->hca_name,
-                           clt_path->hca_port);
+                           "Write request failed: error=%pe path=%s [%s:%u]\n",
+                           ERR_PTR(ret), kobject_name(&clt_path->kobj),
+                           clt_path->hca_name, clt_path->hca_port);
                if (req->mp_policy == MP_POLICY_MIN_INFLIGHT)
                        atomic_dec(&clt_path->stats->inflight);
                if (req->mr->need_inval) {
@@ -1208,8 +1208,8 @@ static int rtrs_clt_read_req(struct rtrs_clt_io_req *req)
                ret = rtrs_map_sg_fr(req, count);
                if (ret < 0) {
                        rtrs_err_rl(s,
-                                    "Read request failed, failed to map fast reg. data, err: %d\n",
-                                    ret);
+                                    "Read request failed, failed to map fast reg. data, err: %pe\n",
+                                    ERR_PTR(ret));
                        ib_dma_unmap_sg(dev->ib_dev, req->sglist, req->sg_cnt,
                                        req->dir);
                        return ret;
@@ -1260,9 +1260,9 @@ static int rtrs_clt_read_req(struct rtrs_clt_io_req *req)
                                   req->data_len, imm, wr);
        if (ret) {
                rtrs_err_rl(s,
-                           "Read request failed: error=%d path=%s [%s:%u]\n",
-                           ret, kobject_name(&clt_path->kobj), clt_path->hca_name,
-                           clt_path->hca_port);
+                           "Read request failed: error=%pe path=%s [%s:%u]\n",
+                           ERR_PTR(ret), kobject_name(&clt_path->kobj),
+                           clt_path->hca_name, clt_path->hca_port);
                if (req->mp_policy == MP_POLICY_MIN_INFLIGHT)
                        atomic_dec(&clt_path->stats->inflight);
                req->mr->need_inval = false;
@@ -1774,12 +1774,12 @@ static int rtrs_rdma_addr_resolved(struct rtrs_clt_con *con)
        err = create_con_cq_qp(con);
        mutex_unlock(&con->con_mutex);
        if (err) {
-               rtrs_err(s, "create_con_cq_qp(), err: %d\n", err);
+               rtrs_err(s, "create_con_cq_qp(), err: %pe\n", ERR_PTR(err));
                return err;
        }
        err = rdma_resolve_route(con->c.cm_id, RTRS_CONNECT_TIMEOUT_MS);
        if (err)
-               rtrs_err(s, "Resolving route failed, err: %d\n", err);
+               rtrs_err(s, "Resolving route failed, err: %pe\n", ERR_PTR(err));
 
        return err;
 }
@@ -1813,7 +1813,7 @@ static int rtrs_rdma_route_resolved(struct rtrs_clt_con *con)
 
        err = rdma_connect_locked(con->c.cm_id, &param);
        if (err)
-               rtrs_err(clt, "rdma_connect_locked(): %d\n", err);
+               rtrs_err(clt, "rdma_connect_locked(): %pe\n", ERR_PTR(err));
 
        return err;
 }
@@ -1846,8 +1846,8 @@ static int rtrs_rdma_conn_established(struct rtrs_clt_con *con,
        }
        errno = le16_to_cpu(msg->errno);
        if (errno) {
-               rtrs_err(clt, "Invalid RTRS message: errno %d\n",
-                         errno);
+               rtrs_err(clt, "Invalid RTRS message: errno %pe\n",
+                        ERR_PTR(errno));
                return -ECONNRESET;
        }
        if (con->c.cid == 0) {
@@ -1936,12 +1936,12 @@ static int rtrs_rdma_conn_rejected(struct rtrs_clt_con *con,
                                  "Previous session is still exists on the server, please reconnect later\n");
                else
                        rtrs_err(s,
-                                 "Connect rejected: status %d (%s), rtrs errno %d\n",
-                                 status, rej_msg, errno);
+                                 "Connect rejected: status %d (%s), rtrs errno %pe\n",
+                                 status, rej_msg, ERR_PTR(errno));
        } else {
                rtrs_err(s,
-                         "Connect rejected but with malformed message: status %d (%s)\n",
-                         status, rej_msg);
+                         "Connect rejected but with malformed message: status %pe (%s)\n",
+                         ERR_PTR(status), rej_msg);
        }
 
        return -ECONNRESET;
@@ -2008,27 +2008,27 @@ static int rtrs_clt_rdma_cm_handler(struct rdma_cm_id *cm_id,
        case RDMA_CM_EVENT_UNREACHABLE:
        case RDMA_CM_EVENT_ADDR_CHANGE:
        case RDMA_CM_EVENT_TIMEWAIT_EXIT:
-               rtrs_wrn(s, "CM error (CM event: %s, err: %d)\n",
-                        rdma_event_msg(ev->event), ev->status);
+               rtrs_wrn(s, "CM error (CM event: %s, err: %pe)\n",
+                        rdma_event_msg(ev->event), ERR_PTR(ev->status));
                cm_err = -ECONNRESET;
                break;
        case RDMA_CM_EVENT_ADDR_ERROR:
        case RDMA_CM_EVENT_ROUTE_ERROR:
-               rtrs_wrn(s, "CM error (CM event: %s, err: %d)\n",
-                        rdma_event_msg(ev->event), ev->status);
+               rtrs_wrn(s, "CM error (CM event: %s, err: %pe)\n",
+                        rdma_event_msg(ev->event), ERR_PTR(ev->status));
                cm_err = -EHOSTUNREACH;
                break;
        case RDMA_CM_EVENT_DEVICE_REMOVAL:
                /*
                 * Device removal is a special case.  Queue close and return 0.
                 */
-               rtrs_wrn_rl(s, "CM event: %s, status: %d\n", rdma_event_msg(ev->event),
-                           ev->status);
+               rtrs_wrn_rl(s, "CM event: %s, status: %pe\n", rdma_event_msg(ev->event),
+                           ERR_PTR(ev->status));
                rtrs_clt_close_conns(clt_path, false);
                return 0;
        default:
-               rtrs_err(s, "Unexpected RDMA CM error (CM event: %s, err: %d)\n",
-                        rdma_event_msg(ev->event), ev->status);
+               rtrs_err(s, "Unexpected RDMA CM error (CM event: %s, err: %pe)\n",
+                        rdma_event_msg(ev->event), ERR_PTR(ev->status));
                cm_err = -ECONNRESET;
                break;
        }
@@ -2065,14 +2065,14 @@ static int create_cm(struct rtrs_clt_con *con)
        /* allow the port to be reused */
        err = rdma_set_reuseaddr(cm_id, 1);
        if (err != 0) {
-               rtrs_err(s, "Set address reuse failed, err: %d\n", err);
+               rtrs_err(s, "Set address reuse failed, err: %pe\n", ERR_PTR(err));
                return err;
        }
        err = rdma_resolve_addr(cm_id, (struct sockaddr *)&clt_path->s.src_addr,
                                (struct sockaddr *)&clt_path->s.dst_addr,
                                RTRS_CONNECT_TIMEOUT_MS);
        if (err) {
-               rtrs_err(s, "Failed to resolve address, err: %d\n", err);
+               rtrs_err(s, "Failed to resolve address, err: %pe\n", ERR_PTR(err));
                return err;
        }
        /*
@@ -2547,7 +2547,7 @@ static int rtrs_send_path_info(struct rtrs_clt_path *clt_path)
        /* Prepare for getting info response */
        err = rtrs_iu_post_recv(&usr_con->c, rx_iu);
        if (err) {
-               rtrs_err(clt_path->clt, "rtrs_iu_post_recv(), err: %d\n", err);
+               rtrs_err(clt_path->clt, "rtrs_iu_post_recv(), err: %pe\n", ERR_PTR(err));
                goto out;
        }
        rx_iu = NULL;
@@ -2563,7 +2563,7 @@ static int rtrs_send_path_info(struct rtrs_clt_path *clt_path)
        /* Send info request */
        err = rtrs_iu_post_send(&usr_con->c, tx_iu, sizeof(*msg), NULL);
        if (err) {
-               rtrs_err(clt_path->clt, "rtrs_iu_post_send(), err: %d\n", err);
+               rtrs_err(clt_path->clt, "rtrs_iu_post_send(), err: %pe\n", ERR_PTR(err));
                goto out;
        }
        tx_iu = NULL;
@@ -2614,15 +2614,15 @@ static int init_path(struct rtrs_clt_path *clt_path)
        err = init_conns(clt_path);
        if (err) {
                rtrs_err(clt_path->clt,
-                        "init_conns() failed: err=%d path=%s [%s:%u]\n", err,
-                        str, clt_path->hca_name, clt_path->hca_port);
+                        "init_conns() failed: err=%pe path=%s [%s:%u]\n",
+                        ERR_PTR(err), str, clt_path->hca_name, clt_path->hca_port);
                goto out;
        }
        err = rtrs_send_path_info(clt_path);
        if (err) {
                rtrs_err(clt_path->clt,
-                        "rtrs_send_path_info() failed: err=%d path=%s [%s:%u]\n",
-                        err, str, clt_path->hca_name, clt_path->hca_port);
+                        "rtrs_send_path_info() failed: err=%pe path=%s [%s:%u]\n",
+                        ERR_PTR(err), str, clt_path->hca_name, clt_path->hca_port);
                goto out;
        }
        rtrs_clt_path_up(clt_path);

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c b/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
index 3f305e694fe8cff7c50641f1d4707221368d6bec..51727c7d710c39a99ebd15d4734a7c713aa02374 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
@@ -176,14 +176,14 @@ static int rtrs_srv_create_once_sysfs_root_folders(struct rtrs_srv_path *srv_pat
        dev_set_uevent_suppress(&srv->dev, true);
        err = device_add(&srv->dev);
        if (err) {
-               pr_err("device_add(): %d\n", err);
+               pr_err("device_add(): %pe\n", ERR_PTR(err));
                put_device(&srv->dev);
                goto unlock;
        }
        srv->kobj_paths = kobject_create_and_add("paths", &srv->dev.kobj);
        if (!srv->kobj_paths) {
                err = -ENOMEM;
-               pr_err("kobject_create_and_add(): %d\n", err);
+               pr_err("kobject_create_and_add(): %pe\n", ERR_PTR(err));
                device_del(&srv->dev);
                put_device(&srv->dev);
                goto unlock;
@@ -237,14 +237,14 @@ static int rtrs_srv_create_stats_files(struct rtrs_srv_path *srv_path)
        err = kobject_init_and_add(&srv_path->stats->kobj_stats, &ktype_stats,
                                   &srv_path->kobj, "stats");
        if (err) {
-               rtrs_err(s, "kobject_init_and_add(): %d\n", err);
+               rtrs_err(s, "kobject_init_and_add(): %pe\n", ERR_PTR(err));
                kobject_put(&srv_path->stats->kobj_stats);
                return err;
        }
        err = sysfs_create_group(&srv_path->stats->kobj_stats,
                                 &rtrs_srv_stats_attr_group);
        if (err) {
-               rtrs_err(s, "sysfs_create_group(): %d\n", err);
+               rtrs_err(s, "sysfs_create_group(): %pe\n", ERR_PTR(err));
                goto err;
        }
 
@@ -276,12 +276,12 @@ int rtrs_srv_create_path_files(struct rtrs_srv_path *srv_path)
        err = kobject_init_and_add(&srv_path->kobj, &ktype, srv->kobj_paths,
                                   "%s", str);
        if (err) {
-               rtrs_err(s, "kobject_init_and_add(): %d\n", err);
+               rtrs_err(s, "kobject_init_and_add(): %pe\n", ERR_PTR(err));
                goto destroy_root;
        }
        err = sysfs_create_group(&srv_path->kobj, &rtrs_srv_path_attr_group);
        if (err) {
-               rtrs_err(s, "sysfs_create_group(): %d\n", err);
+               rtrs_err(s, "sysfs_create_group(): %pe\n", ERR_PTR(err));
                goto put_kobj;
        }
        err = rtrs_srv_create_stats_files(srv_path);

diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.c b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
index adb798e2a54ae1afe5b730f0d2e49aedd6c9dc6a..be44fd1b9944c53ede408b7fb73034908058684a 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.c
@@ -317,8 +317,8 @@ static int rdma_write_sg(struct rtrs_srv_op *id)
        err = ib_post_send(id->con->c.qp, &id->tx_wr.wr, NULL);
        if (err)
                rtrs_err(s,
-                         "Posting RDMA-Write-Request to QP failed, err: %d\n",
-                         err);
+                         "Posting RDMA-Write-Request to QP failed, err: %pe\n",
+                         ERR_PTR(err));
 
        return err;
 }
@@ -434,8 +434,8 @@ static int send_io_resp_imm(struct rtrs_srv_con *con, struct rtrs_srv_op *id,
 
        err = ib_post_send(id->con->c.qp, wr, NULL);
        if (err)
-               rtrs_err_rl(s, "Posting RDMA-Reply to QP failed, err: %d\n",
-                            err);
+               rtrs_err_rl(s, "Posting RDMA-Reply to QP failed, err: %pe\n",
+                           ERR_PTR(err));
 
        return err;
 }
@@ -519,8 +519,8 @@ bool rtrs_srv_resp_rdma(struct rtrs_srv_op *id, int status)
                err = rdma_write_sg(id);
 
        if (err) {
-               rtrs_err_rl(s, "IO response failed: %d: srv_path=%s\n", err,
-                           kobject_name(&srv_path->kobj));
+               rtrs_err_rl(s, "IO response failed: %pe: srv_path=%s\n",
+                           ERR_PTR(err), kobject_name(&srv_path->kobj));
                close_path(srv_path);
        }
 out:
@@ -637,7 +637,7 @@ static int map_cont_bufs(struct rtrs_srv_path *srv_path)
                                        DMA_TO_DEVICE, rtrs_srv_rdma_done);
                        if (!srv_mr->iu) {
                                err = -ENOMEM;
-                               rtrs_err(ss, "rtrs_iu_alloc(), err: %d\n", err);
+                               rtrs_err(ss, "rtrs_iu_alloc(), err: %pe\n", ERR_PTR(err));
                                goto dereg_mr;
                        }
                }
@@ -813,7 +813,7 @@ static int process_info_req(struct rtrs_srv_con *con,
 
        err = post_recv_path(srv_path);
        if (err) {
-               rtrs_err(s, "post_recv_path(), err: %d\n", err);
+               rtrs_err(s, "post_recv_path(), err: %pe\n", ERR_PTR(err));
                return err;
        }
 
@@ -876,7 +876,7 @@ static int process_info_req(struct rtrs_srv_con *con,
        get_device(&srv_path->srv->dev);
        err = rtrs_srv_change_state(srv_path, RTRS_SRV_CONNECTED);
        if (!err) {
-               rtrs_err(s, "rtrs_srv_change_state(), err: %d\n", err);
+               rtrs_err(s, "rtrs_srv_change_state(), err: %pe\n", ERR_PTR(err));
                goto iu_free;
        }
 
@@ -890,7 +890,7 @@ static int process_info_req(struct rtrs_srv_con *con,
         */
        err = rtrs_srv_path_up(srv_path);
        if (err) {
-               rtrs_err(s, "rtrs_srv_path_up(), err: %d\n", err);
+               rtrs_err(s, "rtrs_srv_path_up(), err: %pe\n", ERR_PTR(err));
                goto iu_free;
        }
 
@@ -901,7 +901,7 @@ static int process_info_req(struct rtrs_srv_con *con,
        /* Send info response */
        err = rtrs_iu_post_send(&con->c, tx_iu, tx_sz, reg_wr);
        if (err) {
-               rtrs_err(s, "rtrs_iu_post_send(), err: %d\n", err);
+               rtrs_err(s, "rtrs_iu_post_send(), err: %pe\n", ERR_PTR(err));
 iu_free:
                rtrs_iu_free(tx_iu, srv_path->s.dev->ib_dev, 1);
        }
@@ -969,7 +969,7 @@ static int post_recv_info_req(struct rtrs_srv_con *con)
        /* Prepare for getting info response */
        err = rtrs_iu_post_recv(&con->c, rx_iu);
        if (err) {
-               rtrs_err(s, "rtrs_iu_post_recv(), err: %d\n", err);
+               rtrs_err(s, "rtrs_iu_post_recv(), err: %pe\n", ERR_PTR(err));
                rtrs_iu_free(rx_iu, srv_path->s.dev->ib_dev, 1);
                return err;
        }
@@ -1015,7 +1015,7 @@ static int post_recv_path(struct rtrs_srv_path *srv_path)
 
                err = post_recv_io(to_srv_con(srv_path->s.con[cid]), q_size);
                if (err) {
-                       rtrs_err(s, "post_recv_io(), err: %d\n", err);
+                       rtrs_err(s, "post_recv_io(), err: %pe\n", ERR_PTR(err));
                        return err;
                }
        }
@@ -1063,8 +1063,8 @@ static void process_read(struct rtrs_srv_con *con,
 
        if (ret) {
                rtrs_err_rl(s,
-                            "Processing read request failed, user module cb reported for msg_id %d, err: %d\n",
-                            buf_id, ret);
+                            "Processing read request failed, user module cb reported for msg_id %d, err: %pe\n",
+                            buf_id, ERR_PTR(ret));
                goto send_err_msg;
        }
 
@@ -1074,8 +1074,8 @@ send_err_msg:
        ret = send_io_resp_imm(con, id, ret);
        if (ret < 0) {
                rtrs_err_rl(s,
-                            "Sending err msg for failed RDMA-Write-Req failed, msg_id %d, err: %d\n",
-                            buf_id, ret);
+                            "Sending err msg for failed RDMA-Write-Req failed, msg_id %d, err: %pe\n",
+                            buf_id, ERR_PTR(ret));
                close_path(srv_path);
        }
        rtrs_srv_put_ops_ids(srv_path);
@@ -1115,8 +1115,8 @@ static void process_write(struct rtrs_srv_con *con,
                               data + data_len, usr_len);
        if (ret) {
                rtrs_err_rl(s,
-                            "Processing write request failed, user module callback reports err: %d\n",
-                            ret);
+                            "Processing write request failed, user module callback reports err: %pe\n",
+                            ERR_PTR(ret));
                goto send_err_msg;
        }
 
@@ -1126,8 +1126,8 @@ send_err_msg:
        ret = send_io_resp_imm(con, id, ret);
        if (ret < 0) {
                rtrs_err_rl(s,
-                            "Processing write request failed, sending I/O response failed, msg_id %d, err: %d\n",
-                            buf_id, ret);
+                            "Processing write request failed, sending I/O response failed, msg_id %d, err: %pe\n",
+                            buf_id, ERR_PTR(ret));
                close_path(srv_path);
        }
        rtrs_srv_put_ops_ids(srv_path);
@@ -1257,7 +1257,8 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                srv_path->s.hb_missed_cnt = 0;
                err = rtrs_post_recv_empty(&con->c, &io_comp_cqe);
                if (err) {
-                       rtrs_err(s, "rtrs_post_recv(), err: %d\n", err);
+                       rtrs_err(s, "rtrs_post_recv(), err: %pe\n",
+                                ERR_PTR(err));
                        close_path(srv_path);
                        break;
                }
@@ -1282,8 +1283,8 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc)
                                mr->msg_id = msg_id;
                                err = rtrs_srv_inv_rkey(con, mr);
                                if (err) {
-                                       rtrs_err(s, "rtrs_post_recv(), err: %d\n",
-                                                 err);
+                                       rtrs_err(s, "rtrs_post_recv(), err: %pe\n",
+                                                ERR_PTR(err));
                                        close_path(srv_path);
                                        break;
                                }
@@ -1632,7 +1633,7 @@ static int rtrs_rdma_do_accept(struct rtrs_srv_path *srv_path,
 
        err = rdma_accept(cm_id, &param);
        if (err)
-               pr_err("rdma_accept(), err: %d\n", err);
+               pr_err("rdma_accept(), err: %pe\n", ERR_PTR(err));
 
        return err;
 }
@@ -1650,7 +1651,7 @@ static int rtrs_rdma_do_reject(struct rdma_cm_id *cm_id, int errno)
 
        err = rdma_reject(cm_id, &msg, sizeof(msg), IB_CM_REJ_CONSUMER_DEFINED);
        if (err)
-               pr_err("rdma_reject(), err: %d\n", err);
+               pr_err("rdma_reject(), err: %pe\n", ERR_PTR(err));
 
        /* Bounce errno back */
        return errno;
@@ -1726,7 +1727,7 @@ static int create_con(struct rtrs_srv_path *srv_path,
                                 max_send_wr, max_recv_wr,
                                 IB_POLL_WORKQUEUE);
        if (err) {
-               rtrs_err(s, "rtrs_cq_qp_create(), err: %d\n", err);
+               rtrs_err(s, "rtrs_cq_qp_create(), err: %pe\n", ERR_PTR(err));
                goto free_con;
        }
        if (con->c.cid == 0) {
@@ -1941,7 +1942,7 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
        }
        err = create_con(srv_path, cm_id, cid);
        if (err) {
-               rtrs_err((&srv_path->s), "create_con(), error %d\n", err);
+               rtrs_err((&srv_path->s), "create_con(), error %pe\n", ERR_PTR(err));
                rtrs_rdma_do_reject(cm_id, err);
                /*
                 * Since session has other connections we follow normal way
@@ -1952,7 +1953,8 @@ static int rtrs_rdma_connect(struct rdma_cm_id *cm_id,
        }
        err = rtrs_rdma_do_accept(srv_path, cm_id);
        if (err) {
-               rtrs_err((&srv_path->s), "rtrs_rdma_do_accept(), error %d\n", err);
+               rtrs_err((&srv_path->s), "rtrs_rdma_do_accept(), error %pe\n",
+                        ERR_PTR(err));
                rtrs_rdma_do_reject(cm_id, err);
                /*
                 * Since current connection was successfully added to the
@@ -2003,8 +2005,8 @@ static int rtrs_srv_rdma_cm_handler(struct rdma_cm_id *cm_id,
        case RDMA_CM_EVENT_REJECTED:
        case RDMA_CM_EVENT_CONNECT_ERROR:
        case RDMA_CM_EVENT_UNREACHABLE:
-               rtrs_err(s, "CM error (CM event: %s, err: %d)\n",
-                         rdma_event_msg(ev->event), ev->status);
+               rtrs_err(s, "CM error (CM event: %s, err: %pe)\n",
+                         rdma_event_msg(ev->event), ERR_PTR(ev->status));
                fallthrough;
        case RDMA_CM_EVENT_DISCONNECTED:
        case RDMA_CM_EVENT_ADDR_CHANGE:
@@ -2013,8 +2015,8 @@ static int rtrs_srv_rdma_cm_handler(struct rdma_cm_id *cm_id,
                close_path(srv_path);
                break;
        default:
-               pr_err("Ignoring unexpected CM event %s, err %d\n",
-                      rdma_event_msg(ev->event), ev->status);
+               pr_err("Ignoring unexpected CM event %s, err %pe\n",
+                      rdma_event_msg(ev->event), ERR_PTR(ev->status));
                break;
        }
 
@@ -2038,13 +2040,13 @@ static struct rdma_cm_id *rtrs_srv_cm_init(struct rtrs_srv_ctx *ctx,
        }
        ret = rdma_bind_addr(cm_id, addr);
        if (ret) {
-               pr_err("Binding RDMA address failed, err: %d\n", ret);
+               pr_err("Binding RDMA address failed, err: %pe\n", ERR_PTR(ret));
                goto err_cm;
        }
        ret = rdma_listen(cm_id, 64);
        if (ret) {
-               pr_err("Listening on RDMA connection failed, err: %d\n",
-                      ret);
+               pr_err("Listening on RDMA connection failed, err: %pe\n",
+                      ERR_PTR(ret));
                goto err_cm;
        }
 
@@ -2322,8 +2324,8 @@ static int __init rtrs_server_init(void)
 
        err = check_module_params();
        if (err) {
-               pr_err("Failed to load module, invalid module parameters, err: %d\n",
-                      err);
+               pr_err("Failed to load module, invalid module parameters, err: %pe\n",
+                      ERR_PTR(err));
                return err;
        }
        err = class_register(&rtrs_dev_class);

diff --git a/drivers/infiniband/ulp/rtrs/rtrs.c b/drivers/infiniband/ulp/rtrs/rtrs.c
index bf38ac6f87c47ad8953190c9e334f9c10c804cf4..bc1208ae8216a52ee7b982eb919fc5cc12d43173 100644 (file)
--- a/drivers/infiniband/ulp/rtrs/rtrs.c
+++ b/drivers/infiniband/ulp/rtrs/rtrs.c
@@ -273,7 +273,8 @@ static int create_qp(struct rtrs_con *con, struct ib_pd *pd,
 
        ret = rdma_create_qp(cm_id, pd, &init_attr);
        if (ret) {
-               rtrs_err(con->path, "Creating QP failed, err: %d\n", ret);
+               rtrs_err(con->path, "Creating QP failed, err: %pe\n",
+                        ERR_PTR(ret));
                return ret;
        }
        con->qp = cm_id->qp;
@@ -341,7 +342,8 @@ void rtrs_send_hb_ack(struct rtrs_path *path)
        err = rtrs_post_rdma_write_imm_empty(usr_con, path->hb_cqe, imm,
                                             NULL);
        if (err) {
-               rtrs_err(path, "send HB ACK failed, errno: %d\n", err);
+               rtrs_err(path, "send HB ACK failed, errno: %pe\n",
+                        ERR_PTR(err));
                path->hb_err_handler(usr_con);
                return;
        }
@@ -375,7 +377,8 @@ static void hb_work(struct work_struct *work)
        err = rtrs_post_rdma_write_imm_empty(usr_con, path->hb_cqe, imm,
                                             NULL);
        if (err) {
-               rtrs_err(path, "HB send failed, errno: %d\n", err);
+               rtrs_err(path, "HB send failed, errno: %pe\n",
+                        ERR_PTR(err));
                path->hb_err_handler(usr_con);
                return;
        }