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') 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 'libbpf_det_bind', # created on each bpftool invocation 774] 775 776# Check netdevsim 777if not os.path.isdir("/sys/bus/netdevsim/"): 778 ret, out = cmd("modprobe netdevsim", fail=False) 779 skip(ret != 0, "netdevsim module could not be loaded") 780 781# Check debugfs 782_, out = cmd("mount") 783if out.find("/sys/kernel/debug type debugfs") == -1: 784 cmd("mount -t debugfs none /sys/kernel/debug") 785 786# Check samples are compiled 787samples = ["sample_ret0.bpf.o", "sample_map_ret0.bpf.o"] 788for s in samples: 789 ret, out = cmd("ls %s/%s" % (bpf_test_dir, s), fail=False) 790 skip(ret != 0, "sample %s/%s not found, please compile it" % 791 (bpf_test_dir, s)) 792 793# Check if iproute2 is built with libmnl (needed by extack support) 794_, _, err = cmd("tc qdisc delete dev lo handle 0", 795 fail=False, include_stderr=True) 796if err.find("Error: Failed to find qdisc with specified handle.") == -1: 797 print("Warning: no extack message in iproute2 output, libmnl missing?") 798 log("Warning: no extack message in iproute2 output, libmnl missing?", "") 799 skip_extack = True 800 801# Check if net namespaces seem to work 802ns = mknetns() 803skip(ns is None, "Could not create a net namespace") 804cmd("ip netns delete %s" % (ns)) 805netns = [] 806 807try: 808 obj = bpf_obj("sample_ret0.bpf.o") 809 bytecode = bpf_bytecode("1,6 0 0 4294967295,") 810 811 start_test("Test destruction of generic XDP...") 812 simdev = NetdevSimDev() 813 sim, = simdev.nsims 814 sim.set_xdp(obj, "generic") 815 simdev.remove() 816 bpftool_prog_list_wait(expected=0) 817 818 simdev = NetdevSimDev() 819 sim, = simdev.nsims 820 sim.tc_add_ingress() 821 822 start_test("Test TC non-offloaded...") 823 ret, _ = sim.cls_bpf_add_filter(obj, skip_hw=True, fail=False) 824 fail(ret != 0, "Software TC filter did not load") 825 826 start_test("Test TC non-offloaded isn't getting bound...") 827 ret, _ = sim.cls_bpf_add_filter(obj, fail=False) 828 fail(ret != 0, "Software TC filter did not load") 829 simdev.dfs_get_bound_progs(expected=0) 830 831 sim.tc_flush_filters() 832 833 start_test("Test TC offloads are off by default...") 834 ret, _, err = sim.cls_bpf_add_filter(obj, skip_sw=True, 835 fail=False, include_stderr=True) 836 fail(ret == 0, "TC filter loaded without enabling TC offloads") 837 check_extack(err, "TC offload is disabled on net device.", args) 838 sim.wait_for_flush() 839 840 sim.set_ethtool_tc_offloads(True) 841 sim.dfs["bpf_tc_non_bound_accept"] = "Y" 842 843 start_test("Test TC offload by default...") 844 ret, _ = sim.cls_bpf_add_filter(obj, fail=False) 845 fail(ret != 0, "Software TC filter did not load") 846 simdev.dfs_get_bound_progs(expected=0) 847 ingress = sim.tc_show_ingress(expected=1) 848 fltr = ingress[0] 849 fail(not fltr["in_hw"], "Filter not offloaded by default") 850 851 sim.tc_flush_filters() 852 853 start_test("Test TC cBPF bytcode tries offload by default...") 854 ret, _ = sim.cls_bpf_add_filter(bytecode, fail=False) 855 fail(ret != 0, "Software TC filter did not load") 856 simdev.dfs_get_bound_progs(expected=0) 857 ingress = sim.tc_show_ingress(expected=1) 858 fltr = ingress[0] 859 fail(not fltr["in_hw"], "Bytecode not offloaded by default") 860 861 sim.tc_flush_filters() 862 sim.dfs["bpf_tc_non_bound_accept"] = "N" 863 864 start_test("Test TC cBPF unbound bytecode doesn't offload...") 865 ret, _, err = sim.cls_bpf_add_filter(bytecode, skip_sw=True, 866 fail=False, include_stderr=True) 867 fail(ret == 0, "TC bytecode loaded for offload") 868 check_extack_nsim(err, "netdevsim configured to reject unbound programs.", 869 args) 870 sim.wait_for_flush() 871 872 start_test("Test non-0 chain offload...") 873 ret, _, err = sim.cls_bpf_add_filter(obj, chain=1, prio=1, handle=1, 874 skip_sw=True, 875 fail=False, include_stderr=True) 876 fail(ret == 0, "Offloaded a filter to chain other than 0") 877 check_extack(err, "Driver supports only offload of chain 0.", args) 878 sim.tc_flush_filters() 879 880 start_test("Test TC replace...") 881 sim.cls_bpf_add_filter(obj, prio=1, handle=1) 882 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1) 883 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf") 884 885 sim.cls_bpf_add_filter(obj, prio=1, handle=1, skip_sw=True) 886 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1, skip_sw=True) 887 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf") 888 889 sim.cls_bpf_add_filter(obj, prio=1, handle=1, skip_hw=True) 890 sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1, skip_hw=True) 891 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf") 892 893 start_test("Test TC replace bad flags...") 894 for i in range(3): 895 for j in range(3): 896 ret, _ = sim.cls_bpf_add_filter(obj, op="replace", prio=1, handle=1, 897 skip_sw=(j == 1), skip_hw=(j == 2), 898 fail=False) 899 fail(bool(ret) != bool(j), 900 "Software TC incorrect load in replace test, iteration %d" % 901 (j)) 902 sim.cls_filter_op(op="delete", prio=1, handle=1, cls="bpf") 903 904 start_test("Test spurious extack from the driver...") 905 test_spurios_extack(sim, obj, False, "netdevsim") 906 test_spurios_extack(sim, obj, True, "netdevsim") 907 908 sim.set_ethtool_tc_offloads(False) 909 910 test_spurios_extack(sim, obj, False, "TC offload is disabled") 911 test_spurios_extack(sim, obj, True, "TC offload is disabled") 912 913 sim.set_ethtool_tc_offloads(True) 914 915 sim.tc_flush_filters() 916 917 start_test("Test TC offloads failure...") 918 sim.dfs["dev/bpf_bind_verifier_accept"] = 0 919 ret, _, err = sim.cls_bpf_add_filter(obj, verbose=True, skip_sw=True, 920 fail=False, include_stderr=True) 921 fail(ret == 0, "TC filter did not reject with TC offloads enabled") 922 check_verifier_log(err, "[netdevsim] Hello from netdevsim!") 923 sim.dfs["dev/bpf_bind_verifier_accept"] = 1 924 925 start_test("Test TC offloads work...") 926 ret, _, err = sim.cls_bpf_add_filter(obj, verbose=True, skip_sw=True, 927 fail=False, include_stderr=True) 928 fail(ret != 0, "TC filter did not load with TC offloads enabled") 929 930 start_test("Test TC offload basics...") 931 dfs = simdev.dfs_get_bound_progs(expected=1) 932 progs = bpftool_prog_list(expected=1) 933 ingress = sim.tc_show_ingress(expected=1) 934 935 dprog = dfs[0] 936 prog = progs[0] 937 fltr = ingress[0] 938 fail(fltr["skip_hw"], "TC does reports 'skip_hw' on offloaded filter") 939 fail(not fltr["in_hw"], "TC does not report 'in_hw' for offloaded filter") 940 fail(not fltr["skip_sw"], "TC does not report 'skip_sw' back") 941 942 start_test("Test TC offload is device-bound...") 943 fail(str(prog["id"]) != fltr["id"], "Program IDs don't match") 944 fail(prog["tag"] != fltr["tag"], "Program tags don't match") 945 fail(fltr["id"] != dprog["id"], "Program IDs don't match") 946 fail(dprog["state"] != "xlated", "Offloaded program state not translated") 947 fail(dprog["loaded"] != "Y", "Offloaded program is not loaded") 948 949 start_test("Test disabling TC offloads is rejected while filters installed...") 950 ret, _ = sim.set_ethtool_tc_offloads(False, fail=False) 951 fail(ret == 0, "Driver should refuse to disable TC offloads with filters installed...") 952 sim.set_ethtool_tc_offloads(True) 953 954 start_test("Test qdisc removal frees things...") 955 sim.tc_flush_filters() 956 sim.tc_show_ingress(expected=0) 957 958 start_test("Test disabling TC offloads is OK without filters...") 959 ret, _ = sim.set_ethtool_tc_offloads(False, fail=False) 960 fail(ret != 0, 961 "Driver refused to disable TC offloads without filters installed...") 962 963 sim.set_ethtool_tc_offloads(True) 964 965 start_test("Test destroying device gets rid of TC filters...") 966 sim.cls_bpf_add_filter(obj, skip_sw=True) 967 simdev.remove() 968 bpftool_prog_list_wait(expected=0) 969 970 simdev = NetdevSimDev() 971 sim, = simdev.nsims 972 sim.set_ethtool_tc_offloads(True) 973 974 start_test("Test destroying device gets rid of XDP...") 975 sim.set_xdp(obj, "offload") 976 simdev.remove() 977 bpftool_prog_list_wait(expected=0) 978 979 simdev = NetdevSimDev() 980 sim, = simdev.nsims 981 sim.set_ethtool_tc_offloads(True) 982 983 start_test("Test XDP prog reporting...") 984 sim.set_xdp(obj, "drv") 985 ipl = sim.ip_link_show(xdp=True) 986 progs = bpftool_prog_list(expected=1) 987 fail(ipl["xdp"]["prog"]["id"] != progs[0]["id"], 988 "Loaded program has wrong ID") 989 990 start_test("Test XDP prog replace without force...") 991 ret, _ = sim.set_xdp(obj, "drv", fail=False) 992 fail(ret == 0, "Replaced XDP program without -force") 993 sim.wait_for_flush(total=1) 994 995 start_test("Test XDP prog replace with force...") 996 ret, _ = sim.set_xdp(obj, "drv", force=True, fail=False) 997 fail(ret != 0, "Could not replace XDP program with -force") 998 bpftool_prog_list_wait(expected=1) 999 ipl = sim.ip_link_show(xdp=True) 1000 progs = bpftool_prog_list(expected=1) 1001 fail(ipl["xdp"]["prog"]["id"] != progs[0]["id"], 1002 "Loaded program has wrong ID") 1003 fail("dev" in progs[0].keys(), 1004 "Device parameters reported for non-offloaded program") 1005 1006 start_test("Test XDP prog replace with bad flags...") 1007 ret, _, err = sim.set_xdp(obj, "generic", force=True, 1008 fail=False, include_stderr=True) 1009 fail(ret == 0, "Replaced XDP program with a program in different mode") 1010 check_extack(err, 1011 "Native and generic XDP can't be active at the same time.", 1012 args) 1013 1014 start_test("Test MTU restrictions...") 1015 ret, _ = sim.set_mtu(9000, fail=False) 1016 fail(ret == 0, 1017 "Driver should refuse to increase MTU to 9000 with XDP loaded...") 1018 sim.unset_xdp("drv") 1019 bpftool_prog_list_wait(expected=0) 1020 sim.set_mtu(9000) 1021 ret, _, err = sim.set_xdp(obj, "drv", fail=False, include_stderr=True) 1022 fail(ret == 0, "Driver should refuse to load program with MTU of 9000...") 1023 check_extack_nsim(err, "MTU too large w/ XDP enabled.", args) 1024 sim.set_mtu(1500) 1025 1026 sim.wait_for_flush() 1027 start_test("Test non-offload XDP attaching to HW...") 1028 bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/nooffload") 1029 nooffload = bpf_pinned("/sys/fs/bpf/nooffload") 1030 ret, _, err = sim.set_xdp(nooffload, "offload", 1031 fail=False, include_stderr=True) 1032 fail(ret == 0, "attached non-offloaded XDP program to HW") 1033 check_extack_nsim(err, "xdpoffload of non-bound program.", args) 1034 rm("/sys/fs/bpf/nooffload") 1035 1036 start_test("Test offload XDP attaching to drv...") 1037 bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/offload", 1038 dev=sim['ifname']) 1039 offload = bpf_pinned("/sys/fs/bpf/offload") 1040 ret, _, err = sim.set_xdp(offload, "drv", fail=False, include_stderr=True) 1041 fail(ret == 0, "attached offloaded XDP program to drv") 1042 check_extack(err, "Using offloaded program without HW_MODE flag is not supported.", args) 1043 rm("/sys/fs/bpf/offload") 1044 sim.wait_for_flush() 1045 1046 start_test("Test XDP load failure...") 1047 sim.dfs["dev/bpf_bind_verifier_accept"] = 0 1048 ret, _, err = bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/offload", 1049 dev=sim['ifname'], fail=False, include_stderr=True) 1050 fail(ret == 0, "verifier should fail on load") 1051 check_verifier_log(err, "[netdevsim] Hello from netdevsim!") 1052 sim.dfs["dev/bpf_bind_verifier_accept"] = 1 1053 sim.wait_for_flush() 1054 1055 start_test("Test XDP offload...") 1056 _, _, err = sim.set_xdp(obj, "offload", verbose=True, include_stderr=True) 1057 ipl = sim.ip_link_show(xdp=True) 1058 link_xdp = ipl["xdp"]["prog"] 1059 progs = bpftool_prog_list(expected=1) 1060 prog = progs[0] 1061 fail(link_xdp["id"] != prog["id"], "Loaded program has wrong ID") 1062 1063 start_test("Test XDP offload is device bound...") 1064 dfs = simdev.dfs_get_bound_progs(expected=1) 1065 dprog = dfs[0] 1066 1067 fail(prog["id"] != link_xdp["id"], "Program IDs don't match") 1068 fail(prog["tag"] != link_xdp["tag"], "Program tags don't match") 1069 fail(str(link_xdp["id"]) != dprog["id"], "Program IDs don't match") 1070 fail(dprog["state"] != "xlated", "Offloaded program state not translated") 1071 fail(dprog["loaded"] != "Y", "Offloaded program is not loaded") 1072 1073 start_test("Test removing XDP program many times...") 1074 sim.unset_xdp("offload") 1075 sim.unset_xdp("offload") 1076 sim.unset_xdp("drv") 1077 sim.unset_xdp("drv") 1078 sim.unset_xdp("") 1079 sim.unset_xdp("") 1080 bpftool_prog_list_wait(expected=0) 1081 1082 start_test("Test attempt to use a program for a wrong device...") 1083 simdev2 = NetdevSimDev() 1084 sim2, = simdev2.nsims 1085 sim2.set_xdp(obj, "offload") 1086 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp") 1087 1088 ret, _, err = sim.set_xdp(pinned, "offload", 1089 fail=False, include_stderr=True) 1090 fail(ret == 0, "Pinned program loaded for a different device accepted") 1091 check_extack(err, "Program bound to different device.", args) 1092 simdev2.remove() 1093 ret, _, err = sim.set_xdp(pinned, "offload", 1094 fail=False, include_stderr=True) 1095 fail(ret == 0, "Pinned program loaded for a removed device accepted") 1096 check_extack(err, "Program bound to different device.", args) 1097 rm(pin_file) 1098 bpftool_prog_list_wait(expected=0) 1099 1100 simdev, sim = test_multi_prog(simdev, sim, obj, "", 1) 1101 simdev, sim = test_multi_prog(simdev, sim, obj, "drv", 1) 1102 simdev, sim = test_multi_prog(simdev, sim, obj, "generic", 2) 1103 1104 start_test("Test mixing of TC and XDP...") 1105 sim.tc_add_ingress() 1106 sim.set_xdp(obj, "offload") 1107 ret, _, err = sim.cls_bpf_add_filter(obj, skip_sw=True, 1108 fail=False, include_stderr=True) 1109 fail(ret == 0, "Loading TC when XDP active should fail") 1110 check_extack_nsim(err, "driver and netdev offload states mismatch.", args) 1111 sim.unset_xdp("offload") 1112 sim.wait_for_flush() 1113 1114 sim.cls_bpf_add_filter(obj, skip_sw=True) 1115 ret, _, err = sim.set_xdp(obj, "offload", fail=False, include_stderr=True) 1116 fail(ret == 0, "Loading XDP when TC active should fail") 1117 check_extack_nsim(err, "TC program is already loaded.", args) 1118 1119 start_test("Test binding TC from pinned...") 1120 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp") 1121 sim.tc_flush_filters(bound=1, total=1) 1122 sim.cls_bpf_add_filter(pinned, da=True, skip_sw=True) 1123 sim.tc_flush_filters(bound=1, total=1) 1124 1125 start_test("Test binding XDP from pinned...") 1126 sim.set_xdp(obj, "offload") 1127 pin_file, pinned = pin_prog("/sys/fs/bpf/tmp2", idx=1) 1128 1129 sim.set_xdp(pinned, "offload", force=True) 1130 sim.unset_xdp("offload") 1131 sim.set_xdp(pinned, "offload", force=True) 1132 sim.unset_xdp("offload") 1133 1134 start_test("Test offload of wrong type fails...") 1135 ret, _ = sim.cls_bpf_add_filter(pinned, da=True, skip_sw=True, fail=False) 1136 fail(ret == 0, "Managed to attach XDP program to TC") 1137 1138 start_test("Test asking for TC offload of two filters...") 1139 sim.cls_bpf_add_filter(obj, da=True, skip_sw=True) 1140 ret, _, err = sim.cls_bpf_add_filter(obj, da=True, skip_sw=True, 1141 fail=False, include_stderr=True) 1142 fail(ret == 0, "Managed to offload two TC filters at the same time") 1143 check_extack_nsim(err, "driver and netdev offload states mismatch.", args) 1144 1145 sim.tc_flush_filters(bound=2, total=2) 1146 1147 start_test("Test if netdev removal waits for translation...") 1148 delay_msec = 500 1149 sim.dfs["dev/bpf_bind_verifier_delay"] = delay_msec 1150 start = time.time() 1151 cmd_line = "tc filter add dev %s ingress bpf %s da skip_sw" % \ 1152 (sim['ifname'], obj) 1153 tc_proc = cmd(cmd_line, background=True, fail=False) 1154 # Wait for the verifier to start 1155 while simdev.dfs_num_bound_progs() <= 2: 1156 pass 1157 simdev.remove() 1158 end = time.time() 1159 ret, _ = cmd_result(tc_proc, fail=False) 1160 time_diff = end - start 1161 log("Time", "start:\t%s\nend:\t%s\ndiff:\t%s" % (start, end, time_diff)) 1162 1163 fail(ret == 0, "Managed to load TC filter on a unregistering device") 1164 delay_sec = delay_msec * 0.001 1165 fail(time_diff < delay_sec, "Removal process took %s, expected %s" % 1166 (time_diff, delay_sec)) 1167 1168 # Remove all pinned files and reinstantiate the netdev 1169 clean_up() 1170 bpftool_prog_list_wait(expected=0) 1171 1172 simdev = NetdevSimDev() 1173 sim, = simdev.nsims 1174 map_obj = bpf_obj("sample_map_ret0.bpf.o") 1175 start_test("Test loading program with maps...") 1176 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON 1177 1178 start_test("Test bpftool bound info reporting (own ns)...") 1179 check_dev_info(False, "") 1180 1181 start_test("Test bpftool bound info reporting (other ns)...") 1182 ns = mknetns() 1183 sim.set_ns(ns) 1184 check_dev_info(True, "") 1185 1186 start_test("Test bpftool bound info reporting (remote ns)...") 1187 check_dev_info(False, ns) 1188 1189 start_test("Test bpftool bound info reporting (back to own ns)...") 1190 sim.set_ns("") 1191 check_dev_info(False, "") 1192 1193 prog_file, _ = pin_prog("/sys/fs/bpf/tmp_prog") 1194 map_file, _ = pin_map("/sys/fs/bpf/tmp_map", idx=1, expected=2) 1195 simdev.remove() 1196 1197 start_test("Test bpftool bound info reporting (removed dev)...") 1198 check_dev_info_removed(prog_file=prog_file, map_file=map_file) 1199 1200 # Remove all pinned files and reinstantiate the netdev 1201 clean_up() 1202 bpftool_prog_list_wait(expected=0) 1203 1204 simdev = NetdevSimDev() 1205 sim, = simdev.nsims 1206 1207 start_test("Test map update (no flags)...") 1208 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON 1209 maps = bpftool_map_list(expected=2) 1210 array = maps[0] if maps[0]["type"] == "array" else maps[1] 1211 htab = maps[0] if maps[0]["type"] == "hash" else maps[1] 1212 for m in maps: 1213 for i in range(2): 1214 bpftool("map update id %d key %s value %s" % 1215 (m["id"], int2str("I", i), int2str("Q", i * 3))) 1216 1217 for m in maps: 1218 ret, _ = bpftool("map update id %d key %s value %s" % 1219 (m["id"], int2str("I", 3), int2str("Q", 3 * 3)), 1220 fail=False) 1221 fail(ret == 0, "added too many entries") 1222 1223 start_test("Test map update (exists)...") 1224 for m in maps: 1225 for i in range(2): 1226 bpftool("map update id %d key %s value %s exist" % 1227 (m["id"], int2str("I", i), int2str("Q", i * 3))) 1228 1229 for m in maps: 1230 ret, err = bpftool("map update id %d key %s value %s exist" % 1231 (m["id"], int2str("I", 3), int2str("Q", 3 * 3)), 1232 fail=False) 1233 fail(ret == 0, "updated non-existing key") 1234 fail(err["error"].find("No such file or directory") == -1, 1235 "expected ENOENT, error is '%s'" % (err["error"])) 1236 1237 start_test("Test map update (noexist)...") 1238 for m in maps: 1239 for i in range(2): 1240 ret, err = bpftool("map update id %d key %s value %s noexist" % 1241 (m["id"], int2str("I", i), int2str("Q", i * 3)), 1242 fail=False) 1243 fail(ret == 0, "updated existing key") 1244 fail(err["error"].find("File exists") == -1, 1245 "expected EEXIST, error is '%s'" % (err["error"])) 1246 1247 start_test("Test map dump...") 1248 for m in maps: 1249 _, entries = bpftool("map dump id %d" % (m["id"])) 1250 for i in range(2): 1251 key = str2int(entries[i]["key"]) 1252 fail(key != i, "expected key %d, got %d" % (key, i)) 1253 val = str2int(entries[i]["value"]) 1254 fail(val != i * 3, "expected value %d, got %d" % (val, i * 3)) 1255 1256 start_test("Test map getnext...") 1257 for m in maps: 1258 _, entry = bpftool("map getnext id %d" % (m["id"])) 1259 key = str2int(entry["next_key"]) 1260 fail(key != 0, "next key %d, expected %d" % (key, 0)) 1261 _, entry = bpftool("map getnext id %d key %s" % 1262 (m["id"], int2str("I", 0))) 1263 key = str2int(entry["next_key"]) 1264 fail(key != 1, "next key %d, expected %d" % (key, 1)) 1265 ret, err = bpftool("map getnext id %d key %s" % 1266 (m["id"], int2str("I", 1)), fail=False) 1267 fail(ret == 0, "got next key past the end of map") 1268 fail(err["error"].find("No such file or directory") == -1, 1269 "expected ENOENT, error is '%s'" % (err["error"])) 1270 1271 start_test("Test map delete (htab)...") 1272 for i in range(2): 1273 bpftool("map delete id %d key %s" % (htab["id"], int2str("I", i))) 1274 1275 start_test("Test map delete (array)...") 1276 for i in range(2): 1277 ret, err = bpftool("map delete id %d key %s" % 1278 (htab["id"], int2str("I", i)), fail=False) 1279 fail(ret == 0, "removed entry from an array") 1280 fail(err["error"].find("No such file or directory") == -1, 1281 "expected ENOENT, error is '%s'" % (err["error"])) 1282 1283 start_test("Test map remove...") 1284 sim.unset_xdp("offload") 1285 bpftool_map_list_wait(expected=0) 1286 simdev.remove() 1287 1288 simdev = NetdevSimDev() 1289 sim, = simdev.nsims 1290 sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON 1291 simdev.remove() 1292 bpftool_map_list_wait(expected=0) 1293 1294 start_test("Test map creation fail path...") 1295 simdev = NetdevSimDev() 1296 sim, = simdev.nsims 1297 sim.dfs["bpf_map_accept"] = "N" 1298 ret, _ = sim.set_xdp(map_obj, "offload", JSON=False, fail=False) 1299 fail(ret == 0, 1300 "netdevsim didn't refuse to create a map with offload disabled") 1301 1302 simdev.remove() 1303 1304 start_test("Test multi-dev ASIC program reuse...") 1305 simdevA = NetdevSimDev() 1306 simA, = simdevA.nsims 1307 simdevB = NetdevSimDev(3) 1308 simB1, simB2, simB3 = simdevB.nsims 1309 sims = (simA, simB1, simB2, simB3) 1310 simB = (simB1, simB2, simB3) 1311 1312 bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimA", 1313 dev=simA['ifname']) 1314 progA = bpf_pinned("/sys/fs/bpf/nsimA") 1315 bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB", 1316 dev=simB1['ifname']) 1317 progB = bpf_pinned("/sys/fs/bpf/nsimB") 1318 1319 simA.set_xdp(progA, "offload", JSON=False) 1320 for d in simdevB.nsims: 1321 d.set_xdp(progB, "offload", JSON=False) 1322 1323 start_test("Test multi-dev ASIC cross-dev replace...") 1324 ret, _ = simA.set_xdp(progB, "offload", force=True, JSON=False, fail=False) 1325 fail(ret == 0, "cross-ASIC program allowed") 1326 for d in simdevB.nsims: 1327 ret, _ = d.set_xdp(progA, "offload", force=True, JSON=False, fail=False) 1328 fail(ret == 0, "cross-ASIC program allowed") 1329 1330 start_test("Test multi-dev ASIC cross-dev install...") 1331 for d in sims: 1332 d.unset_xdp("offload") 1333 1334 ret, _, err = simA.set_xdp(progB, "offload", force=True, JSON=False, 1335 fail=False, include_stderr=True) 1336 fail(ret == 0, "cross-ASIC program allowed") 1337 check_extack(err, "Program bound to different device.", args) 1338 for d in simdevB.nsims: 1339 ret, _, err = d.set_xdp(progA, "offload", force=True, JSON=False, 1340 fail=False, include_stderr=True) 1341 fail(ret == 0, "cross-ASIC program allowed") 1342 check_extack(err, "Program bound to different device.", args) 1343 1344 start_test("Test multi-dev ASIC cross-dev map reuse...") 1345 1346 mapA = bpftool("prog show %s" % (progA))[1]["map_ids"][0] 1347 mapB = bpftool("prog show %s" % (progB))[1]["map_ids"][0] 1348 1349 ret, _ = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB_", 1350 dev=simB3['ifname'], 1351 maps=["idx 0 id %d" % (mapB)], 1352 fail=False) 1353 fail(ret != 0, "couldn't reuse a map on the same ASIC") 1354 rm("/sys/fs/bpf/nsimB_") 1355 1356 ret, _, err = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimA_", 1357 dev=simA['ifname'], 1358 maps=["idx 0 id %d" % (mapB)], 1359 fail=False, include_stderr=True) 1360 fail(ret == 0, "could reuse a map on a different ASIC") 1361 fail(err.count("offload device mismatch between prog and map") == 0, 1362 "error message missing for cross-ASIC map") 1363 1364 ret, _, err = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB_", 1365 dev=simB1['ifname'], 1366 maps=["idx 0 id %d" % (mapA)], 1367 fail=False, include_stderr=True) 1368 fail(ret == 0, "could reuse a map on a different ASIC") 1369 fail(err.count("offload device mismatch between prog and map") == 0, 1370 "error message missing for cross-ASIC map") 1371 1372 start_test("Test multi-dev ASIC cross-dev destruction...") 1373 bpftool_prog_list_wait(expected=2) 1374 1375 simdevA.remove() 1376 bpftool_prog_list_wait(expected=1) 1377 1378 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"] 1379 fail(ifnameB != simB1['ifname'], "program not bound to original device") 1380 simB1.remove() 1381 bpftool_prog_list_wait(expected=1) 1382 1383 start_test("Test multi-dev ASIC cross-dev destruction - move...") 1384 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"] 1385 fail(ifnameB not in (simB2['ifname'], simB3['ifname']), 1386 "program not bound to remaining devices") 1387 1388 simB2.remove() 1389 ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"] 1390 fail(ifnameB != simB3['ifname'], "program not bound to remaining device") 1391 1392 simB3.remove() 1393 simdevB.remove() 1394 bpftool_prog_list_wait(expected=0) 1395 1396 start_test("Test multi-dev ASIC cross-dev destruction - orphaned...") 1397 ret, out = bpftool("prog show %s" % (progB), fail=False) 1398 fail(ret == 0, "got information about orphaned program") 1399 fail("error" not in out, "no error reported for get info on orphaned") 1400 fail(out["error"] != "can't get prog info: No such device", 1401 "wrong error for get info on orphaned") 1402 1403 print("%s: OK" % (os.path.basename(__file__))) 1404 1405finally: 1406 log("Clean up...", "", level=1) 1407 log_level_inc() 1408 clean_up() 1409
