Add tx push buf len param to ethtool
Subsystems (6)
v6 cover Add tx push buf len param to ethtool
Changed since v5:
- Added a print of the maximum tx-push-buf-len when user tries to configure a value which exceeds it.
Changed since v4:
- Added advertisement for tx-push-mode in ENA driver
- Modified the documentation to make the distinction from tx-copybreak clearer
Changes since v3:
- Removed RFC tag and added a Jakub's signoff on one of the first patch
Changes since v2:
- Added a check that the driver advertises support for TX push buffer instead of defaulting the response to 0.
- Moved cosmetic changes to their own commits
- Removed usage of gotos which goes against Linux coding style
- Make ENA driver reject an attempt to configure TX push buffer when it's not supported (no LLQ is used)
Changes since v1:
- Added the new ethtool param to generic netlink specs
- Dropped dynamic advertisement of tx push buff support in ENA. The driver will advertise it for all platforms
This patchset adds a new sub-configuration to ethtool get/set queue params (ethtool -g) called 'tx-push-buf-len'.
This configuration specifies the maximum number of bytes of a transmitted packet a driver can push directly to the underlying device ('push' mode). The motivation for pushing some of the bytes to the device has the advantages of
- Allowing a smart device to take fast actions based on the packet's header
- Reducing latency for small packets that can be copied completely into the device
This new param is practically similar to tx-copybreak value that can be set using ethtool's tunable but conceptually serves a different purpose. While tx-copybreak is used to reduce the overhead of DMA mapping and makes no sense to use if less than the whole segment gets copied, tx-push-buf-len allows to improve performance by analyzing the packet's data (usually headers) before performing the DMA operation.
The configuration can be queried and set using the commands:
$ ethtool -g [interface]
# ethtool -G [interface] tx-push-buf-len [number of bytes]
This patchset also adds support for the new configuration in ENA driver for which this parameter ensures efficient resources management on the device side.
David Arinzon (1):
net: ena: Add an option to configure large LLQ headers
Shay Agroskin (6):
netlink: Add a macro to set policy message with format string
ethtool: Add support for configuring tx_push_buf_len
net: ena: Make few cosmetic preparations to support large LLQ
net: ena: Recalculate TX state variables every device reset
net: ena: Add support to changing tx_push_buf_len
net: ena: Advertise TX push support
Documentation/netlink/specs/ethtool.yaml | 8 + Documentation/networking/ethtool-netlink.rst | 47 ++-- drivers/net/ethernet/amazon/ena/ena_eth_com.h | 4 + drivers/net/ethernet/amazon/ena/ena_ethtool.c | 66 ++++- drivers/net/ethernet/amazon/ena/ena_netdev.c | 259 +++++++++++------- drivers/net/ethernet/amazon/ena/ena_netdev.h | 15 +- include/linux/ethtool.h | 14 +- include/linux/netlink.h | 13 + include/uapi/linux/ethtool_netlink.h | 2 + net/ethtool/netlink.h | 2 +- net/ethtool/rings.c | 34 ++- 11 files changed, 340 insertions(+), 124 deletions(-)
Signature · 1 line
2.25.1
PATCH v6 1/7 netlink: Add a macro to set policy message with format string
Similar to NL_SET_ERR_MSG_FMT, add a macro which sets netlink policy error message with a format string.
--- include/linux/netlink.h | 13 +++++++++++++ 1 file changed, 13 insertions(+)
include/linux/netlink.h +13 -0
@@ -161,9 +161,22 @@ struct netlink_ext_ack { } \ }while (0 ) +#define NL_SET_ERR_MSG_ATTR_POL_FMT(extack, attr, pol, fmt, args...) do { \ +struct netlink_ext_ack *__extack = (extack); \ + \ +if (__extack) { \ + NL_SET_ERR_MSG_FMT(extack, fmt, ##args); \ + __extack->bad_attr = (attr); \ + __extack->policy = (pol); \ + } \ +} while (0) +#define NL_SET_ERR_MSG_ATTR (extack, attr, msg) \ NL_SET_ERR_MSG_ATTR_POL(extack, attr, NULL, msg) +#define NL_SET_ERR_MSG_ATTR_FMT(extack, attr, msg, args...) \ + NL_SET_ERR_MSG_ATTR_POL_FMT(extack, attr, NULL, msg, ##args) +#define NL_SET_ERR_ATTR_MISS (extack, nest, type) do { \ struct netlink_ext_ack *__extack = (extack); \ \
Signature · 1 line
2.25.1
Paolo Abeni
maintainerRe: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 13 lines · Shay Agroskin
Similar to
NL_SET_ERR_MSG_FMT, add a macro which sets netlink policy error message with a format string.Signed-off-by Shay Agroskin <[email protected]>--- include/linux/netlink.h | 13 +++++++++++++ 1 file changed, 13 insertions(+)include/linux/netlink.h +0
-0
include/linux/netlink.h struct netlink_ext_ack { · line 168
Quoted 8 lines
include/linux/netlink.h +5
-0@@ -161,9 +161,22 @@ struct netlink_ext_ack { } \ } while (0) +#define NL_SET_ERR_MSG_ATTR_POL_FMT(extack, attr, pol, fmt, args...) do { \ + struct netlink_ext_ack *__extack = (extack); \ + \ + if (__extack) { \ + NL_SET_ERR_MSG_FMT(extack, fmt, ##args); \
You should use '__extack' even above, to avoid multiple evaluation of the 'extack' expression.
Side note: you dropped the acked-by/revied-by tags collected on previous iterations, you could and should have retained them for the unmodified patches.
Thanks,
Paolo
Re: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 21 lines · Paolo Abeni
CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 16 lines · Shay Agroskin
Similar to
NL_SET_ERR_MSG_FMT, add a macro which sets netlink policy error message with a format string.Signed-off-by Shay Agroskin <[email protected]>--- include/linux/netlink.h | 13 +++++++++++++ 1 file changed, 13 insertions(+)include/linux/netlink.h +0
-0@@ -161,9 +161,22 @@ struct netlink_ext_ack { } \ }while (0 )
Quoted 10 lines
include/linux/netlink.h struct netlink_ext_ack { · line 173
Quoted 10 lines
include/linux/netlink.h +5
-0+#define NL_SET_ERR_MSG_ATTR_POL_FMT (extack, attr, pol, fmt, args...) do { \ + struct netlink_ext_ack *__extack = (extack); \ + \ +if (__extack) { \ + NL_SET_ERR_MSG_FMT(extack, fmt, ##args); \
Thanks for reviewing the patch
Quoted 3 lines
You should use '
__extack' even above, to avoid multiple evaluation of the 'extack' expression.
I've got to admit that I don't understand the cost of such evaluations. I thought that it was added to help readers of the source code to understand what is the type of this attribute and have a better warning message when the wrong variable is passed (kind of typing in Python which isn't strictly needed). What cost is there for casting a pointer ?
Quoted 4 lines
Side note: you dropped the acked-by/revied-by tags collected on previous iterations, you could and should have retained them for the unmodified patches.
Yap that's an oversight by my side. Forgot to do it in the last patchset. I'll make sure to do it in the next patchset
Quoted 4 lines
Thanks,
Paolo
Jakub Kicinski
maintainerRe: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 10 lines · On Wed, 22 Mar 2023 14:39:49 +0200 Shay Agroskin wrote:
Quoted 3 lines
You should use '
__extack' even above, to avoid multiple evaluation of
the 'extack' expression.I've got to admit that I don't understand the cost of such evaluations. I thought that it was added to help readers of the source code to understand what is the type of this attribute and have a better warning message when the wrong variable is passed (kind of typing in Python which isn't strictly needed). What cost is there for casting a pointer ?
It's not about the cost, the macros are unfolded by the preprocessor, in the unlikely case someone passes extack++ as an argument using it twice inside the body of the macro will increment the value twice.
#define MACRO(arg) function_bla(arg, arg) // use arg twice
int a = 1;
MACRO(a++);
print(a); // should print 2, will print 3
Re: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 11 lines · Jakub Kicinski
Quoted 5 lines · On Wed, 22 Mar 2023 14:39:49 +0200 Shay Agroskin wrote:
Quoted 2 lines
You should use '
__extack' even above, to avoid multiple evaluation of the 'extack' expression.I've got to admit that I don't understand the cost of such evaluations. I thought that it was added to help readers of the source code to understand what is the type of this attribute and have a better warning message when the wrong variable is passed (kind of typing in Python which isn't strictly needed). What cost is there for casting a pointer ?
It's not about the cost, the macros are unfolded by the preprocessor, in the unlikely case someone passes extack++ as an argument using it twice inside the body of the macro will increment the value twice.
Quoted 5 lines
#define MACRO(arg)
function_bla(arg, arg)// use arg twiceint a = 1;
MACRO(a++);
print(a); // should print 2, will print 3
Thanks for explaining, that's quite cool how something like this can cause a very hard to find bug.
Couldn't find a way to avoid both code duplication and evaluating extact only once \= Submitted a new patchset with the modified version of this macro.
Also added Reviewed-by tags where appropriate
Jakub Kicinski
maintainerRe: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 3 lines · On Thu, 23 Mar 2023 18:38:59 +0200 Shay Agroskin wrote:
Couldn't find a way to avoid both code duplication and evaluating extact only once \= Submitted a new patchset with the modified version of this macro.
That's why we have the local variable called __extack, that we *can* use multiple times, because it's a separate variable, (extack) is evaluated only once, to initialize it...
We don't need to copy the string formatting, unless I'm missing something. Paolo was just asking for:
- NL_SET_ERR_MSG_FMT(extack, fmt, ##args);
+ NL_SET_ERR_MSG_FMT(__extack, fmt, ##args);
that's it.
Re: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 19 lines · Jakub Kicinski
CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 3 lines · On Thu, 23 Mar 2023 18:38:59 +0200 Shay Agroskin wrote:
Couldn't find a way to avoid both code duplication and evaluating extact only once \= Submitted a new patchset with the modified version of this macro.
That's why we have the local variable called
__extack, that we *can* use multiple times, because it's a separate variable, (extack) is evaluated only once, to initialize it...We don't need to copy the string formatting, unless I'm missing something. Paolo was just asking for:
(quoted diff) +1
-1- NL_SET_ERR_MSG_FMT(extack, fmt, ##args); + NL_SET_ERR_MSG_FMT(__extack, fmt, ##args);
Quoted 1 line
that's it.
Oh shoot... That makes much more sense than my solution ....
Thanks
Re: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
In reply to Jakub KicinskiQuoted 9 lines · Jakub Kicinski
CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 3 lines · On Thu, 23 Mar 2023 18:38:59 +0200 Shay Agroskin wrote:
Couldn't find a way to avoid both code duplication and evaluating extact only once \= Submitted a new patchset with the modified version of this macro.
Quoted 6 lines
That's why we have the local variable called
__extack, that we *can* use multiple times, because it's a separate variable, (extack) is evaluated only once, to initialize it...We don't need to copy the string formatting, unless I'm missing something. Paolo was just asking for:
There is an issue with shadowing __extack by NL_SET_ERR_MSG_FMT causing the changes to __extack not to be propagated back to the caller. I'm not that big of an expert in C but changing __extack -> _extack fixes the shadowing issue.
Might not be the most robust solution, though it might suffice for this use case.
Quoted 5 lines
(quoted diff) +1
-1- NL_SET_ERR_MSG_FMT(extack, fmt, ##args); + NL_SET_ERR_MSG_FMT(__extack, fmt, ##args);that's it.
Jakub Kicinski
maintainerRe: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 9 lines · On Thu, 23 Mar 2023 21:44:52 +0200 Shay Agroskin wrote:
Quoted 8 lines
That's why we have the local variable called
__extack, that we *can*
use multiple times, because it's a separate variable, (extack) is
evaluated only once, to initialize it...We don't need to copy the string formatting, unless I'm missing something. Paolo was just asking for:
Quoted 8 lines
There is an issue with shadowing
__extackbyNL_SET_ERR_MSG_FMTcausing the changes to__extacknot to be propagated back to the caller.
I'm not that big of an expert in C but changing__extack->_extackfixes the shadowing issue.Might not be the most robust solution, though it might suffice for this use case.
TBH the hierarchy should be the other way around, NL_SET_ERR_MSG_FMT() should be converted to be:
#define NL_SET_ERR_MSG_FMT(extack, attr, msg, args...) \
NL_SET_ERR_MSG_ATTR_POL_FMT(extack, NULL, NULL, msg, ##args)
and that'd fix the shadowing, right?
Re: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 23 lines · Jakub Kicinski
CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 9 lines · On Thu, 23 Mar 2023 21:44:52 +0200 Shay Agroskin wrote:
Quoted 8 lines
That's why we have the local variable called
__extack, that we *can*
use multiple times, because it's a separate variable, (extack) is
evaluated only once, to initialize it...We don't need to copy the string formatting, unless I'm missing something. Paolo was just asking for:
Quoted 8 lines
There is an issue with shadowing
__extackbyNL_SET_ERR_MSG_FMTcausing the changes to__extacknot to be propagated back to the caller.
I'm not that big of an expert in C but changing__extack->_extackfixes the shadowing issue.Might not be the most robust solution, though it might suffice for this use case.
Quoted 8 lines
TBH the hierarchy should be the other way around,
NL_SET_ERR_MSG_FMT()should be converted to be:#define
NL_SET_ERR_MSG_FMT(extack, attr, msg, args...)\
NL_SET_ERR_MSG_ATTR_POL_FMT(extack, NULL, NULL, msg, ##args)and that'd fix the shadowing, right?
Well ... It will but it will contradict the current order of calls as I see it.
NL_SET_ERR_MSG_FMT_MOD calls NL_SET_ERR_MSG_FMT which can be described as 'the former extends the latter'.
On the other hand NL_SET_ERR_MSG_ATTR_POL implements the message setting by itself and doesn't use NL_SET_ERR_MSG to set the message.
So it seems like we already have two approaches for macro ordering here and following your suggestion would create another type of call direction of 'the former shrinks the latter by setting to NULL its attributes'.
Overall given the nature of C macros and the weird issues arise by shadowing variables (ending up for some reason in not modifying the pointer at all..) I'd say I mostly prefer V7 version which re-implements the message setting and avoids creating such very hard to find issues later.
Then again I'd follow your implementation suggestion if you still prefer it (also I can modify the macro NL_SET_ERR_MSG to call NL_SET_ERR_MSG_ATTR_POL to be consistent with the other change)
Shay
Jakub Kicinski
maintainerRe: [PATCH v6 net-next 1/7] netlink: Add a macro to set policy message with format string
Quoted 30 lines · On Sat, 25 Mar 2023 16:49:34 +0300 Shay Agroskin wrote:
Quoted 9 lines
TBH the hierarchy should be the other way around,
NL_SET_ERR_MSG_FMT()
should be converted to be:#define
NL_SET_ERR_MSG_FMT(extack, attr, msg, args...)\
NL_SET_ERR_MSG_ATTR_POL_FMT(extack, NULL, NULL, msg, ##args)and that'd fix the shadowing, right?
Well ... It will but it will contradict the current order of calls as I see it.
NL_SET_ERR_MSG_FMT_MODcallsNL_SET_ERR_MSG_FMTwhich can be described as 'the former extends the latter'.On the other hand
NL_SET_ERR_MSG_ATTR_POLimplements the message setting by itself and doesn't useNL_SET_ERR_MSGto set the message.So it seems like we already have two approaches for macro ordering here and following your suggestion would create another type of call direction of 'the former shrinks the latter by setting to NULL its attributes'.
Overall given the nature of C macros and the weird issues arise by shadowing variables (ending up for some reason in not modifying the pointer at all..) I'd say I mostly prefer V7 version which re-implements the message setting and avoids creating such very hard to find issues later.
Quoted 3 lines
Then again I'd follow your implementation suggestion if you still prefer it (also I can modify the macro
NL_SET_ERR_MSGto callNL_SET_ERR_MSG_ATTR_POLto be consistent with the other change)
Alright, it doesn't matter all that much.
PATCH v6 2/7 ethtool: Add support for configuring tx_push_buf_len
In reply to Shay AgroskinThis attribute, which is part of ethtool's ring param configuration allows the user to specify the maximum number of the packet's payload that can be written directly to the device.
Example usage:
# ethtool -G [interface] tx-push-buf-len [number of bytes]
--- Documentation/netlink/specs/ethtool.yaml | 8 ++++ Documentation/networking/ethtool-netlink.rst | 47 +++++++++++++------- include/linux/ethtool.h | 14 ++++-- include/uapi/linux/ethtool_netlink.h | 2 + net/ethtool/netlink.h | 2 +- net/ethtool/rings.c | 34 +++++++++++++- 6 files changed, 84 insertions(+), 23 deletions(-)
Documentation/netlink/specs/ethtool.yaml +8 -0
@@ -165,6 +165,12 @@ attribute-sets: - name: rx-push type: u8 + - + name: tx-push-buf-len + type: u32 + - + name: tx-push-buf-len-max + type: u32 - name: mm-stat
@@ -311,6 +317,8 @@ operations: - cqe-size - tx-push - rx-push + - tx-push-buf-len + - tx-push-buf-len-max dump: *ring-get-op - name: rings-set
Documentation/networking/ethtool-netlink.rst +31 -16
65 lines not on this page · raw message
include/linux/ethtool.h +10 -4
@@ -75,6 +75,8 @@ enum {* @tx_push: The flag of tx push mode * @rx_push: The flag of rx push mode * @cqe_size: Size of TX/RX completion queue event +* @tx_push_buf_len: Size of TX push buffer +* @tx_push_buf_max_len: Maximum allowed size of TX push buffer */ struct kernel_ethtool_ringparam {u32 rx_buf_len;
@@ -82,6 +84,8 @@ struct kernel_ethtool_ringparam {u8 tx_push;u8 rx_push;u32 cqe_size; +u32 tx_push_buf_len; +u32 tx_push_buf_max_len; };/**
@@ -90,12 +94,14 @@ struct kernel_ethtool_ringparam {* @ETHTOOL_RING_USE_CQE_SIZE: capture for setting cqe_size * @ETHTOOL_RING_USE_TX_PUSH: capture for setting tx_push * @ETHTOOL_RING_USE_RX_PUSH: capture for setting rx_push +* @ETHTOOL_RING_USE_TX_PUSH_BUF_LEN: capture for setting tx_push_buf_len */ enum ethtool_supported_ring_param { -ETHTOOL_RING_USE_RX_BUF_LEN =BIT (0 ), -ETHTOOL_RING_USE_CQE_SIZE =BIT (1 ), -ETHTOOL_RING_USE_TX_PUSH =BIT (2 ), -ETHTOOL_RING_USE_RX_PUSH =BIT (3 ), +ETHTOOL_RING_USE_RX_BUF_LEN =BIT (0 ), +ETHTOOL_RING_USE_CQE_SIZE =BIT (1 ), +ETHTOOL_RING_USE_TX_PUSH =BIT (2 ), +ETHTOOL_RING_USE_RX_PUSH =BIT (3 ), +ETHTOOL_RING_USE_TX_PUSH_BUF_LEN =BIT (4 ), };#define __ETH_RSS_HASH_BIT (bit) ((u32)1 << (bit))
include/uapi/linux/ethtool_netlink.h +2 -0
@@ -357,6 +357,8 @@ enum {ETHTOOL_A_RINGS_CQE_SIZE ,/* u32 */ ETHTOOL_A_RINGS_TX_PUSH ,/* u8 */ ETHTOOL_A_RINGS_RX_PUSH ,/* u8 */ +ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN ,/* u32 */ +ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX ,/* u32 */ /* add new constants above here */ __ETHTOOL_A_RINGS_CNT,
net/ethtool/netlink.h +1 -1
@@ -413,7 +413,7 @@ extern const struct nla_policy ethnl_features_set_policy[ETHTOOL_A_FEATURES_WANTextern const struct nla_policy ethnl_privflags_get_policy[ETHTOOL_A_PRIVFLAGS_HEADER +1 ];extern const struct nla_policy ethnl_privflags_set_policy[ETHTOOL_A_PRIVFLAGS_FLAGS +1 ];extern const struct nla_policy ethnl_rings_get_policy[ETHTOOL_A_RINGS_HEADER +1 ]; -extern const struct nla_policy ethnl_rings_set_policy[ETHTOOL_A_RINGS_RX_PUSH +1 ]; +extern const struct nla_policy ethnl_rings_set_policy[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX +1 ];extern const struct nla_policy ethnl_channels_get_policy[ETHTOOL_A_CHANNELS_HEADER +1 ];extern const struct nla_policy ethnl_channels_set_policy[ETHTOOL_A_CHANNELS_COMBINED_COUNT +1 ];extern const struct nla_policy ethnl_coalesce_get_policy[ETHTOOL_A_COALESCE_HEADER +1 ];
net/ethtool/rings.c +32 -2
@@ -11,6 +11,7 @@ struct rings_reply_data {struct ethnl_reply_data base;struct ethtool_ringparam ringparam;struct kernel_ethtool_ringparam kernel_ringparam; +u32 supported_ring_params; };#define RINGS_REPDATA (__reply_base) \
@@ -32,6 +33,8 @@ static int rings_prepare_data(const struct ethnl_req_info *req_base,if (!dev->ethtool_ops->get_ringparam)return -EOPNOTSUPP ; + + data->supported_ring_params = dev->ethtool_ops->supported_ring_params; ret =ethnl_ops_begin (dev);if (ret <0 )return ret;
@@ -57,7 +60,9 @@ static int rings_reply_size(const struct ethnl_req_info *req_base,nla_total_size (sizeof (u8)) +/* _RINGS_TCP_DATA_SPLIT */ nla_total_size (sizeof (u32) +/* _RINGS_CQE_SIZE */ nla_total_size (sizeof (u8)) +/* _RINGS_TX_PUSH */ -nla_total_size (sizeof (u8)));/* _RINGS_RX_PUSH */ +nla_total_size (sizeof (u8))) +/* _RINGS_RX_PUSH */ +nla_total_size (sizeof (u32)) +/* _RINGS_TX_PUSH_BUF_LEN */ +nla_total_size (sizeof (u32));/* _RINGS_TX_PUSH_BUF_LEN_MAX */ } static int rings_fill_reply(struct sk_buff *skb,
@@ -67,6 +72,7 @@ static int rings_fill_reply(struct sk_buff *skb,const struct rings_reply_data *data =RINGS_REPDATA (reply_base);const struct kernel_ethtool_ringparam *kr = &data->kernel_ringparam;const struct ethtool_ringparam *ringparam = &data->ringparam; +u32 supported_ring_params = data->supported_ring_params;WARN_ON (kr->tcp_data_split >ETHTOOL_TCP_DATA_SPLIT_ENABLED );
@@ -98,7 +104,12 @@ static int rings_fill_reply(struct sk_buff *skb, (kr->cqe_size && (nla_put_u32 (skb,ETHTOOL_A_RINGS_CQE_SIZE , kr->cqe_size))) ||nla_put_u8 (skb,ETHTOOL_A_RINGS_TX_PUSH , !!kr->tx_push) || - nla_put_u8(skb, ETHTOOL_A_RINGS_RX_PUSH, !!kr->rx_push)) +nla_put_u8 (skb,ETHTOOL_A_RINGS_RX_PUSH , !!kr->rx_push) || + ((supported_ring_params ÐTOOL_RING_USE_TX_PUSH_BUF_LEN ) && + (nla_put_u32 (skb,ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX , + kr->tx_push_buf_max_len) || +nla_put_u32 (skb,ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN , + kr->tx_push_buf_len)))) return -EMSGSIZE;return 0 ;
@@ -117,6 +128,7 @@ const struct nla_policy ethnl_rings_set_policy[] = { [ETHTOOL_A_RINGS_CQE_SIZE] = NLA_POLICY_MIN(NLA_U32, 1), [ETHTOOL_A_RINGS_TX_PUSH] = NLA_POLICY_MAX(NLA_U8, 1), [ETHTOOL_A_RINGS_RX_PUSH] = NLA_POLICY_MAX(NLA_U8, 1), + [ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN] = { .type = NLA_U32 }, }; static int
@@ -158,6 +170,14 @@ ethnl_set_rings_validate(struct ethnl_req_info *req_info,return -EOPNOTSUPP ; } +if (tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN ] && + !(ops->supported_ring_params ÐTOOL_RING_USE_TX_PUSH_BUF_LEN )) { +NL_SET_ERR_MSG_ATTR (info->extack, + tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN ], +"setting tx push buf len is not supported" ); +return -EOPNOTSUPP ; + } +return ops->get_ringparam && ops->set_ringparam ?1 : -EOPNOTSUPP ; }
@@ -189,6 +209,8 @@ ethnl_set_rings(struct ethnl_req_info *req_info, struct genl_info *info) tb[ETHTOOL_A_RINGS_TX_PUSH], &mod);ethnl_update_u8 (&kernel_ringparam.rx_push, tb[ETHTOOL_A_RINGS_RX_PUSH ], &mod); +ethnl_update_u32 (&kernel_ringparam.tx_push_buf_len, + tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN ], &mod);if (!mod)return 0 ;
@@ -209,6 +231,14 @@ ethnl_set_rings(struct ethnl_req_info *req_info, struct genl_info *info)return -EINVAL ; } +if (kernel_ringparam.tx_push_buf_len > kernel_ringparam.tx_push_buf_max_len) { +NL_SET_ERR_MSG_ATTR_FMT (info->extack, tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN ], +"Requested TX push buffer exceeds the maximum of %u" , + kernel_ringparam.tx_push_buf_max_len); + +return -EINVAL ; + } + ret = dev->ethtool_ops->set_ringparam (dev, &ringparam, &kernel_ringparam, info->extack);return ret <0 ? ret :1 ;
Signature · 1 line
2.25.1
PATCH v6 3/7 net: ena: Make few cosmetic preparations to support large LLQ
In reply to Shay AgroskinMove ena_calc_io_queue_size() implementation closer to the file's beginning so that it can be later called from ena_device_init() function without adding a function declaration.
Also add an empty line at some spots to separate logical blocks in funcitons.
--- drivers/net/ethernet/amazon/ena/ena_netdev.c | 133 ++++++++++--------- 1 file changed, 67 insertions(+), 66 deletions(-)
drivers/net/ethernet/amazon/ena/ena_netdev.c +67 -66
@@ -3364,6 +3364,71 @@ static const struct net_device_ops ena_netdev_ops = { .ndo_xdp_xmit = ena_xdp_xmit, }; +static void ena_calc_io_queue_size (struct ena_adapter *adapter, +struct ena_com_dev_get_features_ctx *get_feat_ctx) +{ +struct ena_admin_feature_llq_desc *llq = &get_feat_ctx->llq; +struct ena_com_dev *ena_dev = adapter->ena_dev; +u32 tx_queue_size =ENA_DEFAULT_RING_SIZE ; +u32 rx_queue_size =ENA_DEFAULT_RING_SIZE ; +u32 max_tx_queue_size; +u32 max_rx_queue_size; + +if (ena_dev->supported_features &BIT (ENA_ADMIN_MAX_QUEUES_EXT )) { +struct ena_admin_queue_ext_feature_fields *max_queue_ext = + &get_feat_ctx->max_queue_ext.max_queue_ext; + max_rx_queue_size =min_t (u32, max_queue_ext->max_rx_cq_depth, + max_queue_ext->max_rx_sq_depth); + max_tx_queue_size = max_queue_ext->max_tx_cq_depth; + +if (ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) + max_tx_queue_size =min_t (u32, max_tx_queue_size, + llq->max_llq_depth); +else + max_tx_queue_size =min_t (u32, max_tx_queue_size, + max_queue_ext->max_tx_sq_depth); + + adapter->max_tx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , + max_queue_ext->max_per_packet_tx_descs); + adapter->max_rx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , + max_queue_ext->max_per_packet_rx_descs); + }else { +struct ena_admin_queue_feature_desc *max_queues = + &get_feat_ctx->max_queues; + max_rx_queue_size =min_t (u32, max_queues->max_cq_depth, + max_queues->max_sq_depth); + max_tx_queue_size = max_queues->max_cq_depth; + +if (ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) + max_tx_queue_size =min_t (u32, max_tx_queue_size, + llq->max_llq_depth); +else + max_tx_queue_size =min_t (u32, max_tx_queue_size, + max_queues->max_sq_depth); + + adapter->max_tx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , + max_queues->max_packet_tx_descs); + adapter->max_rx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , + max_queues->max_packet_rx_descs); + } + + max_tx_queue_size =rounddown_pow_of_two (max_tx_queue_size); + max_rx_queue_size =rounddown_pow_of_two (max_rx_queue_size); + + tx_queue_size =clamp_val (tx_queue_size,ENA_MIN_RING_SIZE , + max_tx_queue_size); + rx_queue_size =clamp_val (rx_queue_size,ENA_MIN_RING_SIZE , + max_rx_queue_size); + + tx_queue_size =rounddown_pow_of_two (tx_queue_size); + rx_queue_size =rounddown_pow_of_two (rx_queue_size); + + adapter->max_tx_ring_size = max_tx_queue_size; + adapter->max_rx_ring_size = max_rx_queue_size; + adapter->requested_tx_ring_size = tx_queue_size; + adapter->requested_rx_ring_size = rx_queue_size; +} +static int ena_device_validate_params (struct ena_adapter *adapter,struct ena_com_dev_get_features_ctx *get_feat_ctx) {
@@ -4162,72 +4227,6 @@ static void ena_release_bars(struct ena_com_dev *ena_dev, struct pci_dev *pdev)pci_release_selected_regions (pdev, release_bars); } - -static void ena_calc_io_queue_size (struct ena_adapter *adapter, -struct ena_com_dev_get_features_ctx *get_feat_ctx) -{ -struct ena_admin_feature_llq_desc *llq = &get_feat_ctx->llq; -struct ena_com_dev *ena_dev = adapter->ena_dev; -u32 tx_queue_size =ENA_DEFAULT_RING_SIZE ; -u32 rx_queue_size =ENA_DEFAULT_RING_SIZE ; -u32 max_tx_queue_size; -u32 max_rx_queue_size; - -if (ena_dev->supported_features &BIT (ENA_ADMIN_MAX_QUEUES_EXT )) { -struct ena_admin_queue_ext_feature_fields *max_queue_ext = - &get_feat_ctx->max_queue_ext.max_queue_ext; - max_rx_queue_size =min_t (u32, max_queue_ext->max_rx_cq_depth, - max_queue_ext->max_rx_sq_depth); - max_tx_queue_size = max_queue_ext->max_tx_cq_depth; - -if (ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) - max_tx_queue_size =min_t (u32, max_tx_queue_size, - llq->max_llq_depth); -else - max_tx_queue_size =min_t (u32, max_tx_queue_size, - max_queue_ext->max_tx_sq_depth); - - adapter->max_tx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , - max_queue_ext->max_per_packet_tx_descs); - adapter->max_rx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , - max_queue_ext->max_per_packet_rx_descs); - }else { -struct ena_admin_queue_feature_desc *max_queues = - &get_feat_ctx->max_queues; - max_rx_queue_size =min_t (u32, max_queues->max_cq_depth, - max_queues->max_sq_depth); - max_tx_queue_size = max_queues->max_cq_depth; - -if (ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) - max_tx_queue_size =min_t (u32, max_tx_queue_size, - llq->max_llq_depth); -else - max_tx_queue_size =min_t (u32, max_tx_queue_size, - max_queues->max_sq_depth); - - adapter->max_tx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , - max_queues->max_packet_tx_descs); - adapter->max_rx_sgl_size =min_t (u16,ENA_PKT_MAX_BUFS , - max_queues->max_packet_rx_descs); - } - - max_tx_queue_size =rounddown_pow_of_two (max_tx_queue_size); - max_rx_queue_size =rounddown_pow_of_two (max_rx_queue_size); - - tx_queue_size =clamp_val (tx_queue_size,ENA_MIN_RING_SIZE , - max_tx_queue_size); - rx_queue_size =clamp_val (rx_queue_size,ENA_MIN_RING_SIZE , - max_rx_queue_size); - - tx_queue_size =rounddown_pow_of_two (tx_queue_size); - rx_queue_size =rounddown_pow_of_two (rx_queue_size); - - adapter->max_tx_ring_size = max_tx_queue_size; - adapter->max_rx_ring_size = max_rx_queue_size; - adapter->requested_tx_ring_size = tx_queue_size; - adapter->requested_rx_ring_size = rx_queue_size; -} -/* ena_probe - Device Initialization Routine * @pdev: PCI device information struct * @ent: entry in ena_pci_tbl
@@ -4364,6 +4363,7 @@ static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent) "Failed to query interrupt moderation feature\n"); goto err_device_destroy; } + ena_init_io_rings(adapter, 0, adapter->xdp_num_queues +
@@ -4488,6 +4488,7 @@ static void __ena_shutoff(struct pci_dev *pdev, bool shutdown)rtnl_lock ();/* lock released inside the below if-else block */ adapter->reset_reason =ENA_REGS_RESET_SHUTDOWN ;ena_destroy_device (adapter, true); +if (shutdown) {netif_device_detach (netdev);dev_close (netdev);
Signature · 1 line
2.25.1
PATCH v6 4/7 net: ena: Add an option to configure large LLQ headers
In reply to Shay AgroskinFrom: David Arinzon <[email protected]>
Allow configuring the device with large LLQ headers. The Low Latency Queue (LLQ) allows the driver to write the first N bytes of the packet, along with the rest of the TX descriptors directly into device (N can be either 96 or 224 for large LLQ headers configuration).
Having L4 TCP/UDP headers contained in the first 96 bytes of the packet is required to get maximum performance from the device.
--- drivers/net/ethernet/amazon/ena/ena_netdev.c | 90 +++++++++++++++----- drivers/net/ethernet/amazon/ena/ena_netdev.h | 8 ++ 2 files changed, 76 insertions(+), 22 deletions(-)
drivers/net/ethernet/amazon/ena/ena_netdev.c +68 -22
@@ -3374,6 +3374,15 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter,u32 max_tx_queue_size;u32 max_rx_queue_size; +/* If this function is called after driver load, the ring sizes have already +* been configured. Take it into account when recalculating ring size. +*/ +if (adapter->tx_ring->ring_size) + tx_queue_size = adapter->tx_ring->ring_size; + +if (adapter->rx_ring->ring_size) + rx_queue_size = adapter->rx_ring->ring_size; +if (ena_dev->supported_features &BIT (ENA_ADMIN_MAX_QUEUES_EXT )) {struct ena_admin_queue_ext_feature_fields *max_queue_ext = &get_feat_ctx->max_queue_ext.max_queue_ext;
@@ -3415,6 +3424,24 @@ static void ena_calc_io_queue_size(struct ena_adapter *adapter, max_tx_queue_size =rounddown_pow_of_two (max_tx_queue_size); max_rx_queue_size =rounddown_pow_of_two (max_rx_queue_size); +/* When forcing large headers, we multiply the entry size by 2, and therefore divide +* the queue size by 2, leaving the amount of memory used by the queues unchanged. +*/ +if (adapter->large_llq_header_enabled) { +if ((llq->entry_size_ctrl_supported &ENA_ADMIN_LIST_ENTRY_SIZE_256B ) && + ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) { + max_tx_queue_size /=2 ; +dev_info (&adapter->pdev->dev, +"Forcing large headers and decreasing maximum TX queue size to %d\n" , + max_tx_queue_size); + }else { +dev_err (&adapter->pdev->dev, +"Forcing large headers failed: LLQ is disabled or device does not support large headers\n" ); + + adapter->large_llq_header_enabled = false; + } + } + tx_queue_size =clamp_val (tx_queue_size,ENA_MIN_RING_SIZE , max_tx_queue_size); rx_queue_size = clamp_val(rx_queue_size, ENA_MIN_RING_SIZE,
@@ -3452,13 +3479,30 @@ static int ena_device_validate_params(struct ena_adapter *adapter,return 0 ; } -static void set_default_llq_configurations (struct ena_llq_configurations *llq_config) +static void set_default_llq_configurations (struct ena_adapter *adapter, +struct ena_llq_configurations *llq_config, +struct ena_admin_feature_llq_desc *llq) { +struct ena_com_dev *ena_dev = adapter->ena_dev; + llq_config->llq_header_location =ENA_ADMIN_INLINE_HEADER ; llq_config->llq_stride_ctrl =ENA_ADMIN_MULTIPLE_DESCS_PER_ENTRY ; llq_config->llq_num_decs_before_header =ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_2 ; - llq_config->llq_ring_entry_size =ENA_ADMIN_LIST_ENTRY_SIZE_128B ; - llq_config->llq_ring_entry_size_value =128 ; + + adapter->large_llq_header_supported = + !!(ena_dev->supported_features &BIT (ENA_ADMIN_LLQ )); + adapter->large_llq_header_supported &= + !!(llq->entry_size_ctrl_supported & +ENA_ADMIN_LIST_ENTRY_SIZE_256B ); + +if ((llq->entry_size_ctrl_supported &ENA_ADMIN_LIST_ENTRY_SIZE_256B ) && + adapter->large_llq_header_enabled) { + llq_config->llq_ring_entry_size =ENA_ADMIN_LIST_ENTRY_SIZE_256B ; + llq_config->llq_ring_entry_size_value =256 ; + }else { + llq_config->llq_ring_entry_size =ENA_ADMIN_LIST_ENTRY_SIZE_128B ; + llq_config->llq_ring_entry_size_value =128 ; + } } static int ena_set_queues_placement_policy(struct pci_dev *pdev,
@@ -3477,6 +3521,13 @@ static int ena_set_queues_placement_policy(struct pci_dev *pdev,return 0 ; } +if (!ena_dev->mem_bar) { +netdev_err (ena_dev->net_device, +"LLQ is advertised as supported but device doesn't expose mem bar\n" ); + ena_dev->tx_mem_queue_type =ENA_ADMIN_PLACEMENT_POLICY_HOST ; +return 0 ; + } + rc =ena_com_config_dev_mode (ena_dev, llq, llq_default_configurations);if (unlikely (rc)) { dev_err(&pdev->dev,
@@ -3492,15 +3543,8 @@ static int ena_map_llq_mem_bar(struct pci_dev *pdev, struct ena_com_dev *ena_dev {bool has_mem_bar = !!(bars &BIT (ENA_MEM_BAR )); -if (!has_mem_bar) { -if (ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) { -dev_err (&pdev->dev, -"ENA device does not expose LLQ bar. Fallback to host mode policy.\n" ); - ena_dev->tx_mem_queue_type =ENA_ADMIN_PLACEMENT_POLICY_HOST ; - } - +if (!has_mem_bar)return 0 ; - } ena_dev->mem_bar = devm_ioremap_wc(&pdev->dev, pci_resource_start(pdev, ENA_MEM_BAR),
@@ -3512,10 +3556,11 @@ static int ena_map_llq_mem_bar(struct pci_dev *pdev, struct ena_com_dev *ena_devreturn 0 ; } -static int ena_device_init (struct ena_com_dev *ena_dev,struct pci_dev *pdev, +static int ena_device_init (struct ena_adapter *adapter,struct pci_dev *pdev,struct ena_com_dev_get_features_ctx *get_feat_ctx,bool *wd_state) { +struct ena_com_dev *ena_dev = adapter->ena_dev;struct ena_llq_configurations llq_config;struct device *dev = &pdev->dev;bool readless_supported;
@@ -3600,7 +3645,7 @@ static int ena_device_init(struct ena_com_dev *ena_dev, struct pci_dev *pdev, *wd_state = !!(aenq_groups &BIT (ENA_ADMIN_KEEP_ALIVE )); -set_default_llq_configurations (&llq_config); +set_default_llq_configurations (adapter, &llq_config, &get_feat_ctx->llq); rc =ena_set_queues_placement_policy (pdev, ena_dev, &get_feat_ctx->llq, &llq_config);
@@ -3609,6 +3654,8 @@ static int ena_device_init(struct ena_com_dev *ena_dev, struct pci_dev *pdev, goto err_admin_init; } +ena_calc_io_queue_size (adapter, get_feat_ctx); +return 0 ; err_admin_init:
@@ -3707,7 +3754,7 @@ static int ena_restore_device(struct ena_adapter *adapter)int rc;set_bit (ENA_FLAG_ONGOING_RESET , &adapter->flags); - rc =ena_device_init (ena_dev, adapter->pdev, &get_feat_ctx, &wd_state); + rc =ena_device_init (adapter, adapter->pdev, &get_feat_ctx, &wd_state);if (rc) {dev_err (&pdev->dev,"Can not initialize device\n" ); goto err;
@@ -4309,18 +4356,18 @@ static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent)pci_set_drvdata (pdev, adapter); - rc =ena_device_init (ena_dev, pdev, &get_feat_ctx, &wd_state); + rc =ena_map_llq_mem_bar (pdev, ena_dev, bars);if (rc) { -dev_err (&pdev->dev,"ENA device init failed\n" ); -if (rc == -ETIME ) - rc = -EPROBE_DEFER ; +dev_err (&pdev->dev,"ENA LLQ bar mapping failed\n" ); goto err_netdev_destroy; } - rc =ena_map_llq_mem_bar (pdev, ena_dev, bars); + rc =ena_device_init (adapter, pdev, &get_feat_ctx, &wd_state);if (rc) { -dev_err (&pdev->dev,"ENA llq bar mapping failed\n" ); - goto err_device_destroy; +dev_err (&pdev->dev,"ENA device init failed\n" ); +if (rc == -ETIME ) + rc = -EPROBE_DEFER ; + goto err_netdev_destroy; }/* Initial TX and RX interrupt delay. Assumes 1 usec granularity.
@@ -4330,7 +4377,6 @@ static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ena_dev->intr_moder_rx_interval =ENA_INTR_INITIAL_RX_INTERVAL_USECS ; ena_dev->intr_delay_resolution =ENA_DEFAULT_INTR_DELAY_RESOLUTION ; max_num_io_queues =ena_calc_max_io_queue_num (pdev, ena_dev, &get_feat_ctx); -ena_calc_io_queue_size (adapter, &get_feat_ctx);if (unlikely (!max_num_io_queues)) { rc = -EFAULT ; goto err_device_destroy;
drivers/net/ethernet/amazon/ena/ena_netdev.h +8 -0
@@ -334,6 +334,14 @@ struct ena_adapter {u32 msg_enable; +/* large_llq_header_enabled is used for two purposes: +* 1. Indicates that large LLQ has been requested. +* 2. Indicates whether large LLQ is set or not after device +* initialization / configuration. +*/ +bool large_llq_header_enabled; +bool large_llq_header_supported; +u16 max_tx_sgl_size;u16 max_rx_sgl_size;
Signature · 1 line
2.25.1
PATCH v6 5/7 net: ena: Recalculate TX state variables every device reset
In reply to Shay AgroskinWith the ability to modify LLQ entry size, the size of packet's payload that can be written directly to the device changes. This patch makes the driver recalculate this information every device negotiation (also called device reset).
--- drivers/net/ethernet/amazon/ena/ena_netdev.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
drivers/net/ethernet/amazon/ena/ena_netdev.c +9 -1
@@ -3750,8 +3750,9 @@ static int ena_restore_device(struct ena_adapter *adapter)struct ena_com_dev_get_features_ctx get_feat_ctx;struct ena_com_dev *ena_dev = adapter->ena_dev;struct pci_dev *pdev = adapter->pdev; +struct ena_ring *txr; +int rc, count, i;bool wd_state; -int rc;set_bit (ENA_FLAG_ONGOING_RESET , &adapter->flags); rc =ena_device_init (adapter, adapter->pdev, &get_feat_ctx, &wd_state);
@@ -3761,6 +3762,13 @@ static int ena_restore_device(struct ena_adapter *adapter) } adapter->wd_state = wd_state; + count = adapter->xdp_num_queues + adapter->num_io_queues; +for (i =0 ; i < count; i++) { + txr = &adapter->tx_ring[i]; + txr->tx_mem_queue_type = ena_dev->tx_mem_queue_type; + txr->tx_max_header_size = ena_dev->tx_max_header_size; + } + rc =ena_device_validate_params (adapter, &get_feat_ctx);if (rc) {dev_err (&pdev->dev,"Validation of device parameters failed\n" );
Signature · 1 line
2.25.1
PATCH v6 6/7 net: ena: Add support to changing tx_push_buf_len
In reply to Shay AgroskinThe ENA driver allows for two distinct values for the number of bytes of the packet's payload that can be written directly to the device.
For a value of 224 the driver turns on Large LLQ Header mode in which the first 224 of the packet's payload are written to the LLQ.
--- drivers/net/ethernet/amazon/ena/ena_eth_com.h | 4 ++ drivers/net/ethernet/amazon/ena/ena_ethtool.c | 57 +++++++++++++++++-- drivers/net/ethernet/amazon/ena/ena_netdev.c | 26 +++++++-- drivers/net/ethernet/amazon/ena/ena_netdev.h | 7 ++- 4 files changed, 82 insertions(+), 12 deletions(-)
drivers/net/ethernet/amazon/ena/ena_eth_com.h +4 -0
@@ -10,6 +10,10 @@/* head update threshold in units of (queue size / ENA_COMP_HEAD_THRESH) */ #define ENA_COMP_HEAD_THRESH 4 +/* we allow 2 DMA descriptors per LLQ entry */ +#define ENA_LLQ_ENTRY_DESC_CHUNK_SIZE (2 * sizeof(struct ena_eth_io_tx_desc)) +#define ENA_LLQ_HEADER (128UL - ENA_LLQ_ENTRY_DESC_CHUNK_SIZE) +#define ENA_LLQ_LARGE_HEADER (256UL - ENA_LLQ_ENTRY_DESC_CHUNK_SIZE)struct ena_com_tx_ctx {struct ena_com_tx_meta ena_meta;
drivers/net/ethernet/amazon/ena/ena_ethtool.c +53 -4
83 lines not on this page · raw message
drivers/net/ethernet/amazon/ena/ena_netdev.c +21 -5
@@ -2809,11 +2809,13 @@ static int ena_close(struct net_device *netdev)return 0 ; } -int ena_update_queue_sizes (struct ena_adapter *adapter, -u32 new_tx_size, -u32 new_rx_size) +int ena_update_queue_params (struct ena_adapter *adapter, +u32 new_tx_size, +u32 new_rx_size, +u32 new_llq_header_len) { -bool dev_was_up; +bool dev_was_up, large_llq_changed = false; +int rc =0 ; dev_was_up =test_bit (ENA_FLAG_DEV_UP , &adapter->flags);ena_close (adapter->netdev);
@@ -2823,7 +2825,21 @@ int ena_update_queue_sizes(struct ena_adapter *adapter,0 , adapter->xdp_num_queues + adapter->num_io_queues); -return dev_was_up ?ena_up (adapter) :0 ; + + large_llq_changed = adapter->ena_dev->tx_mem_queue_type == +ENA_ADMIN_PLACEMENT_POLICY_DEV ; + large_llq_changed &= + new_llq_header_len != adapter->ena_dev->tx_max_header_size; + +/* a check that the configuration is valid is done by caller */ +if (large_llq_changed) { + adapter->large_llq_header_enabled = !adapter->large_llq_header_enabled; + +ena_destroy_device (adapter, false); + rc =ena_restore_device (adapter); + } + +return dev_was_up && !rc ?ena_up (adapter) : rc; }int ena_set_rx_copybreak (struct ena_adapter *adapter,u32 rx_copybreak)
drivers/net/ethernet/amazon/ena/ena_netdev.h +4 -3
@@ -396,9 +396,10 @@ void ena_dump_stats_to_buf(struct ena_adapter *adapter, u8 *buf);int ena_update_hw_stats (struct ena_adapter *adapter); -int ena_update_queue_sizes (struct ena_adapter *adapter, -u32 new_tx_size, -u32 new_rx_size); +int ena_update_queue_params (struct ena_adapter *adapter, +u32 new_tx_size, +u32 new_rx_size, +u32 new_llq_header_len);int ena_update_queue_count (struct ena_adapter *adapter,u32 new_channel_count);
Signature · 1 line
2.25.1
PATCH v6 7/7 net: ena: Advertise TX push support
In reply to Shay AgroskinLLQ is auto enabled by the device and disabling it isn't supported on new ENA generations while on old ones causes sub-optimal performance.
This patch adds advertisement of push-mode when LLQ mode is used, but rejects an attempt to modify it.
--- drivers/net/ethernet/amazon/ena/ena_ethtool.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
drivers/net/ethernet/amazon/ena/ena_ethtool.c +10 -1
@@ -479,12 +479,14 @@ static void ena_get_ringparam(struct net_device *netdev,if (adapter->ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) {bool large_llq_supported = adapter->large_llq_header_supported; + kernel_ring->tx_push = true; kernel_ring->tx_push_buf_len = adapter->ena_dev->tx_max_header_size;if (large_llq_supported) kernel_ring->tx_push_buf_max_len =ENA_LLQ_LARGE_HEADER ;else kernel_ring->tx_push_buf_max_len =ENA_LLQ_HEADER ; }else { + kernel_ring->tx_push = false; kernel_ring->tx_push_buf_max_len =0 ; kernel_ring->tx_push_buf_len =0 ; }
@@ -516,6 +518,12 @@ static int ena_set_ringparam(struct net_device *netdev,/* This value is ignored if LLQ is not supported */ new_tx_push_buf_len = adapter->ena_dev->tx_max_header_size; +if ((adapter->ena_dev->tx_mem_queue_type ==ENA_ADMIN_PLACEMENT_POLICY_DEV ) != + kernel_ring->tx_push) { +NL_SET_ERR_MSG_MOD (extack,"Push mode state cannot be modified" ); +return -EINVAL ; + } +/* Validate that the push buffer is supported on the underlying device */ if (kernel_ring->tx_push_buf_len) {enum ena_admin_placement_policy_type placement;
@@ -957,7 +965,8 @@ static int ena_set_tunable(struct net_device *netdev,static const struct ethtool_ops ena_ethtool_ops = { .supported_coalesce_params =ETHTOOL_COALESCE_USECS |ETHTOOL_COALESCE_USE_ADAPTIVE_RX , - .supported_ring_params =ETHTOOL_RING_USE_TX_PUSH_BUF_LEN , + .supported_ring_params =ETHTOOL_RING_USE_TX_PUSH_BUF_LEN | +ETHTOOL_RING_USE_TX_PUSH , .get_link_ksettings = ena_get_link_ksettings, .get_drvinfo = ena_get_drvinfo, .get_msglevel = ena_get_msglevel,
Signature · 1 line
2.25.1