Merge tag 'safesetid-5.10' of git://github.com/micah-morton/linux

[linux-2.6-microblaze.git] / drivers / infiniband / core / cm.c

diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index fbc28f1..5740d1b 100644 (file)
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -27,6 +27,7 @@
 #include <rdma/ib_cm.h>
 #include "cm_msgs.h"
 #include "core_priv.h"
+#include "cm_trace.h"
 
 MODULE_AUTHOR("Sean Hefty");
 MODULE_DESCRIPTION("InfiniBand CM");
@@ -201,7 +202,6 @@ static struct attribute *cm_counter_default_attrs[] = {
 struct cm_port {
        struct cm_device *cm_dev;
        struct ib_mad_agent *mad_agent;
-       struct kobject port_obj;
        u8 port_num;
        struct list_head cm_priv_prim_list;
        struct list_head cm_priv_altr_list;
@@ -1563,6 +1563,7 @@ int ib_send_cm_req(struct ib_cm_id *cm_id,
        cm_id_priv->local_qpn = cpu_to_be32(IBA_GET(CM_REQ_LOCAL_QPN, req_msg));
        cm_id_priv->rq_psn = cpu_to_be32(IBA_GET(CM_REQ_STARTING_PSN, req_msg));
 
+       trace_icm_send_req(&cm_id_priv->id);
        spin_lock_irqsave(&cm_id_priv->lock, flags);
        ret = ib_post_send_mad(cm_id_priv->msg, NULL);
        if (ret) {
@@ -1610,6 +1611,9 @@ static int cm_issue_rej(struct cm_port *port,
                IBA_SET_MEM(CM_REJ_ARI, rej_msg, ari, ari_length);
        }
 
+       trace_icm_issue_rej(
+               IBA_GET(CM_REJ_LOCAL_COMM_ID, rcv_msg),
+               IBA_GET(CM_REJ_REMOTE_COMM_ID, rcv_msg));
        ret = ib_post_send_mad(msg, NULL);
        if (ret)
                cm_free_msg(msg);
@@ -1961,6 +1965,7 @@ static void cm_dup_req_handler(struct cm_work *work,
        }
        spin_unlock_irq(&cm_id_priv->lock);
 
+       trace_icm_send_dup_req(&cm_id_priv->id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret)
                goto free;
@@ -2124,8 +2129,7 @@ static int cm_req_handler(struct cm_work *work)
 
        listen_cm_id_priv = cm_match_req(work, cm_id_priv);
        if (!listen_cm_id_priv) {
-               pr_debug("%s: local_id %d, no listen_cm_id_priv\n", __func__,
-                        be32_to_cpu(cm_id_priv->id.local_id));
+               trace_icm_no_listener_err(&cm_id_priv->id);
                cm_id_priv->id.state = IB_CM_IDLE;
                ret = -EINVAL;
                goto destroy;
@@ -2274,8 +2278,7 @@ int ib_send_cm_rep(struct ib_cm_id *cm_id,
        spin_lock_irqsave(&cm_id_priv->lock, flags);
        if (cm_id->state != IB_CM_REQ_RCVD &&
            cm_id->state != IB_CM_MRA_REQ_SENT) {
-               pr_debug("%s: local_comm_id %d, cm_id->state: %d\n", __func__,
-                        be32_to_cpu(cm_id_priv->id.local_id), cm_id->state);
+               trace_icm_send_rep_err(cm_id_priv->id.local_id, cm_id->state);
                ret = -EINVAL;
                goto out;
        }
@@ -2289,6 +2292,7 @@ int ib_send_cm_rep(struct ib_cm_id *cm_id,
        msg->timeout_ms = cm_id_priv->timeout_ms;
        msg->context[1] = (void *) (unsigned long) IB_CM_REP_SENT;
 
+       trace_icm_send_rep(cm_id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                spin_unlock_irqrestore(&cm_id_priv->lock, flags);
@@ -2348,8 +2352,7 @@ int ib_send_cm_rtu(struct ib_cm_id *cm_id,
        spin_lock_irqsave(&cm_id_priv->lock, flags);
        if (cm_id->state != IB_CM_REP_RCVD &&
            cm_id->state != IB_CM_MRA_REP_SENT) {
-               pr_debug("%s: local_id %d, cm_id->state %d\n", __func__,
-                        be32_to_cpu(cm_id->local_id), cm_id->state);
+               trace_icm_send_cm_rtu_err(cm_id);
                ret = -EINVAL;
                goto error;
        }
@@ -2361,6 +2364,7 @@ int ib_send_cm_rtu(struct ib_cm_id *cm_id,
        cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
                      private_data, private_data_len);
 
+       trace_icm_send_rtu(cm_id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                spin_unlock_irqrestore(&cm_id_priv->lock, flags);
@@ -2442,6 +2446,7 @@ static void cm_dup_rep_handler(struct cm_work *work)
                goto unlock;
        spin_unlock_irq(&cm_id_priv->lock);
 
+       trace_icm_send_dup_rep(&cm_id_priv->id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret)
                goto free;
@@ -2465,7 +2470,7 @@ static int cm_rep_handler(struct cm_work *work)
                cpu_to_be32(IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg)), 0);
        if (!cm_id_priv) {
                cm_dup_rep_handler(work);
-               pr_debug("%s: remote_comm_id %d, no cm_id_priv\n", __func__,
+               trace_icm_remote_no_priv_err(
                         IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg));
                return -EINVAL;
        }
@@ -2479,11 +2484,10 @@ static int cm_rep_handler(struct cm_work *work)
                break;
        default:
                ret = -EINVAL;
-               pr_debug(
-                       "%s: cm_id_priv->id.state: %d, local_comm_id %d, remote_comm_id %d\n",
-                       __func__, cm_id_priv->id.state,
+               trace_icm_rep_unknown_err(
                        IBA_GET(CM_REP_LOCAL_COMM_ID, rep_msg),
-                       IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg));
+                       IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg),
+                       cm_id_priv->id.state);
                spin_unlock_irq(&cm_id_priv->lock);
                goto error;
        }
@@ -2500,7 +2504,7 @@ static int cm_rep_handler(struct cm_work *work)
                spin_unlock(&cm.lock);
                spin_unlock_irq(&cm_id_priv->lock);
                ret = -EINVAL;
-               pr_debug("%s: Failed to insert remote id %d\n", __func__,
+               trace_icm_insert_failed_err(
                         IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg));
                goto error;
        }
@@ -2517,9 +2521,8 @@ static int cm_rep_handler(struct cm_work *work)
                             IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REP,
                             NULL, 0);
                ret = -EINVAL;
-               pr_debug(
-                       "%s: Stale connection. local_comm_id %d, remote_comm_id %d\n",
-                       __func__, IBA_GET(CM_REP_LOCAL_COMM_ID, rep_msg),
+               trace_icm_staleconn_err(
+                       IBA_GET(CM_REP_LOCAL_COMM_ID, rep_msg),
                        IBA_GET(CM_REP_REMOTE_COMM_ID, rep_msg));
 
                if (cur_cm_id_priv) {
@@ -2646,9 +2649,7 @@ static int cm_send_dreq_locked(struct cm_id_private *cm_id_priv,
                return -EINVAL;
 
        if (cm_id_priv->id.state != IB_CM_ESTABLISHED) {
-               pr_debug("%s: local_id %d, cm_id->state: %d\n", __func__,
-                        be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_dreq_skipped(&cm_id_priv->id);
                return -EINVAL;
        }
 
@@ -2667,6 +2668,7 @@ static int cm_send_dreq_locked(struct cm_id_private *cm_id_priv,
        msg->timeout_ms = cm_id_priv->timeout_ms;
        msg->context[1] = (void *) (unsigned long) IB_CM_DREQ_SENT;
 
+       trace_icm_send_dreq(&cm_id_priv->id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                cm_enter_timewait(cm_id_priv);
@@ -2722,10 +2724,7 @@ static int cm_send_drep_locked(struct cm_id_private *cm_id_priv,
                return -EINVAL;
 
        if (cm_id_priv->id.state != IB_CM_DREQ_RCVD) {
-               pr_debug(
-                       "%s: local_id %d, cm_idcm_id->state(%d) != IB_CM_DREQ_RCVD\n",
-                       __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                       cm_id_priv->id.state);
+               trace_icm_send_drep_err(&cm_id_priv->id);
                kfree(private_data);
                return -EINVAL;
        }
@@ -2740,6 +2739,7 @@ static int cm_send_drep_locked(struct cm_id_private *cm_id_priv,
        cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
                       private_data, private_data_len);
 
+       trace_icm_send_drep(&cm_id_priv->id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                cm_free_msg(msg);
@@ -2789,6 +2789,9 @@ static int cm_issue_drep(struct cm_port *port,
        IBA_SET(CM_DREP_LOCAL_COMM_ID, drep_msg,
                IBA_GET(CM_DREQ_REMOTE_COMM_ID, dreq_msg));
 
+       trace_icm_issue_drep(
+               IBA_GET(CM_DREQ_LOCAL_COMM_ID, dreq_msg),
+               IBA_GET(CM_DREQ_REMOTE_COMM_ID, dreq_msg));
        ret = ib_post_send_mad(msg, NULL);
        if (ret)
                cm_free_msg(msg);
@@ -2810,9 +2813,8 @@ static int cm_dreq_handler(struct cm_work *work)
                atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
                                counter[CM_DREQ_COUNTER]);
                cm_issue_drep(work->port, work->mad_recv_wc);
-               pr_debug(
-                       "%s: no cm_id_priv, local_comm_id %d, remote_comm_id %d\n",
-                       __func__, IBA_GET(CM_DREQ_LOCAL_COMM_ID, dreq_msg),
+               trace_icm_no_priv_err(
+                       IBA_GET(CM_DREQ_LOCAL_COMM_ID, dreq_msg),
                        IBA_GET(CM_DREQ_REMOTE_COMM_ID, dreq_msg));
                return -EINVAL;
        }
@@ -2858,9 +2860,7 @@ static int cm_dreq_handler(struct cm_work *work)
                                counter[CM_DREQ_COUNTER]);
                goto unlock;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_dreq_unknown_err(&cm_id_priv->id);
                goto unlock;
        }
        cm_id_priv->id.state = IB_CM_DREQ_RCVD;
@@ -2945,12 +2945,11 @@ static int cm_send_rej_locked(struct cm_id_private *cm_id_priv,
                              state);
                break;
        default:
-               pr_debug("%s: local_id %d, cm_id->state: %d\n", __func__,
-                        be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_send_unknown_rej_err(&cm_id_priv->id);
                return -EINVAL;
        }
 
+       trace_icm_send_rej(&cm_id_priv->id, reason);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                cm_free_msg(msg);
@@ -3060,9 +3059,7 @@ static int cm_rej_handler(struct cm_work *work)
                }
                fallthrough;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_rej_unknown_err(&cm_id_priv->id);
                spin_unlock_irq(&cm_id_priv->lock);
                goto out;
        }
@@ -3118,9 +3115,7 @@ int ib_send_cm_mra(struct ib_cm_id *cm_id,
                }
                fallthrough;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_send_mra_unknown_err(&cm_id_priv->id);
                ret = -EINVAL;
                goto error1;
        }
@@ -3133,6 +3128,7 @@ int ib_send_cm_mra(struct ib_cm_id *cm_id,
                cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
                              msg_response, service_timeout,
                              private_data, private_data_len);
+               trace_icm_send_mra(cm_id);
                ret = ib_post_send_mad(msg, NULL);
                if (ret)
                        goto error2;
@@ -3229,9 +3225,7 @@ static int cm_mra_handler(struct cm_work *work)
                                counter[CM_MRA_COUNTER]);
                fallthrough;
        default:
-               pr_debug("%s local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_mra_unknown_err(&cm_id_priv->id);
                goto out;
        }
 
@@ -3505,10 +3499,12 @@ int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
        msg->context[1] = (void *) (unsigned long) IB_CM_SIDR_REQ_SENT;
 
        spin_lock_irqsave(&cm_id_priv->lock, flags);
-       if (cm_id->state == IB_CM_IDLE)
+       if (cm_id->state == IB_CM_IDLE) {
+               trace_icm_send_sidr_req(&cm_id_priv->id);
                ret = ib_post_send_mad(msg, NULL);
-       else
+       } else {
                ret = -EINVAL;
+       }
 
        if (ret) {
                spin_unlock_irqrestore(&cm_id_priv->lock, flags);
@@ -3670,6 +3666,7 @@ static int cm_send_sidr_rep_locked(struct cm_id_private *cm_id_priv,
 
        cm_format_sidr_rep((struct cm_sidr_rep_msg *) msg->mad, cm_id_priv,
                           param);
+       trace_icm_send_sidr_rep(&cm_id_priv->id);
        ret = ib_post_send_mad(msg, NULL);
        if (ret) {
                cm_free_msg(msg);
@@ -3767,8 +3764,7 @@ static void cm_process_send_error(struct ib_mad_send_buf *msg,
        if (msg != cm_id_priv->msg || state != cm_id_priv->id.state)
                goto discard;
 
-       pr_debug_ratelimited("CM: failed sending MAD in state %d. (%s)\n",
-                            state, ib_wc_status_msg(wc_status));
+       trace_icm_mad_send_err(state, wc_status);
        switch (state) {
        case IB_CM_REQ_SENT:
        case IB_CM_MRA_REQ_RCVD:
@@ -3891,7 +3887,7 @@ static void cm_work_handler(struct work_struct *_work)
                ret = cm_timewait_handler(work);
                break;
        default:
-               pr_debug("cm_event.event: 0x%x\n", work->cm_event.event);
+               trace_icm_handler_err(work->cm_event.event);
                ret = -EINVAL;
                break;
        }
@@ -3927,8 +3923,7 @@ static int cm_establish(struct ib_cm_id *cm_id)
                ret = -EISCONN;
                break;
        default:
-               pr_debug("%s: local_id %d, cm_id->state: %d\n", __func__,
-                        be32_to_cpu(cm_id->local_id), cm_id->state);
+               trace_icm_establish_err(cm_id);
                ret = -EINVAL;
                break;
        }
@@ -4125,9 +4120,7 @@ static int cm_init_qp_init_attr(struct cm_id_private *cm_id_priv,
                ret = 0;
                break;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_qp_init_err(&cm_id_priv->id);
                ret = -EINVAL;
                break;
        }
@@ -4175,9 +4168,7 @@ static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
                ret = 0;
                break;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_qp_rtr_err(&cm_id_priv->id);
                ret = -EINVAL;
                break;
        }
@@ -4237,9 +4228,7 @@ static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv,
                ret = 0;
                break;
        default:
-               pr_debug("%s: local_id %d, cm_id_priv->id.state: %d\n",
-                        __func__, be32_to_cpu(cm_id_priv->id.local_id),
-                        cm_id_priv->id.state);
+               trace_icm_qp_rts_err(&cm_id_priv->id);
                ret = -EINVAL;
                break;
        }
@@ -4295,20 +4284,6 @@ static struct kobj_type cm_counter_obj_type = {
        .default_attrs = cm_counter_default_attrs
 };
 
-static char *cm_devnode(struct device *dev, umode_t *mode)
-{
-       if (mode)
-               *mode = 0666;
-       return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
-}
-
-struct class cm_class = {
-       .owner   = THIS_MODULE,
-       .name    = "infiniband_cm",
-       .devnode = cm_devnode,
-};
-EXPORT_SYMBOL(cm_class);
-
 static int cm_create_port_fs(struct cm_port *port)
 {
        int i, ret;
@@ -4511,12 +4486,6 @@ static int __init ib_cm_init(void)
        get_random_bytes(&cm.random_id_operand, sizeof cm.random_id_operand);
        INIT_LIST_HEAD(&cm.timewait_list);
 
-       ret = class_register(&cm_class);
-       if (ret) {
-               ret = -ENOMEM;
-               goto error1;
-       }
-
        cm.wq = alloc_workqueue("ib_cm", 0, 1);
        if (!cm.wq) {
                ret = -ENOMEM;
@@ -4531,8 +4500,6 @@ static int __init ib_cm_init(void)
 error3:
        destroy_workqueue(cm.wq);
 error2:
-       class_unregister(&cm_class);
-error1:
        return ret;
 }
 
@@ -4553,7 +4520,6 @@ static void __exit ib_cm_cleanup(void)
                kfree(timewait_info);
        }
 
-       class_unregister(&cm_class);
        WARN_ON(!xa_empty(&cm.local_id_table));
 }