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