| // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB |
| /* Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved. */ |
| |
| #include <net/pkt_cls.h> |
| #include "htb.h" |
| #include "en.h" |
| #include "../qos.h" |
| |
| struct mlx5e_qos_node { |
| struct hlist_node hnode; |
| struct mlx5e_qos_node *parent; |
| u64 rate; |
| u32 bw_share; |
| u32 max_average_bw; |
| u32 hw_id; |
| u32 classid; /* 16-bit, except root. */ |
| u16 qid; |
| }; |
| |
| struct mlx5e_htb { |
| DECLARE_HASHTABLE(qos_tc2node, order_base_2(MLX5E_QOS_MAX_LEAF_NODES)); |
| DECLARE_BITMAP(qos_used_qids, MLX5E_QOS_MAX_LEAF_NODES); |
| struct mlx5_core_dev *mdev; |
| struct net_device *netdev; |
| struct mlx5e_priv *priv; |
| struct mlx5e_selq *selq; |
| }; |
| |
| #define MLX5E_QOS_QID_INNER 0xffff |
| #define MLX5E_HTB_CLASSID_ROOT 0xffffffff |
| |
| /* Software representation of the QoS tree */ |
| |
| int mlx5e_htb_enumerate_leaves(struct mlx5e_htb *htb, mlx5e_fp_htb_enumerate callback, void *data) |
| { |
| struct mlx5e_qos_node *node = NULL; |
| int bkt, err; |
| |
| hash_for_each(htb->qos_tc2node, bkt, node, hnode) { |
| if (node->qid == MLX5E_QOS_QID_INNER) |
| continue; |
| err = callback(data, node->qid, node->hw_id); |
| if (err) |
| return err; |
| } |
| return 0; |
| } |
| |
| int mlx5e_htb_cur_leaf_nodes(struct mlx5e_htb *htb) |
| { |
| int last; |
| |
| last = find_last_bit(htb->qos_used_qids, mlx5e_qos_max_leaf_nodes(htb->mdev)); |
| return last == mlx5e_qos_max_leaf_nodes(htb->mdev) ? 0 : last + 1; |
| } |
| |
| static int mlx5e_htb_find_unused_qos_qid(struct mlx5e_htb *htb) |
| { |
| int size = mlx5e_qos_max_leaf_nodes(htb->mdev); |
| struct mlx5e_priv *priv = htb->priv; |
| int res; |
| |
| WARN_ONCE(!mutex_is_locked(&priv->state_lock), "%s: state_lock is not held\n", __func__); |
| res = find_first_zero_bit(htb->qos_used_qids, size); |
| |
| return res == size ? -ENOSPC : res; |
| } |
| |
| static struct mlx5e_qos_node * |
| mlx5e_htb_node_create_leaf(struct mlx5e_htb *htb, u16 classid, u16 qid, |
| struct mlx5e_qos_node *parent) |
| { |
| struct mlx5e_qos_node *node; |
| |
| node = kzalloc(sizeof(*node), GFP_KERNEL); |
| if (!node) |
| return ERR_PTR(-ENOMEM); |
| |
| node->parent = parent; |
| |
| node->qid = qid; |
| __set_bit(qid, htb->qos_used_qids); |
| |
| node->classid = classid; |
| hash_add_rcu(htb->qos_tc2node, &node->hnode, classid); |
| |
| mlx5e_update_tx_netdev_queues(htb->priv); |
| |
| return node; |
| } |
| |
| static struct mlx5e_qos_node *mlx5e_htb_node_create_root(struct mlx5e_htb *htb) |
| { |
| struct mlx5e_qos_node *node; |
| |
| node = kzalloc(sizeof(*node), GFP_KERNEL); |
| if (!node) |
| return ERR_PTR(-ENOMEM); |
| |
| node->qid = MLX5E_QOS_QID_INNER; |
| node->classid = MLX5E_HTB_CLASSID_ROOT; |
| hash_add_rcu(htb->qos_tc2node, &node->hnode, node->classid); |
| |
| return node; |
| } |
| |
| static struct mlx5e_qos_node *mlx5e_htb_node_find(struct mlx5e_htb *htb, u32 classid) |
| { |
| struct mlx5e_qos_node *node = NULL; |
| |
| hash_for_each_possible(htb->qos_tc2node, node, hnode, classid) { |
| if (node->classid == classid) |
| break; |
| } |
| |
| return node; |
| } |
| |
| static struct mlx5e_qos_node *mlx5e_htb_node_find_rcu(struct mlx5e_htb *htb, u32 classid) |
| { |
| struct mlx5e_qos_node *node = NULL; |
| |
| hash_for_each_possible_rcu(htb->qos_tc2node, node, hnode, classid) { |
| if (node->classid == classid) |
| break; |
| } |
| |
| return node; |
| } |
| |
| static void mlx5e_htb_node_delete(struct mlx5e_htb *htb, struct mlx5e_qos_node *node) |
| { |
| hash_del_rcu(&node->hnode); |
| if (node->qid != MLX5E_QOS_QID_INNER) { |
| __clear_bit(node->qid, htb->qos_used_qids); |
| mlx5e_update_tx_netdev_queues(htb->priv); |
| } |
| /* Make sure this qid is no longer selected by mlx5e_select_queue, so |
| * that mlx5e_reactivate_qos_sq can safely restart the netdev TX queue. |
| */ |
| synchronize_net(); |
| kfree(node); |
| } |
| |
| /* TX datapath API */ |
| |
| int mlx5e_htb_get_txq_by_classid(struct mlx5e_htb *htb, u16 classid) |
| { |
| struct mlx5e_qos_node *node; |
| u16 qid; |
| int res; |
| |
| rcu_read_lock(); |
| |
| node = mlx5e_htb_node_find_rcu(htb, classid); |
| if (!node) { |
| res = -ENOENT; |
| goto out; |
| } |
| qid = READ_ONCE(node->qid); |
| if (qid == MLX5E_QOS_QID_INNER) { |
| res = -EINVAL; |
| goto out; |
| } |
| res = mlx5e_qid_from_qos(&htb->priv->channels, qid); |
| |
| out: |
| rcu_read_unlock(); |
| return res; |
| } |
| |
| /* HTB TC handlers */ |
| |
| static int |
| mlx5e_htb_root_add(struct mlx5e_htb *htb, u16 htb_maj_id, u16 htb_defcls, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_priv *priv = htb->priv; |
| struct mlx5e_qos_node *root; |
| bool opened; |
| int err; |
| |
| qos_dbg(htb->mdev, "TC_HTB_CREATE handle %04x:, default :%04x\n", htb_maj_id, htb_defcls); |
| |
| mlx5e_selq_prepare_htb(htb->selq, htb_maj_id, htb_defcls); |
| |
| opened = test_bit(MLX5E_STATE_OPENED, &priv->state); |
| if (opened) { |
| err = mlx5e_qos_alloc_queues(priv, &priv->channels); |
| if (err) |
| goto err_cancel_selq; |
| } |
| |
| root = mlx5e_htb_node_create_root(htb); |
| if (IS_ERR(root)) { |
| err = PTR_ERR(root); |
| goto err_free_queues; |
| } |
| |
| err = mlx5_qos_create_root_node(htb->mdev, &root->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error. Try upgrading firmware."); |
| goto err_sw_node_delete; |
| } |
| |
| mlx5e_selq_apply(htb->selq); |
| |
| return 0; |
| |
| err_sw_node_delete: |
| mlx5e_htb_node_delete(htb, root); |
| |
| err_free_queues: |
| if (opened) |
| mlx5e_qos_close_all_queues(&priv->channels); |
| err_cancel_selq: |
| mlx5e_selq_cancel(htb->selq); |
| return err; |
| } |
| |
| static int mlx5e_htb_root_del(struct mlx5e_htb *htb) |
| { |
| struct mlx5e_priv *priv = htb->priv; |
| struct mlx5e_qos_node *root; |
| int err; |
| |
| qos_dbg(htb->mdev, "TC_HTB_DESTROY\n"); |
| |
| /* Wait until real_num_tx_queues is updated for mlx5e_select_queue, |
| * so that we can safely switch to its non-HTB non-PTP fastpath. |
| */ |
| synchronize_net(); |
| |
| mlx5e_selq_prepare_htb(htb->selq, 0, 0); |
| mlx5e_selq_apply(htb->selq); |
| |
| root = mlx5e_htb_node_find(htb, MLX5E_HTB_CLASSID_ROOT); |
| if (!root) { |
| qos_err(htb->mdev, "Failed to find the root node in the QoS tree\n"); |
| return -ENOENT; |
| } |
| err = mlx5_qos_destroy_node(htb->mdev, root->hw_id); |
| if (err) |
| qos_err(htb->mdev, "Failed to destroy root node %u, err = %d\n", |
| root->hw_id, err); |
| mlx5e_htb_node_delete(htb, root); |
| |
| mlx5e_qos_deactivate_all_queues(&priv->channels); |
| mlx5e_qos_close_all_queues(&priv->channels); |
| |
| return err; |
| } |
| |
| static int mlx5e_htb_convert_rate(struct mlx5e_htb *htb, u64 rate, |
| struct mlx5e_qos_node *parent, u32 *bw_share) |
| { |
| u64 share = 0; |
| |
| while (parent->classid != MLX5E_HTB_CLASSID_ROOT && !parent->max_average_bw) |
| parent = parent->parent; |
| |
| if (parent->max_average_bw) |
| share = div64_u64(div_u64(rate * 100, BYTES_IN_MBIT), |
| parent->max_average_bw); |
| else |
| share = 101; |
| |
| *bw_share = share == 0 ? 1 : share > 100 ? 0 : share; |
| |
| qos_dbg(htb->mdev, "Convert: rate %llu, parent ceil %llu -> bw_share %u\n", |
| rate, (u64)parent->max_average_bw * BYTES_IN_MBIT, *bw_share); |
| |
| return 0; |
| } |
| |
| static void mlx5e_htb_convert_ceil(struct mlx5e_htb *htb, u64 ceil, u32 *max_average_bw) |
| { |
| /* Hardware treats 0 as "unlimited", set at least 1. */ |
| *max_average_bw = max_t(u32, div_u64(ceil, BYTES_IN_MBIT), 1); |
| |
| qos_dbg(htb->mdev, "Convert: ceil %llu -> max_average_bw %u\n", |
| ceil, *max_average_bw); |
| } |
| |
| int |
| mlx5e_htb_leaf_alloc_queue(struct mlx5e_htb *htb, u16 classid, |
| u32 parent_classid, u64 rate, u64 ceil, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_qos_node *node, *parent; |
| struct mlx5e_priv *priv = htb->priv; |
| int qid; |
| int err; |
| |
| qos_dbg(htb->mdev, "TC_HTB_LEAF_ALLOC_QUEUE classid %04x, parent %04x, rate %llu, ceil %llu\n", |
| classid, parent_classid, rate, ceil); |
| |
| qid = mlx5e_htb_find_unused_qos_qid(htb); |
| if (qid < 0) { |
| NL_SET_ERR_MSG_MOD(extack, "Maximum amount of leaf classes is reached."); |
| return qid; |
| } |
| |
| parent = mlx5e_htb_node_find(htb, parent_classid); |
| if (!parent) |
| return -EINVAL; |
| |
| node = mlx5e_htb_node_create_leaf(htb, classid, qid, parent); |
| if (IS_ERR(node)) |
| return PTR_ERR(node); |
| |
| node->rate = rate; |
| mlx5e_htb_convert_rate(htb, rate, node->parent, &node->bw_share); |
| mlx5e_htb_convert_ceil(htb, ceil, &node->max_average_bw); |
| |
| err = mlx5_qos_create_leaf_node(htb->mdev, node->parent->hw_id, |
| node->bw_share, node->max_average_bw, |
| &node->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when creating a leaf node."); |
| qos_err(htb->mdev, "Failed to create a leaf node (class %04x), err = %d\n", |
| classid, err); |
| mlx5e_htb_node_delete(htb, node); |
| return err; |
| } |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| err = mlx5e_open_qos_sq(priv, &priv->channels, node->qid, node->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Error creating an SQ."); |
| qos_warn(htb->mdev, "Failed to create a QoS SQ (class %04x), err = %d\n", |
| classid, err); |
| } else { |
| mlx5e_activate_qos_sq(priv, node->qid, node->hw_id); |
| } |
| } |
| |
| return mlx5e_qid_from_qos(&priv->channels, node->qid); |
| } |
| |
| int |
| mlx5e_htb_leaf_to_inner(struct mlx5e_htb *htb, u16 classid, u16 child_classid, |
| u64 rate, u64 ceil, struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_qos_node *node, *child; |
| struct mlx5e_priv *priv = htb->priv; |
| int err, tmp_err; |
| u32 new_hw_id; |
| u16 qid; |
| |
| qos_dbg(htb->mdev, "TC_HTB_LEAF_TO_INNER classid %04x, upcoming child %04x, rate %llu, ceil %llu\n", |
| classid, child_classid, rate, ceil); |
| |
| node = mlx5e_htb_node_find(htb, classid); |
| if (!node) |
| return -ENOENT; |
| |
| err = mlx5_qos_create_inner_node(htb->mdev, node->parent->hw_id, |
| node->bw_share, node->max_average_bw, |
| &new_hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when creating an inner node."); |
| qos_err(htb->mdev, "Failed to create an inner node (class %04x), err = %d\n", |
| classid, err); |
| return err; |
| } |
| |
| /* Intentionally reuse the qid for the upcoming first child. */ |
| child = mlx5e_htb_node_create_leaf(htb, child_classid, node->qid, node); |
| if (IS_ERR(child)) { |
| err = PTR_ERR(child); |
| goto err_destroy_hw_node; |
| } |
| |
| child->rate = rate; |
| mlx5e_htb_convert_rate(htb, rate, node, &child->bw_share); |
| mlx5e_htb_convert_ceil(htb, ceil, &child->max_average_bw); |
| |
| err = mlx5_qos_create_leaf_node(htb->mdev, new_hw_id, child->bw_share, |
| child->max_average_bw, &child->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when creating a leaf node."); |
| qos_err(htb->mdev, "Failed to create a leaf node (class %04x), err = %d\n", |
| classid, err); |
| goto err_delete_sw_node; |
| } |
| |
| /* No fail point. */ |
| |
| qid = node->qid; |
| /* Pairs with mlx5e_htb_get_txq_by_classid. */ |
| WRITE_ONCE(node->qid, MLX5E_QOS_QID_INNER); |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| mlx5e_deactivate_qos_sq(priv, qid); |
| mlx5e_close_qos_sq(priv, qid); |
| } |
| |
| err = mlx5_qos_destroy_node(htb->mdev, node->hw_id); |
| if (err) /* Not fatal. */ |
| qos_warn(htb->mdev, "Failed to destroy leaf node %u (class %04x), err = %d\n", |
| node->hw_id, classid, err); |
| |
| node->hw_id = new_hw_id; |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| err = mlx5e_open_qos_sq(priv, &priv->channels, child->qid, child->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Error creating an SQ."); |
| qos_warn(htb->mdev, "Failed to create a QoS SQ (class %04x), err = %d\n", |
| classid, err); |
| } else { |
| mlx5e_activate_qos_sq(priv, child->qid, child->hw_id); |
| } |
| } |
| |
| return 0; |
| |
| err_delete_sw_node: |
| child->qid = MLX5E_QOS_QID_INNER; |
| mlx5e_htb_node_delete(htb, child); |
| |
| err_destroy_hw_node: |
| tmp_err = mlx5_qos_destroy_node(htb->mdev, new_hw_id); |
| if (tmp_err) /* Not fatal. */ |
| qos_warn(htb->mdev, "Failed to roll back creation of an inner node %u (class %04x), err = %d\n", |
| new_hw_id, classid, tmp_err); |
| return err; |
| } |
| |
| static struct mlx5e_qos_node *mlx5e_htb_node_find_by_qid(struct mlx5e_htb *htb, u16 qid) |
| { |
| struct mlx5e_qos_node *node = NULL; |
| int bkt; |
| |
| hash_for_each(htb->qos_tc2node, bkt, node, hnode) |
| if (node->qid == qid) |
| break; |
| |
| return node; |
| } |
| |
| int mlx5e_htb_leaf_del(struct mlx5e_htb *htb, u16 *classid, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_priv *priv = htb->priv; |
| struct mlx5e_qos_node *node; |
| struct netdev_queue *txq; |
| u16 qid, moved_qid; |
| bool opened; |
| int err; |
| |
| qos_dbg(htb->mdev, "TC_HTB_LEAF_DEL classid %04x\n", *classid); |
| |
| node = mlx5e_htb_node_find(htb, *classid); |
| if (!node) |
| return -ENOENT; |
| |
| /* Store qid for reuse. */ |
| qid = node->qid; |
| |
| opened = test_bit(MLX5E_STATE_OPENED, &priv->state); |
| if (opened) { |
| txq = netdev_get_tx_queue(htb->netdev, |
| mlx5e_qid_from_qos(&priv->channels, qid)); |
| mlx5e_deactivate_qos_sq(priv, qid); |
| mlx5e_close_qos_sq(priv, qid); |
| } |
| |
| err = mlx5_qos_destroy_node(htb->mdev, node->hw_id); |
| if (err) /* Not fatal. */ |
| qos_warn(htb->mdev, "Failed to destroy leaf node %u (class %04x), err = %d\n", |
| node->hw_id, *classid, err); |
| |
| mlx5e_htb_node_delete(htb, node); |
| |
| moved_qid = mlx5e_htb_cur_leaf_nodes(htb); |
| |
| if (moved_qid == 0) { |
| /* The last QoS SQ was just destroyed. */ |
| if (opened) |
| mlx5e_reactivate_qos_sq(priv, qid, txq); |
| return 0; |
| } |
| moved_qid--; |
| |
| if (moved_qid < qid) { |
| /* The highest QoS SQ was just destroyed. */ |
| WARN(moved_qid != qid - 1, "Gaps in queue numeration: destroyed queue %u, the highest queue is %u", |
| qid, moved_qid); |
| if (opened) |
| mlx5e_reactivate_qos_sq(priv, qid, txq); |
| return 0; |
| } |
| |
| WARN(moved_qid == qid, "Can't move node with qid %u to itself", qid); |
| qos_dbg(htb->mdev, "Moving QoS SQ %u to %u\n", moved_qid, qid); |
| |
| node = mlx5e_htb_node_find_by_qid(htb, moved_qid); |
| WARN(!node, "Could not find a node with qid %u to move to queue %u", |
| moved_qid, qid); |
| |
| /* Stop traffic to the old queue. */ |
| WRITE_ONCE(node->qid, MLX5E_QOS_QID_INNER); |
| __clear_bit(moved_qid, priv->htb->qos_used_qids); |
| |
| if (opened) { |
| txq = netdev_get_tx_queue(htb->netdev, |
| mlx5e_qid_from_qos(&priv->channels, moved_qid)); |
| mlx5e_deactivate_qos_sq(priv, moved_qid); |
| mlx5e_close_qos_sq(priv, moved_qid); |
| } |
| |
| /* Prevent packets from the old class from getting into the new one. */ |
| mlx5e_reset_qdisc(htb->netdev, moved_qid); |
| |
| __set_bit(qid, htb->qos_used_qids); |
| WRITE_ONCE(node->qid, qid); |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| err = mlx5e_open_qos_sq(priv, &priv->channels, node->qid, node->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Error creating an SQ."); |
| qos_warn(htb->mdev, "Failed to create a QoS SQ (class %04x) while moving qid %u to %u, err = %d\n", |
| node->classid, moved_qid, qid, err); |
| } else { |
| mlx5e_activate_qos_sq(priv, node->qid, node->hw_id); |
| } |
| } |
| |
| mlx5e_update_tx_netdev_queues(priv); |
| if (opened) |
| mlx5e_reactivate_qos_sq(priv, moved_qid, txq); |
| |
| *classid = node->classid; |
| return 0; |
| } |
| |
| int |
| mlx5e_htb_leaf_del_last(struct mlx5e_htb *htb, u16 classid, bool force, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_qos_node *node, *parent; |
| struct mlx5e_priv *priv = htb->priv; |
| u32 old_hw_id, new_hw_id; |
| int err, saved_err = 0; |
| u16 qid; |
| |
| qos_dbg(htb->mdev, "TC_HTB_LEAF_DEL_LAST%s classid %04x\n", |
| force ? "_FORCE" : "", classid); |
| |
| node = mlx5e_htb_node_find(htb, classid); |
| if (!node) |
| return -ENOENT; |
| |
| err = mlx5_qos_create_leaf_node(htb->mdev, node->parent->parent->hw_id, |
| node->parent->bw_share, |
| node->parent->max_average_bw, |
| &new_hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when creating a leaf node."); |
| qos_err(htb->mdev, "Failed to create a leaf node (class %04x), err = %d\n", |
| classid, err); |
| if (!force) |
| return err; |
| saved_err = err; |
| } |
| |
| /* Store qid for reuse and prevent clearing the bit. */ |
| qid = node->qid; |
| /* Pairs with mlx5e_htb_get_txq_by_classid. */ |
| WRITE_ONCE(node->qid, MLX5E_QOS_QID_INNER); |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| mlx5e_deactivate_qos_sq(priv, qid); |
| mlx5e_close_qos_sq(priv, qid); |
| } |
| |
| /* Prevent packets from the old class from getting into the new one. */ |
| mlx5e_reset_qdisc(htb->netdev, qid); |
| |
| err = mlx5_qos_destroy_node(htb->mdev, node->hw_id); |
| if (err) /* Not fatal. */ |
| qos_warn(htb->mdev, "Failed to destroy leaf node %u (class %04x), err = %d\n", |
| node->hw_id, classid, err); |
| |
| parent = node->parent; |
| mlx5e_htb_node_delete(htb, node); |
| |
| node = parent; |
| WRITE_ONCE(node->qid, qid); |
| |
| /* Early return on error in force mode. Parent will still be an inner |
| * node to be deleted by a following delete operation. |
| */ |
| if (saved_err) |
| return saved_err; |
| |
| old_hw_id = node->hw_id; |
| node->hw_id = new_hw_id; |
| |
| if (test_bit(MLX5E_STATE_OPENED, &priv->state)) { |
| err = mlx5e_open_qos_sq(priv, &priv->channels, node->qid, node->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Error creating an SQ."); |
| qos_warn(htb->mdev, "Failed to create a QoS SQ (class %04x), err = %d\n", |
| classid, err); |
| } else { |
| mlx5e_activate_qos_sq(priv, node->qid, node->hw_id); |
| } |
| } |
| |
| err = mlx5_qos_destroy_node(htb->mdev, old_hw_id); |
| if (err) /* Not fatal. */ |
| qos_warn(htb->mdev, "Failed to destroy leaf node %u (class %04x), err = %d\n", |
| node->hw_id, classid, err); |
| |
| return 0; |
| } |
| |
| static int |
| mlx5e_htb_update_children(struct mlx5e_htb *htb, struct mlx5e_qos_node *node, |
| struct netlink_ext_ack *extack) |
| { |
| struct mlx5e_qos_node *child; |
| int err = 0; |
| int bkt; |
| |
| hash_for_each(htb->qos_tc2node, bkt, child, hnode) { |
| u32 old_bw_share = child->bw_share; |
| int err_one; |
| |
| if (child->parent != node) |
| continue; |
| |
| mlx5e_htb_convert_rate(htb, child->rate, node, &child->bw_share); |
| if (child->bw_share == old_bw_share) |
| continue; |
| |
| err_one = mlx5_qos_update_node(htb->mdev, child->bw_share, |
| child->max_average_bw, child->hw_id); |
| if (!err && err_one) { |
| err = err_one; |
| |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when modifying a child node."); |
| qos_err(htb->mdev, "Failed to modify a child node (class %04x), err = %d\n", |
| node->classid, err); |
| } |
| } |
| |
| return err; |
| } |
| |
| int |
| mlx5e_htb_node_modify(struct mlx5e_htb *htb, u16 classid, u64 rate, u64 ceil, |
| struct netlink_ext_ack *extack) |
| { |
| u32 bw_share, max_average_bw; |
| struct mlx5e_qos_node *node; |
| bool ceil_changed = false; |
| int err; |
| |
| qos_dbg(htb->mdev, "TC_HTB_LEAF_MODIFY classid %04x, rate %llu, ceil %llu\n", |
| classid, rate, ceil); |
| |
| node = mlx5e_htb_node_find(htb, classid); |
| if (!node) |
| return -ENOENT; |
| |
| node->rate = rate; |
| mlx5e_htb_convert_rate(htb, rate, node->parent, &bw_share); |
| mlx5e_htb_convert_ceil(htb, ceil, &max_average_bw); |
| |
| err = mlx5_qos_update_node(htb->mdev, bw_share, |
| max_average_bw, node->hw_id); |
| if (err) { |
| NL_SET_ERR_MSG_MOD(extack, "Firmware error when modifying a node."); |
| qos_err(htb->mdev, "Failed to modify a node (class %04x), err = %d\n", |
| classid, err); |
| return err; |
| } |
| |
| if (max_average_bw != node->max_average_bw) |
| ceil_changed = true; |
| |
| node->bw_share = bw_share; |
| node->max_average_bw = max_average_bw; |
| |
| if (ceil_changed) |
| err = mlx5e_htb_update_children(htb, node, extack); |
| |
| return err; |
| } |
| |
| struct mlx5e_htb *mlx5e_htb_alloc(void) |
| { |
| return kvzalloc(sizeof(struct mlx5e_htb), GFP_KERNEL); |
| } |
| |
| void mlx5e_htb_free(struct mlx5e_htb *htb) |
| { |
| kvfree(htb); |
| } |
| |
| int mlx5e_htb_init(struct mlx5e_htb *htb, struct tc_htb_qopt_offload *htb_qopt, |
| struct net_device *netdev, struct mlx5_core_dev *mdev, |
| struct mlx5e_selq *selq, struct mlx5e_priv *priv) |
| { |
| htb->mdev = mdev; |
| htb->netdev = netdev; |
| htb->selq = selq; |
| htb->priv = priv; |
| hash_init(htb->qos_tc2node); |
| return mlx5e_htb_root_add(htb, htb_qopt->parent_classid, htb_qopt->classid, |
| htb_qopt->extack); |
| } |
| |
| void mlx5e_htb_cleanup(struct mlx5e_htb *htb) |
| { |
| mlx5e_htb_root_del(htb); |
| } |
| |