]> Git Repo - linux.git/blob - tools/net/ynl/ethtool.py
treewide: remove meaningless assignments in Makefiles
[linux.git] / tools / net / ynl / ethtool.py
1 #!/usr/bin/env python3
2 # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
3
4 import argparse
5 import json
6 import pprint
7 import sys
8 import re
9
10 from lib import YnlFamily
11
12 def args_to_req(ynl, op_name, args, req):
13     """
14     Verify and convert command-line arguments to the ynl-compatible request.
15     """
16     valid_attrs = ynl.operation_do_attributes(op_name)
17     valid_attrs.remove('header') # not user-provided
18
19     if len(args) == 0:
20         print(f'no attributes, expected: {valid_attrs}')
21         sys.exit(1)
22
23     i = 0
24     while i < len(args):
25         attr = args[i]
26         if i + 1 >= len(args):
27             print(f'expected value for \'{attr}\'')
28             sys.exit(1)
29
30         if attr not in valid_attrs:
31             print(f'invalid attribute \'{attr}\', expected: {valid_attrs}')
32             sys.exit(1)
33
34         val = args[i+1]
35         i += 2
36
37         req[attr] = val
38
39 def print_field(reply, *desc):
40     """
41     Pretty-print a set of fields from the reply. desc specifies the
42     fields and the optional type (bool/yn).
43     """
44     if len(desc) == 0:
45         return print_field(reply, *zip(reply.keys(), reply.keys()))
46
47     for spec in desc:
48         try:
49             field, name, tp = spec
50         except:
51             field, name = spec
52             tp = 'int'
53
54         value = reply.get(field, None)
55         if tp == 'yn':
56             value = 'yes' if value else 'no'
57         elif tp == 'bool' or isinstance(value, bool):
58             value = 'on' if value else 'off'
59         else:
60             value = 'n/a' if value is None else value
61
62         print(f'{name}: {value}')
63
64 def print_speed(name, value):
65     """
66     Print out the speed-like strings from the value dict.
67     """
68     speed_re = re.compile(r'[0-9]+base[^/]+/.+')
69     speed = [ k for k, v in value.items() if v and speed_re.match(k) ]
70     print(f'{name}: {" ".join(speed)}')
71
72 def doit(ynl, args, op_name):
73     """
74     Prepare request header, parse arguments and doit.
75     """
76     req = {
77         'header': {
78           'dev-name': args.device,
79         },
80     }
81
82     args_to_req(ynl, op_name, args.args, req)
83     ynl.do(op_name, req)
84
85 def dumpit(ynl, args, op_name, extra = {}):
86     """
87     Prepare request header, parse arguments and dumpit (filtering out the
88     devices we're not interested in).
89     """
90     reply = ynl.dump(op_name, { 'header': {} } | extra)
91     if not reply:
92         return {}
93
94     for msg in reply:
95         if msg['header']['dev-name'] == args.device:
96             if args.json:
97                 pprint.PrettyPrinter().pprint(msg)
98                 sys.exit(0)
99             msg.pop('header', None)
100             return msg
101
102     print(f"Not supported for device {args.device}")
103     sys.exit(1)
104
105 def bits_to_dict(attr):
106     """
107     Convert ynl-formatted bitmask to a dict of bit=value.
108     """
109     ret = {}
110     if 'bits' not in attr:
111         return dict()
112     if 'bit' not in attr['bits']:
113         return dict()
114     for bit in attr['bits']['bit']:
115         if bit['name'] == '':
116             continue
117         name = bit['name']
118         value = bit.get('value', False)
119         ret[name] = value
120     return ret
121
122 def main():
123     parser = argparse.ArgumentParser(description='ethtool wannabe')
124     parser.add_argument('--json', action=argparse.BooleanOptionalAction)
125     parser.add_argument('--show-priv-flags', action=argparse.BooleanOptionalAction)
126     parser.add_argument('--set-priv-flags', action=argparse.BooleanOptionalAction)
127     parser.add_argument('--show-eee', action=argparse.BooleanOptionalAction)
128     parser.add_argument('--set-eee', action=argparse.BooleanOptionalAction)
129     parser.add_argument('-a', '--show-pause', action=argparse.BooleanOptionalAction)
130     parser.add_argument('-A', '--set-pause', action=argparse.BooleanOptionalAction)
131     parser.add_argument('-c', '--show-coalesce', action=argparse.BooleanOptionalAction)
132     parser.add_argument('-C', '--set-coalesce', action=argparse.BooleanOptionalAction)
133     parser.add_argument('-g', '--show-ring', action=argparse.BooleanOptionalAction)
134     parser.add_argument('-G', '--set-ring', action=argparse.BooleanOptionalAction)
135     parser.add_argument('-k', '--show-features', action=argparse.BooleanOptionalAction)
136     parser.add_argument('-K', '--set-features', action=argparse.BooleanOptionalAction)
137     parser.add_argument('-l', '--show-channels', action=argparse.BooleanOptionalAction)
138     parser.add_argument('-L', '--set-channels', action=argparse.BooleanOptionalAction)
139     parser.add_argument('-T', '--show-time-stamping', action=argparse.BooleanOptionalAction)
140     parser.add_argument('-S', '--statistics', action=argparse.BooleanOptionalAction)
141     # TODO: --show-tunnels        tunnel-info-get
142     # TODO: --show-module         module-get
143     # TODO: --get-plca-cfg        plca-get
144     # TODO: --get-plca-status     plca-get-status
145     # TODO: --show-mm             mm-get
146     # TODO: --show-fec            fec-get
147     # TODO: --dump-module-eerpom  module-eeprom-get
148     # TODO:                       pse-get
149     # TODO:                       rss-get
150     parser.add_argument('device', metavar='device', type=str)
151     parser.add_argument('args', metavar='args', type=str, nargs='*')
152     global args
153     args = parser.parse_args()
154
155     spec = '../../../Documentation/netlink/specs/ethtool.yaml'
156     schema = '../../../Documentation/netlink/genetlink-legacy.yaml'
157
158     ynl = YnlFamily(spec, schema)
159
160     if args.set_priv_flags:
161         # TODO: parse the bitmask
162         print("not implemented")
163         return
164
165     if args.set_eee:
166         return doit(ynl, args, 'eee-set')
167
168     if args.set_pause:
169         return doit(ynl, args, 'pause-set')
170
171     if args.set_coalesce:
172         return doit(ynl, args, 'coalesce-set')
173
174     if args.set_features:
175         # TODO: parse the bitmask
176         print("not implemented")
177         return
178
179     if args.set_channels:
180         return doit(ynl, args, 'channels-set')
181
182     if args.set_ring:
183         return doit(ynl, args, 'rings-set')
184
185     if args.show_priv_flags:
186         flags = bits_to_dict(dumpit(ynl, args, 'privflags-get')['flags'])
187         print_field(flags)
188         return
189
190     if args.show_eee:
191         eee = dumpit(ynl, args, 'eee-get')
192         ours = bits_to_dict(eee['modes-ours'])
193         peer = bits_to_dict(eee['modes-peer'])
194
195         if 'enabled' in eee:
196             status = 'enabled' if eee['enabled'] else 'disabled'
197             if 'active' in eee and eee['active']:
198                 status = status + ' - active'
199             else:
200                 status = status + ' - inactive'
201         else:
202             status = 'not supported'
203
204         print(f'EEE status: {status}')
205         print_field(eee, ('tx-lpi-timer', 'Tx LPI'))
206         print_speed('Advertised EEE link modes', ours)
207         print_speed('Link partner advertised EEE link modes', peer)
208
209         return
210
211     if args.show_pause:
212         print_field(dumpit(ynl, args, 'pause-get'),
213                 ('autoneg', 'Autonegotiate', 'bool'),
214                 ('rx', 'RX', 'bool'),
215                 ('tx', 'TX', 'bool'))
216         return
217
218     if args.show_coalesce:
219         print_field(dumpit(ynl, args, 'coalesce-get'))
220         return
221
222     if args.show_features:
223         reply = dumpit(ynl, args, 'features-get')
224         available = bits_to_dict(reply['hw'])
225         requested = bits_to_dict(reply['wanted']).keys()
226         active = bits_to_dict(reply['active']).keys()
227         never_changed = bits_to_dict(reply['nochange']).keys()
228
229         for f in sorted(available):
230             value = "off"
231             if f in active:
232                 value = "on"
233
234             fixed = ""
235             if f not in available or f in never_changed:
236                 fixed = " [fixed]"
237
238             req = ""
239             if f in requested:
240                 if f in active:
241                     req = " [requested on]"
242                 else:
243                     req = " [requested off]"
244
245             print(f'{f}: {value}{fixed}{req}')
246
247         return
248
249     if args.show_channels:
250         reply = dumpit(ynl, args, 'channels-get')
251         print(f'Channel parameters for {args.device}:')
252
253         print(f'Pre-set maximums:')
254         print_field(reply,
255             ('rx-max', 'RX'),
256             ('tx-max', 'TX'),
257             ('other-max', 'Other'),
258             ('combined-max', 'Combined'))
259
260         print(f'Current hardware settings:')
261         print_field(reply,
262             ('rx-count', 'RX'),
263             ('tx-count', 'TX'),
264             ('other-count', 'Other'),
265             ('combined-count', 'Combined'))
266
267         return
268
269     if args.show_ring:
270         reply = dumpit(ynl, args, 'channels-get')
271
272         print(f'Ring parameters for {args.device}:')
273
274         print(f'Pre-set maximums:')
275         print_field(reply,
276             ('rx-max', 'RX'),
277             ('rx-mini-max', 'RX Mini'),
278             ('rx-jumbo-max', 'RX Jumbo'),
279             ('tx-max', 'TX'))
280
281         print(f'Current hardware settings:')
282         print_field(reply,
283             ('rx', 'RX'),
284             ('rx-mini', 'RX Mini'),
285             ('rx-jumbo', 'RX Jumbo'),
286             ('tx', 'TX'))
287
288         print_field(reply,
289             ('rx-buf-len', 'RX Buf Len'),
290             ('cqe-size', 'CQE Size'),
291             ('tx-push', 'TX Push', 'bool'))
292
293         return
294
295     if args.statistics:
296         print(f'NIC statistics:')
297
298         # TODO: pass id?
299         strset = dumpit(ynl, args, 'strset-get')
300         pprint.PrettyPrinter().pprint(strset)
301
302         req = {
303           'groups': {
304             'size': 1,
305             'bits': {
306               'bit':
307                 # TODO: support passing the bitmask
308                 #[
309                   #{ 'name': 'eth-phy', 'value': True },
310                   { 'name': 'eth-mac', 'value': True },
311                   #{ 'name': 'eth-ctrl', 'value': True },
312                   #{ 'name': 'rmon', 'value': True },
313                 #],
314             },
315           },
316         }
317
318         rsp = dumpit(ynl, args, 'stats-get', req)
319         pprint.PrettyPrinter().pprint(rsp)
320         return
321
322     if args.show_time_stamping:
323         tsinfo = dumpit(ynl, args, 'tsinfo-get')
324
325         print(f'Time stamping parameters for {args.device}:')
326
327         print('Capabilities:')
328         [print(f'\t{v}') for v in bits_to_dict(tsinfo['timestamping'])]
329
330         print(f'PTP Hardware Clock: {tsinfo["phc-index"]}')
331
332         print('Hardware Transmit Timestamp Modes:')
333         [print(f'\t{v}') for v in bits_to_dict(tsinfo['tx-types'])]
334
335         print('Hardware Receive Filter Modes:')
336         [print(f'\t{v}') for v in bits_to_dict(tsinfo['rx-filters'])]
337         return
338
339     print(f'Settings for {args.device}:')
340     linkmodes = dumpit(ynl, args, 'linkmodes-get')
341     ours = bits_to_dict(linkmodes['ours'])
342
343     supported_ports = ('TP',  'AUI', 'BNC', 'MII', 'FIBRE', 'Backplane')
344     ports = [ p for p in supported_ports if ours.get(p, False)]
345     print(f'Supported ports: [ {" ".join(ports)} ]')
346
347     print_speed('Supported link modes', ours)
348
349     print_field(ours, ('Pause', 'Supported pause frame use', 'yn'))
350     print_field(ours, ('Autoneg', 'Supports auto-negotiation', 'yn'))
351
352     supported_fec = ('None',  'PS', 'BASER', 'LLRS')
353     fec = [ p for p in supported_fec if ours.get(p, False)]
354     fec_str = " ".join(fec)
355     if len(fec) == 0:
356         fec_str = "Not reported"
357
358     print(f'Supported FEC modes: {fec_str}')
359
360     speed = 'Unknown!'
361     if linkmodes['speed'] > 0 and linkmodes['speed'] < 0xffffffff:
362         speed = f'{linkmodes["speed"]}Mb/s'
363     print(f'Speed: {speed}')
364
365     duplex_modes = {
366             0: 'Half',
367             1: 'Full',
368     }
369     duplex = duplex_modes.get(linkmodes["duplex"], None)
370     if not duplex:
371         duplex = f'Unknown! ({linkmodes["duplex"]})'
372     print(f'Duplex: {duplex}')
373
374     autoneg = "off"
375     if linkmodes.get("autoneg", 0) != 0:
376         autoneg = "on"
377     print(f'Auto-negotiation: {autoneg}')
378
379     ports = {
380             0: 'Twisted Pair',
381             1: 'AUI',
382             2: 'MII',
383             3: 'FIBRE',
384             4: 'BNC',
385             5: 'Directly Attached Copper',
386             0xef: 'None',
387     }
388     linkinfo = dumpit(ynl, args, 'linkinfo-get')
389     print(f'Port: {ports.get(linkinfo["port"], "Other")}')
390
391     print_field(linkinfo, ('phyaddr', 'PHYAD'))
392
393     transceiver = {
394             0: 'Internal',
395             1: 'External',
396     }
397     print(f'Transceiver: {transceiver.get(linkinfo["transceiver"], "Unknown")}')
398
399     mdix_ctrl = {
400             1: 'off',
401             2: 'on',
402     }
403     mdix = mdix_ctrl.get(linkinfo['tp-mdix-ctrl'], None)
404     if mdix:
405         mdix = mdix + ' (forced)'
406     else:
407         mdix = mdix_ctrl.get(linkinfo['tp-mdix'], 'Unknown (auto)')
408     print(f'MDI-X: {mdix}')
409
410     debug = dumpit(ynl, args, 'debug-get')
411     msgmask = bits_to_dict(debug.get("msgmask", [])).keys()
412     print(f'Current message level: {" ".join(msgmask)}')
413
414     linkstate = dumpit(ynl, args, 'linkstate-get')
415     detected_states = {
416             0: 'no',
417             1: 'yes',
418     }
419     # TODO: wol-get
420     detected = detected_states.get(linkstate['link'], 'unknown')
421     print(f'Link detected: {detected}')
422
423 if __name__ == '__main__':
424     main()
This page took 0.056297 seconds and 4 git commands to generate.