Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (C) 2022, Intel Corporation. */
0003 
0004 #include "ice_vf_lib_private.h"
0005 #include "ice.h"
0006 #include "ice_lib.h"
0007 #include "ice_fltr.h"
0008 #include "ice_virtchnl_allowlist.h"
0009 
0010 /* Public functions which may be accessed by all driver files */
0011 
0012 /**
0013  * ice_get_vf_by_id - Get pointer to VF by ID
0014  * @pf: the PF private structure
0015  * @vf_id: the VF ID to locate
0016  *
0017  * Locate and return a pointer to the VF structure associated with a given ID.
0018  * Returns NULL if the ID does not have a valid VF structure associated with
0019  * it.
0020  *
0021  * This function takes a reference to the VF, which must be released by
0022  * calling ice_put_vf() once the caller is finished accessing the VF structure
0023  * returned.
0024  */
0025 struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
0026 {
0027     struct ice_vf *vf;
0028 
0029     rcu_read_lock();
0030     hash_for_each_possible_rcu(pf->vfs.table, vf, entry, vf_id) {
0031         if (vf->vf_id == vf_id) {
0032             struct ice_vf *found;
0033 
0034             if (kref_get_unless_zero(&vf->refcnt))
0035                 found = vf;
0036             else
0037                 found = NULL;
0038 
0039             rcu_read_unlock();
0040             return found;
0041         }
0042     }
0043     rcu_read_unlock();
0044 
0045     return NULL;
0046 }
0047 
0048 /**
0049  * ice_release_vf - Release VF associated with a refcount
0050  * @ref: the kref decremented to zero
0051  *
0052  * Callback function for kref_put to release a VF once its reference count has
0053  * hit zero.
0054  */
0055 static void ice_release_vf(struct kref *ref)
0056 {
0057     struct ice_vf *vf = container_of(ref, struct ice_vf, refcnt);
0058 
0059     vf->vf_ops->free(vf);
0060 }
0061 
0062 /**
0063  * ice_put_vf - Release a reference to a VF
0064  * @vf: the VF structure to decrease reference count on
0065  *
0066  * Decrease the reference count for a VF, and free the entry if it is no
0067  * longer in use.
0068  *
0069  * This must be called after ice_get_vf_by_id() once the reference to the VF
0070  * structure is no longer used. Otherwise, the VF structure will never be
0071  * freed.
0072  */
0073 void ice_put_vf(struct ice_vf *vf)
0074 {
0075     kref_put(&vf->refcnt, ice_release_vf);
0076 }
0077 
0078 /**
0079  * ice_has_vfs - Return true if the PF has any associated VFs
0080  * @pf: the PF private structure
0081  *
0082  * Return whether or not the PF has any allocated VFs.
0083  *
0084  * Note that this function only guarantees that there are no VFs at the point
0085  * of calling it. It does not guarantee that no more VFs will be added.
0086  */
0087 bool ice_has_vfs(struct ice_pf *pf)
0088 {
0089     /* A simple check that the hash table is not empty does not require
0090      * the mutex or rcu_read_lock.
0091      */
0092     return !hash_empty(pf->vfs.table);
0093 }
0094 
0095 /**
0096  * ice_get_num_vfs - Get number of allocated VFs
0097  * @pf: the PF private structure
0098  *
0099  * Return the total number of allocated VFs. NOTE: VF IDs are not guaranteed
0100  * to be contiguous. Do not assume that a VF ID is guaranteed to be less than
0101  * the output of this function.
0102  */
0103 u16 ice_get_num_vfs(struct ice_pf *pf)
0104 {
0105     struct ice_vf *vf;
0106     unsigned int bkt;
0107     u16 num_vfs = 0;
0108 
0109     rcu_read_lock();
0110     ice_for_each_vf_rcu(pf, bkt, vf)
0111         num_vfs++;
0112     rcu_read_unlock();
0113 
0114     return num_vfs;
0115 }
0116 
0117 /**
0118  * ice_get_vf_vsi - get VF's VSI based on the stored index
0119  * @vf: VF used to get VSI
0120  */
0121 struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
0122 {
0123     if (vf->lan_vsi_idx == ICE_NO_VSI)
0124         return NULL;
0125 
0126     return vf->pf->vsi[vf->lan_vsi_idx];
0127 }
0128 
0129 /**
0130  * ice_is_vf_disabled
0131  * @vf: pointer to the VF info
0132  *
0133  * If the PF has been disabled, there is no need resetting VF until PF is
0134  * active again. Similarly, if the VF has been disabled, this means something
0135  * else is resetting the VF, so we shouldn't continue.
0136  *
0137  * Returns true if the caller should consider the VF as disabled whether
0138  * because that single VF is explicitly disabled or because the PF is
0139  * currently disabled.
0140  */
0141 bool ice_is_vf_disabled(struct ice_vf *vf)
0142 {
0143     struct ice_pf *pf = vf->pf;
0144 
0145     return (test_bit(ICE_VF_DIS, pf->state) ||
0146         test_bit(ICE_VF_STATE_DIS, vf->vf_states));
0147 }
0148 
0149 /**
0150  * ice_wait_on_vf_reset - poll to make sure a given VF is ready after reset
0151  * @vf: The VF being resseting
0152  *
0153  * The max poll time is about ~800ms, which is about the maximum time it takes
0154  * for a VF to be reset and/or a VF driver to be removed.
0155  */
0156 static void ice_wait_on_vf_reset(struct ice_vf *vf)
0157 {
0158     int i;
0159 
0160     for (i = 0; i < ICE_MAX_VF_RESET_TRIES; i++) {
0161         if (test_bit(ICE_VF_STATE_INIT, vf->vf_states))
0162             break;
0163         msleep(ICE_MAX_VF_RESET_SLEEP_MS);
0164     }
0165 }
0166 
0167 /**
0168  * ice_check_vf_ready_for_cfg - check if VF is ready to be configured/queried
0169  * @vf: VF to check if it's ready to be configured/queried
0170  *
0171  * The purpose of this function is to make sure the VF is not in reset, not
0172  * disabled, and initialized so it can be configured and/or queried by a host
0173  * administrator.
0174  */
0175 int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
0176 {
0177     ice_wait_on_vf_reset(vf);
0178 
0179     if (ice_is_vf_disabled(vf))
0180         return -EINVAL;
0181 
0182     if (ice_check_vf_init(vf))
0183         return -EBUSY;
0184 
0185     return 0;
0186 }
0187 
0188 /**
0189  * ice_trigger_vf_reset - Reset a VF on HW
0190  * @vf: pointer to the VF structure
0191  * @is_vflr: true if VFLR was issued, false if not
0192  * @is_pfr: true if the reset was triggered due to a previous PFR
0193  *
0194  * Trigger hardware to start a reset for a particular VF. Expects the caller
0195  * to wait the proper amount of time to allow hardware to reset the VF before
0196  * it cleans up and restores VF functionality.
0197  */
0198 static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr, bool is_pfr)
0199 {
0200     /* Inform VF that it is no longer active, as a warning */
0201     clear_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
0202 
0203     /* Disable VF's configuration API during reset. The flag is re-enabled
0204      * when it's safe again to access VF's VSI.
0205      */
0206     clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
0207 
0208     /* VF_MBX_ARQLEN and VF_MBX_ATQLEN are cleared by PFR, so the driver
0209      * needs to clear them in the case of VFR/VFLR. If this is done for
0210      * PFR, it can mess up VF resets because the VF driver may already
0211      * have started cleanup by the time we get here.
0212      */
0213     if (!is_pfr)
0214         vf->vf_ops->clear_mbx_register(vf);
0215 
0216     vf->vf_ops->trigger_reset_register(vf, is_vflr);
0217 }
0218 
0219 static void ice_vf_clear_counters(struct ice_vf *vf)
0220 {
0221     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
0222 
0223     if (vsi)
0224         vsi->num_vlan = 0;
0225 
0226     vf->num_mac = 0;
0227     memset(&vf->mdd_tx_events, 0, sizeof(vf->mdd_tx_events));
0228     memset(&vf->mdd_rx_events, 0, sizeof(vf->mdd_rx_events));
0229 }
0230 
0231 /**
0232  * ice_vf_pre_vsi_rebuild - tasks to be done prior to VSI rebuild
0233  * @vf: VF to perform pre VSI rebuild tasks
0234  *
0235  * These tasks are items that don't need to be amortized since they are most
0236  * likely called in a for loop with all VF(s) in the reset_all_vfs() case.
0237  */
0238 static void ice_vf_pre_vsi_rebuild(struct ice_vf *vf)
0239 {
0240     ice_vf_clear_counters(vf);
0241     vf->vf_ops->clear_reset_trigger(vf);
0242 }
0243 
0244 /**
0245  * ice_vf_rebuild_vsi - rebuild the VF's VSI
0246  * @vf: VF to rebuild the VSI for
0247  *
0248  * This is only called when all VF(s) are being reset (i.e. PCIe Reset on the
0249  * host, PFR, CORER, etc.).
0250  */
0251 static int ice_vf_rebuild_vsi(struct ice_vf *vf)
0252 {
0253     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
0254     struct ice_pf *pf = vf->pf;
0255 
0256     if (WARN_ON(!vsi))
0257         return -EINVAL;
0258 
0259     if (ice_vsi_rebuild(vsi, true)) {
0260         dev_err(ice_pf_to_dev(pf), "failed to rebuild VF %d VSI\n",
0261             vf->vf_id);
0262         return -EIO;
0263     }
0264     /* vsi->idx will remain the same in this case so don't update
0265      * vf->lan_vsi_idx
0266      */
0267     vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx);
0268     vf->lan_vsi_num = vsi->vsi_num;
0269 
0270     return 0;
0271 }
0272 
0273 /**
0274  * ice_is_any_vf_in_unicast_promisc - check if any VF(s)
0275  * are in unicast promiscuous mode
0276  * @pf: PF structure for accessing VF(s)
0277  *
0278  * Return false if no VF(s) are in unicast promiscuous mode,
0279  * else return true
0280  */
0281 bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf)
0282 {
0283     bool is_vf_promisc = false;
0284     struct ice_vf *vf;
0285     unsigned int bkt;
0286 
0287     rcu_read_lock();
0288     ice_for_each_vf_rcu(pf, bkt, vf) {
0289         /* found a VF that has promiscuous mode configured */
0290         if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) {
0291             is_vf_promisc = true;
0292             break;
0293         }
0294     }
0295     rcu_read_unlock();
0296 
0297     return is_vf_promisc;
0298 }
0299 
0300 /**
0301  * ice_vf_get_promisc_masks - Calculate masks for promiscuous modes
0302  * @vf: the VF pointer
0303  * @vsi: the VSI to configure
0304  * @ucast_m: promiscuous mask to apply to unicast
0305  * @mcast_m: promiscuous mask to apply to multicast
0306  *
0307  * Decide which mask should be used for unicast and multicast filter,
0308  * based on presence of VLANs
0309  */
0310 void
0311 ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi,
0312              u8 *ucast_m, u8 *mcast_m)
0313 {
0314     if (ice_vf_is_port_vlan_ena(vf) ||
0315         ice_vsi_has_non_zero_vlans(vsi)) {
0316         *mcast_m = ICE_MCAST_VLAN_PROMISC_BITS;
0317         *ucast_m = ICE_UCAST_VLAN_PROMISC_BITS;
0318     } else {
0319         *mcast_m = ICE_MCAST_PROMISC_BITS;
0320         *ucast_m = ICE_UCAST_PROMISC_BITS;
0321     }
0322 }
0323 
0324 /**
0325  * ice_vf_clear_all_promisc_modes - Clear promisc/allmulticast on VF VSI
0326  * @vf: the VF pointer
0327  * @vsi: the VSI to configure
0328  *
0329  * Clear all promiscuous/allmulticast filters for a VF
0330  */
0331 static int
0332 ice_vf_clear_all_promisc_modes(struct ice_vf *vf, struct ice_vsi *vsi)
0333 {
0334     struct ice_pf *pf = vf->pf;
0335     u8 ucast_m, mcast_m;
0336     int ret = 0;
0337 
0338     ice_vf_get_promisc_masks(vf, vsi, &ucast_m, &mcast_m);
0339     if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states)) {
0340         if (!test_bit(ICE_FLAG_VF_TRUE_PROMISC_ENA, pf->flags)) {
0341             if (ice_is_dflt_vsi_in_use(vsi->port_info))
0342                 ret = ice_clear_dflt_vsi(vsi);
0343         } else {
0344             ret = ice_vf_clear_vsi_promisc(vf, vsi, ucast_m);
0345         }
0346 
0347         if (ret) {
0348             dev_err(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode failed\n");
0349         } else {
0350             clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
0351             dev_info(ice_pf_to_dev(vf->pf), "Disabling promiscuous mode succeeded\n");
0352         }
0353     }
0354 
0355     if (test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) {
0356         ret = ice_vf_clear_vsi_promisc(vf, vsi, mcast_m);
0357         if (ret) {
0358             dev_err(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode failed\n");
0359         } else {
0360             clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
0361             dev_info(ice_pf_to_dev(vf->pf), "Disabling allmulticast mode succeeded\n");
0362         }
0363     }
0364     return ret;
0365 }
0366 
0367 /**
0368  * ice_vf_set_vsi_promisc - Enable promiscuous mode for a VF VSI
0369  * @vf: the VF to configure
0370  * @vsi: the VF's VSI
0371  * @promisc_m: the promiscuous mode to enable
0372  */
0373 int
0374 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
0375 {
0376     struct ice_hw *hw = &vsi->back->hw;
0377     int status;
0378 
0379     if (ice_vf_is_port_vlan_ena(vf))
0380         status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m,
0381                           ice_vf_get_port_vlan_id(vf));
0382     else if (ice_vsi_has_non_zero_vlans(vsi))
0383         status = ice_fltr_set_vlan_vsi_promisc(hw, vsi, promisc_m);
0384     else
0385         status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m, 0);
0386 
0387     if (status && status != -EEXIST) {
0388         dev_err(ice_pf_to_dev(vsi->back), "enable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
0389             vf->vf_id, status);
0390         return status;
0391     }
0392 
0393     return 0;
0394 }
0395 
0396 /**
0397  * ice_vf_clear_vsi_promisc - Disable promiscuous mode for a VF VSI
0398  * @vf: the VF to configure
0399  * @vsi: the VF's VSI
0400  * @promisc_m: the promiscuous mode to disable
0401  */
0402 int
0403 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
0404 {
0405     struct ice_hw *hw = &vsi->back->hw;
0406     int status;
0407 
0408     if (ice_vf_is_port_vlan_ena(vf))
0409         status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m,
0410                             ice_vf_get_port_vlan_id(vf));
0411     else if (ice_vsi_has_non_zero_vlans(vsi))
0412         status = ice_fltr_clear_vlan_vsi_promisc(hw, vsi, promisc_m);
0413     else
0414         status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m, 0);
0415 
0416     if (status && status != -ENOENT) {
0417         dev_err(ice_pf_to_dev(vsi->back), "disable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
0418             vf->vf_id, status);
0419         return status;
0420     }
0421 
0422     return 0;
0423 }
0424 
0425 /**
0426  * ice_reset_all_vfs - reset all allocated VFs in one go
0427  * @pf: pointer to the PF structure
0428  *
0429  * Reset all VFs at once, in response to a PF or other device reset.
0430  *
0431  * First, tell the hardware to reset each VF, then do all the waiting in one
0432  * chunk, and finally finish restoring each VF after the wait. This is useful
0433  * during PF routines which need to reset all VFs, as otherwise it must perform
0434  * these resets in a serialized fashion.
0435  */
0436 void ice_reset_all_vfs(struct ice_pf *pf)
0437 {
0438     struct device *dev = ice_pf_to_dev(pf);
0439     struct ice_hw *hw = &pf->hw;
0440     struct ice_vf *vf;
0441     unsigned int bkt;
0442 
0443     /* If we don't have any VFs, then there is nothing to reset */
0444     if (!ice_has_vfs(pf))
0445         return;
0446 
0447     mutex_lock(&pf->vfs.table_lock);
0448 
0449     /* clear all malicious info if the VFs are getting reset */
0450     ice_for_each_vf(pf, bkt, vf)
0451         if (ice_mbx_clear_malvf(&hw->mbx_snapshot, pf->vfs.malvfs,
0452                     ICE_MAX_SRIOV_VFS, vf->vf_id))
0453             dev_dbg(dev, "failed to clear malicious VF state for VF %u\n",
0454                 vf->vf_id);
0455 
0456     /* If VFs have been disabled, there is no need to reset */
0457     if (test_and_set_bit(ICE_VF_DIS, pf->state)) {
0458         mutex_unlock(&pf->vfs.table_lock);
0459         return;
0460     }
0461 
0462     /* Begin reset on all VFs at once */
0463     ice_for_each_vf(pf, bkt, vf)
0464         ice_trigger_vf_reset(vf, true, true);
0465 
0466     /* HW requires some time to make sure it can flush the FIFO for a VF
0467      * when it resets it. Now that we've triggered all of the VFs, iterate
0468      * the table again and wait for each VF to complete.
0469      */
0470     ice_for_each_vf(pf, bkt, vf) {
0471         if (!vf->vf_ops->poll_reset_status(vf)) {
0472             /* Display a warning if at least one VF didn't manage
0473              * to reset in time, but continue on with the
0474              * operation.
0475              */
0476             dev_warn(dev, "VF %u reset check timeout\n", vf->vf_id);
0477             break;
0478         }
0479     }
0480 
0481     /* free VF resources to begin resetting the VSI state */
0482     ice_for_each_vf(pf, bkt, vf) {
0483         mutex_lock(&vf->cfg_lock);
0484 
0485         vf->driver_caps = 0;
0486         ice_vc_set_default_allowlist(vf);
0487 
0488         ice_vf_fdir_exit(vf);
0489         ice_vf_fdir_init(vf);
0490         /* clean VF control VSI when resetting VFs since it should be
0491          * setup only when VF creates its first FDIR rule.
0492          */
0493         if (vf->ctrl_vsi_idx != ICE_NO_VSI)
0494             ice_vf_ctrl_invalidate_vsi(vf);
0495 
0496         ice_vf_pre_vsi_rebuild(vf);
0497         ice_vf_rebuild_vsi(vf);
0498         vf->vf_ops->post_vsi_rebuild(vf);
0499 
0500         mutex_unlock(&vf->cfg_lock);
0501     }
0502 
0503     if (ice_is_eswitch_mode_switchdev(pf))
0504         if (ice_eswitch_rebuild(pf))
0505             dev_warn(dev, "eswitch rebuild failed\n");
0506 
0507     ice_flush(hw);
0508     clear_bit(ICE_VF_DIS, pf->state);
0509 
0510     mutex_unlock(&pf->vfs.table_lock);
0511 }
0512 
0513 /**
0514  * ice_notify_vf_reset - Notify VF of a reset event
0515  * @vf: pointer to the VF structure
0516  */
0517 static void ice_notify_vf_reset(struct ice_vf *vf)
0518 {
0519     struct ice_hw *hw = &vf->pf->hw;
0520     struct virtchnl_pf_event pfe;
0521 
0522     /* Bail out if VF is in disabled state, neither initialized, nor active
0523      * state - otherwise proceed with notifications
0524      */
0525     if ((!test_bit(ICE_VF_STATE_INIT, vf->vf_states) &&
0526          !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) ||
0527         test_bit(ICE_VF_STATE_DIS, vf->vf_states))
0528         return;
0529 
0530     pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
0531     pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
0532     ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT,
0533                   VIRTCHNL_STATUS_SUCCESS, (u8 *)&pfe, sizeof(pfe),
0534                   NULL);
0535 }
0536 
0537 /**
0538  * ice_reset_vf - Reset a particular VF
0539  * @vf: pointer to the VF structure
0540  * @flags: flags controlling behavior of the reset
0541  *
0542  * Flags:
0543  *   ICE_VF_RESET_VFLR - Indicates a reset is due to VFLR event
0544  *   ICE_VF_RESET_NOTIFY - Send VF a notification prior to reset
0545  *   ICE_VF_RESET_LOCK - Acquire VF cfg_lock before resetting
0546  *
0547  * Returns 0 if the VF is currently in reset, if resets are disabled, or if
0548  * the VF resets successfully. Returns an error code if the VF fails to
0549  * rebuild.
0550  */
0551 int ice_reset_vf(struct ice_vf *vf, u32 flags)
0552 {
0553     struct ice_pf *pf = vf->pf;
0554     struct ice_vsi *vsi;
0555     struct device *dev;
0556     struct ice_hw *hw;
0557     int err = 0;
0558     bool rsd;
0559 
0560     dev = ice_pf_to_dev(pf);
0561     hw = &pf->hw;
0562 
0563     if (flags & ICE_VF_RESET_NOTIFY)
0564         ice_notify_vf_reset(vf);
0565 
0566     if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) {
0567         dev_dbg(dev, "Trying to reset VF %d, but all VF resets are disabled\n",
0568             vf->vf_id);
0569         return 0;
0570     }
0571 
0572     if (ice_is_vf_disabled(vf)) {
0573         vsi = ice_get_vf_vsi(vf);
0574         if (!vsi) {
0575             dev_dbg(dev, "VF is already removed\n");
0576             return -EINVAL;
0577         }
0578         ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
0579         ice_vsi_stop_all_rx_rings(vsi);
0580         dev_dbg(dev, "VF is already disabled, there is no need for resetting it, telling VM, all is fine %d\n",
0581             vf->vf_id);
0582         return 0;
0583     }
0584 
0585     if (flags & ICE_VF_RESET_LOCK)
0586         mutex_lock(&vf->cfg_lock);
0587     else
0588         lockdep_assert_held(&vf->cfg_lock);
0589 
0590     /* Set VF disable bit state here, before triggering reset */
0591     set_bit(ICE_VF_STATE_DIS, vf->vf_states);
0592     ice_trigger_vf_reset(vf, flags & ICE_VF_RESET_VFLR, false);
0593 
0594     vsi = ice_get_vf_vsi(vf);
0595     if (WARN_ON(!vsi)) {
0596         err = -EIO;
0597         goto out_unlock;
0598     }
0599 
0600     ice_dis_vf_qs(vf);
0601 
0602     /* Call Disable LAN Tx queue AQ whether or not queues are
0603      * enabled. This is needed for successful completion of VFR.
0604      */
0605     ice_dis_vsi_txq(vsi->port_info, vsi->idx, 0, 0, NULL, NULL,
0606             NULL, vf->vf_ops->reset_type, vf->vf_id, NULL);
0607 
0608     /* poll VPGEN_VFRSTAT reg to make sure
0609      * that reset is complete
0610      */
0611     rsd = vf->vf_ops->poll_reset_status(vf);
0612 
0613     /* Display a warning if VF didn't manage to reset in time, but need to
0614      * continue on with the operation.
0615      */
0616     if (!rsd)
0617         dev_warn(dev, "VF reset check timeout on VF %d\n", vf->vf_id);
0618 
0619     vf->driver_caps = 0;
0620     ice_vc_set_default_allowlist(vf);
0621 
0622     /* disable promiscuous modes in case they were enabled
0623      * ignore any error if disabling process failed
0624      */
0625     ice_vf_clear_all_promisc_modes(vf, vsi);
0626 
0627     ice_eswitch_del_vf_mac_rule(vf);
0628 
0629     ice_vf_fdir_exit(vf);
0630     ice_vf_fdir_init(vf);
0631     /* clean VF control VSI when resetting VF since it should be setup
0632      * only when VF creates its first FDIR rule.
0633      */
0634     if (vf->ctrl_vsi_idx != ICE_NO_VSI)
0635         ice_vf_ctrl_vsi_release(vf);
0636 
0637     ice_vf_pre_vsi_rebuild(vf);
0638 
0639     if (vf->vf_ops->vsi_rebuild(vf)) {
0640         dev_err(dev, "Failed to release and setup the VF%u's VSI\n",
0641             vf->vf_id);
0642         err = -EFAULT;
0643         goto out_unlock;
0644     }
0645 
0646     vf->vf_ops->post_vsi_rebuild(vf);
0647     vsi = ice_get_vf_vsi(vf);
0648     if (WARN_ON(!vsi)) {
0649         err = -EINVAL;
0650         goto out_unlock;
0651     }
0652 
0653     ice_eswitch_update_repr(vsi);
0654     ice_eswitch_replay_vf_mac_rule(vf);
0655 
0656     /* if the VF has been reset allow it to come up again */
0657     if (ice_mbx_clear_malvf(&hw->mbx_snapshot, pf->vfs.malvfs,
0658                 ICE_MAX_SRIOV_VFS, vf->vf_id))
0659         dev_dbg(dev, "failed to clear malicious VF state for VF %u\n",
0660             vf->vf_id);
0661 
0662 out_unlock:
0663     if (flags & ICE_VF_RESET_LOCK)
0664         mutex_unlock(&vf->cfg_lock);
0665 
0666     return err;
0667 }
0668 
0669 /**
0670  * ice_set_vf_state_qs_dis - Set VF queues state to disabled
0671  * @vf: pointer to the VF structure
0672  */
0673 void ice_set_vf_state_qs_dis(struct ice_vf *vf)
0674 {
0675     /* Clear Rx/Tx enabled queues flag */
0676     bitmap_zero(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF);
0677     bitmap_zero(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF);
0678     clear_bit(ICE_VF_STATE_QS_ENA, vf->vf_states);
0679 }
0680 
0681 /* Private functions only accessed from other virtualization files */
0682 
0683 /**
0684  * ice_dis_vf_qs - Disable the VF queues
0685  * @vf: pointer to the VF structure
0686  */
0687 void ice_dis_vf_qs(struct ice_vf *vf)
0688 {
0689     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
0690 
0691     if (WARN_ON(!vsi))
0692         return;
0693 
0694     ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
0695     ice_vsi_stop_all_rx_rings(vsi);
0696     ice_set_vf_state_qs_dis(vf);
0697 }
0698 
0699 /**
0700  * ice_check_vf_init - helper to check if VF init complete
0701  * @vf: the pointer to the VF to check
0702  */
0703 int ice_check_vf_init(struct ice_vf *vf)
0704 {
0705     struct ice_pf *pf = vf->pf;
0706 
0707     if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
0708         dev_err(ice_pf_to_dev(pf), "VF ID: %u in reset. Try again.\n",
0709             vf->vf_id);
0710         return -EBUSY;
0711     }
0712     return 0;
0713 }
0714 
0715 /**
0716  * ice_vf_get_port_info - Get the VF's port info structure
0717  * @vf: VF used to get the port info structure for
0718  */
0719 struct ice_port_info *ice_vf_get_port_info(struct ice_vf *vf)
0720 {
0721     return vf->pf->hw.port_info;
0722 }
0723 
0724 /**
0725  * ice_cfg_mac_antispoof - Configure MAC antispoof checking behavior
0726  * @vsi: the VSI to configure
0727  * @enable: whether to enable or disable the spoof checking
0728  *
0729  * Configure a VSI to enable (or disable) spoof checking behavior.
0730  */
0731 static int ice_cfg_mac_antispoof(struct ice_vsi *vsi, bool enable)
0732 {
0733     struct ice_vsi_ctx *ctx;
0734     int err;
0735 
0736     ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
0737     if (!ctx)
0738         return -ENOMEM;
0739 
0740     ctx->info.sec_flags = vsi->info.sec_flags;
0741     ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
0742 
0743     if (enable)
0744         ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
0745     else
0746         ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
0747 
0748     err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL);
0749     if (err)
0750         dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx MAC anti-spoof %s for VSI %d, error %d\n",
0751             enable ? "ON" : "OFF", vsi->vsi_num, err);
0752     else
0753         vsi->info.sec_flags = ctx->info.sec_flags;
0754 
0755     kfree(ctx);
0756 
0757     return err;
0758 }
0759 
0760 /**
0761  * ice_vsi_ena_spoofchk - enable Tx spoof checking for this VSI
0762  * @vsi: VSI to enable Tx spoof checking for
0763  */
0764 static int ice_vsi_ena_spoofchk(struct ice_vsi *vsi)
0765 {
0766     struct ice_vsi_vlan_ops *vlan_ops;
0767     int err = 0;
0768 
0769     vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
0770 
0771     /* Allow VF with VLAN 0 only to send all tagged traffic */
0772     if (vsi->type != ICE_VSI_VF || ice_vsi_has_non_zero_vlans(vsi)) {
0773         err = vlan_ops->ena_tx_filtering(vsi);
0774         if (err)
0775             return err;
0776     }
0777 
0778     return ice_cfg_mac_antispoof(vsi, true);
0779 }
0780 
0781 /**
0782  * ice_vsi_dis_spoofchk - disable Tx spoof checking for this VSI
0783  * @vsi: VSI to disable Tx spoof checking for
0784  */
0785 static int ice_vsi_dis_spoofchk(struct ice_vsi *vsi)
0786 {
0787     struct ice_vsi_vlan_ops *vlan_ops;
0788     int err;
0789 
0790     vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
0791 
0792     err = vlan_ops->dis_tx_filtering(vsi);
0793     if (err)
0794         return err;
0795 
0796     return ice_cfg_mac_antispoof(vsi, false);
0797 }
0798 
0799 /**
0800  * ice_vsi_apply_spoofchk - Apply Tx spoof checking setting to a VSI
0801  * @vsi: VSI associated to the VF
0802  * @enable: whether to enable or disable the spoof checking
0803  */
0804 int ice_vsi_apply_spoofchk(struct ice_vsi *vsi, bool enable)
0805 {
0806     int err;
0807 
0808     if (enable)
0809         err = ice_vsi_ena_spoofchk(vsi);
0810     else
0811         err = ice_vsi_dis_spoofchk(vsi);
0812 
0813     return err;
0814 }
0815 
0816 /**
0817  * ice_is_vf_trusted
0818  * @vf: pointer to the VF info
0819  */
0820 bool ice_is_vf_trusted(struct ice_vf *vf)
0821 {
0822     return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
0823 }
0824 
0825 /**
0826  * ice_vf_has_no_qs_ena - check if the VF has any Rx or Tx queues enabled
0827  * @vf: the VF to check
0828  *
0829  * Returns true if the VF has no Rx and no Tx queues enabled and returns false
0830  * otherwise
0831  */
0832 bool ice_vf_has_no_qs_ena(struct ice_vf *vf)
0833 {
0834     return (!bitmap_weight(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF) &&
0835         !bitmap_weight(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF));
0836 }
0837 
0838 /**
0839  * ice_is_vf_link_up - check if the VF's link is up
0840  * @vf: VF to check if link is up
0841  */
0842 bool ice_is_vf_link_up(struct ice_vf *vf)
0843 {
0844     struct ice_port_info *pi = ice_vf_get_port_info(vf);
0845 
0846     if (ice_check_vf_init(vf))
0847         return false;
0848 
0849     if (ice_vf_has_no_qs_ena(vf))
0850         return false;
0851     else if (vf->link_forced)
0852         return vf->link_up;
0853     else
0854         return pi->phy.link_info.link_info &
0855             ICE_AQ_LINK_UP;
0856 }
0857 
0858 /**
0859  * ice_vf_set_host_trust_cfg - set trust setting based on pre-reset value
0860  * @vf: VF to configure trust setting for
0861  */
0862 static void ice_vf_set_host_trust_cfg(struct ice_vf *vf)
0863 {
0864     if (vf->trusted)
0865         set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
0866     else
0867         clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
0868 }
0869 
0870 /**
0871  * ice_vf_rebuild_host_mac_cfg - add broadcast and the VF's perm_addr/LAA
0872  * @vf: VF to add MAC filters for
0873  *
0874  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
0875  * always re-adds a broadcast filter and the VF's perm_addr/LAA after reset.
0876  */
0877 static int ice_vf_rebuild_host_mac_cfg(struct ice_vf *vf)
0878 {
0879     struct device *dev = ice_pf_to_dev(vf->pf);
0880     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
0881     u8 broadcast[ETH_ALEN];
0882     int status;
0883 
0884     if (WARN_ON(!vsi))
0885         return -EINVAL;
0886 
0887     if (ice_is_eswitch_mode_switchdev(vf->pf))
0888         return 0;
0889 
0890     eth_broadcast_addr(broadcast);
0891     status = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI);
0892     if (status) {
0893         dev_err(dev, "failed to add broadcast MAC filter for VF %u, error %d\n",
0894             vf->vf_id, status);
0895         return status;
0896     }
0897 
0898     vf->num_mac++;
0899 
0900     if (is_valid_ether_addr(vf->hw_lan_addr.addr)) {
0901         status = ice_fltr_add_mac(vsi, vf->hw_lan_addr.addr,
0902                       ICE_FWD_TO_VSI);
0903         if (status) {
0904             dev_err(dev, "failed to add default unicast MAC filter %pM for VF %u, error %d\n",
0905                 &vf->hw_lan_addr.addr[0], vf->vf_id,
0906                 status);
0907             return status;
0908         }
0909         vf->num_mac++;
0910 
0911         ether_addr_copy(vf->dev_lan_addr.addr, vf->hw_lan_addr.addr);
0912     }
0913 
0914     return 0;
0915 }
0916 
0917 /**
0918  * ice_vf_rebuild_host_vlan_cfg - add VLAN 0 filter or rebuild the Port VLAN
0919  * @vf: VF to add MAC filters for
0920  * @vsi: Pointer to VSI
0921  *
0922  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
0923  * always re-adds either a VLAN 0 or port VLAN based filter after reset.
0924  */
0925 static int ice_vf_rebuild_host_vlan_cfg(struct ice_vf *vf, struct ice_vsi *vsi)
0926 {
0927     struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
0928     struct device *dev = ice_pf_to_dev(vf->pf);
0929     int err;
0930 
0931     if (ice_vf_is_port_vlan_ena(vf)) {
0932         err = vlan_ops->set_port_vlan(vsi, &vf->port_vlan_info);
0933         if (err) {
0934             dev_err(dev, "failed to configure port VLAN via VSI parameters for VF %u, error %d\n",
0935                 vf->vf_id, err);
0936             return err;
0937         }
0938 
0939         err = vlan_ops->add_vlan(vsi, &vf->port_vlan_info);
0940     } else {
0941         err = ice_vsi_add_vlan_zero(vsi);
0942     }
0943 
0944     if (err) {
0945         dev_err(dev, "failed to add VLAN %u filter for VF %u during VF rebuild, error %d\n",
0946             ice_vf_is_port_vlan_ena(vf) ?
0947             ice_vf_get_port_vlan_id(vf) : 0, vf->vf_id, err);
0948         return err;
0949     }
0950 
0951     err = vlan_ops->ena_rx_filtering(vsi);
0952     if (err)
0953         dev_warn(dev, "failed to enable Rx VLAN filtering for VF %d VSI %d during VF rebuild, error %d\n",
0954              vf->vf_id, vsi->idx, err);
0955 
0956     return 0;
0957 }
0958 
0959 /**
0960  * ice_vf_rebuild_host_tx_rate_cfg - re-apply the Tx rate limiting configuration
0961  * @vf: VF to re-apply the configuration for
0962  *
0963  * Called after a VF VSI has been re-added/rebuild during reset. The PF driver
0964  * needs to re-apply the host configured Tx rate limiting configuration.
0965  */
0966 static int ice_vf_rebuild_host_tx_rate_cfg(struct ice_vf *vf)
0967 {
0968     struct device *dev = ice_pf_to_dev(vf->pf);
0969     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
0970     int err;
0971 
0972     if (WARN_ON(!vsi))
0973         return -EINVAL;
0974 
0975     if (vf->min_tx_rate) {
0976         err = ice_set_min_bw_limit(vsi, (u64)vf->min_tx_rate * 1000);
0977         if (err) {
0978             dev_err(dev, "failed to set min Tx rate to %d Mbps for VF %u, error %d\n",
0979                 vf->min_tx_rate, vf->vf_id, err);
0980             return err;
0981         }
0982     }
0983 
0984     if (vf->max_tx_rate) {
0985         err = ice_set_max_bw_limit(vsi, (u64)vf->max_tx_rate * 1000);
0986         if (err) {
0987             dev_err(dev, "failed to set max Tx rate to %d Mbps for VF %u, error %d\n",
0988                 vf->max_tx_rate, vf->vf_id, err);
0989             return err;
0990         }
0991     }
0992 
0993     return 0;
0994 }
0995 
0996 /**
0997  * ice_vf_rebuild_aggregator_node_cfg - rebuild aggregator node config
0998  * @vsi: Pointer to VSI
0999  *
1000  * This function moves VSI into corresponding scheduler aggregator node
1001  * based on cached value of "aggregator node info" per VSI
1002  */
1003 static void ice_vf_rebuild_aggregator_node_cfg(struct ice_vsi *vsi)
1004 {
1005     struct ice_pf *pf = vsi->back;
1006     struct device *dev;
1007     int status;
1008 
1009     if (!vsi->agg_node)
1010         return;
1011 
1012     dev = ice_pf_to_dev(pf);
1013     if (vsi->agg_node->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {
1014         dev_dbg(dev,
1015             "agg_id %u already has reached max_num_vsis %u\n",
1016             vsi->agg_node->agg_id, vsi->agg_node->num_vsis);
1017         return;
1018     }
1019 
1020     status = ice_move_vsi_to_agg(pf->hw.port_info, vsi->agg_node->agg_id,
1021                      vsi->idx, vsi->tc_cfg.ena_tc);
1022     if (status)
1023         dev_dbg(dev, "unable to move VSI idx %u into aggregator %u node",
1024             vsi->idx, vsi->agg_node->agg_id);
1025     else
1026         vsi->agg_node->num_vsis++;
1027 }
1028 
1029 /**
1030  * ice_vf_rebuild_host_cfg - host admin configuration is persistent across reset
1031  * @vf: VF to rebuild host configuration on
1032  */
1033 void ice_vf_rebuild_host_cfg(struct ice_vf *vf)
1034 {
1035     struct device *dev = ice_pf_to_dev(vf->pf);
1036     struct ice_vsi *vsi = ice_get_vf_vsi(vf);
1037 
1038     if (WARN_ON(!vsi))
1039         return;
1040 
1041     ice_vf_set_host_trust_cfg(vf);
1042 
1043     if (ice_vf_rebuild_host_mac_cfg(vf))
1044         dev_err(dev, "failed to rebuild default MAC configuration for VF %d\n",
1045             vf->vf_id);
1046 
1047     if (ice_vf_rebuild_host_vlan_cfg(vf, vsi))
1048         dev_err(dev, "failed to rebuild VLAN configuration for VF %u\n",
1049             vf->vf_id);
1050 
1051     if (ice_vf_rebuild_host_tx_rate_cfg(vf))
1052         dev_err(dev, "failed to rebuild Tx rate limiting configuration for VF %u\n",
1053             vf->vf_id);
1054 
1055     if (ice_vsi_apply_spoofchk(vsi, vf->spoofchk))
1056         dev_err(dev, "failed to rebuild spoofchk configuration for VF %d\n",
1057             vf->vf_id);
1058 
1059     /* rebuild aggregator node config for main VF VSI */
1060     ice_vf_rebuild_aggregator_node_cfg(vsi);
1061 }
1062 
1063 /**
1064  * ice_vf_ctrl_invalidate_vsi - invalidate ctrl_vsi_idx to remove VSI access
1065  * @vf: VF that control VSI is being invalidated on
1066  */
1067 void ice_vf_ctrl_invalidate_vsi(struct ice_vf *vf)
1068 {
1069     vf->ctrl_vsi_idx = ICE_NO_VSI;
1070 }
1071 
1072 /**
1073  * ice_vf_ctrl_vsi_release - invalidate the VF's control VSI after freeing it
1074  * @vf: VF that control VSI is being released on
1075  */
1076 void ice_vf_ctrl_vsi_release(struct ice_vf *vf)
1077 {
1078     ice_vsi_release(vf->pf->vsi[vf->ctrl_vsi_idx]);
1079     ice_vf_ctrl_invalidate_vsi(vf);
1080 }
1081 
1082 /**
1083  * ice_vf_ctrl_vsi_setup - Set up a VF control VSI
1084  * @vf: VF to setup control VSI for
1085  *
1086  * Returns pointer to the successfully allocated VSI struct on success,
1087  * otherwise returns NULL on failure.
1088  */
1089 struct ice_vsi *ice_vf_ctrl_vsi_setup(struct ice_vf *vf)
1090 {
1091     struct ice_port_info *pi = ice_vf_get_port_info(vf);
1092     struct ice_pf *pf = vf->pf;
1093     struct ice_vsi *vsi;
1094 
1095     vsi = ice_vsi_setup(pf, pi, ICE_VSI_CTRL, vf, NULL);
1096     if (!vsi) {
1097         dev_err(ice_pf_to_dev(pf), "Failed to create VF control VSI\n");
1098         ice_vf_ctrl_invalidate_vsi(vf);
1099     }
1100 
1101     return vsi;
1102 }
1103 
1104 /**
1105  * ice_vf_invalidate_vsi - invalidate vsi_idx/vsi_num to remove VSI access
1106  * @vf: VF to remove access to VSI for
1107  */
1108 void ice_vf_invalidate_vsi(struct ice_vf *vf)
1109 {
1110     vf->lan_vsi_idx = ICE_NO_VSI;
1111     vf->lan_vsi_num = ICE_NO_VSI;
1112 }
1113 
1114 /**
1115  * ice_vf_set_initialized - VF is ready for VIRTCHNL communication
1116  * @vf: VF to set in initialized state
1117  *
1118  * After this function the VF will be ready to receive/handle the
1119  * VIRTCHNL_OP_GET_VF_RESOURCES message
1120  */
1121 void ice_vf_set_initialized(struct ice_vf *vf)
1122 {
1123     ice_set_vf_state_qs_dis(vf);
1124     clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
1125     clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
1126     clear_bit(ICE_VF_STATE_DIS, vf->vf_states);
1127     set_bit(ICE_VF_STATE_INIT, vf->vf_states);
1128     memset(&vf->vlan_v2_caps, 0, sizeof(vf->vlan_v2_caps));
1129 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!