ice: pass mbxdata to ice_is_malicious_vf()

The ice_is_malicious_vf() function takes information about the current
state of the mailbox during a single interrupt. This information includes
the number of messages processed so far, as well as the number of pending
messages not yet processed.

A future refactor is going to make ice_vc_process_vf_msg() call
ice_is_malicious_vf() instead of having it called separately in ice_main.c
This change will require passing all the necessary arguments into
ice_vc_process_vf_msg().

To make this simpler, have the main loop fill in the struct ice_mbx_data
and pass that rather than passing in the num_msg_proc and num_msg_pending.

Signed-off-by: Jacob Keller <jacob.e.keller@intel.com>
Reviewed-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Tested-by: Marek Szlosek <marek.szlosek@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 615a731d7afe086a840fedc2224537f77f5c784a..a7e7a186009e1257e09dd643fb861b343422f1e4 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -1393,6 +1393,8 @@ static void ice_aq_cancel_waiting_tasks(struct ice_pf *pf)
        wake_up(&pf->aq_wait_queue);
 }
 
+#define ICE_MBX_OVERFLOW_WATERMARK 64
+
 /**
  * __ice_clean_ctrlq - helper function to clean controlq rings
  * @pf: ptr to struct ice_pf
@@ -1483,6 +1485,7 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type)
                return 0;
 
        do {
+               struct ice_mbx_data data = {};
                u16 opcode;
                int ret;
 
@@ -1509,7 +1512,12 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type)
                        ice_vf_lan_overflow_event(pf, &event);
                        break;
                case ice_mbx_opc_send_msg_to_pf:
-                       if (!ice_is_malicious_vf(pf, &event, i, pending))
+                       data.num_msg_proc = i;
+                       data.num_pending_arq = pending;
+                       data.max_num_msgs_mbx = hw->mailboxq.num_rq_entries;
+                       data.async_watermark_val = ICE_MBX_OVERFLOW_WATERMARK;
+
+                       if (!ice_is_malicious_vf(pf, &event, &data))
                                ice_vc_process_vf_msg(pf, &event);
                        break;
                case ice_aqc_opc_fw_logging:

diff --git a/drivers/net/ethernet/intel/ice/ice_sriov.c b/drivers/net/ethernet/intel/ice/ice_sriov.c
index 938be486721ec47042ebb1e4892197ea598a5633..5ae923ea979c6019325083cda315f66e6b4718aa 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_sriov.c
+++ b/drivers/net/ethernet/intel/ice/ice_sriov.c
@@ -1782,16 +1782,14 @@ void ice_restore_all_vfs_msi_state(struct pci_dev *pdev)
  * ice_is_malicious_vf - helper function to detect a malicious VF
  * @pf: ptr to struct ice_pf
  * @event: pointer to the AQ event
- * @num_msg_proc: the number of messages processed so far
- * @num_msg_pending: the number of messages peinding in admin queue
+ * @mbxdata: data about the state of the mailbox
  */
 bool
 ice_is_malicious_vf(struct ice_pf *pf, struct ice_rq_event_info *event,
-                   u16 num_msg_proc, u16 num_msg_pending)
+                   struct ice_mbx_data *mbxdata)
 {
        s16 vf_id = le16_to_cpu(event->desc.retval);
        struct device *dev = ice_pf_to_dev(pf);
-       struct ice_mbx_data mbxdata;
        bool report_malvf = false;
        struct ice_vf *vf;
        int status;
@@ -1803,14 +1801,8 @@ ice_is_malicious_vf(struct ice_pf *pf, struct ice_rq_event_info *event,
        if (test_bit(ICE_VF_STATE_DIS, vf->vf_states))
                goto out_put_vf;
 
-       mbxdata.num_msg_proc = num_msg_proc;
-       mbxdata.num_pending_arq = num_msg_pending;
-       mbxdata.max_num_msgs_mbx = pf->hw.mailboxq.num_rq_entries;
-#define ICE_MBX_OVERFLOW_WATERMARK 64
-       mbxdata.async_watermark_val = ICE_MBX_OVERFLOW_WATERMARK;
-
        /* check to see if we have a newly malicious VF */
-       status = ice_mbx_vf_state_handler(&pf->hw, &mbxdata, &vf->mbx_info,
+       status = ice_mbx_vf_state_handler(&pf->hw, mbxdata, &vf->mbx_info,
                                          &report_malvf);
        if (status)
                goto out_put_vf;

diff --git a/drivers/net/ethernet/intel/ice/ice_sriov.h b/drivers/net/ethernet/intel/ice/ice_sriov.h
index 1082b0691a3f62414a9d86195134a94c00a3286d..8fa61d954fae451f6b53ae70bb2945098cff7ee5 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_sriov.h
+++ b/drivers/net/ethernet/intel/ice/ice_sriov.h
@@ -36,7 +36,7 @@ void ice_free_vfs(struct ice_pf *pf);
 void ice_restore_all_vfs_msi_state(struct pci_dev *pdev);
 bool
 ice_is_malicious_vf(struct ice_pf *pf, struct ice_rq_event_info *event,
-                   u16 num_msg_proc, u16 num_msg_pending);
+                   struct ice_mbx_data *mbxdata);
 
 int
 ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos,
@@ -75,8 +75,7 @@ static inline void ice_restore_all_vfs_msi_state(struct pci_dev *pdev) { }
 static inline bool
 ice_is_malicious_vf(struct ice_pf __always_unused *pf,
                    struct ice_rq_event_info __always_unused *event,
-                   u16 __always_unused num_msg_proc,
-                   u16 __always_unused num_msg_pending)
+                   struct ice_mbx_data *mbxdata)
 {
        return false;
 }