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="", exclude_orphaned=True):
 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 exclude_orphaned:
 179        progs = [ p for p in progs if not p['orphaned'] ]
 180    if expected is not None:
 181        if len(progs) != expected:
 182            fail(True, "%d BPF programs loaded, expected %d" %
 183                 (len(progs), expected))
 184    return progs
 185
 186def bpftool_map_list(expected=None, ns=""):
 187    _, maps = bpftool("map show", JSON=True, ns=ns, fail=True)
 188    # Remove the base maps
 189    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]
 
 
 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                # We need to init trap_flow_action_cookie before read it
 322                if f == "trap_flow_action_cookie":
 323                    cmd('echo deadbeef > %s/%s' % (path, f))
 324                _, out = cmd('cat %s/%s' % (path, f))
 325                dfs[f] = out.strip()
 326            elif os.path.isdir(p):
 327                dfs[f] = DebugfsDir(p)
 328            else:
 329                raise Exception("%s is neither file nor directory" % (p))
 330
 331        log_level_dec()
 332        log("DebugFS state", dfs)
 333        log_level_dec()
 334
 335        return dfs
 336
 337class NetdevSimDev:
 338    """
 339    Class for netdevsim bus device and its attributes.
 340    """
 341    @staticmethod
 342    def ctrl_write(path, val):
 343        fullpath = os.path.join("/sys/bus/netdevsim/", path)
 344        try:
 345            with open(fullpath, "w") as f:
 346                f.write(val)
 347        except OSError as e:
 348            log("WRITE %s: %r" % (fullpath, val), -e.errno)
 349            raise e
 350        log("WRITE %s: %r" % (fullpath, val), 0)
 351
 352    def __init__(self, port_count=1):
 353        addr = 0
 354        while True:
 355            try:
 356                self.ctrl_write("new_device", "%u %u" % (addr, port_count))
 357            except OSError as e:
 358                if e.errno == errno.ENOSPC:
 359                    addr += 1
 360                    continue
 361                raise e
 362            break
 363        self.addr = addr
 364
 365        # As probe of netdevsim device might happen from a workqueue,
 366        # so wait here until all netdevs appear.
 367        self.wait_for_netdevs(port_count)
 368
 369        ret, out = cmd("udevadm settle", fail=False)
 370        if ret:
 371            raise Exception("udevadm settle failed")
 372        ifnames = self.get_ifnames()
 373
 374        devs.append(self)
 375        self.dfs_dir = "/sys/kernel/debug/netdevsim/netdevsim%u/" % addr
 376
 377        self.nsims = []
 378        for port_index in range(port_count):
 379            self.nsims.append(NetdevSim(self, port_index, ifnames[port_index]))
 380
 381    def get_ifnames(self):
 382        ifnames = []
 383        listdir = os.listdir("/sys/bus/netdevsim/devices/netdevsim%u/net/" % self.addr)
 384        for ifname in listdir:
 385            ifnames.append(ifname)
 386        ifnames.sort()
 387        return ifnames
 388
 389    def wait_for_netdevs(self, port_count):
 390        timeout = 5
 391        timeout_start = time.time()
 392
 393        while True:
 394            try:
 395                ifnames = self.get_ifnames()
 396            except FileNotFoundError as e:
 397                ifnames = []
 398            if len(ifnames) == port_count:
 399                break
 400            if time.time() < timeout_start + timeout:
 401                continue
 402            raise Exception("netdevices did not appear within timeout")
 403
 404    def dfs_num_bound_progs(self):
 405        path = os.path.join(self.dfs_dir, "bpf_bound_progs")
 406        _, progs = cmd('ls %s' % (path))
 407        return len(progs.split())
 408
 409    def dfs_get_bound_progs(self, expected):
 410        progs = DebugfsDir(os.path.join(self.dfs_dir, "bpf_bound_progs"))
 411        if expected is not None:
 412            if len(progs) != expected:
 413                fail(True, "%d BPF programs bound, expected %d" %
 414                     (len(progs), expected))
 415        return progs
 416
 417    def remove(self):
 418        self.ctrl_write("del_device", "%u" % (self.addr, ))
 419        devs.remove(self)
 420
 421    def remove_nsim(self, nsim):
 422        self.nsims.remove(nsim)
 423        self.ctrl_write("devices/netdevsim%u/del_port" % (self.addr, ),
 424                        "%u" % (nsim.port_index, ))
 425
 426class NetdevSim:
 427    """
 428    Class for netdevsim netdevice and its attributes.
 429    """
 430
 431    def __init__(self, nsimdev, port_index, ifname):
 432        # In case udev renamed the netdev to according to new schema,
 433        # check if the name matches the port_index.
 434        nsimnamere = re.compile("eni\d+np(\d+)")
 435        match = nsimnamere.match(ifname)
 436        if match and int(match.groups()[0]) != port_index + 1:
 437            raise Exception("netdevice name mismatches the expected one")
 438
 439        self.nsimdev = nsimdev
 440        self.port_index = port_index
 441        self.ns = ""
 442        self.dfs_dir = "%s/ports/%u/" % (nsimdev.dfs_dir, port_index)
 443        self.dfs_refresh()
 444        _, [self.dev] = ip("link show dev %s" % ifname)
 445
 446    def __getitem__(self, key):
 447        return self.dev[key]
 448
 449    def remove(self):
 450        self.nsimdev.remove_nsim(self)
 451
 452    def dfs_refresh(self):
 453        self.dfs = DebugfsDir(self.dfs_dir)
 454        return self.dfs
 455
 456    def dfs_read(self, f):
 457        path = os.path.join(self.dfs_dir, f)
 458        _, data = cmd('cat %s' % (path))
 459        return data.strip()
 460
 461    def wait_for_flush(self, bound=0, total=0, n_retry=20):
 462        for i in range(n_retry):
 463            nbound = self.nsimdev.dfs_num_bound_progs()
 464            nprogs = len(bpftool_prog_list())
 465            if nbound == bound and nprogs == total:
 466                return
 467            time.sleep(0.05)
 468        raise Exception("Time out waiting for program counts to stabilize want %d/%d, have %d bound, %d loaded" % (bound, total, nbound, nprogs))
 469
 470    def set_ns(self, ns):
 471        name = "1" if ns == "" else ns
 472        ip("link set dev %s netns %s" % (self.dev["ifname"], name), ns=self.ns)
 473        self.ns = ns
 474
 475    def set_mtu(self, mtu, fail=True):
 476        return ip("link set dev %s mtu %d" % (self.dev["ifname"], mtu),
 477                  fail=fail)
 478
 479    def set_xdp(self, bpf, mode, force=False, JSON=True, verbose=False,
 480                fail=True, include_stderr=False):
 481        if verbose:
 482            bpf += " verbose"
 483        return ip("link set dev %s xdp%s %s" % (self.dev["ifname"], mode, bpf),
 484                  force=force, JSON=JSON,
 485                  fail=fail, include_stderr=include_stderr)
 486
 487    def unset_xdp(self, mode, force=False, JSON=True,
 488                  fail=True, include_stderr=False):
 489        return ip("link set dev %s xdp%s off" % (self.dev["ifname"], mode),
 490                  force=force, JSON=JSON,
 491                  fail=fail, include_stderr=include_stderr)
 492
 493    def ip_link_show(self, xdp):
 494        _, link = ip("link show dev %s" % (self['ifname']))
 495        if len(link) > 1:
 496            raise Exception("Multiple objects on ip link show")
 497        if len(link) < 1:
 498            return {}
 499        fail(xdp != "xdp" in link,
 500             "XDP program not reporting in iplink (reported %s, expected %s)" %
 501             ("xdp" in link, xdp))
 502        return link[0]
 503
 504    def tc_add_ingress(self):
 505        tc("qdisc add dev %s ingress" % (self['ifname']))
 506
 507    def tc_del_ingress(self):
 508        tc("qdisc del dev %s ingress" % (self['ifname']))
 509
 510    def tc_flush_filters(self, bound=0, total=0):
 511        self.tc_del_ingress()
 512        self.tc_add_ingress()
 513        self.wait_for_flush(bound=bound, total=total)
 514
 515    def tc_show_ingress(self, expected=None):
 516        # No JSON support, oh well...
 517        flags = ["skip_sw", "skip_hw", "in_hw"]
 518        named = ["protocol", "pref", "chain", "handle", "id", "tag"]
 519
 520        args = "-s filter show dev %s ingress" % (self['ifname'])
 521        _, out = tc(args, JSON=False)
 522
 523        filters = []
 524        lines = out.split('\n')
 525        for line in lines:
 526            words = line.split()
 527            if "handle" not in words:
 528                continue
 529            fltr = {}
 530            for flag in flags:
 531                fltr[flag] = flag in words
 532            for name in named:
 533                try:
 534                    idx = words.index(name)
 535                    fltr[name] = words[idx + 1]
 536                except ValueError:
 537                    pass
 538            filters.append(fltr)
 539
 540        if expected is not None:
 541            fail(len(filters) != expected,
 542                 "%d ingress filters loaded, expected %d" %
 543                 (len(filters), expected))
 544        return filters
 545
 546    def cls_filter_op(self, op, qdisc="ingress", prio=None, handle=None,
 547                      chain=None, cls="", params="",
 548                      fail=True, include_stderr=False):
 549        spec = ""
 550        if prio is not None:
 551            spec += " prio %d" % (prio)
 552        if handle:
 553            spec += " handle %s" % (handle)
 554        if chain is not None:
 555            spec += " chain %d" % (chain)
 556
 557        return tc("filter {op} dev {dev} {qdisc} {spec} {cls} {params}"\
 558                  .format(op=op, dev=self['ifname'], qdisc=qdisc, spec=spec,
 559                          cls=cls, params=params),
 560                  fail=fail, include_stderr=include_stderr)
 561
 562    def cls_bpf_add_filter(self, bpf, op="add", prio=None, handle=None,
 563                           chain=None, da=False, verbose=False,
 564                           skip_sw=False, skip_hw=False,
 565                           fail=True, include_stderr=False):
 566        cls = "bpf " + bpf
 567
 568        params = ""
 569        if da:
 570            params += " da"
 571        if verbose:
 572            params += " verbose"
 573        if skip_sw:
 574            params += " skip_sw"
 575        if skip_hw:
 576            params += " skip_hw"
 577
 578        return self.cls_filter_op(op=op, prio=prio, handle=handle, cls=cls,
 579                                  chain=chain, params=params,
 580                                  fail=fail, include_stderr=include_stderr)
 581
 582    def set_ethtool_tc_offloads(self, enable, fail=True):
 583        args = "hw-tc-offload %s" % ("on" if enable else "off")
 584        return ethtool(self, "-K", args, fail=fail)
 585
 586################################################################################
 587def clean_up():
 588    global files, netns, devs
 589
 590    for dev in devs:
 591        dev.remove()
 592    for f in files:
 593        cmd("rm -f %s" % (f))
 594    for ns in netns:
 595        cmd("ip netns delete %s" % (ns))
 596    files = []
 597    netns = []
 598
 599def pin_prog(file_name, idx=0):
 600    progs = bpftool_prog_list(expected=(idx + 1))
 601    prog = progs[idx]
 602    bpftool("prog pin id %d %s" % (prog["id"], file_name))
 603    files.append(file_name)
 604
 605    return file_name, bpf_pinned(file_name)
 606
 607def pin_map(file_name, idx=0, expected=1):
 608    maps = bpftool_map_list(expected=expected)
 609    m = maps[idx]
 610    bpftool("map pin id %d %s" % (m["id"], file_name))
 611    files.append(file_name)
 612
 613    return file_name, bpf_pinned(file_name)
 614
 615def check_dev_info_removed(prog_file=None, map_file=None):
 616    bpftool_prog_list(expected=0)
 617    bpftool_prog_list(expected=1, exclude_orphaned=False)
 618    ret, err = bpftool("prog show pin %s" % (prog_file), fail=False)
 619    fail(ret != 0, "failed to show prog with removed device")
 
 
 
 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, "couldn't get information about orphaned program")
 
 
 
1399
1400    print("%s: OK" % (os.path.basename(__file__)))
1401
1402finally:
1403    log("Clean up...", "", level=1)
1404    log_level_inc()
1405    clean_up()