1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0
"""
Test channel and ring size configuration via ethtool (-L / -G).
"""
from lib.py import ksft_run, ksft_exit, ksft_pr
from lib.py import ksft_eq
from lib.py import NetDrvEpEnv, EthtoolFamily, GenerateTraffic
from lib.py import defer, NlError
def channels(cfg) -> None:
"""
Twiddle channel counts in various combinations of parameters.
We're only looking for driver adhering to the requested config
if the config is accepted and crashes.
"""
ehdr = {'header':{'dev-index': cfg.ifindex}}
chans = cfg.eth.channels_get(ehdr)
all_keys = ["rx", "tx", "combined"]
mixes = [{"combined"}, {"rx", "tx"}, {"rx", "combined"}, {"tx", "combined"},
{"rx", "tx", "combined"},]
# Get the set of keys that device actually supports
restore = {}
supported = set()
for key in all_keys:
if key + "-max" in chans:
supported.add(key)
restore |= {key + "-count": chans[key + "-count"]}
defer(cfg.eth.channels_set, ehdr | restore)
def test_config(config):
try:
cfg.eth.channels_set(ehdr | config)
get = cfg.eth.channels_get(ehdr)
for k, v in config.items():
ksft_eq(get.get(k, 0), v)
except NlError as e:
failed.append(mix)
ksft_pr("Can't set", config, e)
else:
ksft_pr("Okay", config)
failed = []
for mix in mixes:
if not mix.issubset(supported):
continue
# Set all the values in the mix to 1, other supported to 0
config = {}
for key in all_keys:
config[key + "-count"] = 1 if key in mix else 0
test_config(config)
for mix in mixes:
if not mix.issubset(supported):
continue
if mix in failed:
continue
# Set all the values in the mix to max, other supported to 0
config = {}
for key in all_keys:
config[key + "-count"] = chans[key + '-max'] if key in mix else 0
test_config(config)
def _configure_min_ring_cnt(cfg) -> None:
""" Try to configure a single Rx/Tx ring. """
ehdr = {'header':{'dev-index': cfg.ifindex}}
chans = cfg.eth.channels_get(ehdr)
all_keys = ["rx-count", "tx-count", "combined-count"]
restore = {}
config = {}
for key in all_keys:
if key in chans:
restore[key] = chans[key]
config[key] = 0
if chans.get('combined-count', 0) > 1:
config['combined-count'] = 1
elif chans.get('rx-count', 0) > 1 and chans.get('tx-count', 0) > 1:
config['tx-count'] = 1
config['rx-count'] = 1
else:
# looks like we're already on 1 channel
return
cfg.eth.channels_set(ehdr | config)
defer(cfg.eth.channels_set, ehdr | restore)
def ringparam(cfg) -> None:
"""
Tweak the ringparam configuration. Try to run some traffic over min
ring size to make sure it actually functions.
"""
ehdr = {'header':{'dev-index': cfg.ifindex}}
rings = cfg.eth.rings_get(ehdr)
restore = {}
maxes = {}
params = set()
for key in rings.keys():
if 'max' in key:
param = key[:-4]
maxes[param] = rings[key]
params.add(param)
restore[param] = rings[param]
defer(cfg.eth.rings_set, ehdr | restore)
# Speed up the reconfig by configuring just one ring
_configure_min_ring_cnt(cfg)
# Try to reach min on all settings
for param in params:
val = rings[param]
while True:
try:
cfg.eth.rings_set({'header':{'dev-index': cfg.ifindex},
param: val // 2})
if val == 0:
break
val //= 2
except NlError:
break
get = cfg.eth.rings_get(ehdr)
ksft_eq(get[param], val)
ksft_pr(f"Reached min for '{param}' at {val} (max {rings[param]})")
GenerateTraffic(cfg).wait_pkts_and_stop(10000)
# Try max across all params, if the driver supports large rings
# this may OOM so we ignore errors
try:
ksft_pr("Applying max settings")
config = {p: maxes[p] for p in params}
cfg.eth.rings_set(ehdr | config)
except NlError as e:
ksft_pr("Can't set max params", config, e)
else:
GenerateTraffic(cfg).wait_pkts_and_stop(10000)
def main() -> None:
""" Ksft boiler plate main """
with NetDrvEpEnv(__file__) as cfg:
cfg.eth = EthtoolFamily()
ksft_run([channels,
ringparam],
args=(cfg, ))
ksft_exit()
if __name__ == "__main__":
main()
|
