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