idpf: use a saner limit for default number of queues to allocate

Currently, the maximum number of queues available for one vport is 16.
This is hardcoded, but then the function calculating the optimal number
of queues takes min(16, num_online_cpus()).
In order to be able to allocate more queues, which will be then used for
XDP, stop hardcoding 16 and rely on what the device gives us[*]. Instead
of num_online_cpus(), which is considered suboptimal since at least 2013,
use netif_get_num_default_rss_queues() to still have free queues in the
pool.

[*] With the note:

Currently, idpf always allocates `IDPF_MAX_BUFQS_PER_RXQ_GRP` (== 2)
buffer queues for each Rx queue and one completion queue for each Tx for
best performance. But there was no check whether such number is available,
IOW the assumption was not backed by any "harmonizing" / actual checks.
Fix this while at it.

nr_cpu_ids number of Tx queues are needed only for lockless XDP sending,
the regular stack doesn't benefit from that anyhow.
On a 128-thread Xeon, this now gives me 32 regular Tx queues and leaves
224 free for XDP (128 of which will handle XDP_TX, .ndo_xdp_xmit(), and
XSk xmit when enabled).

Note 2:

Unfortunately, some CP/FW versions are not able to
reconfigure/enable/disable large amount of queues within the minimum
timeout (2 seconds). For now, fall back to the default timeout for
every operation until this is resolved.

Signed-off-by: Alexander Lobakin <aleksander.lobakin@intel.com>
Tested-by: Ramu R <ramu.r@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

diff --git a/drivers/net/ethernet/intel/idpf/idpf_txrx.c b/drivers/net/ethernet/intel/idpf/idpf_txrx.c
index e75a94d7ac2ac493acbf26573c75fe9853ddd404..53fb5cf496cc2eb8011769e4ebe1b74f10757c33 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_txrx.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_txrx.c
@@ -1176,13 +1176,7 @@ int idpf_vport_calc_total_qs(struct idpf_adapter *adapter, u16 vport_idx,
                num_req_tx_qs = vport_config->user_config.num_req_tx_qs;
                num_req_rx_qs = vport_config->user_config.num_req_rx_qs;
        } else {
-               int num_cpus;
-
-               /* Restrict num of queues to cpus online as a default
-                * configuration to give best performance. User can always
-                * override to a max number of queues via ethtool.
-                */
-               num_cpus = num_online_cpus();
+               u32 num_cpus = netif_get_num_default_rss_queues();
 
                dflt_splitq_txq_grps = min_t(int, max_q->max_txq, num_cpus);
                dflt_singleq_txqs = min_t(int, max_q->max_txq, num_cpus);

diff --git a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
index 6330d4a0ae075da0defd52289c02693107aab6fb..fc45c28251d74af840f2555000c68896c067f96b 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.c
@@ -1061,21 +1061,35 @@ int idpf_vport_alloc_max_qs(struct idpf_adapter *adapter,
        struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues;
        struct virtchnl2_get_capabilities *caps = &adapter->caps;
        u16 default_vports = idpf_get_default_vports(adapter);
-       int max_rx_q, max_tx_q;
+       u32 max_rx_q, max_tx_q, max_buf_q, max_compl_q;
 
        mutex_lock(&adapter->queue_lock);
 
+       /* Caps are device-wide. Give each vport an equal piece */
        max_rx_q = le16_to_cpu(caps->max_rx_q) / default_vports;
        max_tx_q = le16_to_cpu(caps->max_tx_q) / default_vports;
-       if (adapter->num_alloc_vports < default_vports) {
-               max_q->max_rxq = min_t(u16, max_rx_q, IDPF_MAX_Q);
-               max_q->max_txq = min_t(u16, max_tx_q, IDPF_MAX_Q);
-       } else {
-               max_q->max_rxq = IDPF_MIN_Q;
-               max_q->max_txq = IDPF_MIN_Q;
+       max_buf_q = le16_to_cpu(caps->max_rx_bufq) / default_vports;
+       max_compl_q = le16_to_cpu(caps->max_tx_complq) / default_vports;
+
+       if (adapter->num_alloc_vports >= default_vports) {
+               max_rx_q = IDPF_MIN_Q;
+               max_tx_q = IDPF_MIN_Q;
        }
-       max_q->max_bufq = max_q->max_rxq * IDPF_MAX_BUFQS_PER_RXQ_GRP;
-       max_q->max_complq = max_q->max_txq;
+
+       /*
+        * Harmonize the numbers. The current implementation always creates
+        * `IDPF_MAX_BUFQS_PER_RXQ_GRP` buffer queues for each Rx queue and
+        * one completion queue for each Tx queue for best performance.
+        * If less buffer or completion queues is available, cap the number
+        * of the corresponding Rx/Tx queues.
+        */
+       max_rx_q = min(max_rx_q, max_buf_q / IDPF_MAX_BUFQS_PER_RXQ_GRP);
+       max_tx_q = min(max_tx_q, max_compl_q);
+
+       max_q->max_rxq = max_rx_q;
+       max_q->max_txq = max_tx_q;
+       max_q->max_bufq = max_rx_q * IDPF_MAX_BUFQS_PER_RXQ_GRP;
+       max_q->max_complq = max_tx_q;
 
        if (avail_queues->avail_rxq < max_q->max_rxq ||
            avail_queues->avail_txq < max_q->max_txq ||
@@ -1506,7 +1520,7 @@ int idpf_send_destroy_vport_msg(struct idpf_vport *vport)
        xn_params.vc_op = VIRTCHNL2_OP_DESTROY_VPORT;
        xn_params.send_buf.iov_base = &v_id;
        xn_params.send_buf.iov_len = sizeof(v_id);
-       xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
+       xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
        reply_sz = idpf_vc_xn_exec(vport->adapter, &xn_params);
 
        return reply_sz < 0 ? reply_sz : 0;
@@ -1554,7 +1568,7 @@ int idpf_send_disable_vport_msg(struct idpf_vport *vport)
        xn_params.vc_op = VIRTCHNL2_OP_DISABLE_VPORT;
        xn_params.send_buf.iov_base = &v_id;
        xn_params.send_buf.iov_len = sizeof(v_id);
-       xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
+       xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
        reply_sz = idpf_vc_xn_exec(vport->adapter, &xn_params);
 
        return reply_sz < 0 ? reply_sz : 0;
@@ -1845,7 +1859,9 @@ static int idpf_send_ena_dis_queues_msg(struct idpf_vport *vport, bool ena)
        struct virtchnl2_del_ena_dis_queues *eq __free(kfree) = NULL;
        struct virtchnl2_queue_chunk *qc __free(kfree) = NULL;
        u32 num_msgs, num_chunks, num_txq, num_rxq, num_q;
-       struct idpf_vc_xn_params xn_params = {};
+       struct idpf_vc_xn_params xn_params = {
+               .timeout_ms     = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC,
+       };
        struct virtchnl2_queue_chunks *qcs;
        u32 config_sz, chunk_sz, buf_sz;
        ssize_t reply_sz;
@@ -1946,13 +1962,10 @@ send_msg:
        if (!eq)
                return -ENOMEM;
 
-       if (ena) {
+       if (ena)
                xn_params.vc_op = VIRTCHNL2_OP_ENABLE_QUEUES;
-               xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
-       } else {
+       else
                xn_params.vc_op = VIRTCHNL2_OP_DISABLE_QUEUES;
-               xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
-       }
 
        for (i = 0, k = 0; i < num_msgs; i++) {
                memset(eq, 0, buf_sz);
@@ -1990,7 +2003,9 @@ int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map)
 {
        struct virtchnl2_queue_vector_maps *vqvm __free(kfree) = NULL;
        struct virtchnl2_queue_vector *vqv __free(kfree) = NULL;
-       struct idpf_vc_xn_params xn_params = {};
+       struct idpf_vc_xn_params xn_params = {
+               .timeout_ms     = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC,
+       };
        u32 config_sz, chunk_sz, buf_sz;
        u32 num_msgs, num_chunks, num_q;
        ssize_t reply_sz;
@@ -2074,13 +2089,10 @@ int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map)
        if (!vqvm)
                return -ENOMEM;
 
-       if (map) {
+       if (map)
                xn_params.vc_op = VIRTCHNL2_OP_MAP_QUEUE_VECTOR;
-               xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
-       } else {
+       else
                xn_params.vc_op = VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR;
-               xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
-       }
 
        for (i = 0, k = 0; i < num_msgs; i++) {
                memset(vqvm, 0, buf_sz);
@@ -2207,7 +2219,7 @@ int idpf_send_delete_queues_msg(struct idpf_vport *vport)
                                         num_chunks);
 
        xn_params.vc_op = VIRTCHNL2_OP_DEL_QUEUES;
-       xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
+       xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
        xn_params.send_buf.iov_base = eq;
        xn_params.send_buf.iov_len = buf_size;
        reply_sz = idpf_vc_xn_exec(vport->adapter, &xn_params);
@@ -2371,7 +2383,7 @@ int idpf_send_dealloc_vectors_msg(struct idpf_adapter *adapter)
        xn_params.vc_op = VIRTCHNL2_OP_DEALLOC_VECTORS;
        xn_params.send_buf.iov_base = vcs;
        xn_params.send_buf.iov_len = buf_size;
-       xn_params.timeout_ms = IDPF_VC_XN_MIN_TIMEOUT_MSEC;
+       xn_params.timeout_ms = IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC;
        reply_sz = idpf_vc_xn_exec(adapter, &xn_params);
        if (reply_sz < 0)
                return reply_sz;

diff --git a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.h b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.h
index 86f30f0db07a709cd0b8840e82047603c694c674..d714ff0eaca0ed5f94e26fdadcd1e9042a79ab65 100644 (file)
--- a/drivers/net/ethernet/intel/idpf/idpf_virtchnl.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_virtchnl.h
@@ -4,7 +4,6 @@
 #ifndef _IDPF_VIRTCHNL_H_
 #define _IDPF_VIRTCHNL_H_
 
-#define IDPF_VC_XN_MIN_TIMEOUT_MSEC    2000
 #define IDPF_VC_XN_DEFAULT_TIMEOUT_MSEC        (60 * 1000)
 #define IDPF_VC_XN_IDX_M               GENMASK(7, 0)
 #define IDPF_VC_XN_SALT_M              GENMASK(15, 8)