Loading...
Note: File does not exist in v6.13.7.
1#!/usr/bin/env python3
2
3# Copyright (C) 2017 Netronome Systems, Inc.
4# Copyright (c) 2019 Mellanox Technologies. All rights reserved
5#
6# This software is licensed under the GNU General License Version 2,
7# June 1991 as shown in the file COPYING in the top-level directory of this
8# source tree.
9#
10# THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
11# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
12# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
13# FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
14# OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
15# THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16
17from datetime import datetime
18import argparse
19import errno
20import json
21import os
22import pprint
23import random
24import re
25import stat
26import string
27import struct
28import subprocess
29import time
30import traceback
31
32logfile = None
33log_level = 1
34skip_extack = False
35bpf_test_dir = os.path.dirname(os.path.realpath(__file__))
36pp = pprint.PrettyPrinter()
37devs = [] # devices we created for clean up
38files = [] # files to be removed
39netns = [] # net namespaces to be removed
40
41def log_get_sec(level=0):
42 return "*" * (log_level + level)
43
44def log_level_inc(add=1):
45 global log_level
46 log_level += add
47
48def log_level_dec(sub=1):
49 global log_level
50 log_level -= sub
51
52def log_level_set(level):
53 global log_level
54 log_level = level
55
56def log(header, data, level=None):
57 """
58 Output to an optional log.
59 """
60 if logfile is None:
61 return
62 if level is not None:
63 log_level_set(level)
64
65 if not isinstance(data, str):
66 data = pp.pformat(data)
67
68 if len(header):
69 logfile.write("\n" + log_get_sec() + " ")
70 logfile.write(header)
71 if len(header) and len(data.strip()):
72 logfile.write("\n")
73 logfile.write(data)
74
75def skip(cond, msg):
76 if not cond:
77 return
78 print("SKIP: " + msg)
79 log("SKIP: " + msg, "", level=1)
80 os.sys.exit(0)
81
82def fail(cond, msg):
83 if not cond:
84 return
85 print("FAIL: " + msg)
86 tb = "".join(traceback.extract_stack().format())
87 print(tb)
88 log("FAIL: " + msg, tb, level=1)
89 os.sys.exit(1)
90
91def start_test(msg):
92 log(msg, "", level=1)
93 log_level_inc()
94 print(msg)
95
96def cmd(cmd, shell=True, include_stderr=False, background=False, fail=True):
97 """
98 Run a command in subprocess and return tuple of (retval, stdout);
99 optionally return stderr as well as third value.
100 """
101 proc = subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE,
102 stderr=subprocess.PIPE)
103 if background:
104 msg = "%s START: %s" % (log_get_sec(1),
105 datetime.now().strftime("%H:%M:%S.%f"))
106 log("BKG " + proc.args, msg)
107 return proc
108
109 return cmd_result(proc, include_stderr=include_stderr, fail=fail)
110
111def cmd_result(proc, include_stderr=False, fail=False):
112 stdout, stderr = proc.communicate()
113 stdout = stdout.decode("utf-8")
114 stderr = stderr.decode("utf-8")
115 proc.stdout.close()
116 proc.stderr.close()
117
118 stderr = "\n" + stderr
119 if stderr[-1] == "\n":
120 stderr = stderr[:-1]
121
122 sec = log_get_sec(1)
123 log("CMD " + proc.args,
124 "RETCODE: %d\n%s STDOUT:\n%s%s STDERR:%s\n%s END: %s" %
125 (proc.returncode, sec, stdout, sec, stderr,
126 sec, datetime.now().strftime("%H:%M:%S.%f")))
127
128 if proc.returncode != 0 and fail:
129 if len(stderr) > 0 and stderr[-1] == "\n":
130 stderr = stderr[:-1]
131 raise Exception("Command failed: %s\n%s" % (proc.args, stderr))
132
133 if include_stderr:
134 return proc.returncode, stdout, stderr
135 else:
136 return proc.returncode, stdout
137
138def rm(f):
139 cmd("rm -f %s" % (f))
140 if f in files:
141 files.remove(f)
142
143def tool(name, args, flags, JSON=True, ns="", fail=True, include_stderr=False):
144 params = ""
145 if JSON:
146 params += "%s " % (flags["json"])
147
148 if ns != "":
149 ns = "ip netns exec %s " % (ns)
150
151 if include_stderr:
152 ret, stdout, stderr = cmd(ns + name + " " + params + args,
153 fail=fail, include_stderr=True)
154 else:
155 ret, stdout = cmd(ns + name + " " + params + args,
156 fail=fail, include_stderr=False)
157
158 if JSON and len(stdout.strip()) != 0:
159 out = json.loads(stdout)
160 else:
161 out = stdout
162
163 if include_stderr:
164 return ret, out, stderr
165 else:
166 return ret, out
167
168def bpftool(args, JSON=True, ns="", fail=True, include_stderr=False):
169 return tool("bpftool", args, {"json":"-p"}, JSON=JSON, ns=ns,
170 fail=fail, include_stderr=include_stderr)
171
172def bpftool_prog_list(expected=None, ns=""):
173 _, progs = bpftool("prog show", JSON=True, ns=ns, fail=True)
174 # Remove the base progs
175 for p in base_progs:
176 if p in progs:
177 progs.remove(p)
178 if expected is not None:
179 if len(progs) != expected:
180 fail(True, "%d BPF programs loaded, expected %d" %
181 (len(progs), expected))
182 return progs
183
184def bpftool_map_list(expected=None, ns=""):
185 _, maps = bpftool("map show", JSON=True, ns=ns, fail=True)
186 # Remove the base maps
187 maps = [m for m in maps if m not in base_maps and m.get('name') not in base_map_names]
188 if expected is not None:
189 if len(maps) != expected:
190 fail(True, "%d BPF maps loaded, expected %d" %
191 (len(maps), expected))
192 return maps
193
194def bpftool_prog_list_wait(expected=0, n_retry=20):
195 for i in range(n_retry):
196 nprogs = len(bpftool_prog_list())
197 if nprogs == expected:
198 return
199 time.sleep(0.05)
200 raise Exception("Time out waiting for program counts to stabilize want %d, have %d" % (expected, nprogs))
201
202def bpftool_map_list_wait(expected=0, n_retry=20):
203 for i in range(n_retry):
204 nmaps = len(bpftool_map_list())
205 if nmaps == expected:
206 return
207 time.sleep(0.05)
208 raise Exception("Time out waiting for map counts to stabilize want %d, have %d" % (expected, nmaps))
209
210def bpftool_prog_load(sample, file_name, maps=[], prog_type="xdp", dev=None,
211 fail=True, include_stderr=False):
212 args = "prog load %s %s" % (os.path.join(bpf_test_dir, sample), file_name)
213 if prog_type is not None:
214 args += " type " + prog_type
215 if dev is not None:
216 args += " dev " + dev
217 if len(maps):
218 args += " map " + " map ".join(maps)
219
220 res = bpftool(args, fail=fail, include_stderr=include_stderr)
221 if res[0] == 0:
222 files.append(file_name)
223 return res
224
225def ip(args, force=False, JSON=True, ns="", fail=True, include_stderr=False):
226 if force:
227 args = "-force " + args
228 return tool("ip", args, {"json":"-j"}, JSON=JSON, ns=ns,
229 fail=fail, include_stderr=include_stderr)
230
231def tc(args, JSON=True, ns="", fail=True, include_stderr=False):
232 return tool("tc", args, {"json":"-p"}, JSON=JSON, ns=ns,
233 fail=fail, include_stderr=include_stderr)
234
235def ethtool(dev, opt, args, fail=True):
236 return cmd("ethtool %s %s %s" % (opt, dev["ifname"], args), fail=fail)
237
238def bpf_obj(name, sec=".text", path=bpf_test_dir,):
239 return "obj %s sec %s" % (os.path.join(path, name), sec)
240
241def bpf_pinned(name):
242 return "pinned %s" % (name)
243
244def bpf_bytecode(bytecode):
245 return "bytecode \"%s\"" % (bytecode)
246
247def mknetns(n_retry=10):
248 for i in range(n_retry):
249 name = ''.join([random.choice(string.ascii_letters) for i in range(8)])
250 ret, _ = ip("netns add %s" % (name), fail=False)
251 if ret == 0:
252 netns.append(name)
253 return name
254 return None
255
256def int2str(fmt, val):
257 ret = []
258 for b in struct.pack(fmt, val):
259 ret.append(int(b))
260 return " ".join(map(lambda x: str(x), ret))
261
262def str2int(strtab):
263 inttab = []
264 for i in strtab:
265 inttab.append(int(i, 16))
266 ba = bytearray(inttab)
267 if len(strtab) == 4:
268 fmt = "I"
269 elif len(strtab) == 8:
270 fmt = "Q"
271 else:
272 raise Exception("String array of len %d can't be unpacked to an int" %
273 (len(strtab)))
274 return struct.unpack(fmt, ba)[0]
275
276class DebugfsDir:
277 """
278 Class for accessing DebugFS directories as a dictionary.
279 """
280
281 def __init__(self, path):
282 self.path = path
283 self._dict = self._debugfs_dir_read(path)
284
285 def __len__(self):
286 return len(self._dict.keys())
287
288 def __getitem__(self, key):
289 if type(key) is int:
290 key = list(self._dict.keys())[key]
291 return self._dict[key]
292
293 def __setitem__(self, key, value):
294 log("DebugFS set %s = %s" % (key, value), "")
295 log_level_inc()
296
297 cmd("echo '%s' > %s/%s" % (value, self.path, key))
298 log_level_dec()
299
300 _, out = cmd('cat %s/%s' % (self.path, key))
301 self._dict[key] = out.strip()
302
303 def _debugfs_dir_read(self, path):
304 dfs = {}
305
306 log("DebugFS state for %s" % (path), "")
307 log_level_inc(add=2)
308
309 _, out = cmd('ls ' + path)
310 for f in out.split():
311 if f == "ports":
312 continue
313
314 p = os.path.join(path, f)
315 if not os.stat(p).st_mode & stat.S_IRUSR:
316 continue
317
318 if os.path.isfile(p):
319 # We need to init trap_flow_action_cookie before read it
320 if f == "trap_flow_action_cookie":
321 cmd('echo deadbeef > %s/%s' % (path, f))
322 _, out = cmd('cat %s/%s' % (path, f))
323 dfs[f] = out.strip()
324 elif os.path.isdir(p):
325 dfs[f] = DebugfsDir(p)
326 else:
327 raise Exception("%s is neither file nor directory" % (p))
328
329 log_level_dec()
330 log("DebugFS state", dfs)
331 log_level_dec()
332
333 return dfs
334
335class NetdevSimDev:
336 """
337 Class for netdevsim bus device and its attributes.
338 """
339 @staticmethod
340 def ctrl_write(path, val):
341 fullpath = os.path.join("/sys/bus/netdevsim/", path)
342 try:
343 with open(fullpath, "w") as f:
344 f.write(val)
345 except OSError as e:
346 log("WRITE %s: %r" % (fullpath, val), -e.errno)
347 raise e
348 log("WRITE %s: %r" % (fullpath, val), 0)
349
350 def __init__(self, port_count=1):
351 addr = 0
352 while True:
353 try:
354 self.ctrl_write("new_device", "%u %u" % (addr, port_count))
355 except OSError as e:
356 if e.errno == errno.ENOSPC:
357 addr += 1
358 continue
359 raise e
360 break
361 self.addr = addr
362
363 # As probe of netdevsim device might happen from a workqueue,
364 # so wait here until all netdevs appear.
365 self.wait_for_netdevs(port_count)
366
367 ret, out = cmd("udevadm settle", fail=False)
368 if ret:
369 raise Exception("udevadm settle failed")
370 ifnames = self.get_ifnames()
371
372 devs.append(self)
373 self.dfs_dir = "/sys/kernel/debug/netdevsim/netdevsim%u/" % addr
374
375 self.nsims = []
376 for port_index in range(port_count):
377 self.nsims.append(NetdevSim(self, port_index, ifnames[port_index]))
378
379 def get_ifnames(self):
380 ifnames = []
381 listdir = os.listdir("/sys/bus/netdevsim/devices/netdevsim%u/net/" % self.addr)
382 for ifname in listdir:
383 ifnames.append(ifname)
384 ifnames.sort()
385 return ifnames
386
387 def wait_for_netdevs(self, port_count):
388 timeout = 5
389 timeout_start = time.time()
390
391 while True:
392 try:
393 ifnames = self.get_ifnames()
394 except FileNotFoundError as e:
395 ifnames = []
396 if len(ifnames) == port_count:
397 break
398 if time.time() < timeout_start + timeout:
399 continue
400 raise Exception("netdevices did not appear within timeout")
401
402 def dfs_num_bound_progs(self):
403 path = os.path.join(self.dfs_dir, "bpf_bound_progs")
404 _, progs = cmd('ls %s' % (path))
405 return len(progs.split())
406
407 def dfs_get_bound_progs(self, expected):
408 progs = DebugfsDir(os.path.join(self.dfs_dir, "bpf_bound_progs"))
409 if expected is not None:
410 if len(progs) != expected:
411 fail(True, "%d BPF programs bound, expected %d" %
412 (len(progs), expected))
413 return progs
414
415 def remove(self):
416 self.ctrl_write("del_device", "%u" % (self.addr, ))
417 devs.remove(self)
418
419 def remove_nsim(self, nsim):
420 self.nsims.remove(nsim)
421 self.ctrl_write("devices/netdevsim%u/del_port" % (self.addr, ),
422 "%u" % (nsim.port_index, ))
423
424class NetdevSim:
425 """
426 Class for netdevsim netdevice and its attributes.
427 """
428
429 def __init__(self, nsimdev, port_index, ifname):
430 # In case udev renamed the netdev to according to new schema,
431 # check if the name matches the port_index.
432 nsimnamere = re.compile("eni\d+np(\d+)")
433 match = nsimnamere.match(ifname)
434 if match and int(match.groups()[0]) != port_index + 1:
435 raise Exception("netdevice name mismatches the expected one")
436
437 self.nsimdev = nsimdev
438 self.port_index = port_index
439 self.ns = ""
440 self.dfs_dir = "%s/ports/%u/" % (nsimdev.dfs_dir, port_index)
441 self.dfs_refresh()
442 _, [self.dev] = ip("link show dev %s" % ifname)
443
444 def __getitem__(self, key):
445 return self.dev[key]
446
447 def remove(self):
448 self.nsimdev.remove_nsim(self)
449
450 def dfs_refresh(self):
451 self.dfs = DebugfsDir(self.dfs_dir)
452 return self.dfs
453
454 def dfs_read(self, f):
455 path = os.path.join(self.dfs_dir, f)
456 _, data = cmd('cat %s' % (path))
457 return data.strip()
458
459 def wait_for_flush(self, bound=0, total=0, n_retry=20):
460 for i in range(n_retry):
461 nbound = self.nsimdev.dfs_num_bound_progs()
462 nprogs = len(bpftool_prog_list())
463 if nbound == bound and nprogs == total:
464 return
465 time.sleep(0.05)
466 raise Exception("Time out waiting for program counts to stabilize want %d/%d, have %d bound, %d loaded" % (bound, total, nbound, nprogs))
467
468 def set_ns(self, ns):
469 name = "1" if ns == "" else ns
470 ip("link set dev %s netns %s" % (self.dev["ifname"], name), ns=self.ns)
471 self.ns = ns
472
473 def set_mtu(self, mtu, fail=True):
474 return ip("link set dev %s mtu %d" % (self.dev["ifname"], mtu),
475 fail=fail)
476
477 def set_xdp(self, bpf, mode, force=False, JSON=True, verbose=False,
478 fail=True, include_stderr=False):
479 if verbose:
480 bpf += " verbose"
481 return ip("link set dev %s xdp%s %s" % (self.dev["ifname"], mode, bpf),
482 force=force, JSON=JSON,
483 fail=fail, include_stderr=include_stderr)
484
485 def unset_xdp(self, mode, force=False, JSON=True,
486 fail=True, include_stderr=False):
487 return ip("link set dev %s xdp%s off" % (self.dev["ifname"], mode),
488 force=force, JSON=JSON,
489 fail=fail, include_stderr=include_stderr)
490
491 def ip_link_show(self, xdp):
492 _, link = ip("link show dev %s" % (self['ifname']))
493 if len(link) > 1:
494 raise Exception("Multiple objects on ip link show")
495 if len(link) < 1:
496 return {}
497 fail(xdp != "xdp" in link,
498 "XDP program not reporting in iplink (reported %s, expected %s)" %
499 ("xdp" in link, xdp))
500 return link[0]
501
502 def tc_add_ingress(self):
503 tc("qdisc add dev %s ingress" % (self['ifname']))
504
505 def tc_del_ingress(self):
506 tc("qdisc del dev %s ingress" % (self['ifname']))
507
508 def tc_flush_filters(self, bound=0, total=0):
509 self.tc_del_ingress()
510 self.tc_add_ingress()
511 self.wait_for_flush(bound=bound, total=total)
512
513 def tc_show_ingress(self, expected=None):
514 # No JSON support, oh well...
515 flags = ["skip_sw", "skip_hw", "in_hw"]
516 named = ["protocol", "pref", "chain", "handle", "id", "tag"]
517
518 args = "-s filter show dev %s ingress" % (self['ifname'])
519 _, out = tc(args, JSON=False)
520
521 filters = []
522 lines = out.split('\n')
523 for line in lines:
524 words = line.split()
525 if "handle" not in words:
526 continue
527 fltr = {}
528 for flag in flags:
529 fltr[flag] = flag in words
530 for name in named:
531 try:
532 idx = words.index(name)
533 fltr[name] = words[idx + 1]
534 except ValueError:
535 pass
536 filters.append(fltr)
537
538 if expected is not None:
539 fail(len(filters) != expected,
540 "%d ingress filters loaded, expected %d" %
541 (len(filters), expected))
542 return filters
543
544 def cls_filter_op(self, op, qdisc="ingress", prio=None, handle=None,
545 chain=None, cls="", params="",
546 fail=True, include_stderr=False):
547 spec = ""
548 if prio is not None:
549 spec += " prio %d" % (prio)
550 if handle:
551 spec += " handle %s" % (handle)
552 if chain is not None:
553 spec += " chain %d" % (chain)
554
555 return tc("filter {op} dev {dev} {qdisc} {spec} {cls} {params}"\
556 .format(op=op, dev=self['ifname'], qdisc=qdisc, spec=spec,
557 cls=cls, params=params),
558 fail=fail, include_stderr=include_stderr)
559
560 def cls_bpf_add_filter(self, bpf, op="add", prio=None, handle=None,
561 chain=None, da=False, verbose=False,
562 skip_sw=False, skip_hw=False,
563 fail=True, include_stderr=False):
564 cls = "bpf " + bpf
565
566 params = ""
567 if da:
568 params += " da"
569 if verbose:
570 params += " verbose"
571 if skip_sw:
572 params += " skip_sw"
573 if skip_hw:
574 params += " skip_hw"
575
576 return self.cls_filter_op(op=op, prio=prio, handle=handle, cls=cls,
577 chain=chain, params=params,
578 fail=fail, include_stderr=include_stderr)
579
580 def set_ethtool_tc_offloads(self, enable, fail=True):
581 args = "hw-tc-offload %s" % ("on" if enable else "off")
582 return ethtool(self, "-K", args, fail=fail)
583
584################################################################################
585def clean_up():
586 global files, netns, devs
587
588 for dev in devs:
589 dev.remove()
590 for f in files:
591 cmd("rm -f %s" % (f))
592 for ns in netns:
593 cmd("ip netns delete %s" % (ns))
594 files = []
595 netns = []
596
597def pin_prog(file_name, idx=0):
598 progs = bpftool_prog_list(expected=(idx + 1))
599 prog = progs[idx]
600 bpftool("prog pin id %d %s" % (prog["id"], file_name))
601 files.append(file_name)
602
603 return file_name, bpf_pinned(file_name)
604
605def pin_map(file_name, idx=0, expected=1):
606 maps = bpftool_map_list(expected=expected)
607 m = maps[idx]
608 bpftool("map pin id %d %s" % (m["id"], file_name))
609 files.append(file_name)
610
611 return file_name, bpf_pinned(file_name)
612
613def check_dev_info_removed(prog_file=None, map_file=None):
614 bpftool_prog_list(expected=0)
615 ret, err = bpftool("prog show pin %s" % (prog_file), fail=False)
616 fail(ret == 0, "Showing prog with removed device did not fail")
617 fail(err["error"].find("No such device") == -1,
618 "Showing prog with removed device expected ENODEV, error is %s" %
619 (err["error"]))
620
621 bpftool_map_list(expected=0)
622 ret, err = bpftool("map show pin %s" % (map_file), fail=False)
623 fail(ret == 0, "Showing map with removed device did not fail")
624 fail(err["error"].find("No such device") == -1,
625 "Showing map with removed device expected ENODEV, error is %s" %
626 (err["error"]))
627
628def check_dev_info(other_ns, ns, prog_file=None, map_file=None, removed=False):
629 progs = bpftool_prog_list(expected=1, ns=ns)
630 prog = progs[0]
631
632 fail("dev" not in prog.keys(), "Device parameters not reported")
633 dev = prog["dev"]
634 fail("ifindex" not in dev.keys(), "Device parameters not reported")
635 fail("ns_dev" not in dev.keys(), "Device parameters not reported")
636 fail("ns_inode" not in dev.keys(), "Device parameters not reported")
637
638 if not other_ns:
639 fail("ifname" not in dev.keys(), "Ifname not reported")
640 fail(dev["ifname"] != sim["ifname"],
641 "Ifname incorrect %s vs %s" % (dev["ifname"], sim["ifname"]))
642 else:
643 fail("ifname" in dev.keys(), "Ifname is reported for other ns")
644
645 maps = bpftool_map_list(expected=2, ns=ns)
646 for m in maps:
647 fail("dev" not in m.keys(), "Device parameters not reported")
648 fail(dev != m["dev"], "Map's device different than program's")
649
650def check_extack(output, reference, args):
651 if skip_extack:
652 return
653 lines = output.split("\n")
654 comp = len(lines) >= 2 and lines[1] == 'Error: ' + reference
655 fail(not comp, "Missing or incorrect netlink extack message")
656
657def check_extack_nsim(output, reference, args):
658 check_extack(output, "netdevsim: " + reference, args)
659
660def check_no_extack(res, needle):
661 fail((res[1] + res[2]).count(needle) or (res[1] + res[2]).count("Warning:"),
662 "Found '%s' in command output, leaky extack?" % (needle))
663
664def check_verifier_log(output, reference):
665 lines = output.split("\n")
666 for l in reversed(lines):
667 if l == reference:
668 return
669 fail(True, "Missing or incorrect message from netdevsim in verifier log")
670
671def check_multi_basic(two_xdps):
672 fail(two_xdps["mode"] != 4, "Bad mode reported with multiple programs")
673 fail("prog" in two_xdps, "Base program reported in multi program mode")
674 fail(len(two_xdps["attached"]) != 2,
675 "Wrong attached program count with two programs")
676 fail(two_xdps["attached"][0]["prog"]["id"] ==
677 two_xdps["attached"][1]["prog"]["id"],
678 "Offloaded and other programs have the same id")
679
680def test_spurios_extack(sim, obj, skip_hw, needle):
681 res = sim.cls_bpf_add_filter(obj, prio=1, handle=1, skip_hw=skip_hw,
682 include_stderr=True)
683 check_no_extack(res, needle)
684 res = sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1,
685 skip_hw=skip_hw, include_stderr=True)
686 check_no_extack(res, needle)
687 res = sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf",
688 include_stderr=True)
689 check_no_extack(res, needle)
690
691def test_multi_prog(simdev, sim, obj, modename, modeid):
692 start_test("Test multi-attachment XDP - %s + offload..." %
693 (modename or "default", ))
694 sim.set_xdp(obj, "offload")
695 xdp = sim.ip_link_show(xdp=True)["xdp"]
696 offloaded = sim.dfs_read("bpf_offloaded_id")
697 fail("prog" not in xdp, "Base program not reported in single program mode")
698 fail(len(xdp["attached"]) != 1,
699 "Wrong attached program count with one program")
700
701 sim.set_xdp(obj, modename)
702 two_xdps = sim.ip_link_show(xdp=True)["xdp"]
703
704 fail(xdp["attached"][0] not in two_xdps["attached"],
705 "Offload program not reported after other activated")
706 check_multi_basic(two_xdps)
707
708 offloaded2 = sim.dfs_read("bpf_offloaded_id")
709 fail(offloaded != offloaded2,
710 "Offload ID changed after loading other program")
711
712 start_test("Test multi-attachment XDP - replace...")
713 ret, _, err = sim.set_xdp(obj, "offload", fail=False, include_stderr=True)
714 fail(ret == 0, "Replaced one of programs without -force")
715 check_extack(err, "XDP program already attached.", args)
716
717 start_test("Test multi-attachment XDP - remove without mode...")
718 ret, _, err = sim.unset_xdp("", force=True,
719 fail=False, include_stderr=True)
720 fail(ret == 0, "Removed program without a mode flag")
721 check_extack(err, "More than one program loaded, unset mode is ambiguous.", args)
722
723 sim.unset_xdp("offload")
724 xdp = sim.ip_link_show(xdp=True)["xdp"]
725 offloaded = sim.dfs_read("bpf_offloaded_id")
726
727 fail(xdp["mode"] != modeid, "Bad mode reported after multiple programs")
728 fail("prog" not in xdp,
729 "Base program not reported after multi program mode")
730 fail(xdp["attached"][0] not in two_xdps["attached"],
731 "Offload program not reported after other activated")
732 fail(len(xdp["attached"]) != 1,
733 "Wrong attached program count with remaining programs")
734 fail(offloaded != "0", "Offload ID reported with only other program left")
735
736 start_test("Test multi-attachment XDP - reattach...")
737 sim.set_xdp(obj, "offload")
738 two_xdps = sim.ip_link_show(xdp=True)["xdp"]
739
740 fail(xdp["attached"][0] not in two_xdps["attached"],
741 "Other program not reported after offload activated")
742 check_multi_basic(two_xdps)
743
744 start_test("Test multi-attachment XDP - device remove...")
745 simdev.remove()
746
747 simdev = NetdevSimDev()
748 sim, = simdev.nsims
749 sim.set_ethtool_tc_offloads(True)
750 return [simdev, sim]
751
752# Parse command line
753parser = argparse.ArgumentParser()
754parser.add_argument("--log", help="output verbose log to given file")
755args = parser.parse_args()
756if args.log:
757 logfile = open(args.log, 'w+')
758 logfile.write("# -*-Org-*-")
759
760log("Prepare...", "", level=1)
761log_level_inc()
762
763# Check permissions
764skip(os.getuid() != 0, "test must be run as root")
765
766# Check tools
767ret, progs = bpftool("prog", fail=False)
768skip(ret != 0, "bpftool not installed")
769base_progs = progs
770_, base_maps = bpftool("map")
771base_map_names = [
772 'pid_iter.rodata' # created on each bpftool invocation
773]
774
775# Check netdevsim
776ret, out = cmd("modprobe netdevsim", fail=False)
777skip(ret != 0, "netdevsim module could not be loaded")
778
779# Check debugfs
780_, out = cmd("mount")
781if out.find("/sys/kernel/debug type debugfs") == -1:
782 cmd("mount -t debugfs none /sys/kernel/debug")
783
784# Check samples are compiled
785samples = ["sample_ret0.o", "sample_map_ret0.o"]
786for s in samples:
787 ret, out = cmd("ls %s/%s" % (bpf_test_dir, s), fail=False)
788 skip(ret != 0, "sample %s/%s not found, please compile it" %
789 (bpf_test_dir, s))
790
791# Check if iproute2 is built with libmnl (needed by extack support)
792_, _, err = cmd("tc qdisc delete dev lo handle 0",
793 fail=False, include_stderr=True)
794if err.find("Error: Failed to find qdisc with specified handle.") == -1:
795 print("Warning: no extack message in iproute2 output, libmnl missing?")
796 log("Warning: no extack message in iproute2 output, libmnl missing?", "")
797 skip_extack = True
798
799# Check if net namespaces seem to work
800ns = mknetns()
801skip(ns is None, "Could not create a net namespace")
802cmd("ip netns delete %s" % (ns))
803netns = []
804
805try:
806 obj = bpf_obj("sample_ret0.o")
807 bytecode = bpf_bytecode("1,6 0 0 4294967295,")
808
809 start_test("Test destruction of generic XDP...")
810 simdev = NetdevSimDev()
811 sim, = simdev.nsims
812 sim.set_xdp(obj, "generic")
813 simdev.remove()
814 bpftool_prog_list_wait(expected=0)
815
816 simdev = NetdevSimDev()
817 sim, = simdev.nsims
818 sim.tc_add_ingress()
819
820 start_test("Test TC non-offloaded...")
821 ret, _ = sim.cls_bpf_add_filter(obj, skip_hw=True, fail=False)
822 fail(ret != 0, "Software TC filter did not load")
823
824 start_test("Test TC non-offloaded isn't getting bound...")
825 ret, _ = sim.cls_bpf_add_filter(obj, fail=False)
826 fail(ret != 0, "Software TC filter did not load")
827 simdev.dfs_get_bound_progs(expected=0)
828
829 sim.tc_flush_filters()
830
831 start_test("Test TC offloads are off by default...")
832 ret, _, err = sim.cls_bpf_add_filter(obj, skip_sw=True,
833 fail=False, include_stderr=True)
834 fail(ret == 0, "TC filter loaded without enabling TC offloads")
835 check_extack(err, "TC offload is disabled on net device.", args)
836 sim.wait_for_flush()
837
838 sim.set_ethtool_tc_offloads(True)
839 sim.dfs["bpf_tc_non_bound_accept"] = "Y"
840
841 start_test("Test TC offload by default...")
842 ret, _ = sim.cls_bpf_add_filter(obj, fail=False)
843 fail(ret != 0, "Software TC filter did not load")
844 simdev.dfs_get_bound_progs(expected=0)
845 ingress = sim.tc_show_ingress(expected=1)
846 fltr = ingress[0]
847 fail(not fltr["in_hw"], "Filter not offloaded by default")
848
849 sim.tc_flush_filters()
850
851 start_test("Test TC cBPF bytcode tries offload by default...")
852 ret, _ = sim.cls_bpf_add_filter(bytecode, fail=False)
853 fail(ret != 0, "Software TC filter did not load")
854 simdev.dfs_get_bound_progs(expected=0)
855 ingress = sim.tc_show_ingress(expected=1)
856 fltr = ingress[0]
857 fail(not fltr["in_hw"], "Bytecode not offloaded by default")
858
859 sim.tc_flush_filters()
860 sim.dfs["bpf_tc_non_bound_accept"] = "N"
861
862 start_test("Test TC cBPF unbound bytecode doesn't offload...")
863 ret, _, err = sim.cls_bpf_add_filter(bytecode, skip_sw=True,
864 fail=False, include_stderr=True)
865 fail(ret == 0, "TC bytecode loaded for offload")
866 check_extack_nsim(err, "netdevsim configured to reject unbound programs.",
867 args)
868 sim.wait_for_flush()
869
870 start_test("Test non-0 chain offload...")
871 ret, _, err = sim.cls_bpf_add_filter(obj, chain=1, prio=1, handle=1,
872 skip_sw=True,
873 fail=False, include_stderr=True)
874 fail(ret == 0, "Offloaded a filter to chain other than 0")
875 check_extack(err, "Driver supports only offload of chain 0.", args)
876 sim.tc_flush_filters()
877
878 start_test("Test TC replace...")
879 sim.cls_bpf_add_filter(obj, prio=1, handle=1)
880 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1)
881 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf")
882
883 sim.cls_bpf_add_filter(obj, prio=1, handle=1, skip_sw=True)
884 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1, skip_sw=True)
885 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf")
886
887 sim.cls_bpf_add_filter(obj, prio=1, handle=1, skip_hw=True)
888 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1, skip_hw=True)
889 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf")
890
891 start_test("Test TC replace bad flags...")
892 for i in range(3):
893 for j in range(3):
894 ret, _ = sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1,
895 skip_sw=(j == 1), skip_hw=(j == 2),
896 fail=False)
897 fail(bool(ret) != bool(j),
898 "Software TC incorrect load in replace test, iteration %d" %
899 (j))
900 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf")
901
902 start_test("Test spurious extack from the driver...")
903 test_spurios_extack(sim, obj, False, "netdevsim")
904 test_spurios_extack(sim, obj, True, "netdevsim")
905
906 sim.set_ethtool_tc_offloads(False)
907
908 test_spurios_extack(sim, obj, False, "TC offload is disabled")
909 test_spurios_extack(sim, obj, True, "TC offload is disabled")
910
911 sim.set_ethtool_tc_offloads(True)
912
913 sim.tc_flush_filters()
914
915 start_test("Test TC offloads failure...")
916 sim.dfs["dev/bpf_bind_verifier_accept"] = 0
917 ret, _, err = sim.cls_bpf_add_filter(obj, verbose=True, skip_sw=True,
918 fail=False, include_stderr=True)
919 fail(ret == 0, "TC filter did not reject with TC offloads enabled")
920 check_verifier_log(err, "[netdevsim] Hello from netdevsim!")
921 sim.dfs["dev/bpf_bind_verifier_accept"] = 1
922
923 start_test("Test TC offloads work...")
924 ret, _, err = sim.cls_bpf_add_filter(obj, verbose=True, skip_sw=True,
925 fail=False, include_stderr=True)
926 fail(ret != 0, "TC filter did not load with TC offloads enabled")
927
928 start_test("Test TC offload basics...")
929 dfs = simdev.dfs_get_bound_progs(expected=1)
930 progs = bpftool_prog_list(expected=1)
931 ingress = sim.tc_show_ingress(expected=1)
932
933 dprog = dfs[0]
934 prog = progs[0]
935 fltr = ingress[0]
936 fail(fltr["skip_hw"], "TC does reports 'skip_hw' on offloaded filter")
937 fail(not fltr["in_hw"], "TC does not report 'in_hw' for offloaded filter")
938 fail(not fltr["skip_sw"], "TC does not report 'skip_sw' back")
939
940 start_test("Test TC offload is device-bound...")
941 fail(str(prog["id"]) != fltr["id"], "Program IDs don't match")
942 fail(prog["tag"] != fltr["tag"], "Program tags don't match")
943 fail(fltr["id"] != dprog["id"], "Program IDs don't match")
944 fail(dprog["state"] != "xlated", "Offloaded program state not translated")
945 fail(dprog["loaded"] != "Y", "Offloaded program is not loaded")
946
947 start_test("Test disabling TC offloads is rejected while filters installed...")
948 ret, _ = sim.set_ethtool_tc_offloads(False, fail=False)
949 fail(ret == 0, "Driver should refuse to disable TC offloads with filters installed...")
950 sim.set_ethtool_tc_offloads(True)
951
952 start_test("Test qdisc removal frees things...")
953 sim.tc_flush_filters()
954 sim.tc_show_ingress(expected=0)
955
956 start_test("Test disabling TC offloads is OK without filters...")
957 ret, _ = sim.set_ethtool_tc_offloads(False, fail=False)
958 fail(ret != 0,
959 "Driver refused to disable TC offloads without filters installed...")
960
961 sim.set_ethtool_tc_offloads(True)
962
963 start_test("Test destroying device gets rid of TC filters...")
964 sim.cls_bpf_add_filter(obj, skip_sw=True)
965 simdev.remove()
966 bpftool_prog_list_wait(expected=0)
967
968 simdev = NetdevSimDev()
969 sim, = simdev.nsims
970 sim.set_ethtool_tc_offloads(True)
971
972 start_test("Test destroying device gets rid of XDP...")
973 sim.set_xdp(obj, "offload")
974 simdev.remove()
975 bpftool_prog_list_wait(expected=0)
976
977 simdev = NetdevSimDev()
978 sim, = simdev.nsims
979 sim.set_ethtool_tc_offloads(True)
980
981 start_test("Test XDP prog reporting...")
982 sim.set_xdp(obj, "drv")
983 ipl = sim.ip_link_show(xdp=True)
984 progs = bpftool_prog_list(expected=1)
985 fail(ipl["xdp"]["prog"]["id"] != progs[0]["id"],
986 "Loaded program has wrong ID")
987
988 start_test("Test XDP prog replace without force...")
989 ret, _ = sim.set_xdp(obj, "drv", fail=False)
990 fail(ret == 0, "Replaced XDP program without -force")
991 sim.wait_for_flush(total=1)
992
993 start_test("Test XDP prog replace with force...")
994 ret, _ = sim.set_xdp(obj, "drv", force=True, fail=False)
995 fail(ret != 0, "Could not replace XDP program with -force")
996 bpftool_prog_list_wait(expected=1)
997 ipl = sim.ip_link_show(xdp=True)
998 progs = bpftool_prog_list(expected=1)
999 fail(ipl["xdp"]["prog"]["id"] != progs[0]["id"],
1000 "Loaded program has wrong ID")
1001 fail("dev" in progs[0].keys(),
1002 "Device parameters reported for non-offloaded program")
1003
1004 start_test("Test XDP prog replace with bad flags...")
1005 ret, _, err = sim.set_xdp(obj, "generic", force=True,
1006 fail=False, include_stderr=True)
1007 fail(ret == 0, "Replaced XDP program with a program in different mode")
1008 check_extack(err,
1009 "Native and generic XDP can't be active at the same time.",
1010 args)
1011
1012 start_test("Test MTU restrictions...")
1013 ret, _ = sim.set_mtu(9000, fail=False)
1014 fail(ret == 0,
1015 "Driver should refuse to increase MTU to 9000 with XDP loaded...")
1016 sim.unset_xdp("drv")
1017 bpftool_prog_list_wait(expected=0)
1018 sim.set_mtu(9000)
1019 ret, _, err = sim.set_xdp(obj, "drv", fail=False, include_stderr=True)
1020 fail(ret == 0, "Driver should refuse to load program with MTU of 9000...")
1021 check_extack_nsim(err, "MTU too large w/ XDP enabled.", args)
1022 sim.set_mtu(1500)
1023
1024 sim.wait_for_flush()
1025 start_test("Test non-offload XDP attaching to HW...")
1026 bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/nooffload")
1027 nooffload = bpf_pinned("/sys/fs/bpf/nooffload")
1028 ret, _, err = sim.set_xdp(nooffload, "offload",
1029 fail=False, include_stderr=True)
1030 fail(ret == 0, "attached non-offloaded XDP program to HW")
1031 check_extack_nsim(err, "xdpoffload of non-bound program.", args)
1032 rm("/sys/fs/bpf/nooffload")
1033
1034 start_test("Test offload XDP attaching to drv...")
1035 bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/offload",
1036 dev=sim['ifname'])
1037 offload = bpf_pinned("/sys/fs/bpf/offload")
1038 ret, _, err = sim.set_xdp(offload, "drv", fail=False, include_stderr=True)
1039 fail(ret == 0, "attached offloaded XDP program to drv")
1040 check_extack(err, "Using device-bound program without HW_MODE flag is not supported.", args)
1041 rm("/sys/fs/bpf/offload")
1042 sim.wait_for_flush()
1043
1044 start_test("Test XDP load failure...")
1045 sim.dfs["dev/bpf_bind_verifier_accept"] = 0
1046 ret, _, err = bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/offload",
1047 dev=sim['ifname'], fail=False, include_stderr=True)
1048 fail(ret == 0, "verifier should fail on load")
1049 check_verifier_log(err, "[netdevsim] Hello from netdevsim!")
1050 sim.dfs["dev/bpf_bind_verifier_accept"] = 1
1051 sim.wait_for_flush()
1052
1053 start_test("Test XDP offload...")
1054 _, _, err = sim.set_xdp(obj, "offload", verbose=True, include_stderr=True)
1055 ipl = sim.ip_link_show(xdp=True)
1056 link_xdp = ipl["xdp"]["prog"]
1057 progs = bpftool_prog_list(expected=1)
1058 prog = progs[0]
1059 fail(link_xdp["id"] != prog["id"], "Loaded program has wrong ID")
1060
1061 start_test("Test XDP offload is device bound...")
1062 dfs = simdev.dfs_get_bound_progs(expected=1)
1063 dprog = dfs[0]
1064
1065 fail(prog["id"] != link_xdp["id"], "Program IDs don't match")
1066 fail(prog["tag"] != link_xdp["tag"], "Program tags don't match")
1067 fail(str(link_xdp["id"]) != dprog["id"], "Program IDs don't match")
1068 fail(dprog["state"] != "xlated", "Offloaded program state not translated")
1069 fail(dprog["loaded"] != "Y", "Offloaded program is not loaded")
1070
1071 start_test("Test removing XDP program many times...")
1072 sim.unset_xdp("offload")
1073 sim.unset_xdp("offload")
1074 sim.unset_xdp("drv")
1075 sim.unset_xdp("drv")
1076 sim.unset_xdp("")
1077 sim.unset_xdp("")
1078 bpftool_prog_list_wait(expected=0)
1079
1080 start_test("Test attempt to use a program for a wrong device...")
1081 simdev2 = NetdevSimDev()
1082 sim2, = simdev2.nsims
1083 sim2.set_xdp(obj, "offload")
1084 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp")
1085
1086 ret, _, err = sim.set_xdp(pinned, "offload",
1087 fail=False, include_stderr=True)
1088 fail(ret == 0, "Pinned program loaded for a different device accepted")
1089 check_extack_nsim(err, "program bound to different dev.", args)
1090 simdev2.remove()
1091 ret, _, err = sim.set_xdp(pinned, "offload",
1092 fail=False, include_stderr=True)
1093 fail(ret == 0, "Pinned program loaded for a removed device accepted")
1094 check_extack_nsim(err, "xdpoffload of non-bound program.", args)
1095 rm(pin_file)
1096 bpftool_prog_list_wait(expected=0)
1097
1098 simdev, sim = test_multi_prog(simdev, sim, obj, "", 1)
1099 simdev, sim = test_multi_prog(simdev, sim, obj, "drv", 1)
1100 simdev, sim = test_multi_prog(simdev, sim, obj, "generic", 2)
1101
1102 start_test("Test mixing of TC and XDP...")
1103 sim.tc_add_ingress()
1104 sim.set_xdp(obj, "offload")
1105 ret, _, err = sim.cls_bpf_add_filter(obj, skip_sw=True,
1106 fail=False, include_stderr=True)
1107 fail(ret == 0, "Loading TC when XDP active should fail")
1108 check_extack_nsim(err, "driver and netdev offload states mismatch.", args)
1109 sim.unset_xdp("offload")
1110 sim.wait_for_flush()
1111
1112 sim.cls_bpf_add_filter(obj, skip_sw=True)
1113 ret, _, err = sim.set_xdp(obj, "offload", fail=False, include_stderr=True)
1114 fail(ret == 0, "Loading XDP when TC active should fail")
1115 check_extack_nsim(err, "TC program is already loaded.", args)
1116
1117 start_test("Test binding TC from pinned...")
1118 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp")
1119 sim.tc_flush_filters(bound=1, total=1)
1120 sim.cls_bpf_add_filter(pinned, da=True, skip_sw=True)
1121 sim.tc_flush_filters(bound=1, total=1)
1122
1123 start_test("Test binding XDP from pinned...")
1124 sim.set_xdp(obj, "offload")
1125 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp2", idx=1)
1126
1127 sim.set_xdp(pinned, "offload", force=True)
1128 sim.unset_xdp("offload")
1129 sim.set_xdp(pinned, "offload", force=True)
1130 sim.unset_xdp("offload")
1131
1132 start_test("Test offload of wrong type fails...")
1133 ret, _ = sim.cls_bpf_add_filter(pinned, da=True, skip_sw=True, fail=False)
1134 fail(ret == 0, "Managed to attach XDP program to TC")
1135
1136 start_test("Test asking for TC offload of two filters...")
1137 sim.cls_bpf_add_filter(obj, da=True, skip_sw=True)
1138 ret, _, err = sim.cls_bpf_add_filter(obj, da=True, skip_sw=True,
1139 fail=False, include_stderr=True)
1140 fail(ret == 0, "Managed to offload two TC filters at the same time")
1141 check_extack_nsim(err, "driver and netdev offload states mismatch.", args)
1142
1143 sim.tc_flush_filters(bound=2, total=2)
1144
1145 start_test("Test if netdev removal waits for translation...")
1146 delay_msec = 500
1147 sim.dfs["dev/bpf_bind_verifier_delay"] = delay_msec
1148 start = time.time()
1149 cmd_line = "tc filter add dev %s ingress bpf %s da skip_sw" % \
1150 (sim['ifname'], obj)
1151 tc_proc = cmd(cmd_line, background=True, fail=False)
1152 # Wait for the verifier to start
1153 while simdev.dfs_num_bound_progs() <= 2:
1154 pass
1155 simdev.remove()
1156 end = time.time()
1157 ret, _ = cmd_result(tc_proc, fail=False)
1158 time_diff = end - start
1159 log("Time", "start:\t%s\nend:\t%s\ndiff:\t%s" % (start, end, time_diff))
1160
1161 fail(ret == 0, "Managed to load TC filter on a unregistering device")
1162 delay_sec = delay_msec * 0.001
1163 fail(time_diff < delay_sec, "Removal process took %s, expected %s" %
1164 (time_diff, delay_sec))
1165
1166 # Remove all pinned files and reinstantiate the netdev
1167 clean_up()
1168 bpftool_prog_list_wait(expected=0)
1169
1170 simdev = NetdevSimDev()
1171 sim, = simdev.nsims
1172 map_obj = bpf_obj("sample_map_ret0.o")
1173 start_test("Test loading program with maps...")
1174 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON
1175
1176 start_test("Test bpftool bound info reporting (own ns)...")
1177 check_dev_info(False, "")
1178
1179 start_test("Test bpftool bound info reporting (other ns)...")
1180 ns = mknetns()
1181 sim.set_ns(ns)
1182 check_dev_info(True, "")
1183
1184 start_test("Test bpftool bound info reporting (remote ns)...")
1185 check_dev_info(False, ns)
1186
1187 start_test("Test bpftool bound info reporting (back to own ns)...")
1188 sim.set_ns("")
1189 check_dev_info(False, "")
1190
1191 prog_file, _ = pin_prog("/sys/fs/bpf/tmp_prog")
1192 map_file, _ = pin_map("/sys/fs/bpf/tmp_map", idx=1, expected=2)
1193 simdev.remove()
1194
1195 start_test("Test bpftool bound info reporting (removed dev)...")
1196 check_dev_info_removed(prog_file=prog_file, map_file=map_file)
1197
1198 # Remove all pinned files and reinstantiate the netdev
1199 clean_up()
1200 bpftool_prog_list_wait(expected=0)
1201
1202 simdev = NetdevSimDev()
1203 sim, = simdev.nsims
1204
1205 start_test("Test map update (no flags)...")
1206 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON
1207 maps = bpftool_map_list(expected=2)
1208 array = maps[0] if maps[0]["type"] == "array" else maps[1]
1209 htab = maps[0] if maps[0]["type"] == "hash" else maps[1]
1210 for m in maps:
1211 for i in range(2):
1212 bpftool("map update id %d key %s value %s" %
1213 (m["id"], int2str("I", i), int2str("Q", i * 3)))
1214
1215 for m in maps:
1216 ret, _ = bpftool("map update id %d key %s value %s" %
1217 (m["id"], int2str("I", 3), int2str("Q", 3 * 3)),
1218 fail=False)
1219 fail(ret == 0, "added too many entries")
1220
1221 start_test("Test map update (exists)...")
1222 for m in maps:
1223 for i in range(2):
1224 bpftool("map update id %d key %s value %s exist" %
1225 (m["id"], int2str("I", i), int2str("Q", i * 3)))
1226
1227 for m in maps:
1228 ret, err = bpftool("map update id %d key %s value %s exist" %
1229 (m["id"], int2str("I", 3), int2str("Q", 3 * 3)),
1230 fail=False)
1231 fail(ret == 0, "updated non-existing key")
1232 fail(err["error"].find("No such file or directory") == -1,
1233 "expected ENOENT, error is '%s'" % (err["error"]))
1234
1235 start_test("Test map update (noexist)...")
1236 for m in maps:
1237 for i in range(2):
1238 ret, err = bpftool("map update id %d key %s value %s noexist" %
1239 (m["id"], int2str("I", i), int2str("Q", i * 3)),
1240 fail=False)
1241 fail(ret == 0, "updated existing key")
1242 fail(err["error"].find("File exists") == -1,
1243 "expected EEXIST, error is '%s'" % (err["error"]))
1244
1245 start_test("Test map dump...")
1246 for m in maps:
1247 _, entries = bpftool("map dump id %d" % (m["id"]))
1248 for i in range(2):
1249 key = str2int(entries[i]["key"])
1250 fail(key != i, "expected key %d, got %d" % (key, i))
1251 val = str2int(entries[i]["value"])
1252 fail(val != i * 3, "expected value %d, got %d" % (val, i * 3))
1253
1254 start_test("Test map getnext...")
1255 for m in maps:
1256 _, entry = bpftool("map getnext id %d" % (m["id"]))
1257 key = str2int(entry["next_key"])
1258 fail(key != 0, "next key %d, expected %d" % (key, 0))
1259 _, entry = bpftool("map getnext id %d key %s" %
1260 (m["id"], int2str("I", 0)))
1261 key = str2int(entry["next_key"])
1262 fail(key != 1, "next key %d, expected %d" % (key, 1))
1263 ret, err = bpftool("map getnext id %d key %s" %
1264 (m["id"], int2str("I", 1)), fail=False)
1265 fail(ret == 0, "got next key past the end of map")
1266 fail(err["error"].find("No such file or directory") == -1,
1267 "expected ENOENT, error is '%s'" % (err["error"]))
1268
1269 start_test("Test map delete (htab)...")
1270 for i in range(2):
1271 bpftool("map delete id %d key %s" % (htab["id"], int2str("I", i)))
1272
1273 start_test("Test map delete (array)...")
1274 for i in range(2):
1275 ret, err = bpftool("map delete id %d key %s" %
1276 (htab["id"], int2str("I", i)), fail=False)
1277 fail(ret == 0, "removed entry from an array")
1278 fail(err["error"].find("No such file or directory") == -1,
1279 "expected ENOENT, error is '%s'" % (err["error"]))
1280
1281 start_test("Test map remove...")
1282 sim.unset_xdp("offload")
1283 bpftool_map_list_wait(expected=0)
1284 simdev.remove()
1285
1286 simdev = NetdevSimDev()
1287 sim, = simdev.nsims
1288 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON
1289 simdev.remove()
1290 bpftool_map_list_wait(expected=0)
1291
1292 start_test("Test map creation fail path...")
1293 simdev = NetdevSimDev()
1294 sim, = simdev.nsims
1295 sim.dfs["bpf_map_accept"] = "N"
1296 ret, _ = sim.set_xdp(map_obj, "offload", JSON=False, fail=False)
1297 fail(ret == 0,
1298 "netdevsim didn't refuse to create a map with offload disabled")
1299
1300 simdev.remove()
1301
1302 start_test("Test multi-dev ASIC program reuse...")
1303 simdevA = NetdevSimDev()
1304 simA, = simdevA.nsims
1305 simdevB = NetdevSimDev(3)
1306 simB1, simB2, simB3 = simdevB.nsims
1307 sims = (simA, simB1, simB2, simB3)
1308 simB = (simB1, simB2, simB3)
1309
1310 bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA",
1311 dev=simA['ifname'])
1312 progA = bpf_pinned("/sys/fs/bpf/nsimA")
1313 bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB",
1314 dev=simB1['ifname'])
1315 progB = bpf_pinned("/sys/fs/bpf/nsimB")
1316
1317 simA.set_xdp(progA, "offload", JSON=False)
1318 for d in simdevB.nsims:
1319 d.set_xdp(progB, "offload", JSON=False)
1320
1321 start_test("Test multi-dev ASIC cross-dev replace...")
1322 ret, _ = simA.set_xdp(progB, "offload", force=True, JSON=False, fail=False)
1323 fail(ret == 0, "cross-ASIC program allowed")
1324 for d in simdevB.nsims:
1325 ret, _ = d.set_xdp(progA, "offload", force=True, JSON=False, fail=False)
1326 fail(ret == 0, "cross-ASIC program allowed")
1327
1328 start_test("Test multi-dev ASIC cross-dev install...")
1329 for d in sims:
1330 d.unset_xdp("offload")
1331
1332 ret, _, err = simA.set_xdp(progB, "offload", force=True, JSON=False,
1333 fail=False, include_stderr=True)
1334 fail(ret == 0, "cross-ASIC program allowed")
1335 check_extack_nsim(err, "program bound to different dev.", args)
1336 for d in simdevB.nsims:
1337 ret, _, err = d.set_xdp(progA, "offload", force=True, JSON=False,
1338 fail=False, include_stderr=True)
1339 fail(ret == 0, "cross-ASIC program allowed")
1340 check_extack_nsim(err, "program bound to different dev.", args)
1341
1342 start_test("Test multi-dev ASIC cross-dev map reuse...")
1343
1344 mapA = bpftool("prog show %s" % (progA))[1]["map_ids"][0]
1345 mapB = bpftool("prog show %s" % (progB))[1]["map_ids"][0]
1346
1347 ret, _ = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
1348 dev=simB3['ifname'],
1349 maps=["idx 0 id %d" % (mapB)],
1350 fail=False)
1351 fail(ret != 0, "couldn't reuse a map on the same ASIC")
1352 rm("/sys/fs/bpf/nsimB_")
1353
1354 ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA_",
1355 dev=simA['ifname'],
1356 maps=["idx 0 id %d" % (mapB)],
1357 fail=False, include_stderr=True)
1358 fail(ret == 0, "could reuse a map on a different ASIC")
1359 fail(err.count("offload device mismatch between prog and map") == 0,
1360 "error message missing for cross-ASIC map")
1361
1362 ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
1363 dev=simB1['ifname'],
1364 maps=["idx 0 id %d" % (mapA)],
1365 fail=False, include_stderr=True)
1366 fail(ret == 0, "could reuse a map on a different ASIC")
1367 fail(err.count("offload device mismatch between prog and map") == 0,
1368 "error message missing for cross-ASIC map")
1369
1370 start_test("Test multi-dev ASIC cross-dev destruction...")
1371 bpftool_prog_list_wait(expected=2)
1372
1373 simdevA.remove()
1374 bpftool_prog_list_wait(expected=1)
1375
1376 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
1377 fail(ifnameB != simB1['ifname'], "program not bound to original device")
1378 simB1.remove()
1379 bpftool_prog_list_wait(expected=1)
1380
1381 start_test("Test multi-dev ASIC cross-dev destruction - move...")
1382 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
1383 fail(ifnameB not in (simB2['ifname'], simB3['ifname']),
1384 "program not bound to remaining devices")
1385
1386 simB2.remove()
1387 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
1388 fail(ifnameB != simB3['ifname'], "program not bound to remaining device")
1389
1390 simB3.remove()
1391 simdevB.remove()
1392 bpftool_prog_list_wait(expected=0)
1393
1394 start_test("Test multi-dev ASIC cross-dev destruction - orphaned...")
1395 ret, out = bpftool("prog show %s" % (progB), fail=False)
1396 fail(ret == 0, "got information about orphaned program")
1397 fail("error" not in out, "no error reported for get info on orphaned")
1398 fail(out["error"] != "can't get prog info: No such device",
1399 "wrong error for get info on orphaned")
1400
1401 print("%s: OK" % (os.path.basename(__file__)))
1402
1403finally:
1404 log("Clean up...", "", level=1)
1405 log_level_inc()
1406 clean_up()