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