- Linux-kselftest-mirror - lists.linaro.org

[PATCH v4 0/5] Some improvements of resctrl selftest

by Shaopeng Tan

Hello, The aim of this patch series is to improve the resctrl selftest. Without these fixes, some unnecessary processing will be executed and test results will be confusing. There is no behavior change in test themselves. [patch 1] Make write_schemata() run to set up shemata with 100% allocation on first run in MBM test. [patch 2] The MBA test result message is always output as "ok", make output message to be "not ok" if MBA check result is failed. [patch 3] When a child process is created by fork(), the buffer of the parent process is also copied. Flush the buffer before executing fork(). [patch 4] Add a signal handler to cleanup properly before exiting the parent process if there is an error occurs after creating a child process with fork() in the CAT test. [patch 5] Before exiting each test CMT/CAT/MBM/MBA, clear test result files function cat/cmt/mbm/mba_test_cleanup() are called twice. Delete once. This patch series is based on Linux v6.1-rc5 Difference from v3: [patch 2] Rename "failed" to "ret" to avoid confusion. [patch 4] - Use sigaction(2) instead of signal(). - Add a description of using global bm_pid in commit message. - Add comments to clarify why let the child continue to its infinite loop after the write() failed. [patch 5] Ensure to run cat/cmt/mbm/mba_test_cleanup() to clear test result file before return if an error occurs. Pervious versions of this series: [v1] https://lore.kernel.org/lkml/20220914015147.3071025-1-tan.shaopeng@jp.fujit… [v2] https://lore.kernel.org/lkml/20221005013933.1486054-1-tan.shaopeng@jp.fujit… [v3] https://lore.kernel.org/lkml/20221101094341.3383073-1-tan.shaopeng@jp.fujit… Shaopeng Tan (5): selftests/resctrl: Fix set up schemata with 100% allocation on first run in MBM test selftests/resctrl: Return MBA check result and make it to output message selftests/resctrl: Flush stdout file buffer before executing fork() selftests/resctrl: Cleanup properly when an error occurs in CAT test selftests/resctrl: Remove duplicate codes that clear each test result file tools/testing/selftests/resctrl/cat_test.c | 31 +++++++++++++------ tools/testing/selftests/resctrl/cmt_test.c | 7 ++--- tools/testing/selftests/resctrl/mba_test.c | 23 +++++++------- tools/testing/selftests/resctrl/mbm_test.c | 20 ++++++------ .../testing/selftests/resctrl/resctrl_tests.c | 4 --- tools/testing/selftests/resctrl/resctrl_val.c | 1 + tools/testing/selftests/resctrl/resctrlfs.c | 5 ++- 7 files changed, 50 insertions(+), 41 deletions(-) -- 2.27.0

2 years, 4 months

3
15
0 0

Słowa kluczowe do wypozycjonowania

by Adam Charachuta

Dzień dobry, zapoznałem się z Państwa ofertą i z przyjemnością przyznaję, że przyciąga uwagę i zachęca do dalszych rozmów. Pomyślałem, że może mógłbym mieć swój wkład w Państwa rozwój i pomóc dotrzeć z tą ofertą do większego grona odbiorców. Pozycjonuję strony www, dzięki czemu generują świetny ruch w sieci. Możemy porozmawiać w najbliższym czasie? Pozdrawiam Adam Charachuta

2 years, 4 months

1
0
0 0

[PATCH bpf-next 6/6] bpf: selftests: Add bpf_ip_check_defrag() selftest

by Daniel Xu

This selftest tests 2 major scenarios: the BPF based defragmentation can succesfully be done and that packet pointers are invalidated after calls to the kfunc. In the first scenario, we create a UDP client and UDP echo server. The the server side is fairly straightforward: we attach the prog and simply echo back the message. The on the client side, we send fragmented packets to and expect the reassembled message back from the server. Signed-off-by: Daniel Xu <dxu(a)dxuuu.xyz> --- .../selftests/bpf/generate_udp_fragments.py | 52 +++ .../bpf/prog_tests/ip_check_defrag.c | 296 ++++++++++++++++++ .../selftests/bpf/progs/bpf_tracing_net.h | 1 + .../selftests/bpf/progs/ip_check_defrag.c | 83 +++++ 4 files changed, 432 insertions(+) create mode 100755 tools/testing/selftests/bpf/generate_udp_fragments.py create mode 100644 tools/testing/selftests/bpf/prog_tests/ip_check_defrag.c create mode 100644 tools/testing/selftests/bpf/progs/ip_check_defrag.c diff --git a/tools/testing/selftests/bpf/generate_udp_fragments.py b/tools/testing/selftests/bpf/generate_udp_fragments.py new file mode 100755 index 000000000000..b7ee3f7b42b4 --- /dev/null +++ b/tools/testing/selftests/bpf/generate_udp_fragments.py @@ -0,0 +1,52 @@ +#!/bin/env python3 + +""" +This script helps generate fragmented UDP packets. + +While it is technically possible to dynamically generate +fragmented packets in C, it is much harder to read and write +said code. `scapy` is relatively industry standard and really +easy to read / write. + +So we choose to write this script that generates valid C code. +""" + +import argparse +from scapy.all import * + +def print_frags(frags): + for idx, frag in enumerate(frags): + # 10 bytes per line to keep width in check + chunks = [frag[i: i+10] for i in range(0, len(frag), 10)] + chunks_fmted = [", ".join([str(hex(b)) for b in chunk]) for chunk in chunks] + + print(f"static uint8_t frag{idx}[] = {{") + for chunk in chunks_fmted: + print(f"\t{chunk},") + print(f"}};") + + +def main(args): + # srcip of 0 is filled in by IP_HDRINCL + sip = "0.0.0.0" + dip = args.dst_ip + sport = args.src_port + dport = args.dst_port + payload = args.payload.encode() + + # Disable UDP checksums to keep code simpler + pkt = IP(src=sip,dst=dip) / UDP(sport=sport,dport=dport,chksum=0) / Raw(load=payload) + + frags = [f.build() for f in pkt.fragment(24)] + print_frags(frags) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("dst_ip") + parser.add_argument("src_port", type=int) + parser.add_argument("dst_port", type=int) + parser.add_argument("payload") + args = parser.parse_args() + + main(args) diff --git a/tools/testing/selftests/bpf/prog_tests/ip_check_defrag.c b/tools/testing/selftests/bpf/prog_tests/ip_check_defrag.c new file mode 100644 index 000000000000..ed078e8265de --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/ip_check_defrag.c @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <test_progs.h> +#include <net/if.h> +#include <network_helpers.h> +#include "ip_check_defrag.skel.h" + +/* + * This selftest spins up a client and an echo server, each in their own + * network namespace. The server will receive fragmented messages which + * the attached BPF prog should reassemble. We verify that reassembly + * occurred by checking the original (fragmented) message is received + * in whole. + * + * Topology: + * ========= + * NS0 | NS1 + * | + * client | server + * ---------- | ---------- + * | veth0 | --------- | veth1 | + * ---------- peer ---------- + * | + * | with bpf + */ + +#define NS0 "defrag_ns0" +#define NS1 "defrag_ns1" +#define VETH0 "veth0" +#define VETH1 "veth1" +#define VETH0_ADDR "172.16.1.100" +#define VETH1_ADDR "172.16.1.200" +#define CLIENT_PORT 48878 +#define SERVER_PORT 48879 +#define MAGIC_MESSAGE "THIS IS THE ORIGINAL MESSAGE, PLEASE REASSEMBLE ME" + +static char log_buf[1024 * 1024]; + +#define SYS(fmt, ...) \ + ({ \ + char cmd[1024]; \ + snprintf(cmd, sizeof(cmd), fmt, ##__VA_ARGS__); \ + if (!ASSERT_OK(system(cmd), cmd)) \ + goto fail; \ + }) + +#define SYS_NOFAIL(fmt, ...) \ + ({ \ + char cmd[1024]; \ + snprintf(cmd, sizeof(cmd), fmt, ##__VA_ARGS__); \ + system(cmd); \ + }) + +/* + * The following fragments are generated with this script invocation: + * + * ./generate_udp_fragments $VETH1_ADDR $CLIENT_PORT $SERVER_PORT $MAGIC_MESSAGE + * + * where the `$` indicates replacement with preprocessor macro. + */ +static uint8_t frag0[] = { + 0x45, 0x0, 0x0, 0x2c, 0x0, 0x1, 0x20, 0x0, 0x40, 0x11, + 0xac, 0xe8, 0x0, 0x0, 0x0, 0x0, 0xac, 0x10, 0x1, 0xc8, + 0xbe, 0xee, 0xbe, 0xef, 0x0, 0x3a, 0x0, 0x0, 0x54, 0x48, + 0x49, 0x53, 0x20, 0x49, 0x53, 0x20, 0x54, 0x48, 0x45, 0x20, + 0x4f, 0x52, 0x49, 0x47, +}; +static uint8_t frag1[] = { + 0x45, 0x0, 0x0, 0x2c, 0x0, 0x1, 0x20, 0x3, 0x40, 0x11, + 0xac, 0xe5, 0x0, 0x0, 0x0, 0x0, 0xac, 0x10, 0x1, 0xc8, + 0x49, 0x4e, 0x41, 0x4c, 0x20, 0x4d, 0x45, 0x53, 0x53, 0x41, + 0x47, 0x45, 0x2c, 0x20, 0x50, 0x4c, 0x45, 0x41, 0x53, 0x45, + 0x20, 0x52, 0x45, 0x41, +}; +static uint8_t frag2[] = { + 0x45, 0x0, 0x0, 0x1e, 0x0, 0x1, 0x0, 0x6, 0x40, 0x11, + 0xcc, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xac, 0x10, 0x1, 0xc8, + 0x53, 0x53, 0x45, 0x4d, 0x42, 0x4c, 0x45, 0x20, 0x4d, 0x45, +}; + +static int setup_topology(void) +{ + SYS("ip netns add " NS0); + SYS("ip netns add " NS1); + SYS("ip link add " VETH0 " netns " NS0 " type veth peer name " VETH1 " netns " NS1); + SYS("ip -net " NS0 " addr add " VETH0_ADDR "/24 dev " VETH0); + SYS("ip -net " NS0 " link set dev " VETH0 " up"); + SYS("ip -net " NS1 " addr add " VETH1_ADDR "/24 dev " VETH1); + SYS("ip -net " NS1 " link set dev " VETH1 " up"); + + return 0; +fail: + return -1; +} + +static void cleanup_topology(void) +{ + SYS_NOFAIL("test -f /var/run/netns/" NS0 " && ip netns delete " NS0); + SYS_NOFAIL("test -f /var/run/netns/" NS1 " && ip netns delete " NS1); +} + +static int attach(struct ip_check_defrag *skel) +{ + LIBBPF_OPTS(bpf_tc_hook, tc_hook, + .attach_point = BPF_TC_INGRESS); + LIBBPF_OPTS(bpf_tc_opts, tc_attach, + .prog_fd = bpf_program__fd(skel->progs.defrag)); + struct nstoken *nstoken; + int err = -1; + + nstoken = open_netns(NS1); + + tc_hook.ifindex = if_nametoindex(VETH1); + if (!ASSERT_OK(bpf_tc_hook_create(&tc_hook), "bpf_tc_hook_create")) + goto out; + + if (!ASSERT_OK(bpf_tc_attach(&tc_hook, &tc_attach), "bpf_tc_attach")) + goto out; + + err = 0; +out: + close_netns(nstoken); + return err; +} + +static int send_frags(int client) +{ + struct sockaddr_storage saddr; + struct sockaddr *saddr_p; + socklen_t saddr_len; + int err; + + saddr_p = (struct sockaddr*)&saddr; + err = make_sockaddr(AF_INET, VETH1_ADDR, SERVER_PORT, &saddr, &saddr_len); + if (!ASSERT_OK(err, "make_sockaddr")) + return -1; + + err = sendto(client, frag0, sizeof(frag0), 0, saddr_p, saddr_len); + if (!ASSERT_GE(err, 0, "sendto frag0")) + return -1; + + err = sendto(client, frag1, sizeof(frag1), 0, saddr_p, saddr_len); + if (!ASSERT_GE(err, 0, "sendto frag1")) + return -1; + + err = sendto(client, frag2, sizeof(frag2), 0, saddr_p, saddr_len); + if (!ASSERT_GE(err, 0, "sendto frag2")) + return -1; + + return 0; +} + +void test_bpf_ip_check_defrag_ok(void) +{ + struct network_helper_opts rx_opts = { + .timeout_ms = 1000, + .noconnect = true, + }; + struct network_helper_opts tx_ops = { + .timeout_ms = 1000, + .type = SOCK_RAW, + .proto = IPPROTO_RAW, + .noconnect = true, + }; + struct ip_check_defrag *skel; + struct sockaddr_in caddr; + struct nstoken *nstoken; + int client_tx_fd = -1; + int client_rx_fd = -1; + socklen_t caddr_len; + int srv_fd = -1; + char buf[1024]; + int len, err; + + skel = ip_check_defrag__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_open")) + return; + + if (!ASSERT_OK(setup_topology(), "setup_topology")) + goto out; + + if (!ASSERT_OK(attach(skel), "attach")) + goto out; + + /* Start server in ns1 */ + nstoken = open_netns(NS1); + if (!ASSERT_OK_PTR(nstoken, "setns ns1")) + goto out; + srv_fd = start_server(AF_INET, SOCK_DGRAM, NULL, SERVER_PORT, 0); + close_netns(nstoken); + if (!ASSERT_GE(srv_fd, 0, "start_server")) + goto out; + + /* Open tx raw socket in ns0 */ + nstoken = open_netns(NS0); + if (!ASSERT_OK_PTR(nstoken, "setns ns0")) + goto out; + client_tx_fd = connect_to_fd_opts(srv_fd, &tx_ops); + close_netns(nstoken); + if (!ASSERT_GE(client_tx_fd, 0, "connect_to_fd_opts")) + goto out; + + /* Open rx socket in ns0 */ + nstoken = open_netns(NS0); + if (!ASSERT_OK_PTR(nstoken, "setns ns0")) + goto out; + client_rx_fd = connect_to_fd_opts(srv_fd, &rx_opts); + close_netns(nstoken); + if (!ASSERT_GE(client_rx_fd, 0, "connect_to_fd_opts")) + goto out; + + /* Bind rx socket to a premeditated port */ + memset(&caddr, 0, sizeof(caddr)); + caddr.sin_family = AF_INET; + inet_pton(AF_INET, VETH0_ADDR, &caddr.sin_addr); + caddr.sin_port = htons(CLIENT_PORT); + nstoken = open_netns(NS0); + err = bind(client_rx_fd, (struct sockaddr *)&caddr, sizeof(caddr)); + close_netns(nstoken); + if (!ASSERT_OK(err, "bind")) + goto out; + + /* Send message in fragments */ + if (!ASSERT_OK(send_frags(client_tx_fd), "send_frags")) + goto out; + + if (!ASSERT_EQ(skel->bss->frags_seen, 3, "frags_seen")) + goto out; + + if (!ASSERT_FALSE(skel->data->is_final_frag, "is_final_frag")) + goto out; + + /* Receive reassembled msg on server and echo back to client */ + len = recvfrom(srv_fd, buf, sizeof(buf), 0, (struct sockaddr *)&caddr, &caddr_len); + if (!ASSERT_GE(len, 0, "server recvfrom")) + goto out; + len = sendto(srv_fd, buf, len, 0, (struct sockaddr *)&caddr, caddr_len); + if (!ASSERT_GE(len, 0, "server sendto")) + goto out; + + /* Expect reassembed message to be echoed back */ + len = recvfrom(client_rx_fd, buf, sizeof(buf), 0, NULL, NULL); + if (!ASSERT_EQ(len, sizeof(MAGIC_MESSAGE) - 1, "client short read")) + goto out; + +out: + if (client_rx_fd != -1) + close(client_rx_fd); + if (client_tx_fd != -1) + close(client_tx_fd); + if (srv_fd != -1) + close(srv_fd); + cleanup_topology(); + ip_check_defrag__destroy(skel); +} + +void test_bpf_ip_check_defrag_fail(void) +{ + const char *err_msg = "invalid mem access 'scalar'"; + LIBBPF_OPTS(bpf_object_open_opts, opts, + .kernel_log_buf = log_buf, + .kernel_log_size = sizeof(log_buf), + .kernel_log_level = 1); + struct ip_check_defrag *skel; + struct bpf_program *prog; + int err; + + skel = ip_check_defrag__open_opts(&opts); + if (!ASSERT_OK_PTR(skel, "ip_check_defrag__open_opts")) + return; + + prog = bpf_object__find_program_by_name(skel->obj, "defrag_fail"); + if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) + goto out; + + bpf_program__set_autoload(prog, true); + + err = ip_check_defrag__load(skel); + if (!ASSERT_ERR(err, "ip_check_defrag__load must fail")) + goto out; + + if (!ASSERT_OK_PTR(strstr(log_buf, err_msg), "expected error message")) { + fprintf(stderr, "Expected: %s\n", err_msg); + fprintf(stderr, "Verifier: %s\n", log_buf); + } + +out: + ip_check_defrag__destroy(skel); +} + +void test_bpf_ip_check_defrag(void) +{ + if (test__start_subtest("ok")) + test_bpf_ip_check_defrag_ok(); + if (test__start_subtest("fail")) + test_bpf_ip_check_defrag_fail(); +} diff --git a/tools/testing/selftests/bpf/progs/bpf_tracing_net.h b/tools/testing/selftests/bpf/progs/bpf_tracing_net.h index b394817126cf..a1d6cc1f2ef8 100644 --- a/tools/testing/selftests/bpf/progs/bpf_tracing_net.h +++ b/tools/testing/selftests/bpf/progs/bpf_tracing_net.h @@ -26,6 +26,7 @@ #define IPV6_AUTOFLOWLABEL 70 #define TC_ACT_UNSPEC (-1) +#define TC_ACT_OK 0 #define TC_ACT_SHOT 2 #define SOL_TCP 6 diff --git a/tools/testing/selftests/bpf/progs/ip_check_defrag.c b/tools/testing/selftests/bpf/progs/ip_check_defrag.c new file mode 100644 index 000000000000..71300b77a43f --- /dev/null +++ b/tools/testing/selftests/bpf/progs/ip_check_defrag.c @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_endian.h> +#include "bpf_tracing_net.h" + +#define ETH_P_IP 0x0800 +#define IP_DF 0x4000 +#define IP_MF 0x2000 +#define IP_OFFSET 0x1FFF +#define ctx_ptr(field) (void *)(long)(field) + +int bpf_ip_check_defrag(struct __sk_buff *ctx, u64 netns) __ksym; + +volatile int frags_seen = 0; +volatile bool is_final_frag = true; + +static inline bool is_frag(struct iphdr *iph) +{ + int offset; + int flags; + + offset = bpf_ntohs(iph->frag_off); + flags = offset & ~IP_OFFSET; + offset &= IP_OFFSET; + offset <<= 3; + + return (flags & IP_MF) || offset; +} + +SEC("tc") +int defrag(struct __sk_buff *skb) +{ + void *data_end = ctx_ptr(skb->data_end); + void *data = ctx_ptr(skb->data); + struct iphdr *iph; + + if (skb->protocol != bpf_htons(ETH_P_IP)) + return TC_ACT_OK; + + iph = data + sizeof(struct ethhdr); + if (iph + 1 > data_end) + return TC_ACT_SHOT; + + if (!is_frag(iph)) + return TC_ACT_OK; + + frags_seen++; + if (bpf_ip_check_defrag(skb, BPF_F_CURRENT_NETNS)) + return TC_ACT_SHOT; + + data_end = ctx_ptr(skb->data_end); + data = ctx_ptr(skb->data); + iph = data + sizeof(struct ethhdr); + if (iph + 1 > data_end) + return TC_ACT_SHOT; + is_final_frag = is_frag(iph); + + return TC_ACT_OK; +} + +SEC("?tc") +int defrag_fail(struct __sk_buff *skb) +{ + void *data_end = ctx_ptr(skb->data_end); + void *data = ctx_ptr(skb->data); + struct iphdr *iph; + + if (skb->protocol != bpf_htons(ETH_P_IP)) + return TC_ACT_OK; + + iph = data + sizeof(struct ethhdr); + if (iph + 1 > data_end) + return TC_ACT_SHOT; + + if (bpf_ip_check_defrag(skb, BPF_F_CURRENT_NETNS)) + return TC_ACT_SHOT; + + /* Boom. Must revalidate pkt ptrs */ + return iph->ttl ? TC_ACT_OK : TC_ACT_SHOT; +} + +char _license[] SEC("license") = "GPL"; -- 2.39.0

2 years, 4 months

1
0
0 0

[PATCH bpf-next 5/6] bpf: selftests: Support custom type and proto for client sockets

by Daniel Xu

Extend connect_to_fd_opts() to take optional type and protocol parameters for the client socket. These parameters are useful when opening a raw socket to send IP fragments. Signed-off-by: Daniel Xu <dxu(a)dxuuu.xyz> --- tools/testing/selftests/bpf/network_helpers.c | 21 +++++++++++++------ tools/testing/selftests/bpf/network_helpers.h | 2 ++ 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/tools/testing/selftests/bpf/network_helpers.c b/tools/testing/selftests/bpf/network_helpers.c index 24f5efebc7dd..4f9ba90b1b7e 100644 --- a/tools/testing/selftests/bpf/network_helpers.c +++ b/tools/testing/selftests/bpf/network_helpers.c @@ -270,14 +270,23 @@ int connect_to_fd_opts(int server_fd, const struct network_helper_opts *opts) opts = &default_opts; optlen = sizeof(type); - if (getsockopt(server_fd, SOL_SOCKET, SO_TYPE, &type, &optlen)) { - log_err("getsockopt(SOL_TYPE)"); - return -1; + + if (opts->type) { + type = opts->type; + } else { + if (getsockopt(server_fd, SOL_SOCKET, SO_TYPE, &type, &optlen)) { + log_err("getsockopt(SOL_TYPE)"); + return -1; + } } - if (getsockopt(server_fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &optlen)) { - log_err("getsockopt(SOL_PROTOCOL)"); - return -1; + if (opts->proto) { + protocol = opts->proto; + } else { + if (getsockopt(server_fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &optlen)) { + log_err("getsockopt(SOL_PROTOCOL)"); + return -1; + } } addrlen = sizeof(addr); diff --git a/tools/testing/selftests/bpf/network_helpers.h b/tools/testing/selftests/bpf/network_helpers.h index 8be04cd76d8b..7119804ea79b 100644 --- a/tools/testing/selftests/bpf/network_helpers.h +++ b/tools/testing/selftests/bpf/network_helpers.h @@ -22,6 +22,8 @@ struct network_helper_opts { int timeout_ms; bool must_fail; bool noconnect; + int type; + int proto; }; /* ipv4 test vector */ -- 2.39.0

2 years, 4 months

1
0
0 0

[PATCH bpf-next 4/6] bpf: selftests: Support not connecting client socket

by Daniel Xu

For connectionless protocols or raw sockets we do not want to actually connect() to the server. Signed-off-by: Daniel Xu <dxu(a)dxuuu.xyz> --- tools/testing/selftests/bpf/network_helpers.c | 5 +++-- tools/testing/selftests/bpf/network_helpers.h | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/bpf/network_helpers.c b/tools/testing/selftests/bpf/network_helpers.c index 01de33191226..24f5efebc7dd 100644 --- a/tools/testing/selftests/bpf/network_helpers.c +++ b/tools/testing/selftests/bpf/network_helpers.c @@ -301,8 +301,9 @@ int connect_to_fd_opts(int server_fd, const struct network_helper_opts *opts) strlen(opts->cc) + 1)) goto error_close; - if (connect_fd_to_addr(fd, &addr, addrlen, opts->must_fail)) - goto error_close; + if (!opts->noconnect) + if (connect_fd_to_addr(fd, &addr, addrlen, opts->must_fail)) + goto error_close; return fd; diff --git a/tools/testing/selftests/bpf/network_helpers.h b/tools/testing/selftests/bpf/network_helpers.h index f882c691b790..8be04cd76d8b 100644 --- a/tools/testing/selftests/bpf/network_helpers.h +++ b/tools/testing/selftests/bpf/network_helpers.h @@ -21,6 +21,7 @@ struct network_helper_opts { const char *cc; int timeout_ms; bool must_fail; + bool noconnect; }; /* ipv4 test vector */ -- 2.39.0

2 years, 4 months

1
0
0 0

[PATCH v6 0/3] Implement IOCTL to get and/or the clear info about PTEs

by Muhammad Usama Anjum

Changes in v6: - Updated the interface and made cosmetic changes Original Cover Letter in v5: Hello, This patch series implements IOCTL on the pagemap procfs file to get the information about the page table entries (PTEs). The following operations are supported in this ioctl: - Get the information if the pages are soft-dirty, file mapped, present or swapped. - Clear the soft-dirty PTE bit of the pages. - Get and clear the soft-dirty PTE bit of the pages atomically. Soft-dirty PTE bit of the memory pages can be read by using the pagemap procfs file. The soft-dirty PTE bit for the whole memory range of the process can be cleared by writing to the clear_refs file. There are other methods to mimic this information entirely in userspace with poor performance: - The mprotect syscall and SIGSEGV handler for bookkeeping - The userfaultfd syscall with the handler for bookkeeping Some benchmarks can be seen here[1]. This series adds features that weren't present earlier: - There is no atomic get soft-dirty PTE bit status and clear operation possible. - The soft-dirty PTE bit of only a part of memory cannot be cleared. Historically, soft-dirty PTE bit tracking has been used in the CRIU project. The procfs interface is enough for finding the soft-dirty bit status and clearing the soft-dirty bit of all the pages of a process. We have the use case where we need to track the soft-dirty PTE bit for only specific pages on demand. We need this tracking and clear mechanism of a region of memory while the process is running to emulate the getWriteWatch() syscall of Windows. This syscall is used by games to keep track of dirty pages to process only the dirty pages. The information related to pages if the page is file mapped, present and swapped is required for the CRIU project[2][3]. The addition of the required mask, any mask, excluded mask and return masks are also required for the CRIU project[2]. The IOCTL returns the addresses of the pages which match the specific masks. The page addresses are returned in struct page_region in a compact form. The max_pages is needed to support a use case where user only wants to get a specific number of pages. So there is no need to find all the pages of interest in the range when max_pages is specified. The IOCTL returns when the maximum number of the pages are found. The max_pages is optional. If max_pages is specified, it must be equal or greater than the vec_size. This restriction is needed to handle worse case when one page_region only contains info of one page and it cannot be compacted. This is needed to emulate the Windows getWriteWatch() syscall. Some non-dirty pages get marked as dirty because of the kernel's internal activity (such as VMA merging as soft-dirty bit difference isn't considered while deciding to merge VMAs). The dirty bit of the pages is stored in the VMA flags and in the per page flags. If any of these two bits are set, the page is considered to be soft dirty. Suppose you have cleared the soft dirty bit of half of VMA which will be done by splitting the VMA and clearing soft dirty bit flag in the half VMA and the pages in it. Now kernel may decide to merge the VMAs again. So the half VMA becomes dirty again. This splitting/merging costs performance. The application receives a lot of pages which aren't dirty in reality but marked as dirty. Performance is lost again here. Also sometimes user doesn't want the newly allocated memory to be marked as dirty. PAGEMAP_NO_REUSED_REGIONS flag solves both the problems. It is used to not depend on the soft dirty flag in the VMA flags. So VMA splitting and merging doesn't happen. It only depends on the soft dirty bit of the individual pages. Thus by using this flag, there may be a scenerio such that the new memory regions which are just created, doesn't look dirty when seen with the IOCTL, but look dirty when seen from procfs. This seems okay as the user of this flag know the implication of using it. [1] https://lore.kernel.org/lkml/54d4c322-cd6e-eefd-b161-2af2b56aae24@collabora… [2] https://lore.kernel.org/all/YyiDg79flhWoMDZB@gmail.com/ [3] https://lore.kernel.org/all/20221014134802.1361436-1-mdanylo@google.com/ Regards, Muhammad Usama Anjum Muhammad Usama Anjum (3): fs/proc/task_mmu: update functions to clear the soft-dirty PTE bit fs/proc/task_mmu: Implement IOCTL to get and/or the clear info about PTEs selftests: vm: add pagemap ioctl tests fs/proc/task_mmu.c | 410 +++++++++++- include/uapi/linux/fs.h | 56 ++ tools/include/uapi/linux/fs.h | 56 ++ tools/testing/selftests/vm/.gitignore | 1 + tools/testing/selftests/vm/Makefile | 5 +- tools/testing/selftests/vm/pagemap_ioctl.c | 698 +++++++++++++++++++++ 6 files changed, 1193 insertions(+), 33 deletions(-) create mode 100644 tools/testing/selftests/vm/pagemap_ioctl.c -- 2.30.2

2 years, 4 months

5
18
0 0

[PATCH hid v12 00/15] Introduce eBPF support for HID devices

by Benjamin Tissoires

Hi, and here comes the v12 of the HID-BPF series. Again, for a full explanation of HID-BPF, please refer to the last patch in this series (15/15). This revision contains most notably few fixes from the various kernel CI bots. I also took Alexei's review into account, and we do not pollute tools/include with useless hid headers. I also removed most of the last checkpatch complains about adding external kfunc declarations in C files. And this led me to also show in samples/ how we can link together 2 BPF object files. Impressive how easy it is :) Cheers, Benjamin Benjamin Tissoires (15): HID: fix I2C_HID not selected when I2C_HID_OF_ELAN is HID: Kconfig: split HID support and hid-core compilation HID: initial BPF implementation selftests: add tests for the HID-bpf initial implementation HID: bpf jmp table: simplify the logic of cleaning up programs HID: bpf: allocate data memory for device_event BPF programs selftests/hid: add test to change the report size HID: bpf: introduce hid_hw_request() selftests/hid: add tests for bpf_hid_hw_request HID: bpf: allow to change the report descriptor selftests/hid: add report descriptor fixup tests selftests/hid: Add a test for BPF_F_INSERT_HEAD samples/hid: add new hid BPF example samples/hid: add Surface Dial example Documentation: add HID-BPF docs Documentation/hid/hid-bpf.rst | 512 +++++++++++ Documentation/hid/index.rst | 1 + MAINTAINERS | 3 + drivers/Makefile | 2 +- drivers/hid/Kconfig | 18 +- drivers/hid/Makefile | 2 + drivers/hid/amd-sfh-hid/Kconfig | 2 +- drivers/hid/bpf/Kconfig | 17 + drivers/hid/bpf/Makefile | 11 + drivers/hid/bpf/entrypoints/Makefile | 93 ++ drivers/hid/bpf/entrypoints/README | 4 + drivers/hid/bpf/entrypoints/entrypoints.bpf.c | 34 + .../hid/bpf/entrypoints/entrypoints.lskel.h | 330 +++++++ drivers/hid/bpf/hid_bpf_dispatch.c | 531 +++++++++++ drivers/hid/bpf/hid_bpf_dispatch.h | 28 + drivers/hid/bpf/hid_bpf_jmp_table.c | 565 ++++++++++++ drivers/hid/hid-core.c | 34 +- drivers/hid/i2c-hid/Kconfig | 4 +- include/linux/hid.h | 5 + include/linux/hid_bpf.h | 163 ++++ samples/hid/.gitignore | 8 + samples/hid/Makefile | 250 ++++++ samples/hid/Makefile.target | 75 ++ samples/hid/hid_bpf_attach.bpf.c | 18 + samples/hid/hid_bpf_attach.h | 14 + samples/hid/hid_bpf_helpers.h | 21 + samples/hid/hid_mouse.bpf.c | 112 +++ samples/hid/hid_mouse.c | 155 ++++ samples/hid/hid_surface_dial.bpf.c | 134 +++ samples/hid/hid_surface_dial.c | 226 +++++ tools/testing/selftests/Makefile | 1 + tools/testing/selftests/hid/.gitignore | 4 + tools/testing/selftests/hid/Makefile | 233 +++++ tools/testing/selftests/hid/config | 20 + tools/testing/selftests/hid/hid_bpf.c | 845 ++++++++++++++++++ tools/testing/selftests/hid/progs/hid.c | 196 ++++ .../selftests/hid/progs/hid_bpf_helpers.h | 21 + 37 files changed, 4682 insertions(+), 10 deletions(-) create mode 100644 Documentation/hid/hid-bpf.rst create mode 100644 drivers/hid/bpf/Kconfig create mode 100644 drivers/hid/bpf/Makefile create mode 100644 drivers/hid/bpf/entrypoints/Makefile create mode 100644 drivers/hid/bpf/entrypoints/README create mode 100644 drivers/hid/bpf/entrypoints/entrypoints.bpf.c create mode 100644 drivers/hid/bpf/entrypoints/entrypoints.lskel.h create mode 100644 drivers/hid/bpf/hid_bpf_dispatch.c create mode 100644 drivers/hid/bpf/hid_bpf_dispatch.h create mode 100644 drivers/hid/bpf/hid_bpf_jmp_table.c create mode 100644 include/linux/hid_bpf.h create mode 100644 samples/hid/.gitignore create mode 100644 samples/hid/Makefile create mode 100644 samples/hid/Makefile.target create mode 100644 samples/hid/hid_bpf_attach.bpf.c create mode 100644 samples/hid/hid_bpf_attach.h create mode 100644 samples/hid/hid_bpf_helpers.h create mode 100644 samples/hid/hid_mouse.bpf.c create mode 100644 samples/hid/hid_mouse.c create mode 100644 samples/hid/hid_surface_dial.bpf.c create mode 100644 samples/hid/hid_surface_dial.c create mode 100644 tools/testing/selftests/hid/.gitignore create mode 100644 tools/testing/selftests/hid/Makefile create mode 100644 tools/testing/selftests/hid/config create mode 100644 tools/testing/selftests/hid/hid_bpf.c create mode 100644 tools/testing/selftests/hid/progs/hid.c create mode 100644 tools/testing/selftests/hid/progs/hid_bpf_helpers.h -- 2.36.1

2 years, 4 months

7
32
0 0

Re: [GIT PULL] KUnit next update for Linux 6.2-rc1

by pr-tracker-bot＠kernel.org

The pull request you sent on Mon, 12 Dec 2022 15:07:05 -0700: > git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-kunit-next-6.2-rc1 has been merged into torvalds/linux.git: https://git.kernel.org/torvalds/c/e2ed78d5d9ca07a2b9d158ebac366170a2d3083d Thank you! -- Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/prtracker.html

2 years, 4 months

1
0
0 0

Re: [GIT PULL] Kselftest update for Linux 6.2-rc1

by pr-tracker-bot＠kernel.org

The pull request you sent on Mon, 12 Dec 2022 12:59:15 -0700: > git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-next-6.2-rc1 has been merged into torvalds/linux.git: https://git.kernel.org/torvalds/c/23a68d14def8247735b66a14b370b42d8fcedb47 Thank you! -- Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/prtracker.html

2 years, 4 months

1
0
0 0

[RFC][PATCH v2 0/7] bpf-lsm: Check return values of security modules

by Roberto Sassu

From: Roberto Sassu <roberto.sassu(a)huawei.com> Notes: - This patch set addresses the kernel panic described below, and not the more broad issue of accessing kernel objects whose pointer is passed as parameter by LSM hooks - Alternative approaches trying to limit return values at run-time either in the security subsystem or in the eBPF JIT are not preferred by the respective maintainers - Although all eBPF selftests have been verified to pass, it still might be cumbersome to have an eBPF program being accepted by the eBPF verifier (e.g. ANDing negative numbers causes existing bounds to be lost) - The patch to store whether a register state changed due to an ALU64 or an ALU32 operation might not be correct/complete, a review by eBPF maintainers would be needed - This patch set requires "lsm: make security_socket_getpeersec_stream() sockptr_t safe", in lsm/next - The modification of the LSM infrastructure to define allowed return values for the LSM hooks could be replaced with an eBPF-only fix, with the drawback of having to update the information manually each time a new hook is added; allowing zero or negative values by default could be reasonable, but there are already exceptions of LSM hooks accepting 0 or 1 (ismaclabel) - The patches to fix the LSM infrastructure documentation are separated from this patch set and available here: https://lore.kernel.org/linux-security-module/20221128144240.210110-1-rober… BPF LSM defines attachment points to allows security modules (eBPF programs with type LSM) to provide their implementation of the desired LSM hooks. Unfortunately, BPF LSM does not restrict which values security modules can return (for non-void LSM hooks). If they put arbitrary values instead of those stated in include/linux/lsm_hooks.h, they could cause big troubles. For example, this simple eBPF program: SEC("lsm/inode_permission") int BPF_PROG(test_int_hook, struct inode *inode, int mask) { return 1; } causes the following kernel panic: [ 181.130807] BUG: kernel NULL pointer dereference, address: 0000000000000079 [ 181.131478] #PF: supervisor read access in kernel mode [ 181.131942] #PF: error_code(0x0000) - not-present page [ 181.132407] PGD 0 P4D 0 [ 181.132650] Oops: 0000 [#1] PREEMPT SMP NOPTI [ 181.133054] CPU: 5 PID: 857 Comm: systemd-oomd Tainted: G OE 6.1.0-rc7+ #530 [ 181.133806] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.13.0-1ubuntu1.1 04/01/2014 [ 181.134601] RIP: 0010:do_sys_openat2+0x235/0x300 [...] [ 181.136682] RSP: 0018:ffffc90001557ee0 EFLAGS: 00010203 [ 181.137154] RAX: 0000000000000001 RBX: ffffc90001557f20 RCX: ffff888112003380 [ 181.137790] RDX: 0000000000000000 RSI: ffffffff8280b026 RDI: ffffc90001557e28 [ 181.138432] RBP: 0000000000000001 R08: 0000000000000001 R09: 0000000000000000 [ 181.139081] R10: ffffffff835097dc R11: 0000000000000000 R12: ffff888106118000 [ 181.139717] R13: 000000000000000c R14: 0000000000000000 R15: 0000000000000000 [ 181.140149] FS: 00007fa6ceb0bb40(0000) GS:ffff88846fb40000(0000) knlGS:0000000000000000 [ 181.140556] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 181.140865] CR2: 0000000000000079 CR3: 0000000135c50000 CR4: 0000000000350ee0 [ 181.141239] Call Trace: [ 181.141373] <TASK> [ 181.141495] do_sys_open+0x34/0x60 [ 181.141678] do_syscall_64+0x3b/0x90 [ 181.141875] entry_SYSCALL_64_after_hwframe+0x63/0xcd Avoid this situation by statically analyzing the eBPF programs attaching to LSM hooks, and ensure that their return values are compatible with the LSM infrastructure conventions. First, add a preliminary patch (patch 1) to fix a small code duplication issue. Extend the eBPF verifier to let BPF LSM determine whether it should check estimated 64 bit values or the 32 bit ones (patch 2). Also, extend the LSM infrastructure to record more precisely the allowed return values depending on the documentation found in include/linux/lsm_hooks.h (patch 3). Add the LSM_RET_NEG, LSM_RET_ZERO, LSM_RET_ONE, LSM_RET_GT_ONE flags to an LSM hook if that hook allows respectively > 0, 0, 1, > 1 return values. Then, extend BPF LSM to verify that return values, estimated by the verifier by analyzing the eBPF program, fall in the allowed intervals found from the return value flags of the LSM hook being attached to (patch 4). Finally, add new tests to ensure that the verifier enforces return values correctly (patch 5), and slightly modify existing tests to make them follow the LSM infrastructure conventions (patches 6-7) and are accepted by the verifier. Changelog: v1: - Complete the documentation of return values in lsm_hooks.h - Introduce return value flags in the LSM infrastructure - Use those flags instead of the scattered logic (suggested by KP) - Expose a single verification function to the verifier (suggested by KP) - Add new patch to remove duplicated function definition - Add new patch to let BPF LSM determine the appropriate register values to use Roberto Sassu (7): bpf: Remove superfluous btf_id_set_contains() declaration bpf: Mark ALU32 operations in bpf_reg_state structure lsm: Redefine LSM_HOOK() macro to add return value flags as argument bpf-lsm: Enforce return value limitations on security modules selftests/bpf: Check if return values of LSM programs are allowed selftests/bpf: Prevent positive ret values in test_lsm and verify_pkcs7_sig selftests/bpf: Change return value in test_libbpf_get_fd_by_id_opts.c include/linux/bpf.h | 1 - include/linux/bpf_lsm.h | 11 +- include/linux/bpf_verifier.h | 1 + include/linux/lsm_hook_defs.h | 780 ++++++++++-------- include/linux/lsm_hooks.h | 9 +- kernel/bpf/bpf_lsm.c | 81 +- kernel/bpf/verifier.c | 17 +- security/bpf/hooks.c | 2 +- security/security.c | 4 +- tools/testing/selftests/bpf/progs/lsm.c | 4 + .../bpf/progs/test_libbpf_get_fd_by_id_opts.c | 7 +- .../bpf/progs/test_verify_pkcs7_sig.c | 11 +- .../testing/selftests/bpf/verifier/lsm_ret.c | 148 ++++ 13 files changed, 729 insertions(+), 347 deletions(-) create mode 100644 tools/testing/selftests/bpf/verifier/lsm_ret.c -- 2.25.1

2 years, 4 months

2
11
0 0

[PATCH v2 7/7] KVM: selftests: Avoid infinite loop if ucall_alloc() fails

by Oliver Upton

Guest assertions depend on successfully allocating a ucall structure. As such, the use of guest assertions when ucall_alloc() fails simply leads to an infinite loop in guest code. Use GUEST_UCALL_NONE() to indicate failure instead. Though not technically necessary, use a goto to have a single callsite and an associated comment about why assertions don't work here. It isn't perfect, at least the poor developer gets some signal out of the guest... Fixes: 426729b2cf2e ("KVM: selftests: Add ucall pool based implementation") Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/lib/ucall_common.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/lib/ucall_common.c b/tools/testing/selftests/kvm/lib/ucall_common.c index 0cc0971ce60e..e8370da3de24 100644 --- a/tools/testing/selftests/kvm/lib/ucall_common.c +++ b/tools/testing/selftests/kvm/lib/ucall_common.c @@ -41,7 +41,8 @@ static struct ucall *ucall_alloc(void) struct ucall *uc; int i; - GUEST_ASSERT(ucall_pool); + if (!ucall_pool) + goto out; for (i = 0; i < KVM_MAX_VCPUS; ++i) { if (!test_and_set_bit(i, ucall_pool->in_use)) { @@ -51,7 +52,14 @@ static struct ucall *ucall_alloc(void) } } - GUEST_ASSERT(0); +out: + /* + * If the guest cannot grab a ucall structure from the pool then the + * only option to get out to userspace is a bare ucall. This is probably + * a good time to mention that guest assertions depend on ucalls with + * arguments too. + */ + GUEST_UCALL_NONE(); return NULL; } -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 4 months

3
3
0 0

[PATCH AUTOSEL 5.15 5/6] selftests: net: Use "grep -E" instead of "egrep"

by Sasha Levin

From: Tiezhu Yang <yangtiezhu(a)loongson.cn> [ Upstream commit 6a30d3e3491dc562384e9f15b201a8a25b57439f ] The latest version of grep claims the egrep is now obsolete so the build now contains warnings that look like: egrep: warning: egrep is obsolescent; using grep -E fix this using "grep -E" instead. sed -i "s/egrep/grep -E/g" `grep egrep -rwl tools/testing/selftests/net` Here are the steps to install the latest grep: wget http://ftp.gnu.org/gnu/grep/grep-3.8.tar.gz tar xf grep-3.8.tar.gz cd grep-3.8 && ./configure && make sudo make install export PATH=/usr/local/bin:$PATH Signed-off-by: Tiezhu Yang <yangtiezhu(a)loongson.cn> Link: https://lore.kernel.org/r/1669864248-829-1-git-send-email-yangtiezhu@loongs… Signed-off-by: Jakub Kicinski <kuba(a)kernel.org> Signed-off-by: Sasha Levin <sashal(a)kernel.org> --- tools/testing/selftests/net/toeplitz.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/net/toeplitz.sh b/tools/testing/selftests/net/toeplitz.sh index 0a49907cd4fe..da5bfd834eff 100755 --- a/tools/testing/selftests/net/toeplitz.sh +++ b/tools/testing/selftests/net/toeplitz.sh @@ -32,7 +32,7 @@ DEV="eth0" # This is determined by reading the RSS indirection table using ethtool. get_rss_cfg_num_rxqs() { echo $(ethtool -x "${DEV}" | - egrep [[:space:]]+[0-9]+:[[:space:]]+ | + grep -E [[:space:]]+[0-9]+:[[:space:]]+ | cut -d: -f2- | awk '{$1=$1};1' | tr ' ' '\n' | -- 2.35.1

2 years, 4 months

1
0
0 0

[PATCH AUTOSEL 6.0 6/7] af_unix: Add test for sock_diag and UDIAG_SHOW_UID.

by Sasha Levin

From: Kuniyuki Iwashima <kuniyu(a)amazon.com> [ Upstream commit ac011361bd4f6206b36d2a242500239881bf8d2a ] The test prog dumps a single AF_UNIX socket's UID with and without unshare(CLONE_NEWUSER) and checks if it matches the result of getuid(). Without the preceding patch, the test prog is killed by a NULL deref in sk_diag_dump_uid(). # ./diag_uid TAP version 13 1..2 # Starting 2 tests from 3 test cases. # RUN diag_uid.uid.1 ... BUG: kernel NULL pointer dereference, address: 0000000000000270 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 105212067 P4D 105212067 PUD 1051fe067 PMD 0 Oops: 0000 [#1] PREEMPT SMP NOPTI Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-1.amzn2022.0.1 04/01/2014 RIP: 0010:sk_diag_fill (./include/net/sock.h:920 net/unix/diag.c:119 net/unix/diag.c:170) ... # 1: Test terminated unexpectedly by signal 9 # FAIL diag_uid.uid.1 not ok 1 diag_uid.uid.1 # RUN diag_uid.uid_unshare.1 ... # 1: Test terminated by timeout # FAIL diag_uid.uid_unshare.1 not ok 2 diag_uid.uid_unshare.1 # FAILED: 0 / 2 tests passed. # Totals: pass:0 fail:2 xfail:0 xpass:0 skip:0 error:0 With the patch, the test succeeds. # ./diag_uid TAP version 13 1..2 # Starting 2 tests from 3 test cases. # RUN diag_uid.uid.1 ... # OK diag_uid.uid.1 ok 1 diag_uid.uid.1 # RUN diag_uid.uid_unshare.1 ... # OK diag_uid.uid_unshare.1 ok 2 diag_uid.uid_unshare.1 # PASSED: 2 / 2 tests passed. # Totals: pass:2 fail:0 xfail:0 xpass:0 skip:0 error:0 Signed-off-by: Kuniyuki Iwashima <kuniyu(a)amazon.com> Signed-off-by: Paolo Abeni <pabeni(a)redhat.com> Signed-off-by: Sasha Levin <sashal(a)kernel.org> --- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/af_unix/Makefile | 2 +- .../testing/selftests/net/af_unix/diag_uid.c | 178 ++++++++++++++++++ 3 files changed, 180 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/net/af_unix/diag_uid.c diff --git a/tools/testing/selftests/net/.gitignore b/tools/testing/selftests/net/.gitignore index de7d5cc15f85..951b3bfe29eb 100644 --- a/tools/testing/selftests/net/.gitignore +++ b/tools/testing/selftests/net/.gitignore @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only cmsg_sender +diag_uid fin_ack_lat gro hwtstamp_config diff --git a/tools/testing/selftests/net/af_unix/Makefile b/tools/testing/selftests/net/af_unix/Makefile index 969620ae9928..1e4b397cece6 100644 --- a/tools/testing/selftests/net/af_unix/Makefile +++ b/tools/testing/selftests/net/af_unix/Makefile @@ -1,3 +1,3 @@ -TEST_GEN_PROGS := test_unix_oob unix_connect +TEST_GEN_PROGS := diag_uid test_unix_oob unix_connect include ../../lib.mk diff --git a/tools/testing/selftests/net/af_unix/diag_uid.c b/tools/testing/selftests/net/af_unix/diag_uid.c new file mode 100644 index 000000000000..5b88f7129fea --- /dev/null +++ b/tools/testing/selftests/net/af_unix/diag_uid.c @@ -0,0 +1,178 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright Amazon.com Inc. or its affiliates. */ + +#define _GNU_SOURCE +#include <sched.h> + +#include <unistd.h> +#include <linux/netlink.h> +#include <linux/rtnetlink.h> +#include <linux/sock_diag.h> +#include <linux/unix_diag.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/un.h> + +#include "../../kselftest_harness.h" + +FIXTURE(diag_uid) +{ + int netlink_fd; + int unix_fd; + __u32 inode; + __u64 cookie; +}; + +FIXTURE_VARIANT(diag_uid) +{ + int unshare; + int udiag_show; +}; + +FIXTURE_VARIANT_ADD(diag_uid, uid) +{ + .unshare = 0, + .udiag_show = UDIAG_SHOW_UID +}; + +FIXTURE_VARIANT_ADD(diag_uid, uid_unshare) +{ + .unshare = CLONE_NEWUSER, + .udiag_show = UDIAG_SHOW_UID +}; + +FIXTURE_SETUP(diag_uid) +{ + struct stat file_stat; + socklen_t optlen; + int ret; + + if (variant->unshare) + ASSERT_EQ(unshare(variant->unshare), 0); + + self->netlink_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG); + ASSERT_NE(self->netlink_fd, -1); + + self->unix_fd = socket(AF_UNIX, SOCK_STREAM, 0); + ASSERT_NE(self->unix_fd, -1); + + ret = fstat(self->unix_fd, &file_stat); + ASSERT_EQ(ret, 0); + + self->inode = file_stat.st_ino; + + optlen = sizeof(self->cookie); + ret = getsockopt(self->unix_fd, SOL_SOCKET, SO_COOKIE, &self->cookie, &optlen); + ASSERT_EQ(ret, 0); +} + +FIXTURE_TEARDOWN(diag_uid) +{ + close(self->netlink_fd); + close(self->unix_fd); +} + +int send_request(struct __test_metadata *_metadata, + FIXTURE_DATA(diag_uid) *self, + const FIXTURE_VARIANT(diag_uid) *variant) +{ + struct { + struct nlmsghdr nlh; + struct unix_diag_req udr; + } req = { + .nlh = { + .nlmsg_len = sizeof(req), + .nlmsg_type = SOCK_DIAG_BY_FAMILY, + .nlmsg_flags = NLM_F_REQUEST + }, + .udr = { + .sdiag_family = AF_UNIX, + .udiag_ino = self->inode, + .udiag_cookie = { + (__u32)self->cookie, + (__u32)(self->cookie >> 32) + }, + .udiag_show = variant->udiag_show + } + }; + struct sockaddr_nl nladdr = { + .nl_family = AF_NETLINK + }; + struct iovec iov = { + .iov_base = &req, + .iov_len = sizeof(req) + }; + struct msghdr msg = { + .msg_name = &nladdr, + .msg_namelen = sizeof(nladdr), + .msg_iov = &iov, + .msg_iovlen = 1 + }; + + return sendmsg(self->netlink_fd, &msg, 0); +} + +void render_response(struct __test_metadata *_metadata, + struct unix_diag_req *udr, __u32 len) +{ + unsigned int rta_len = len - NLMSG_LENGTH(sizeof(*udr)); + struct rtattr *attr; + uid_t uid; + + ASSERT_GT(len, sizeof(*udr)); + ASSERT_EQ(udr->sdiag_family, AF_UNIX); + + attr = (struct rtattr *)(udr + 1); + ASSERT_NE(RTA_OK(attr, rta_len), 0); + ASSERT_EQ(attr->rta_type, UNIX_DIAG_UID); + + uid = *(uid_t *)RTA_DATA(attr); + ASSERT_EQ(uid, getuid()); +} + +void receive_response(struct __test_metadata *_metadata, + FIXTURE_DATA(diag_uid) *self) +{ + long buf[8192 / sizeof(long)]; + struct sockaddr_nl nladdr = { + .nl_family = AF_NETLINK + }; + struct iovec iov = { + .iov_base = buf, + .iov_len = sizeof(buf) + }; + struct msghdr msg = { + .msg_name = &nladdr, + .msg_namelen = sizeof(nladdr), + .msg_iov = &iov, + .msg_iovlen = 1 + }; + struct unix_diag_req *udr; + struct nlmsghdr *nlh; + int ret; + + ret = recvmsg(self->netlink_fd, &msg, 0); + ASSERT_GT(ret, 0); + + nlh = (struct nlmsghdr *)buf; + ASSERT_NE(NLMSG_OK(nlh, ret), 0); + ASSERT_EQ(nlh->nlmsg_type, SOCK_DIAG_BY_FAMILY); + + render_response(_metadata, NLMSG_DATA(nlh), nlh->nlmsg_len); + + nlh = NLMSG_NEXT(nlh, ret); + ASSERT_EQ(NLMSG_OK(nlh, ret), 0); +} + +TEST_F(diag_uid, 1) +{ + int ret; + + ret = send_request(_metadata, self, variant); + ASSERT_GT(ret, 0); + + receive_response(_metadata, self); +} + +TEST_HARNESS_MAIN -- 2.35.1

2 years, 4 months

1
0
0 0

[PATCH AUTOSEL 6.0 5/7] selftests: net: Use "grep -E" instead of "egrep"

by Sasha Levin

From: Tiezhu Yang <yangtiezhu(a)loongson.cn> [ Upstream commit 6a30d3e3491dc562384e9f15b201a8a25b57439f ] The latest version of grep claims the egrep is now obsolete so the build now contains warnings that look like: egrep: warning: egrep is obsolescent; using grep -E fix this using "grep -E" instead. sed -i "s/egrep/grep -E/g" `grep egrep -rwl tools/testing/selftests/net` Here are the steps to install the latest grep: wget http://ftp.gnu.org/gnu/grep/grep-3.8.tar.gz tar xf grep-3.8.tar.gz cd grep-3.8 && ./configure && make sudo make install export PATH=/usr/local/bin:$PATH Signed-off-by: Tiezhu Yang <yangtiezhu(a)loongson.cn> Link: https://lore.kernel.org/r/1669864248-829-1-git-send-email-yangtiezhu@loongs… Signed-off-by: Jakub Kicinski <kuba(a)kernel.org> Signed-off-by: Sasha Levin <sashal(a)kernel.org> --- tools/testing/selftests/net/toeplitz.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/net/toeplitz.sh b/tools/testing/selftests/net/toeplitz.sh index 0a49907cd4fe..da5bfd834eff 100755 --- a/tools/testing/selftests/net/toeplitz.sh +++ b/tools/testing/selftests/net/toeplitz.sh @@ -32,7 +32,7 @@ DEV="eth0" # This is determined by reading the RSS indirection table using ethtool. get_rss_cfg_num_rxqs() { echo $(ethtool -x "${DEV}" | - egrep [[:space:]]+[0-9]+:[[:space:]]+ | + grep -E [[:space:]]+[0-9]+:[[:space:]]+ | cut -d: -f2- | awk '{$1=$1};1' | tr ' ' '\n' | -- 2.35.1

2 years, 4 months

1
0
0 0

[PATCH v2 4/7] KVM: selftests: Correctly initialize the VA space for TTBR0_EL1

by Oliver Upton

An interesting feature of the Arm architecture is that the stage-1 MMU supports two distinct VA regions, controlled by TTBR{0,1}_EL1. As KVM selftests on arm64 only uses TTBR0_EL1, the VA space is constrained to [0, 2^(va_bits)). This is different from other architectures that allow for addressing low and high regions of the VA space from a single page table. KVM selftests' VA space allocator presumes the valid address range is split between low and high memory based the MSB, which of course is a poor match for arm64's TTBR0 region. Add a helper that correctly handles both addressing schemes with a comment describing each. Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- .../selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/lib/kvm_util.c | 49 ++++++++++++++++--- 2 files changed, 44 insertions(+), 6 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index 6cd86da698b3..b193863d754f 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -103,6 +103,7 @@ struct kvm_vm { struct sparsebit *vpages_mapped; bool has_irqchip; bool pgd_created; + bool has_split_va_space; vm_paddr_t ucall_mmio_addr; vm_paddr_t pgd; vm_vaddr_t gdt; diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index a256ec67aff6..53d15f32f220 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -186,6 +186,43 @@ const struct vm_guest_mode_params vm_guest_mode_params[] = { _Static_assert(sizeof(vm_guest_mode_params)/sizeof(struct vm_guest_mode_params) == NUM_VM_MODES, "Missing new mode params?"); +/* + * Initializes vm->vpages_valid to match the canonical VA space of the + * architecture. + * + * Most architectures split the range addressed by a single page table into a + * low and high region based on the MSB of the VA. On architectures with this + * behavior the VA region spans [0, 2^(va_bits - 1)), [-(2^(va_bits - 1), -1]. + * + * arm64 is a bit different from the rest of the crowd, as the low and high + * regions of the VA space are addressed by distinct paging structures + * (TTBR{0,1}_EL1). KVM selftests on arm64 only uses TTBR0_EL1, meaning that we + * only have a low VA region. As there is no VA split based on the MSB, the VA + * region spans [0, 2^va_bits). + */ +static void vm_vaddr_populate_bitmap(struct kvm_vm *vm) +{ + sparsebit_num_t contig_va_bits = vm->va_bits; + sparsebit_num_t nr_contig_pages; + + /* + * Depending on the architecture, the MSB of the VA could split between + * low and high regions. When that is the case each region has + * va_bits - 1 of address. + */ + if (vm->has_split_va_space) + contig_va_bits--; + + nr_contig_pages = (1ULL << contig_va_bits) >> vm->page_shift; + + sparsebit_set_num(vm->vpages_valid, 0, nr_contig_pages); + + if (vm->has_split_va_space) + sparsebit_set_num(vm->vpages_valid, + -(1ULL << contig_va_bits), + nr_contig_pages); +} + struct kvm_vm *____vm_create(enum vm_guest_mode mode) { struct kvm_vm *vm; @@ -268,17 +305,17 @@ struct kvm_vm *____vm_create(enum vm_guest_mode mode) #ifdef __aarch64__ if (vm->pa_bits != 40) vm->type = KVM_VM_TYPE_ARM_IPA_SIZE(vm->pa_bits); + + /* selftests use TTBR0 only, meaning there is a single VA region. */ + vm->has_split_va_space = false; +#else + vm->has_split_va_space = true; #endif vm_open(vm); - /* Limit to VA-bit canonical virtual addresses. */ vm->vpages_valid = sparsebit_alloc(); - sparsebit_set_num(vm->vpages_valid, - 0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift); - sparsebit_set_num(vm->vpages_valid, - (~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift, - (1ULL << (vm->va_bits - 1)) >> vm->page_shift); + vm_vaddr_populate_bitmap(vm); /* Limit physical addresses to PA-bits. */ vm->max_gfn = vm_compute_max_gfn(vm); -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 4 months

3
3
0 0

[PATCH] lib: Add Dhrystone benchmark test

by Geert Uytterhoeven

When working on SoC bring-up, (a full) userspace may not be available, making it hard to benchmark the CPU performance of the system under development. Still, one may want to have a rough idea of the (relative) performance of one or more CPU cores, especially when working on e.g. the clock driver that controls the CPU core clock(s). Hence make the classical Dhrystone 2.1 benchmark available as a Linux kernel test module, based on[1]. When built-in, this benchmark can be run without any userspace present. Parallel runs (run on multiple CPU cores) are supported, just kick the "run" file multiple times. Note that the actual figures depend on the configuration options that control compiler optimization (e.g. CONFIG_CC_OPTIMIZE_FOR_SIZE vs. CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE), and on the compiler options used when building the kernel in general. Hence numbers may differ from those obtained by running similar benchmarks in userspace. [1] https://github.com/qris/dhrystone-deb.git Signed-off-by: Geert Uytterhoeven <geert+renesas(a)glider.be> --- This has been used to validate secondary CPU bringup and cpufreq support on the R-Car S4-8 and V4H SoCs. Changes compared to the original Dhrystone 2.1 C version: - Remove trailing whitespace - Remove unused NOSTRUCTASSIGN - Remove unused NOENUM(S) - Remove unused REG - Use ktime for time measurements - Use kzalloc() for memory allocation - Remove definition and use of Null - Remove definitions of true and false - Use pr_info() for printing - Replace sscanf() use by parameter n - Replace userspace includes by kernel includes - Replace K&R by ANSI function declarations - Move/add external/forward declarations to dhry.h - Reshuffle functions to avoid forward declarations - Make local symbols static - Add kernel module wrapper - Let dhry() return the number of dhrystones - Add automatic iteration handling - Whitespace and indentation fixes - Fix braces and related indentation - Remove parentheses from return values - Reduce printed output - Use %px to print pointers - Verify results automatically - Make time measurement variables local - Add SPDX-License tags - Add Dhrystone benchmark test to config/build system An unsquashed version can be found at https://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git/l… --- lib/Kconfig.debug | 35 +++++ lib/Makefile | 2 + lib/dhry.h | 358 ++++++++++++++++++++++++++++++++++++++++++++++ lib/dhry_1.c | 283 ++++++++++++++++++++++++++++++++++++ lib/dhry_2.c | 175 ++++++++++++++++++++++ lib/dhry_run.c | 85 +++++++++++ 6 files changed, 938 insertions(+) create mode 100644 lib/dhry.h create mode 100644 lib/dhry_1.c create mode 100644 lib/dhry_2.c create mode 100644 lib/dhry_run.c diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index a1b56cde3f843fbc..9e834f8cd6d163db 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2036,6 +2036,41 @@ menuconfig RUNTIME_TESTING_MENU if RUNTIME_TESTING_MENU +config TEST_DHRY + tristate "Dhrystone benchmark test" + help + Enable this to include the Dhrystone 2.1 benchmark. This test + calculates the number of Dhrystones per second, and the number of + DMIPS (Dhrystone MIPS) obtained when the Dhrystone score is divided + by 1757 (the number of Dhrystones per second obtained on the VAX + 11/780, nominally a 1 MIPS machine). + + To run the benchmark, it needs to be enabled explicitly, either from + the kernel command line (when built-in), or from userspace (when + built-in or modular. + + Run once during kernel boot: + + test_dhry.run + + Set number of iterations from kernel command line: + + test_dhry.iterations=<n> + + Set number of iterations from userspace: + + echo <n> > /sys/module/test_dhry/parameters/iterations + + Trigger manual run from userspace: + + echo y > /sys/module/test_dhry/parameters/run + + If the number of iterations is <= 0, the test will devise a suitable + number of iterations (test runs for at least 2s) automatically. + This process takes ca. 4s. + + If unsure, say N. + config LKDTM tristate "Linux Kernel Dump Test Tool Module" depends on DEBUG_FS diff --git a/lib/Makefile b/lib/Makefile index 59bd7c2f793a7e93..f78082e2f7591478 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -57,6 +57,8 @@ obj-$(CONFIG_TEST_HEXDUMP) += test_hexdump.o obj-y += kstrtox.o obj-$(CONFIG_FIND_BIT_BENCHMARK) += find_bit_benchmark.o obj-$(CONFIG_TEST_BPF) += test_bpf.o +test_dhry-objs := dhry_1.o dhry_2.o dhry_run.o +obj-$(CONFIG_TEST_DHRY) += test_dhry.o obj-$(CONFIG_TEST_FIRMWARE) += test_firmware.o obj-$(CONFIG_TEST_BITOPS) += test_bitops.o CFLAGS_test_bitops.o += -Werror diff --git a/lib/dhry.h b/lib/dhry.h new file mode 100644 index 0000000000000000..e1a4db8e252c3342 --- /dev/null +++ b/lib/dhry.h @@ -0,0 +1,358 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */ +/* + **************************************************************************** + * + * "DHRYSTONE" Benchmark Program + * ----------------------------- + * + * Version: C, Version 2.1 + * + * File: dhry.h (part 1 of 3) + * + * Date: May 25, 1988 + * + * Author: Reinhold P. Weicker + * Siemens AG, AUT E 51 + * Postfach 3220 + * 8520 Erlangen + * Germany (West) + * Phone: [+49]-9131-7-20330 + * (8-17 Central European Time) + * Usenet: ..!mcsun!unido!estevax!weicker + * + * Original Version (in Ada) published in + * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984), + * pp. 1013 - 1030, together with the statistics + * on which the distribution of statements etc. is based. + * + * In this C version, the following C library functions are used: + * - strcpy, strcmp (inside the measurement loop) + * - printf, scanf (outside the measurement loop) + * In addition, Berkeley UNIX system calls "times ()" or "time ()" + * are used for execution time measurement. For measurements + * on other systems, these calls have to be changed. + * + * Collection of Results: + * Reinhold Weicker (address see above) and + * + * Rick Richardson + * PC Research. Inc. + * 94 Apple Orchard Drive + * Tinton Falls, NJ 07724 + * Phone: (201) 389-8963 (9-17 EST) + * Usenet: ...!uunet!pcrat!rick + * + * Please send results to Rick Richardson and/or Reinhold Weicker. + * Complete information should be given on hardware and software used. + * Hardware information includes: Machine type, CPU, type and size + * of caches; for microprocessors: clock frequency, memory speed + * (number of wait states). + * Software information includes: Compiler (and runtime library) + * manufacturer and version, compilation switches, OS version. + * The Operating System version may give an indication about the + * compiler; Dhrystone itself performs no OS calls in the measurement loop. + * + * The complete output generated by the program should be mailed + * such that at least some checks for correctness can be made. + * + *************************************************************************** + * + * History: This version C/2.1 has been made for two reasons: + * + * 1) There is an obvious need for a common C version of + * Dhrystone, since C is at present the most popular system + * programming language for the class of processors + * (microcomputers, minicomputers) where Dhrystone is used most. + * There should be, as far as possible, only one C version of + * Dhrystone such that results can be compared without + * restrictions. In the past, the C versions distributed + * by Rick Richardson (Version 1.1) and by Reinhold Weicker + * had small (though not significant) differences. + * + * 2) As far as it is possible without changes to the Dhrystone + * statistics, optimizing compilers should be prevented from + * removing significant statements. + * + * This C version has been developed in cooperation with + * Rick Richardson (Tinton Falls, NJ), it incorporates many + * ideas from the "Version 1.1" distributed previously by + * him over the UNIX network Usenet. + * I also thank Chaim Benedelac (National Semiconductor), + * David Ditzel (SUN), Earl Killian and John Mashey (MIPS), + * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley) + * for their help with comments on earlier versions of the + * benchmark. + * + * Changes: In the initialization part, this version follows mostly + * Rick Richardson's version distributed via Usenet, not the + * version distributed earlier via floppy disk by Reinhold Weicker. + * As a concession to older compilers, names have been made + * unique within the first 8 characters. + * Inside the measurement loop, this version follows the + * version previously distributed by Reinhold Weicker. + * + * At several places in the benchmark, code has been added, + * but within the measurement loop only in branches that + * are not executed. The intention is that optimizing compilers + * should be prevented from moving code out of the measurement + * loop, or from removing code altogether. Since the statements + * that are executed within the measurement loop have NOT been + * changed, the numbers defining the "Dhrystone distribution" + * (distribution of statements, operand types and locality) + * still hold. Except for sophisticated optimizing compilers, + * execution times for this version should be the same as + * for previous versions. + * + * Since it has proven difficult to subtract the time for the + * measurement loop overhead in a correct way, the loop check + * has been made a part of the benchmark. This does have + * an impact - though a very minor one - on the distribution + * statistics which have been updated for this version. + * + * All changes within the measurement loop are described + * and discussed in the companion paper "Rationale for + * Dhrystone version 2". + * + * Because of the self-imposed limitation that the order and + * distribution of the executed statements should not be + * changed, there are still cases where optimizing compilers + * may not generate code for some statements. To a certain + * degree, this is unavoidable for small synthetic benchmarks. + * Users of the benchmark are advised to check code listings + * whether code is generated for all statements of Dhrystone. + * + * Version 2.1 is identical to version 2.0 distributed via + * the UNIX network Usenet in March 1988 except that it corrects + * some minor deficiencies that were found by users of version 2.0. + * The only change within the measurement loop is that a + * non-executed "else" part was added to the "if" statement in + * Func_3, and a non-executed "else" part removed from Proc_3. + * + *************************************************************************** + * + * Compilation model and measurement (IMPORTANT): + * + * This C version of Dhrystone consists of three files: + * - dhry.h (this file, containing global definitions and comments) + * - dhry_1.c (containing the code corresponding to Ada package Pack_1) + * - dhry_2.c (containing the code corresponding to Ada package Pack_2) + * + * The following "ground rules" apply for measurements: + * - Separate compilation + * - No procedure merging + * - Otherwise, compiler optimizations are allowed but should be indicated + * - Default results are those without register declarations + * See the companion paper "Rationale for Dhrystone Version 2" for a more + * detailed discussion of these ground rules. + * + * For 16-Bit processors (e.g. 80186, 80286), times for all compilation + * models ("small", "medium", "large" etc.) should be given if possible, + * together with a definition of these models for the compiler system used. + * + ************************************************************************** + * + * Dhrystone (C version) statistics: + * + * [Comment from the first distribution, updated for version 2. + * Note that because of language differences, the numbers are slightly + * different from the Ada version.] + * + * The following program contains statements of a high level programming + * language (here: C) in a distribution considered representative: + * + * assignments 52 (51.0 %) + * control statements 33 (32.4 %) + * procedure, function calls 17 (16.7 %) + * + * 103 statements are dynamically executed. The program is balanced with + * respect to the three aspects: + * + * - statement type + * - operand type + * - operand locality + * operand global, local, parameter, or constant. + * + * The combination of these three aspects is balanced only approximately. + * + * 1. Statement Type: + * ----------------- number + * + * V1 = V2 9 + * (incl. V1 = F(..) + * V = Constant 12 + * Assignment, 7 + * with array element + * Assignment, 6 + * with record component + * -- + * 34 34 + * + * X = Y +|-|"&&"|"|" Z 5 + * X = Y +|-|"==" Constant 6 + * X = X +|- 1 3 + * X = Y *|/ Z 2 + * X = Expression, 1 + * two operators + * X = Expression, 1 + * three operators + * -- + * 18 18 + * + * if .... 14 + * with "else" 7 + * without "else" 7 + * executed 3 + * not executed 4 + * for ... 7 | counted every time + * while ... 4 | the loop condition + * do ... while 1 | is evaluated + * switch ... 1 + * break 1 + * declaration with 1 + * initialization + * -- + * 34 34 + * + * P (...) procedure call 11 + * user procedure 10 + * library procedure 1 + * X = F (...) + * function call 6 + * user function 5 + * library function 1 + * -- + * 17 17 + * --- + * 103 + * + * The average number of parameters in procedure or function calls + * is 1.82 (not counting the function values as implicit parameters). + * + * + * 2. Operators + * ------------ + * number approximate + * percentage + * + * Arithmetic 32 50.8 + * + * + 21 33.3 + * - 7 11.1 + * * 3 4.8 + * / (int div) 1 1.6 + * + * Comparison 27 42.8 + * + * == 9 14.3 + * /= 4 6.3 + * > 1 1.6 + * < 3 4.8 + * >= 1 1.6 + * <= 9 14.3 + * + * Logic 4 6.3 + * + * && (AND-THEN) 1 1.6 + * | (OR) 1 1.6 + * ! (NOT) 2 3.2 + * + * -- ----- + * 63 100.1 + * + * + * 3. Operand Type (counted once per operand reference): + * --------------- + * number approximate + * percentage + * + * Integer 175 72.3 % + * Character 45 18.6 % + * Pointer 12 5.0 % + * String30 6 2.5 % + * Array 2 0.8 % + * Record 2 0.8 % + * --- ------- + * 242 100.0 % + * + * When there is an access path leading to the final operand (e.g. a record + * component), only the final data type on the access path is counted. + * + * + * 4. Operand Locality: + * ------------------- + * number approximate + * percentage + * + * local variable 114 47.1 % + * global variable 22 9.1 % + * parameter 45 18.6 % + * value 23 9.5 % + * reference 22 9.1 % + * function result 6 2.5 % + * constant 55 22.7 % + * --- ------- + * 242 100.0 % + * + * + * The program does not compute anything meaningful, but it is syntactically + * and semantically correct. All variables have a value assigned to them + * before they are used as a source operand. + * + * There has been no explicit effort to account for the effects of a + * cache, or to balance the use of long or short displacements for code or + * data. + * + *************************************************************************** + */ + +typedef enum { + Ident_1, + Ident_2, + Ident_3, + Ident_4, + Ident_5 +} Enumeration; /* for boolean and enumeration types in Ada, Pascal */ + +/* General definitions: */ + +typedef int One_Thirty; +typedef int One_Fifty; +typedef char Capital_Letter; +typedef int Boolean; +typedef char Str_30[31]; +typedef int Arr_1_Dim[50]; +typedef int Arr_2_Dim[50][50]; + +typedef struct record { + struct record *Ptr_Comp; + Enumeration Discr; + union { + struct { + Enumeration Enum_Comp; + int Int_Comp; + char Str_Comp[31]; + } var_1; + struct { + Enumeration E_Comp_2; + char Str_2_Comp[31]; + } var_2; + struct { + char Ch_1_Comp; + char Ch_2_Comp; + } var_3; + } variant; +} Rec_Type, *Rec_Pointer; + + +extern int Int_Glob; +extern char Ch_1_Glob; + +void Proc_6(Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par); +void Proc_7(One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, + One_Fifty *Int_Par_Ref); +void Proc_8(Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, + int Int_1_Par_Val, int Int_2_Par_Val); +Enumeration Func_1(Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val); +Boolean Func_2(Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref); + +int dhry(int n); diff --git a/lib/dhry_1.c b/lib/dhry_1.c new file mode 100644 index 0000000000000000..83247106824cc7f4 --- /dev/null +++ b/lib/dhry_1.c @@ -0,0 +1,283 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* + **************************************************************************** + * + * "DHRYSTONE" Benchmark Program + * ----------------------------- + * + * Version: C, Version 2.1 + * + * File: dhry_1.c (part 2 of 3) + * + * Date: May 25, 1988 + * + * Author: Reinhold P. Weicker + * + **************************************************************************** + */ + +#include "dhry.h" + +#include <linux/ktime.h> +#include <linux/slab.h> +#include <linux/string.h> + +/* Global Variables: */ + +int Int_Glob; +char Ch_1_Glob; + +static Rec_Pointer Ptr_Glob, Next_Ptr_Glob; +static Boolean Bool_Glob; +static char Ch_2_Glob; +static int Arr_1_Glob[50]; +static int Arr_2_Glob[50][50]; + +static void Proc_3(Rec_Pointer *Ptr_Ref_Par) +/******************/ +/* executed once */ +/* Ptr_Ref_Par becomes Ptr_Glob */ +{ + if (Ptr_Glob) { + /* then, executed */ + *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; + } + Proc_7(10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); +} /* Proc_3 */ + + +static void Proc_1(Rec_Pointer Ptr_Val_Par) +/******************/ +/* executed once */ +{ + Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; + /* == Ptr_Glob_Next */ + /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ + /* corresponds to "rename" in Ada, "with" in Pascal */ + + *Ptr_Val_Par->Ptr_Comp = *Ptr_Glob; + Ptr_Val_Par->variant.var_1.Int_Comp = 5; + Next_Record->variant.var_1.Int_Comp = + Ptr_Val_Par->variant.var_1.Int_Comp; + Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; + Proc_3(&Next_Record->Ptr_Comp); + /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp == Ptr_Glob->Ptr_Comp */ + if (Next_Record->Discr == Ident_1) { + /* then, executed */ + Next_Record->variant.var_1.Int_Comp = 6; + Proc_6(Ptr_Val_Par->variant.var_1.Enum_Comp, + &Next_Record->variant.var_1.Enum_Comp); + Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; + Proc_7(Next_Record->variant.var_1.Int_Comp, 10, + &Next_Record->variant.var_1.Int_Comp); + } else { + /* not executed */ + *Ptr_Val_Par = *Ptr_Val_Par->Ptr_Comp; + } +} /* Proc_1 */ + + +static void Proc_2(One_Fifty *Int_Par_Ref) +/******************/ +/* executed once */ +/* *Int_Par_Ref == 1, becomes 4 */ +{ + One_Fifty Int_Loc; + Enumeration Enum_Loc; + + Int_Loc = *Int_Par_Ref + 10; + do { + /* executed once */ + if (Ch_1_Glob == 'A') { + /* then, executed */ + Int_Loc -= 1; + *Int_Par_Ref = Int_Loc - Int_Glob; + Enum_Loc = Ident_1; + } /* if */ + } while (Enum_Loc != Ident_1); /* true */ +} /* Proc_2 */ + + +static void Proc_4(void) +/*******/ +/* executed once */ +{ + Boolean Bool_Loc; + + Bool_Loc = Ch_1_Glob == 'A'; + Bool_Glob = Bool_Loc | Bool_Glob; + Ch_2_Glob = 'B'; +} /* Proc_4 */ + + +static void Proc_5(void) +/*******/ +/* executed once */ +{ + Ch_1_Glob = 'A'; + Bool_Glob = false; +} /* Proc_5 */ + + +int dhry(int n) +/*****/ + + /* main program, corresponds to procedures */ + /* Main and Proc_0 in the Ada version */ +{ + One_Fifty Int_1_Loc; + One_Fifty Int_2_Loc; + One_Fifty Int_3_Loc; + char Ch_Index; + Enumeration Enum_Loc; + Str_30 Str_1_Loc; + Str_30 Str_2_Loc; + int Run_Index; + int Number_Of_Runs; + ktime_t Begin_Time, End_Time; + u32 User_Time; + + /* Initializations */ + + Next_Ptr_Glob = (Rec_Pointer)kzalloc(sizeof(Rec_Type), GFP_KERNEL); + Ptr_Glob = (Rec_Pointer)kzalloc(sizeof(Rec_Type), GFP_KERNEL); + + Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; + Ptr_Glob->Discr = Ident_1; + Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; + Ptr_Glob->variant.var_1.Int_Comp = 40; + strcpy(Ptr_Glob->variant.var_1.Str_Comp, + "DHRYSTONE PROGRAM, SOME STRING"); + strcpy(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); + + Arr_2_Glob[8][7] = 10; + /* Was missing in published program. Without this statement, */ + /* Arr_2_Glob[8][7] would have an undefined value. */ + /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ + /* overflow may occur for this array element. */ + + pr_debug("Dhrystone Benchmark, Version 2.1 (Language: C)\n"); + + Number_Of_Runs = n; + + pr_debug("Execution starts, %d runs through Dhrystone\n", + Number_Of_Runs); + + /***************/ + /* Start timer */ + /***************/ + + Begin_Time = ktime_get(); + + for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) { + Proc_5(); + Proc_4(); + /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ + Int_1_Loc = 2; + Int_2_Loc = 3; + strcpy(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); + Enum_Loc = Ident_2; + Bool_Glob = !Func_2(Str_1_Loc, Str_2_Loc); + /* Bool_Glob == 1 */ + while (Int_1_Loc < Int_2_Loc) { + /* loop body executed once */ + Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; + /* Int_3_Loc == 7 */ + Proc_7(Int_1_Loc, Int_2_Loc, &Int_3_Loc); + /* Int_3_Loc == 7 */ + Int_1_Loc += 1; + } /* while */ + /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ + Proc_8(Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); + /* Int_Glob == 5 */ + Proc_1(Ptr_Glob); + for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) { + /* loop body executed twice */ + if (Enum_Loc == Func_1(Ch_Index, 'C')) { + /* then, not executed */ + Proc_6(Ident_1, &Enum_Loc); + strcpy(Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); + Int_2_Loc = Run_Index; + Int_Glob = Run_Index; + } + } + /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ + Int_2_Loc = Int_2_Loc * Int_1_Loc; + Int_1_Loc = Int_2_Loc / Int_3_Loc; + Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; + /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ + Proc_2(&Int_1_Loc); + /* Int_1_Loc == 5 */ + + } /* loop "for Run_Index" */ + + /**************/ + /* Stop timer */ + /**************/ + + End_Time = ktime_get(); + +#define dhry_assert_int_eq(val, expected) \ + if (val != expected) \ + pr_err("%s: %d (FAIL, expected %d)\n", #val, val, \ + expected); \ + else \ + pr_debug("%s: %d (OK)\n", #val, val) + +#define dhry_assert_char_eq(val, expected) \ + if (val != expected) \ + pr_err("%s: %c (FAIL, expected %c)\n", #val, val, \ + expected); \ + else \ + pr_debug("%s: %c (OK)\n", #val, val) + +#define dhry_assert_string_eq(val, expected) \ + if (strcmp(val, expected)) \ + pr_err("%s: %s (FAIL, expected %s)\n", #val, val, \ + expected); \ + else \ + pr_debug("%s: %s (OK)\n", #val, val) + + pr_debug("Execution ends\n"); + pr_debug("Final values of the variables used in the benchmark:\n"); + dhry_assert_int_eq(Int_Glob, 5); + dhry_assert_int_eq(Bool_Glob, 1); + dhry_assert_char_eq(Ch_1_Glob, 'A'); + dhry_assert_char_eq(Ch_2_Glob, 'B'); + dhry_assert_int_eq(Arr_1_Glob[8], 7); + dhry_assert_int_eq(Arr_2_Glob[8][7], Number_Of_Runs + 10); + pr_debug("Ptr_Comp: %px\n", Ptr_Glob->Ptr_Comp); + dhry_assert_int_eq(Ptr_Glob->Discr, 0); + dhry_assert_int_eq(Ptr_Glob->variant.var_1.Enum_Comp, 2); + dhry_assert_int_eq(Ptr_Glob->variant.var_1.Int_Comp, 17); + dhry_assert_string_eq(Ptr_Glob->variant.var_1.Str_Comp, + "DHRYSTONE PROGRAM, SOME STRING"); + if (Next_Ptr_Glob->Ptr_Comp != Ptr_Glob->Ptr_Comp) + pr_err("Next_Ptr_Glob->Ptr_Comp: %px (expected %px)\n", + Next_Ptr_Glob->Ptr_Comp, Ptr_Glob->Ptr_Comp); + else + pr_debug("Next_Ptr_Glob->Ptr_Comp: %px\n", + Next_Ptr_Glob->Ptr_Comp); + dhry_assert_int_eq(Next_Ptr_Glob->Discr, 0); + dhry_assert_int_eq(Next_Ptr_Glob->variant.var_1.Enum_Comp, 1); + dhry_assert_int_eq(Next_Ptr_Glob->variant.var_1.Int_Comp, 18); + dhry_assert_string_eq(Next_Ptr_Glob->variant.var_1.Str_Comp, + "DHRYSTONE PROGRAM, SOME STRING"); + dhry_assert_int_eq(Int_1_Loc, 5); + dhry_assert_int_eq(Int_2_Loc, 13); + dhry_assert_int_eq(Int_3_Loc, 7); + dhry_assert_int_eq(Enum_Loc, 1); + dhry_assert_string_eq(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); + dhry_assert_string_eq(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); + + User_Time = ktime_to_ms(ktime_sub(End_Time, Begin_Time)); + + kfree(Ptr_Glob); + kfree(Next_Ptr_Glob); + + /* Measurements should last at least 2 seconds */ + if (User_Time < 2 * MSEC_PER_SEC) + return -EAGAIN; + + return div_u64(mul_u32_u32(MSEC_PER_SEC, Number_Of_Runs), User_Time); +} diff --git a/lib/dhry_2.c b/lib/dhry_2.c new file mode 100644 index 0000000000000000..c19e661f37d30a66 --- /dev/null +++ b/lib/dhry_2.c @@ -0,0 +1,175 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* + **************************************************************************** + * + * "DHRYSTONE" Benchmark Program + * ----------------------------- + * + * Version: C, Version 2.1 + * + * File: dhry_2.c (part 3 of 3) + * + * Date: May 25, 1988 + * + * Author: Reinhold P. Weicker + * + **************************************************************************** + */ + +#include "dhry.h" + +#include <linux/string.h> + + +static Boolean Func_3(Enumeration Enum_Par_Val) +/***************************/ +/* executed once */ +/* Enum_Par_Val == Ident_3 */ +{ + Enumeration Enum_Loc; + + Enum_Loc = Enum_Par_Val; + if (Enum_Loc == Ident_3) { + /* then, executed */ + return true; + } else { + /* not executed */ + return false; + } +} /* Func_3 */ + + +void Proc_6(Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par) +/*********************************/ +/* executed once */ +/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ +{ + *Enum_Ref_Par = Enum_Val_Par; + if (!Func_3(Enum_Val_Par)) { + /* then, not executed */ + *Enum_Ref_Par = Ident_4; + } + switch (Enum_Val_Par) { + case Ident_1: + *Enum_Ref_Par = Ident_1; + break; + case Ident_2: + if (Int_Glob > 100) { + /* then */ + *Enum_Ref_Par = Ident_1; + } else { + *Enum_Ref_Par = Ident_4; + } + break; + case Ident_3: /* executed */ + *Enum_Ref_Par = Ident_2; + break; + case Ident_4: + break; + case Ident_5: + *Enum_Ref_Par = Ident_3; + break; + } /* switch */ +} /* Proc_6 */ + + +void Proc_7(One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref) +/**********************************************/ +/* executed three times */ +/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */ +/* Int_Par_Ref becomes 7 */ +/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */ +/* Int_Par_Ref becomes 17 */ +/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */ +/* Int_Par_Ref becomes 18 */ +{ + One_Fifty Int_Loc; + + Int_Loc = Int_1_Par_Val + 2; + *Int_Par_Ref = Int_2_Par_Val + Int_Loc; +} /* Proc_7 */ + + +void Proc_8(Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, int Int_1_Par_Val, int Int_2_Par_Val) +/*********************************************************************/ +/* executed once */ +/* Int_Par_Val_1 == 3 */ +/* Int_Par_Val_2 == 7 */ +{ + One_Fifty Int_Index; + One_Fifty Int_Loc; + + Int_Loc = Int_1_Par_Val + 5; + Arr_1_Par_Ref[Int_Loc] = Int_2_Par_Val; + Arr_1_Par_Ref[Int_Loc+1] = Arr_1_Par_Ref[Int_Loc]; + Arr_1_Par_Ref[Int_Loc+30] = Int_Loc; + for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index) + Arr_2_Par_Ref[Int_Loc][Int_Index] = Int_Loc; + Arr_2_Par_Ref[Int_Loc][Int_Loc-1] += 1; + Arr_2_Par_Ref[Int_Loc+20][Int_Loc] = Arr_1_Par_Ref[Int_Loc]; + Int_Glob = 5; +} /* Proc_8 */ + + +Enumeration Func_1(Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val) +/*************************************************/ +/* executed three times */ +/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */ +/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */ +/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */ +{ + Capital_Letter Ch_1_Loc; + Capital_Letter Ch_2_Loc; + + Ch_1_Loc = Ch_1_Par_Val; + Ch_2_Loc = Ch_1_Loc; + if (Ch_2_Loc != Ch_2_Par_Val) { + /* then, executed */ + return Ident_1; + } else { + /* not executed */ + Ch_1_Glob = Ch_1_Loc; + return Ident_2; + } +} /* Func_1 */ + + +Boolean Func_2(Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref) +/*************************************************/ +/* executed once */ +/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */ +/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */ +{ + One_Thirty Int_Loc; + Capital_Letter Ch_Loc; + + Int_Loc = 2; + while (Int_Loc <= 2) { + /* loop body executed once */ + if (Func_1(Str_1_Par_Ref[Int_Loc], + Str_2_Par_Ref[Int_Loc+1]) == Ident_1) { + /* then, executed */ + Ch_Loc = 'A'; + Int_Loc += 1; + } + } /* if, while */ + if (Ch_Loc >= 'W' && Ch_Loc < 'Z') { + /* then, not executed */ + Int_Loc = 7; + } + if (Ch_Loc == 'R') { + /* then, not executed */ + return true; + } else { + /* executed */ + if (strcmp(Str_1_Par_Ref, Str_2_Par_Ref) > 0) { + /* then, not executed */ + Int_Loc += 7; + Int_Glob = Int_Loc; + return true; + } else { + /* executed */ + return false; + } + } /* if Ch_Loc */ +} /* Func_2 */ diff --git a/lib/dhry_run.c b/lib/dhry_run.c new file mode 100644 index 0000000000000000..31a1d442e4a0fc19 --- /dev/null +++ b/lib/dhry_run.c @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Dhrystone benchmark test module + * + * Copyright (C) 2022 Glider bv + */ + +#include "dhry.h" + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/mutex.h> +#include <linux/smp.h> + +#define DHRY_VAX 1757 + +static int dhry_run_set(const char *val, const struct kernel_param *kp); +static const struct kernel_param_ops run_ops = { + .flags = KERNEL_PARAM_OPS_FL_NOARG, + .set = dhry_run_set, +}; +static bool dhry_run; +module_param_cb(run, &run_ops, &dhry_run, 0200); +MODULE_PARM_DESC(run, "Run the test (default: false)"); + +static int iterations = -1; +module_param(iterations, int, 0644); +MODULE_PARM_DESC(iterations, + "Number of iterations through the benchmark (default: auto)"); + +static void dhry_benchmark(void) +{ + int i, n; + + if (iterations > 0) { + n = dhry(iterations); + goto report; + } + + for (i = DHRY_VAX; i > 0; i <<= 1) { + n = dhry(i); + if (n != -EAGAIN) + break; + } + +report: + if (n >= 0) + pr_info("CPU%u: Dhrystones per Second: %d (%d DMIPS)\n", + smp_processor_id(), n, n / DHRY_VAX); + else if (n == -EAGAIN) + pr_err("Please increase the number of iterations\n"); + else + pr_err("Dhrystone benchmark failed error %pe\n", ERR_PTR(n)); +} + +static int dhry_run_set(const char *val, const struct kernel_param *kp) +{ + int ret; + + if (val) { + ret = param_set_bool(val, kp); + if (ret) + return ret; + } else { + dhry_run = true; + } + + if (dhry_run && system_state == SYSTEM_RUNNING) + dhry_benchmark(); + + return ret; +} + +static int __init dhry_init(void) +{ + if (dhry_run) + dhry_benchmark(); + + return 0; +} +module_init(dhry_init); + +MODULE_AUTHOR("Geert Uytterhoeven <geert+renesas(a)glider.be>"); +MODULE_LICENSE("GPL"); -- 2.25.1

2 years, 5 months

3
2
0 0

[PATCH net-next] selftests: net: Fix O=dir builds

by Björn Töpel

From: Björn Töpel <bjorn(a)rivosinc.com> The BPF Makefile in net/bpf did incorrect path substitution for O=dir builds, e.g. make O=/tmp/kselftest headers make O=/tmp/kselftest -C tools/testing/selftests would fail in selftest builds [1] net/ with clang-16: error: no such file or directory: 'kselftest/net/bpf/nat6to4.c' clang-16: error: no input files Add a pattern prerequisite and an order-only-prerequisite (for creating the directory), to resolve the issue. [1] https://lore.kernel.org/all/202212060009.34CkQmCN-lkp@intel.com/ Reported-by: kernel test robot <lkp(a)intel.com> Fixes: 837a3d66d698 ("selftests: net: Add cross-compilation support for BPF programs") Signed-off-by: Björn Töpel <bjorn(a)rivosinc.com> --- tools/testing/selftests/net/bpf/Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/net/bpf/Makefile b/tools/testing/selftests/net/bpf/Makefile index a26cb94354f6..4abaf16d2077 100644 --- a/tools/testing/selftests/net/bpf/Makefile +++ b/tools/testing/selftests/net/bpf/Makefile @@ -12,7 +12,7 @@ CCINCLUDE += -I$(SCRATCH_DIR)/include BPFOBJ := $(BUILD_DIR)/libbpf/libbpf.a -MAKE_DIRS := $(BUILD_DIR)/libbpf +MAKE_DIRS := $(BUILD_DIR)/libbpf $(OUTPUT)/bpf $(MAKE_DIRS): mkdir -p $@ @@ -37,8 +37,8 @@ endif CLANG_SYS_INCLUDES = $(call get_sys_includes,$(CLANG),$(CLANG_TARGET_ARCH)) -$(TEST_CUSTOM_PROGS): $(BPFOBJ) - $(CLANG) -O2 -target bpf -c $(@:.o=.c) $(CCINCLUDE) $(CLANG_SYS_INCLUDES) -o $@ +$(TEST_CUSTOM_PROGS): $(OUTPUT)/%.o: %.c $(BPFOBJ) | $(MAKE_DIRS) + $(CLANG) -O2 -target bpf -c $< $(CCINCLUDE) $(CLANG_SYS_INCLUDES) -o $@ $(BPFOBJ): $(wildcard $(BPFDIR)/*.[ch] $(BPFDIR)/Makefile) \ $(APIDIR)/linux/bpf.h \ base-commit: c9f8d73645b6f76c8d14f49bc860f7143d001cb7 -- 2.37.2

2 years, 5 months

2
1
0 0

[PATCH v2 6/7] KVM: selftests: Allocate ucall pool from MEM_REGION_DATA

by Oliver Upton

MEM_REGION_TEST_DATA is meant to hold data explicitly used by a selftest, not implicit allocations due to the selftests infrastructure. Allocate the ucall pool from MEM_REGION_DATA much like the rest of the selftests library allocations. Reviewed-by: Sean Christopherson <seanjc(a)google.com> Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/lib/ucall_common.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/lib/ucall_common.c b/tools/testing/selftests/kvm/lib/ucall_common.c index 820ce6c82829..0cc0971ce60e 100644 --- a/tools/testing/selftests/kvm/lib/ucall_common.c +++ b/tools/testing/selftests/kvm/lib/ucall_common.c @@ -22,7 +22,7 @@ void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa) vm_vaddr_t vaddr; int i; - vaddr = vm_vaddr_alloc(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR); + vaddr = __vm_vaddr_alloc(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR, MEM_REGION_DATA); hdr = (struct ucall_header *)addr_gva2hva(vm, vaddr); memset(hdr, 0, sizeof(*hdr)); -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 5 months

1
0
0 0

[PATCH v2 5/7] KVM: arm64: selftests: Don't identity map the ucall MMIO hole

by Oliver Upton

Currently the ucall MMIO hole is placed immediately after slot0, which is a relatively safe address in the PA space. However, it is possible that the same address has already been used for something else (like the guest program image) in the VA space. At least in my own testing, building the vgic_irq test with clang leads to the MMIO hole appearing underneath gicv3_ops. Stop identity mapping the MMIO hole and instead find an unused VA to map to it. Yet another subtle detail of the KVM selftests library is that virt_pg_map() does not update vm->vpages_mapped. Switch over to virt_map() instead to guarantee that the chosen VA isn't to something else. Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/lib/aarch64/ucall.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/lib/aarch64/ucall.c b/tools/testing/selftests/kvm/lib/aarch64/ucall.c index 562c16dfbb00..f212bd8ab93d 100644 --- a/tools/testing/selftests/kvm/lib/aarch64/ucall.c +++ b/tools/testing/selftests/kvm/lib/aarch64/ucall.c @@ -14,11 +14,13 @@ static vm_vaddr_t *ucall_exit_mmio_addr; void ucall_arch_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa) { - virt_pg_map(vm, mmio_gpa, mmio_gpa); + vm_vaddr_t mmio_gva = vm_vaddr_unused_gap(vm, vm->page_size, KVM_UTIL_MIN_VADDR); + + virt_map(vm, mmio_gva, mmio_gpa, 1); vm->ucall_mmio_addr = mmio_gpa; - write_guest_global(vm, ucall_exit_mmio_addr, (vm_vaddr_t *)mmio_gpa); + write_guest_global(vm, ucall_exit_mmio_addr, (vm_vaddr_t *)mmio_gva); } void ucall_arch_do_ucall(vm_vaddr_t uc) -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 5 months

1
0
0 0

[PATCH v2 3/7] KVM: selftests: Mark correct page as mapped in virt_map()

by Oliver Upton

The loop marks vaddr as mapped after incrementing it by page size, thereby marking the *next* page as mapped. Set the bit in vpages_mapped first instead. Fixes: 56fc7732031d ("KVM: selftests: Fill in vm->vpages_mapped bitmap in virt_map() too") Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/lib/kvm_util.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index e9607eb089be..a256ec67aff6 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -1411,10 +1411,10 @@ void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, while (npages--) { virt_pg_map(vm, vaddr, paddr); + sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift); + vaddr += page_size; paddr += page_size; - - sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift); } } -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 5 months

1
0
0 0

[PATCH v2 2/7] KVM: selftests: Setup ucall after loading program into guest memory

by Oliver Upton

The new ucall infrastructure needs to update a couple of guest globals to pass through the ucall MMIO addr and pool of ucall structs. A precondition of writing to the guest's program image is to have it already loaded into guest memory. Call ucall_init() after kvm_vm_elf_load(). Continue to park the ucall MMIO addr after MEM_REGION_TEST_DATA. Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/aarch64/page_fault_test.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c index 92d3a91153b6..95d22cfb7b41 100644 --- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c +++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c @@ -609,8 +609,13 @@ static void setup_memslots(struct kvm_vm *vm, struct test_params *p) data_size / guest_page_size, p->test_desc->data_memslot_flags); vm->memslots[MEM_REGION_TEST_DATA] = TEST_DATA_MEMSLOT; +} + +static void setup_ucall(struct kvm_vm *vm) +{ + struct userspace_mem_region *region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); - ucall_init(vm, data_gpa + data_size); + ucall_init(vm, region->region.guest_phys_addr + region->region.memory_size); } static void setup_default_handlers(struct test_desc *test) @@ -702,6 +707,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) vm = ____vm_create(mode); setup_memslots(vm, p); kvm_vm_elf_load(vm, program_invocation_name); + setup_ucall(vm); vcpu = vm_vcpu_add(vm, 0, guest_code); setup_gva_maps(vm); -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 5 months

1
0
0 0

[PATCH v2 1/7] KVM: selftests: Fix build due to ucall_uninit() removal

by Oliver Upton

From: Mark Brown <broonie(a)kernel.org> Today's -next fails to build on arm64 due to: In file included from include/kvm_util.h:11, from aarch64/page_fault_test.c:15: include/ucall_common.h:36:47: note: expected ‘vm_paddr_t’ {aka ‘long unsigned int’} but argument is of type ‘void *’ 36 | void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa); | ~~~~~~~~~~~^~~~~~~~ aarch64/page_fault_test.c:725:2: warning: implicit declaration of function ‘ucall_uninit’; did you mean ‘ucall_init’? [-Wimplicit-function-declaration] 725 | ucall_uninit(vm); | ^~~~~~~~~~~~ | ucall_init which is caused by commit interacting poorly with commit 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") As is done for other ucall_uninit() users remove the call in the newly added page_fault_test.c. Fixes: 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") Fixes: 35c581015712 ("KVM: selftests: aarch64: Add aarch64/page_fault_test") Signed-off-by: Mark Brown <broonie(a)kernel.org> Cc: Sean Christopherson <seanjc(a)google.com> Cc: Ricardo Koller <ricarkol(a)google.com> Cc: Marc Zyngier <maz(a)kernel.org> Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/aarch64/page_fault_test.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c index 0cda70bef5d5..92d3a91153b6 100644 --- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c +++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c @@ -722,7 +722,6 @@ static void run_test(enum vm_guest_mode mode, void *arg) vcpu_run_loop(vm, vcpu, test); - ucall_uninit(vm); kvm_vm_free(vm); free_uffd(test, pt_uffd, data_uffd); -- 2.39.0.rc1.256.g54fd8350bd-goog

2 years, 5 months

1
0
0 0

[PATCH 2/4] KVM: selftests: Setup ucall after loading program into guest memory

by Oliver Upton

The new ucall infrastructure needs to update a couple of guest globals to pass through the ucall MMIO addr and pool of ucall structs. A precondition of this actually working is to have the program image already loaded into guest memory. Call ucall_init() after kvm_vm_elf_load(). Continue to park the ucall MMIO addr after MEM_REGION_TEST_DATA. Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/aarch64/page_fault_test.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c index 92d3a91153b6..95d22cfb7b41 100644 --- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c +++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c @@ -609,8 +609,13 @@ static void setup_memslots(struct kvm_vm *vm, struct test_params *p) data_size / guest_page_size, p->test_desc->data_memslot_flags); vm->memslots[MEM_REGION_TEST_DATA] = TEST_DATA_MEMSLOT; +} + +static void setup_ucall(struct kvm_vm *vm) +{ + struct userspace_mem_region *region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); - ucall_init(vm, data_gpa + data_size); + ucall_init(vm, region->region.guest_phys_addr + region->region.memory_size); } static void setup_default_handlers(struct test_desc *test) @@ -702,6 +707,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) vm = ____vm_create(mode); setup_memslots(vm, p); kvm_vm_elf_load(vm, program_invocation_name); + setup_ucall(vm); vcpu = vm_vcpu_add(vm, 0, guest_code); setup_gva_maps(vm); -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

3
8
0 0

[PATCH] selftests/x86/msr: Add MSR restore test for suspend cycle

by Pawan Gupta

There are certain security related MSRs that must be restored after a suspend cycle. There have been quite a few fixes done to restore these MSRs: commit e2a1256b17b1 ("x86/speculation: Restore speculation related MSRs during S3 resume") commit 50bcceb7724e ("x86/pm: Add enumeration check before spec MSRs save/restore setup") commit 66065157420c ("x86/bugs: Make sure MSR_SPEC_CTRL is updated properly upon resume from S3") commit 2632daebafd0 ("x86/cpu: Restore AMD's DE_CFG MSR after resume") commit 73924ec4d560 ("x86/pm: Save the MSR validity status at context setup") commit f9e14dbbd454 ("x86/cpu: Load microcode during restore_processor_state()") In order to catch regressions early add a selftest that keeps a copy of below MSRs for all CPUs: MSR_IA32_SPEC_CTRL MSR_IA32_TSX_CTRL MSR_TSX_FORCE_ABORT MSR_IA32_MCU_OPT_CTRL MSR_AMD64_LS_CFG MSR_AMD64_DE_CFG The test does a suspend/resume and reports failure if the MSRs are not restored to the value before suspend. Signed-off-by: Pawan Gupta <pawan.kumar.gupta(a)linux.intel.com> --- tools/testing/selftests/x86/Makefile | 2 +- .../selftests/x86/suspend_msr_restore.c | 193 ++++++++++++++++++ 2 files changed, 194 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/x86/suspend_msr_restore.c diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile index 0388c4d60af0..ef8c6cf7d72e 100644 --- a/tools/testing/selftests/x86/Makefile +++ b/tools/testing/selftests/x86/Makefile @@ -13,7 +13,7 @@ CAN_BUILD_WITH_NOPIE := $(shell ./check_cc.sh "$(CC)" trivial_program.c -no-pie) TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt test_mremap_vdso \ check_initial_reg_state sigreturn iopl ioperm \ test_vsyscall mov_ss_trap \ - syscall_arg_fault fsgsbase_restore sigaltstack + syscall_arg_fault fsgsbase_restore sigaltstack suspend_msr_restore TARGETS_C_32BIT_ONLY := entry_from_vm86 test_syscall_vdso unwind_vdso \ test_FCMOV test_FCOMI test_FISTTP \ vdso_restorer diff --git a/tools/testing/selftests/x86/suspend_msr_restore.c b/tools/testing/selftests/x86/suspend_msr_restore.c new file mode 100644 index 000000000000..30285c565597 --- /dev/null +++ b/tools/testing/selftests/x86/suspend_msr_restore.c @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2022 Intel Corporation + * + * This test caches some chosen MSRs, does a suspend cycle and reports failure + * if the MSRs are not restored to the values before suspend. + */ + +#define _GNU_SOURCE + +#include <fcntl.h> +#include <sched.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <errno.h> +#include <sys/stat.h> +#include <sys/timerfd.h> +#include <sys/sysinfo.h> + +#include "../kselftest.h" + +#define MSR_IA32_SPEC_CTRL 0x00000048 +#define MSR_IA32_TSX_CTRL 0x00000122 +#define MSR_TSX_FORCE_ABORT 0x0000010F +#define MSR_IA32_MCU_OPT_CTRL 0x00000123 +#define MSR_AMD64_LS_CFG 0xc0011020 +#define MSR_AMD64_DE_CFG 0xc0011029 + +struct msr_cache { + unsigned int msr_id; + unsigned long long msr_val; + bool valid; +}; + +int suspend(void) +{ + struct itimerspec spec = {}; + int power_state_fd; + int timerfd; + int ret = -1; + + power_state_fd = open("/sys/power/state", O_RDWR); + if (power_state_fd < 0) { + ksft_test_result_error("open(\"/sys/power/state\") failed %s)\n", strerror(errno)); + goto exit; + } + + timerfd = timerfd_create(CLOCK_BOOTTIME_ALARM, 0); + if (timerfd < 0) { + ksft_test_result_error("timerfd_create() failed\n"); + goto cleanup_power_state; + } + + spec.it_value.tv_sec = 15; + ret = timerfd_settime(timerfd, 0, &spec, NULL); + if (ret < 0) { + ksft_test_result_error("timerfd_settime() failed\n"); + goto cleanup_timer; + } + + if (write(power_state_fd, "mem", strlen("mem")) != strlen("mem")) { + ksft_test_result_error("Failed to enter Suspend state\n"); + ret = -1; + goto cleanup_timer; + } + + ret = 0; + +cleanup_timer: + close(timerfd); +cleanup_power_state: + close(power_state_fd); +exit: + return ret; +} + +int msr_read(int cpu, unsigned int msr_id, unsigned long long *msr_val) +{ + char msr_file_name[32]; + int fd, ret; + + snprintf(msr_file_name, 32, "/dev/cpu/%d/msr", cpu); + fd = open(msr_file_name, O_RDONLY); + + if (fd == -1) { + perror("Failed to open"); + return -ENODEV; + } + + ret = pread(fd, msr_val, sizeof(long long), msr_id); + close(fd); + + return ret != sizeof(long long); +} + +int main(void) +{ + /* List of MSRs to tests */ + unsigned int msr_id[] = { + MSR_IA32_SPEC_CTRL, + MSR_IA32_TSX_CTRL, + MSR_TSX_FORCE_ABORT, + MSR_IA32_MCU_OPT_CTRL, + MSR_AMD64_LS_CFG, + MSR_AMD64_DE_CFG, + }; + int i, cpu, err, max_cpus, msr_idx, total_tests = 0; + int num_msrs = ARRAY_SIZE(msr_id); + unsigned long long msr_val; + cpu_set_t available_cpus; + struct msr_cache *msrs; + bool succeeded = true; + + if (getuid() != 0) + ksft_exit_skip("Please re-run the test as root\n"); + + if (access("/dev/cpu/0/msr", R_OK)) + ksft_exit_skip("Can't read MSRs\n"); + + if (access("/sys/power/state", W_OK)) + ksft_exit_skip("/sys/power/state not writable\n"); + + ksft_print_header(); + + err = sched_getaffinity(0, sizeof(available_cpus), &available_cpus); + if (err < 0) + ksft_exit_fail_msg("sched_getaffinity() failed\n"); + + max_cpus = get_nprocs_conf(); + + msrs = calloc(sizeof(struct msr_cache), max_cpus * num_msrs); + if (!msrs) + ksft_exit_fail_msg("Memory allocation failed\n"); + + for (cpu = 0; cpu < max_cpus; cpu++) { + if (!CPU_ISSET(cpu, &available_cpus)) + continue; + msr_idx = cpu * num_msrs; + for (i = 0; i < num_msrs; i++, msr_idx++) { + if (!msr_read(cpu, msr_id[i], &msr_val)) { + msrs[msr_idx].valid = true; + msrs[msr_idx].msr_id = msr_id[i]; + msrs[msr_idx].msr_val = msr_val; + total_tests++; + } + } + } + + ksft_set_plan(total_tests); + + if (suspend()) { + succeeded = false; + goto cleanup; + } + + for (cpu = 0; cpu < max_cpus; cpu++) { + if (!CPU_ISSET(cpu, &available_cpus)) + continue; + + msr_idx = cpu * num_msrs; + for (i = 0; i < num_msrs; i++, msr_idx++) { + if (!msrs[msr_idx].valid) + continue; + if (msr_read(cpu, msr_id[i], &msr_val)) { + ksft_test_result_fail("Not able to read msr=0x%x on CPU=%d\n", + msr_id[i], cpu); + succeeded = false; + continue; + } + if (msrs[msr_idx].msr_val != msr_val) { + ksft_test_result_fail("CPU%d: msr=0x%x value after resume=[0x%llx] != suspend=[0x%llx]\n", + cpu, msr_id[i], msr_val, msrs[msr_idx].msr_val); + succeeded = false; + continue; + } + + ksft_test_result_pass("CPU%d: MSR[0x%x] restored to 0x%llx\n", + cpu, msr_id[i], msr_val); + } + } + +cleanup: + free(msrs); + + if (succeeded) + ksft_exit_pass(); + else + ksft_exit_fail(); +} -- 2.37.3

2 years, 5 months

1
0
0 0

[V1 PATCH 0/6] selftests: KVM: selftests for fd-based private memory

by Vishal Annapurve

This series implements selftests targeting the feature floated by Chao via: https://lore.kernel.org/linux-mm/20221109041358.GA118963@chaop.bj.intel.com… Below changes aim to test the fd based approach for guest private memory in context of normal (non-confidential) VMs executing on non-confidential platforms. private_mem_test.c file adds selftest to access private memory from the guest via private/shared accesses and checking if the contents can be leaked to/accessed by vmm via shared memory view before/after conversions. Updates in V1 (Compared to RFC v3 patches): 1) Incorporated suggestions from Sean around simplifying KVM changes 2) Addressed comments from Sean 3) Added private mem test with shared memory backed by 2MB hugepages. RFC v3 series: https://lore.kernel.org/lkml/20220819174659.2427983-1-vannapurve@google.com… This series has dependency on following patches: 1) V9 series patches from Chao mentioned above. Github link for the patches posted as part of this series: https://github.com/vishals4gh/linux/commits/priv_memfd_selftests-v1 Vishal Annapurve (6): KVM: x86: Add support for testing private memory KVM: Selftests: Add support for private memory KVM: selftests: x86: Add IS_ALIGNED/IS_PAGE_ALIGNED helpers KVM: selftests: x86: Execute VMs with private memory KVM: selftests: Add get_free_huge_2m_pages KVM: selftests: x86: Add selftest for private memory arch/x86/kvm/mmu/mmu.c | 4 + arch/x86/kvm/mmu/mmu_internal.h | 4 +- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 2 + .../selftests/kvm/include/kvm_util_base.h | 15 +- .../testing/selftests/kvm/include/test_util.h | 5 + .../kvm/include/x86_64/private_mem.h | 37 +++ .../selftests/kvm/include/x86_64/processor.h | 1 + tools/testing/selftests/kvm/lib/kvm_util.c | 58 ++++- tools/testing/selftests/kvm/lib/test_util.c | 30 +++ .../selftests/kvm/lib/x86_64/private_mem.c | 211 ++++++++++++++++++ .../selftests/kvm/x86_64/private_mem_test.c | 190 ++++++++++++++++ virt/kvm/Kconfig | 4 + virt/kvm/kvm_main.c | 2 +- 14 files changed, 555 insertions(+), 9 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/x86_64/private_mem.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/private_mem.c create mode 100644 tools/testing/selftests/kvm/x86_64/private_mem_test.c -- 2.38.1.431.g37b22c650d-goog

2 years, 5 months

6
15
0 0

[PATCH 3/4] KVM: arm64: selftests: Align VA space allocator with TTBR0

by Oliver Upton

An interesting feature of the Arm architecture is that the stage-1 MMU supports two distinct VA regions, controlled by TTBR{0,1}_EL1. As KVM selftests on arm64 only uses TTBR0_EL1, the VA space is constrained to [0, 2^(va_bits-1)). This is different from other architectures that allow for addressing low and high regions of the VA space from a single page table. KVM selftests' VA space allocator presumes the valid address range is split between low and high memory based the MSB, which of course is a poor match for arm64's TTBR0 region. Allow architectures to override the default VA space layout. Make use of the override to align vpages_valid with the behavior of TTBR0 on arm64. Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- .../testing/selftests/kvm/include/kvm_util_base.h | 1 + .../testing/selftests/kvm/lib/aarch64/processor.c | 10 ++++++++++ tools/testing/selftests/kvm/lib/kvm_util.c | 15 ++++++++++----- 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index 6cd86da698b3..fbc2a79369b8 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -420,6 +420,7 @@ void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags); void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa); void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot); struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id); +void vm_populate_vaddr_bitmap(struct kvm_vm *vm); vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min, diff --git a/tools/testing/selftests/kvm/lib/aarch64/processor.c b/tools/testing/selftests/kvm/lib/aarch64/processor.c index 316de70db91d..5972a23b2765 100644 --- a/tools/testing/selftests/kvm/lib/aarch64/processor.c +++ b/tools/testing/selftests/kvm/lib/aarch64/processor.c @@ -541,3 +541,13 @@ void kvm_selftest_arch_init(void) */ guest_modes_append_default(); } + +void vm_vaddr_populate_bitmap(struct kvm_vm *vm) +{ + /* + * arm64 selftests use only TTBR0_EL1, meaning that the valid VA space + * is [0, 2^(64 - TCR_EL1.T0SZ)). + */ + sparsebit_set_num(vm->vpages_valid, 0, + (1ULL << vm->va_bits) >> vm->page_shift); +} diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index e9607eb089be..c88c3ace16d2 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -186,6 +186,15 @@ const struct vm_guest_mode_params vm_guest_mode_params[] = { _Static_assert(sizeof(vm_guest_mode_params)/sizeof(struct vm_guest_mode_params) == NUM_VM_MODES, "Missing new mode params?"); +__weak void vm_vaddr_populate_bitmap(struct kvm_vm *vm) +{ + sparsebit_set_num(vm->vpages_valid, + 0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift); + sparsebit_set_num(vm->vpages_valid, + (~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift, + (1ULL << (vm->va_bits - 1)) >> vm->page_shift); +} + struct kvm_vm *____vm_create(enum vm_guest_mode mode) { struct kvm_vm *vm; @@ -274,11 +283,7 @@ struct kvm_vm *____vm_create(enum vm_guest_mode mode) /* Limit to VA-bit canonical virtual addresses. */ vm->vpages_valid = sparsebit_alloc(); - sparsebit_set_num(vm->vpages_valid, - 0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift); - sparsebit_set_num(vm->vpages_valid, - (~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift, - (1ULL << (vm->va_bits - 1)) >> vm->page_shift); + vm_vaddr_populate_bitmap(vm); /* Limit physical addresses to PA-bits. */ vm->max_gfn = vm_compute_max_gfn(vm); -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

3
4
0 0

[PATCH] selftest: Fix spelling mistake "eith" -> "with"

by Colin Ian King

There is a spelling mistake in a ksft_test_result_fail message. Fix it. Signed-off-by: Colin Ian King <colin.i.king(a)gmail.com> --- tools/testing/selftests/capabilities/test_execve.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/capabilities/test_execve.c b/tools/testing/selftests/capabilities/test_execve.c index df0ef02b4036..5cc2481507a6 100644 --- a/tools/testing/selftests/capabilities/test_execve.c +++ b/tools/testing/selftests/capabilities/test_execve.c @@ -288,7 +288,7 @@ static int do_tests(int uid, const char *our_path) "PR_CAP_AMBIENT_RAISE isn't supported\n"); else ksft_test_result_fail( - "PR_CAP_AMBIENT_RAISE should have failed eith EPERM on a non-inheritable cap\n"); + "PR_CAP_AMBIENT_RAISE should have failed with EPERM on a non-inheritable cap\n"); return 1; } ksft_test_result_pass( -- 2.38.1

2 years, 5 months

1
0
0 0

[PATCH -next 0/2] Add setup/cleanup for run.sh

by Zhao Gongyi

1. Add saving and restore of scaling_governor for cpus 2. Remove the tmp files before the test exit Zhao Gongyi (2): selftests/intel_pstate: Add saving and restore of scaling_governor selftests/intel_pstate: do cleanup at exit tools/testing/selftests/intel_pstate/run.sh | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) -- 2.17.1

2 years, 5 months

1
2
0 0

[PATCH] selftests/powerpc: Fix resource leaks

by Miaoqian Lin

In check_all_cpu_dscr_defaults, opendir() opens the directory stream. Add missing closedir() in the error path to release it. In check_cpu_dscr_default, open() creates an open file descriptor. Add missing close() in the error path to release it. Fixes: ebd5858c904b ("selftests/powerpc: Add test for all DSCR sysfs interfaces") Signed-off-by: Miaoqian Lin <linmq006(a)gmail.com> --- tools/testing/selftests/powerpc/dscr/dscr_sysfs_test.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/powerpc/dscr/dscr_sysfs_test.c b/tools/testing/selftests/powerpc/dscr/dscr_sysfs_test.c index fbbdffdb2e5d..f20d1c166d1e 100644 --- a/tools/testing/selftests/powerpc/dscr/dscr_sysfs_test.c +++ b/tools/testing/selftests/powerpc/dscr/dscr_sysfs_test.c @@ -24,6 +24,7 @@ static int check_cpu_dscr_default(char *file, unsigned long val) rc = read(fd, buf, sizeof(buf)); if (rc == -1) { perror("read() failed"); + close(fd); return 1; } close(fd); @@ -65,8 +66,10 @@ static int check_all_cpu_dscr_defaults(unsigned long val) if (access(file, F_OK)) continue; - if (check_cpu_dscr_default(file, val)) + if (check_cpu_dscr_default(file, val)) { + closedir(sysfs); return 1; + } } closedir(sysfs); return 0; -- 2.25.1

2 years, 5 months

2
1
0 0

[PATCH] selftests: powerpc: Use "grep -E" instead of "egrep"

by Tiezhu Yang

The latest version of grep claims the egrep is now obsolete so the build now contains warnings that look like: egrep: warning: egrep is obsolescent; using grep -E fix this using "grep -E" instead. sed -i "s/egrep/grep -E/g" `grep egrep -rwl tools/testing/selftests/powerpc` Here are the steps to install the latest grep: wget http://ftp.gnu.org/gnu/grep/grep-3.8.tar.gz tar xf grep-3.8.tar.gz cd grep-3.8 && ./configure && make sudo make install export PATH=/usr/local/bin:$PATH Signed-off-by: Tiezhu Yang <yangtiezhu(a)loongson.cn> --- As Shuah suggested, this patch should go through powerpc/linux.git tools/testing/selftests/powerpc/scripts/hmi.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/powerpc/scripts/hmi.sh b/tools/testing/selftests/powerpc/scripts/hmi.sh index dcdb392..bcc7b6b 100755 --- a/tools/testing/selftests/powerpc/scripts/hmi.sh +++ b/tools/testing/selftests/powerpc/scripts/hmi.sh @@ -36,7 +36,7 @@ trap "ppc64_cpu --smt-snooze-delay=100" 0 1 # for each chip+core combination # todo - less fragile parsing -egrep -o 'OCC: Chip [0-9a-f]+ Core [0-9a-f]' < /sys/firmware/opal/msglog | +grep -E -o 'OCC: Chip [0-9a-f]+ Core [0-9a-f]' < /sys/firmware/opal/msglog | while read chipcore; do chip=$(echo "$chipcore"|awk '{print $3}') core=$(echo "$chipcore"|awk '{print $5}') -- 2.1.0

2 years, 5 months

2
1
0 0

[PATCH] selftests/tpm2: Split async tests call to separate shell script runner

by Nícolas F. R. A. Prado

When the async test case was introduced, despite being a completely independent test case, the command to run it was added to the same shell script as the smoke test case. Since a shell script implicitly returns the error code from the last run command, this effectively caused the script to only return as error code the result from the async test case, hiding the smoke test result (which could then only be seen from the python unittest logs). Move the async test case call to its own shell script runner to avoid the aforementioned issue. This also makes the output clearer to read, since each kselftest KTAP result now matches with one python unittest report. While at it, also make it so the async test case is skipped if /dev/tpmrm0 doesn't exist, since commit 8335adb8f9d3 ("selftests: tpm: add async space test with noneexisting handle") added a test that relies on it. Signed-off-by: Nícolas F. R. A. Prado <nfraprado(a)collabora.com> --- tools/testing/selftests/tpm2/Makefile | 2 +- tools/testing/selftests/tpm2/test_async.sh | 10 ++++++++++ tools/testing/selftests/tpm2/test_smoke.sh | 1 - 3 files changed, 11 insertions(+), 2 deletions(-) create mode 100755 tools/testing/selftests/tpm2/test_async.sh diff --git a/tools/testing/selftests/tpm2/Makefile b/tools/testing/selftests/tpm2/Makefile index 1a5db1eb8ed5..a9bf9459fb25 100644 --- a/tools/testing/selftests/tpm2/Makefile +++ b/tools/testing/selftests/tpm2/Makefile @@ -1,5 +1,5 @@ # SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) include ../lib.mk -TEST_PROGS := test_smoke.sh test_space.sh +TEST_PROGS := test_smoke.sh test_space.sh test_async.sh TEST_PROGS_EXTENDED := tpm2.py tpm2_tests.py diff --git a/tools/testing/selftests/tpm2/test_async.sh b/tools/testing/selftests/tpm2/test_async.sh new file mode 100755 index 000000000000..43bf5bd772fd --- /dev/null +++ b/tools/testing/selftests/tpm2/test_async.sh @@ -0,0 +1,10 @@ +#!/bin/sh +# SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) + +# Kselftest framework requirement - SKIP code is 4. +ksft_skip=4 + +[ -e /dev/tpm0 ] || exit $ksft_skip +[ -e /dev/tpmrm0 ] || exit $ksft_skip + +python3 -m unittest -v tpm2_tests.AsyncTest diff --git a/tools/testing/selftests/tpm2/test_smoke.sh b/tools/testing/selftests/tpm2/test_smoke.sh index 3e5ff29ee1dd..58af963e5b55 100755 --- a/tools/testing/selftests/tpm2/test_smoke.sh +++ b/tools/testing/selftests/tpm2/test_smoke.sh @@ -7,4 +7,3 @@ ksft_skip=4 [ -e /dev/tpm0 ] || exit $ksft_skip python3 -m unittest -v tpm2_tests.SmokeTest -python3 -m unittest -v tpm2_tests.AsyncTest -- 2.38.1

2 years, 5 months

3
2
0 0

fw_fallback.sh test failed in Debian 11

by Zhou, Jie2X

hi, fw_fallback.sh test failed. The error may caused by failed to write /sys/devices/virtual/misc/test_firmware/trigger_request. diff firmware/fw_fallback.sh_org firmware/fw_fallback.sh 165c164,165 < echo -n "nope-$NAME" >"$DIR"/trigger_request 2>/dev/null & --- > echo "echo -n \"nope-$NAME\" >\"$DIR\"/trigger_request &" > echo -n "nope-$NAME" >"$DIR"/trigger_request & # Test request_partial_firmware_into_buf() off=1 size=6 nofile: OK # Test request_partial_firmware_into_buf() off=2 size=10 nofile: OK # echo -n "nope-test-firmware.bin" >"/sys/devices/virtual/misc/test_firmware"/trigger_request & # ./fw_fallback.sh: line 165: echo: write error: No such file or directory # ./fw_fallback.sh: fallback mechanism immediately cancelled $ echo -n "nope-test-firmware.bin" >/sys/devices/virtual/misc/test_firmware/trigger_request -bash: echo: write error: No such file or directory test OS: Debian 11 test kernel: v6.1-rc6 test output: # ./fw_fallback.sh: fallback mechanism immediately cancelled # # The file never appeared: /sys/devices/virtual/misc/test_firmware/nope-test-firmware.bin/loading # # This might be a distribution udev rule setup by your distribution # to immediately cancel all fallback requests, this must be # removed before running these tests. To confirm look for # a firmware rule like /lib/udev/rules.d/50-firmware.rules # and see if you have something like this: # # SUBSYSTEM=="firmware", ACTION=="add", ATTR{loading}="-1" # # If you do remove this file or comment out this line before # proceeding with these tests. not ok 1 selftests: firmware: fw_run_tests.sh # exit=1 There is not /lib/udev/rules.d/50-firmware.rules in Debian 11. How can fw_run_tests.sh run successfully in Debian 11? best regards,

2 years, 5 months

4
10
0 0

[PATCH v14 00/39] arm64/sme: Initial support for the Scalable Matrix Extension

by Mark Brown

This series provides initial support for the ARMv9 Scalable Matrix Extension (SME). SME takes the approach used for vectors in SVE and extends this to provide architectural support for matrix operations. A more detailed overview can be found in [1]. For the kernel SME can be thought of as a series of features which are intended to be used together by applications but operate mostly orthogonally: - The ZA matrix register. - Streaming mode, in which ZA can be accessed and a subset of SVE features are available. - A second vector length, used for streaming mode SVE and ZA and controlled using a similar interface to that for SVE. - TPIDR2, a new userspace controllable system register intended for use by the C library for storing context related to the ZA ABI. A substantial part of the series is dedicated to refactoring the existing SVE support so that we don't need to duplicate code for handling vector lengths and the SVE registers, this involves creating an array of vector types and making the users take the vector type as a parameter. I'm not 100% happy with this but wasn't able to come up with anything better, duplicating code definitely felt like a bad idea so this felt like the least bad thing. If this approach makes sense to people it might make sense to split this off into a separate series and/or merge it while the rest is pending review to try to make things a little more digestable, the series is very large so it'd probably make things easier to digest if some of the preparatory refactoring could be merged before the rest is ready. One feature of the architecture of particular note is that switching to and from streaming mode may change the size of and invalidate the contents of the SVE registers, and when in streaming mode the FFR is not accessible. This complicates aspects of the ABI like signal handling and ptrace. This initial implementation is mainly intended to get the ABI in place, there are several areas which will be worked on going forwards - some of these will be blockers, others could be handled in followup serieses: - SME is currently not supported for KVM guests, this will be done as a followup series. A host system can use SME and run KVM guests but SME is not available in the guests. - The KVM host support is done in a very simplistic way, were anyone to attempt to use it in production there would be performance impacts on hosts with SME support. As part of this we also add enumeration of fine grained traps. - There is not currently ptrace or signal support TPIDR2, this will be done as a followup series. - No support is currently provided for scheduler control of SME or SME applications, given the size of the SME register state the context switch overhead may be noticable so this may be needed especially for real time applications. Similar concerns already exist for larger SVE vector lengths but are amplified for SME, particularly as the vector length increases. - There has been no work on optimising the performance of anything the kernel does. It is not expected that any systems will be encountered that support SME but not SVE, SME is an ARMv9 feature and SVE is mandatory for ARMv9. The code attempts to handle any such systems that are encountered but this hasn't been tested extensively. v14: - Rebase onto v5.18-rc3. v13: - Preserve ZA in both parent and child on clone() and add a test case for this. - Fix EFI integration for FA64. - Minor tweaks to the ABI document following Catlain's review. - Add and make use of thread_get_cur_vl() helper. - Fix some issues with SVE/FPSIMD register type moves in streaming SVE ptrace. - Typo fixes. - Roll in separately posted series extending ptrace coverage in kselftest for better integrated testing of the series. v12: - Fix some typos in the ABI document. - Print a message when we skip a vector length in the signal tests. - Add note of earliest toolchain versions with SME to manual encodings for future reference now that's landed. - Drop reference to PCS in sme.rst, it's not referenced and one of the links was broken. - Encode smstop and smstart as sysregs in the kernel. - Don't redundantly flush the SVE register state when loading FPSIMD state with SME enabled for the task, the architecture will do this for us. - Introduce and use task_get_cur_vl() to get the vector length for the currently active SVE registers. - Fix support for !FA64 mode in signal and syscall tests. - Simplify instruction sequence for ssve_regs signal test. - Actually include the ZA signal test in the patch set. v11: - Rebase onto v5.17-rc3. - Provide a sme-inst.h to collect manual encodings in kselftest. v10: - Actually do the rebase of fixups from the previous version into relevant patches. v9: - Remove defensive programming around IS_ENABLED() and FGT in KVM code. - Fix naming of TPIDR2 FGT register bit. - Add patches making handling of floating point register bits more consistent (also sent as separate series). - Drop now unused enumeration of fine grained traps. v8: - Rebase onto v5.17-rc1. - Support interoperation with KVM, SME is disabled for KVM guests with minimal handling for cleaning up SME state when entering and leaving the guest. - Document and implement that signal handlers are invoked with ZA and streaming mode disabled. - Use the RDSVL instruction introduced in EAC2 of the architecture to obtain the streaming mode vector length during enumeration, ZA state loading/saving and in test programs. - Store a pointer to SVCR in fpsimd_last_state and use it in fpsimd_save() for interoperation with KVM. - Add a test case sme_trap_no_sm checking that we generate a SIGILL when using an instruction that requires streaming mode without enabling it. - Add basic ZA context form validation to testcases helper library. - Move signal tests over to validating streaming VL from ZA information. - Pulled in patch removing ARRAY_SIZE() so that kselftest builds cleanly and to avoid trivial conflicts. v7: - Rebase onto v5.16-rc3. - Reduce indentation when supporting custom triggers for signal tests as suggested by Catalin. - Change to specifying a width for all CPU features rather than adding single bit specific infrastructure. - Don't require zeroing of non-shared SVE state during syscalls. v6: - Rebase onto v5.16-rc1. - Return to disabling TIF_SVE on kernel entry even if we have SME state, this avoids the need for KVM to handle the case where TIF_SVE is set on guest entry. - Add syscall-abi.h to SME updates to syscall-abi, mistakenly omitted from commit. v5: - Rebase onto currently merged SVE and kselftest patches. - Add support for the FA64 option, introduced in the recently published EAC1 update to the specification. - Pull in test program for the syscall ABI previously sent separately with some revisions and add coverage for the SME ABI. - Fix checking for options with 1 bit fields in ID_AA64SMFR0_EL1. - Minor fixes and clarifications to the ABI documentation. v4: - Rebase onto merged patches. - Remove an uneeded NULL check in vec_proc_do_default_vl(). - Include patch to factor out utility routines in kselftests written in assembler. - Specify -ffreestanding when building TPIDR2 test. v3: - Skip FFR rather than predicate registers in sve_flush_live(). - Don't assume a bool is all zeros in sve_flush_live() as per AAPCS. - Don't redundantly specify a zero index when clearing FFR. v2: - Fix several issues with !SME and !SVE configurations. - Preserve TPIDR2 when creating a new thread/process unless CLONE_SETTLS is set. - Report traps due to using features in an invalid mode as SIGILL. - Spell out streaming mode behaviour in SVE ABI documentation more directly. - Document TPIDR2 in the ABI document. - Use SMSTART and SMSTOP rather than read/modify/write sequences. - Rework logic for exiting streaming mode on syscall. - Don't needlessly initialise SVCR on access trap. - Always restore SME VL for userspace if SME traps are disabled. - Only yield to encourage preemption every 128 iterations in za-test, otherwise do a getpid(), and validate SVCR after syscall. - Leave streaming mode disabled except when reading the vector length in za-test, and disable ZA after detecting a mismatch. - Add SME support to vlset. - Clarifications and typo fixes in comments. - Move sme_alloc() forward declaration back a patch. [1] https://community.arm.com/developer/ip-products/processors/b/processors-ip-… Mark Brown (39): kselftest/arm64: Fix comment for ptrace_sve_get_fpsimd_data() kselftest/arm64: Remove assumption that tasks start FPSIMD only kselftest/arm64: Validate setting via FPSIMD and read via SVE regsets arm64/sme: Provide ABI documentation for SME arm64/sme: System register and exception syndrome definitions arm64/sme: Manually encode SME instructions arm64/sme: Early CPU setup for SME arm64/sme: Basic enumeration support arm64/sme: Identify supported SME vector lengths at boot arm64/sme: Implement sysctl to set the default vector length arm64/sme: Implement vector length configuration prctl()s arm64/sme: Implement support for TPIDR2 arm64/sme: Implement SVCR context switching arm64/sme: Implement streaming SVE context switching arm64/sme: Implement ZA context switching arm64/sme: Implement traps and syscall handling for SME arm64/sme: Disable ZA and streaming mode when handling signals arm64/sme: Implement streaming SVE signal handling arm64/sme: Implement ZA signal handling arm64/sme: Implement ptrace support for streaming mode SVE registers arm64/sme: Add ptrace support for ZA arm64/sme: Disable streaming mode and ZA when flushing CPU state arm64/sme: Save and restore streaming mode over EFI runtime calls KVM: arm64: Hide SME system registers from guests KVM: arm64: Trap SME usage in guest KVM: arm64: Handle SME host state when running guests arm64/sme: Provide Kconfig for SME kselftest/arm64: Add manual encodings for SME instructions kselftest/arm64: sme: Add SME support to vlset kselftest/arm64: Add tests for TPIDR2 kselftest/arm64: Extend vector configuration API tests to cover SME kselftest/arm64: sme: Provide streaming mode SVE stress test kselftest/arm64: signal: Handle ZA signal context in core code kselftest/arm64: Add stress test for SME ZA context switching kselftest/arm64: signal: Add SME signal handling tests kselftest/arm64: Add streaming SVE to SVE ptrace tests kselftest/arm64: Add coverage for the ZA ptrace interface kselftest/arm64: Add SME support to syscall ABI test selftests/arm64: Add a testcase for handling of ZA on clone() Documentation/arm64/elf_hwcaps.rst | 33 + Documentation/arm64/index.rst | 1 + Documentation/arm64/sme.rst | 428 +++++++++++++ Documentation/arm64/sve.rst | 70 ++- arch/arm64/Kconfig | 11 + arch/arm64/include/asm/cpu.h | 4 + arch/arm64/include/asm/cpufeature.h | 24 + arch/arm64/include/asm/el2_setup.h | 64 +- arch/arm64/include/asm/esr.h | 13 +- arch/arm64/include/asm/exception.h | 1 + arch/arm64/include/asm/fpsimd.h | 123 +++- arch/arm64/include/asm/fpsimdmacros.h | 87 +++ arch/arm64/include/asm/hwcap.h | 8 + arch/arm64/include/asm/kvm_arm.h | 1 + arch/arm64/include/asm/kvm_host.h | 4 + arch/arm64/include/asm/processor.h | 26 +- arch/arm64/include/asm/sysreg.h | 67 ++ arch/arm64/include/asm/thread_info.h | 2 + arch/arm64/include/uapi/asm/hwcap.h | 8 + arch/arm64/include/uapi/asm/ptrace.h | 69 ++- arch/arm64/include/uapi/asm/sigcontext.h | 55 +- arch/arm64/kernel/cpufeature.c | 106 ++++ arch/arm64/kernel/cpuinfo.c | 13 + arch/arm64/kernel/entry-common.c | 11 + arch/arm64/kernel/entry-fpsimd.S | 36 ++ arch/arm64/kernel/fpsimd.c | 585 ++++++++++++++++-- arch/arm64/kernel/process.c | 44 +- arch/arm64/kernel/ptrace.c | 358 +++++++++-- arch/arm64/kernel/signal.c | 188 +++++- arch/arm64/kernel/syscall.c | 29 +- arch/arm64/kernel/traps.c | 1 + arch/arm64/kvm/fpsimd.c | 43 +- arch/arm64/kvm/hyp/nvhe/switch.c | 30 + arch/arm64/kvm/hyp/vhe/switch.c | 11 +- arch/arm64/kvm/sys_regs.c | 9 +- arch/arm64/tools/cpucaps | 2 + include/uapi/linux/elf.h | 2 + include/uapi/linux/prctl.h | 9 + kernel/sys.c | 12 + tools/testing/selftests/arm64/abi/.gitignore | 1 + tools/testing/selftests/arm64/abi/Makefile | 9 +- .../selftests/arm64/abi/syscall-abi-asm.S | 79 ++- .../testing/selftests/arm64/abi/syscall-abi.c | 204 +++++- .../testing/selftests/arm64/abi/syscall-abi.h | 15 + tools/testing/selftests/arm64/abi/tpidr2.c | 298 +++++++++ tools/testing/selftests/arm64/fp/.gitignore | 5 + tools/testing/selftests/arm64/fp/Makefile | 19 +- tools/testing/selftests/arm64/fp/rdvl-sme.c | 14 + tools/testing/selftests/arm64/fp/rdvl.S | 10 + tools/testing/selftests/arm64/fp/rdvl.h | 1 + tools/testing/selftests/arm64/fp/sme-inst.h | 51 ++ tools/testing/selftests/arm64/fp/ssve-stress | 59 ++ tools/testing/selftests/arm64/fp/sve-ptrace.c | 175 +++++- tools/testing/selftests/arm64/fp/sve-test.S | 20 + tools/testing/selftests/arm64/fp/vec-syscfg.c | 10 + tools/testing/selftests/arm64/fp/vlset.c | 10 +- .../testing/selftests/arm64/fp/za-fork-asm.S | 61 ++ tools/testing/selftests/arm64/fp/za-fork.c | 156 +++++ tools/testing/selftests/arm64/fp/za-ptrace.c | 356 +++++++++++ tools/testing/selftests/arm64/fp/za-stress | 59 ++ tools/testing/selftests/arm64/fp/za-test.S | 388 ++++++++++++ .../testing/selftests/arm64/signal/.gitignore | 3 + .../selftests/arm64/signal/test_signals.h | 4 + .../arm64/signal/test_signals_utils.c | 6 + .../testcases/fake_sigreturn_sme_change_vl.c | 92 +++ .../arm64/signal/testcases/sme_trap_no_sm.c | 38 ++ .../signal/testcases/sme_trap_non_streaming.c | 45 ++ .../arm64/signal/testcases/sme_trap_za.c | 36 ++ .../selftests/arm64/signal/testcases/sme_vl.c | 68 ++ .../arm64/signal/testcases/ssve_regs.c | 135 ++++ .../arm64/signal/testcases/testcases.c | 36 ++ .../arm64/signal/testcases/testcases.h | 3 +- .../arm64/signal/testcases/za_regs.c | 128 ++++ 73 files changed, 4991 insertions(+), 191 deletions(-) create mode 100644 Documentation/arm64/sme.rst create mode 100644 tools/testing/selftests/arm64/abi/syscall-abi.h create mode 100644 tools/testing/selftests/arm64/abi/tpidr2.c create mode 100644 tools/testing/selftests/arm64/fp/rdvl-sme.c create mode 100644 tools/testing/selftests/arm64/fp/sme-inst.h create mode 100644 tools/testing/selftests/arm64/fp/ssve-stress create mode 100644 tools/testing/selftests/arm64/fp/za-fork-asm.S create mode 100644 tools/testing/selftests/arm64/fp/za-fork.c create mode 100644 tools/testing/selftests/arm64/fp/za-ptrace.c create mode 100644 tools/testing/selftests/arm64/fp/za-stress create mode 100644 tools/testing/selftests/arm64/fp/za-test.S create mode 100644 tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_sme_change_vl.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/sme_trap_no_sm.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/sme_trap_non_streaming.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/sme_trap_za.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/sme_vl.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/ssve_regs.c create mode 100644 tools/testing/selftests/arm64/signal/testcases/za_regs.c base-commit: b2d229d4ddb17db541098b83524d901257e93845 -- 2.30.2

2 years, 5 months

8
58
0 0

[PATCH 4/4] KVM: selftests: Allocate ucall pool from MEM_REGION_DATA

by Oliver Upton

MEM_REGION_TEST_DATA is meant to hold data explicitly used by a selftest, not implicit allocations due to the selftests infrastructure. Allocate the ucall pool from MEM_REGION_DATA much like the rest of the selftests library allocations. Fixes: 426729b2cf2e ("KVM: selftests: Add ucall pool based implementation") Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/lib/ucall_common.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/lib/ucall_common.c b/tools/testing/selftests/kvm/lib/ucall_common.c index 820ce6c82829..0cc0971ce60e 100644 --- a/tools/testing/selftests/kvm/lib/ucall_common.c +++ b/tools/testing/selftests/kvm/lib/ucall_common.c @@ -22,7 +22,7 @@ void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa) vm_vaddr_t vaddr; int i; - vaddr = vm_vaddr_alloc(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR); + vaddr = __vm_vaddr_alloc(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR, MEM_REGION_DATA); hdr = (struct ucall_header *)addr_gva2hva(vm, vaddr); memset(hdr, 0, sizeof(*hdr)); -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

2
2
0 0

[PATCH 1/4] KVM: selftests: Fix build due to ucall_uninit() removal

by Oliver Upton

From: Mark Brown <broonie(a)kernel.org> Today's -next fails to build on arm64 due to: In file included from include/kvm_util.h:11, from aarch64/page_fault_test.c:15: include/ucall_common.h:36:47: note: expected ‘vm_paddr_t’ {aka ‘long unsigned int’} but argument is of type ‘void *’ 36 | void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa); | ~~~~~~~~~~~^~~~~~~~ aarch64/page_fault_test.c:725:2: warning: implicit declaration of function ‘ucall_uninit’; did you mean ‘ucall_init’? [-Wimplicit-function-declaration] 725 | ucall_uninit(vm); | ^~~~~~~~~~~~ | ucall_init which is caused by commit interacting poorly with commit 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") As is done for other ucall_uninit() users remove the call in the newly added page_fault_test.c. Fixes: 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") Fixes: 35c581015712 ("KVM: selftests: aarch64: Add aarch64/page_fault_test") Signed-off-by: Mark Brown <broonie(a)kernel.org> Cc: Sean Christopherson <seanjc(a)google.com> Cc: Ricardo Koller <ricarkol(a)google.com> Cc: Marc Zyngier <maz(a)kernel.org> Signed-off-by: Oliver Upton <oliver.upton(a)linux.dev> --- tools/testing/selftests/kvm/aarch64/page_fault_test.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c index 0cda70bef5d5..92d3a91153b6 100644 --- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c +++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c @@ -722,7 +722,6 @@ static void run_test(enum vm_guest_mode mode, void *arg) vcpu_run_loop(vm, vcpu, test); - ucall_uninit(vm); kvm_vm_free(vm); free_uffd(test, pt_uffd, data_uffd); -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

1
0
0 0

[PATCH] kunit: tool: make parser preserve whitespace when printing test log

by Daniel Latypov

Currently, kunit_parser.py is stripping all leading whitespace to make parsing easier. But this means we can't accurately show kernel output for failing tests or when the kernel crashes. Embarassingly, this affects even KUnit's own output, e.g. [13:40:46] Expected 2 + 1 == 2, but [13:40:46] 2 + 1 == 3 (0x3) [13:40:46] not ok 1 example_simple_test [13:40:46] [FAILED] example_simple_test After this change, here's what the output in context would look like [13:40:46] =================== example (4 subtests) =================== [13:40:46] # example_simple_test: initializing [13:40:46] # example_simple_test: EXPECTATION FAILED at lib/kunit/kunit-example-test.c:29 [13:40:46] Expected 2 + 1 == 2, but [13:40:46] 2 + 1 == 3 (0x3) [13:40:46] [FAILED] example_simple_test [13:40:46] [SKIPPED] example_skip_test [13:40:46] [SKIPPED] example_mark_skipped_test [13:40:46] [PASSED] example_all_expect_macros_test [13:40:46] # example: initializing suite [13:40:46] # example: pass:1 fail:1 skip:2 total:4 [13:40:46] # Totals: pass:1 fail:1 skip:2 total:4 [13:40:46] ===================== [FAILED] example ===================== This example shows one minor cosmetic defect this approach has. The test counts lines prevent us from dedenting the suite-level output. But at the same time, any form of non-KUnit output would do the same unless it happened to be indented as well. Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- tools/testing/kunit/kunit.py | 2 +- tools/testing/kunit/kunit_parser.py | 27 +++++++++++++------------- tools/testing/kunit/kunit_tool_test.py | 2 ++ 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/tools/testing/kunit/kunit.py b/tools/testing/kunit/kunit.py index e7b6549712d6..43fbe96318fe 100755 --- a/tools/testing/kunit/kunit.py +++ b/tools/testing/kunit/kunit.py @@ -202,7 +202,7 @@ def parse_tests(request: KunitParseRequest, metadata: kunit_json.Metadata, input if request.raw_output == 'all': pass elif request.raw_output == 'kunit': - output = kunit_parser.extract_tap_lines(output, lstrip=False) + output = kunit_parser.extract_tap_lines(output) for line in output: print(line.rstrip()) parse_time = time.time() - parse_start diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index 99b8f058db40..a225799f6b1b 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -13,6 +13,7 @@ from __future__ import annotations from dataclasses import dataclass import re import sys +import textwrap from enum import Enum, auto from typing import Iterable, Iterator, List, Optional, Tuple @@ -208,12 +209,12 @@ class LineStream: # Parsing helper methods: -KTAP_START = re.compile(r'KTAP version ([0-9]+)$') -TAP_START = re.compile(r'TAP version ([0-9]+)$') -KTAP_END = re.compile('(List of all partitions:|' +KTAP_START = re.compile(r'\s*KTAP version ([0-9]+)$') +TAP_START = re.compile(r'\s*TAP version ([0-9]+)$') +KTAP_END = re.compile(r'\s*(List of all partitions:|' 'Kernel panic - not syncing: VFS:|reboot: System halted)') -def extract_tap_lines(kernel_output: Iterable[str], lstrip=True) -> LineStream: +def extract_tap_lines(kernel_output: Iterable[str]) -> LineStream: """Extracts KTAP lines from the kernel output.""" def isolate_ktap_output(kernel_output: Iterable[str]) \ -> Iterator[Tuple[int, str]]: @@ -239,11 +240,8 @@ def extract_tap_lines(kernel_output: Iterable[str], lstrip=True) -> LineStream: # stop extracting KTAP lines break elif started: - # remove the prefix and optionally any leading - # whitespace. Our parsing logic relies on this. + # remove the prefix, if any. line = line[prefix_len:] - if lstrip: - line = line.lstrip() yield line_num, line return LineStream(lines=isolate_ktap_output(kernel_output)) @@ -298,7 +296,7 @@ def parse_ktap_header(lines: LineStream, test: Test) -> bool: lines.pop() return True -TEST_HEADER = re.compile(r'^# Subtest: (.*)$') +TEST_HEADER = re.compile(r'^\s*# Subtest: (.*)$') def parse_test_header(lines: LineStream, test: Test) -> bool: """ @@ -322,7 +320,7 @@ def parse_test_header(lines: LineStream, test: Test) -> bool: lines.pop() return True -TEST_PLAN = re.compile(r'1\.\.([0-9]+)') +TEST_PLAN = re.compile(r'^\s*1\.\.([0-9]+)') def parse_test_plan(lines: LineStream, test: Test) -> bool: """ @@ -350,9 +348,9 @@ def parse_test_plan(lines: LineStream, test: Test) -> bool: lines.pop() return True -TEST_RESULT = re.compile(r'^(ok|not ok) ([0-9]+) (- )?([^#]*)( # .*)?$') +TEST_RESULT = re.compile(r'^\s*(ok|not ok) ([0-9]+) (- )?([^#]*)( # .*)?$') -TEST_RESULT_SKIP = re.compile(r'^(ok|not ok) ([0-9]+) (- )?(.*) # SKIP(.*)$') +TEST_RESULT_SKIP = re.compile(r'^\s*(ok|not ok) ([0-9]+) (- )?(.*) # SKIP(.*)$') def peek_test_name_match(lines: LineStream, test: Test) -> bool: """ @@ -511,8 +509,9 @@ def print_test_header(test: Test) -> None: def print_log(log: Iterable[str]) -> None: """Prints all strings in saved log for test in yellow.""" - for m in log: - stdout.print_with_timestamp(stdout.yellow(m)) + formatted = textwrap.dedent('\n'.join(log)) + for line in formatted.splitlines(): + stdout.print_with_timestamp(stdout.yellow(line)) def format_test_result(test: Test) -> str: """ diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index 1ef921ac4331..0c2190514103 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -336,12 +336,14 @@ class KUnitParserTest(unittest.TestCase): KTAP version 1 1..1 Test output. + Indented more. not ok 1 test1 """ result = kunit_parser.parse_run_tests(output.splitlines()) self.assertEqual(kunit_parser.TestStatus.FAILURE, result.status) self.print_mock.assert_any_call(StrContains('Test output.')) + self.print_mock.assert_any_call(StrContains(' Indented more.')) self.noPrintCallContains('not ok 1 test1') def line_stream_from_strs(strs: Iterable[str]) -> kunit_parser.LineStream: base-commit: 0f08f3e2a0186dfb8e33cb46105228eb18448a0e -- 2.38.1.584.g0f3c55d4c2-goog

2 years, 5 months

2
2
0 0

Re: [PATCH v3 18/20] drm/vc4: tests: Fail the current test if we access a register

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > Accessing a register when running under kunit is a bad idea since our > device is completely mocked. > > Fail the current test if we ever access any of our hardware registers. > > Reviewed-by: Javier Martinez Canillas <javierm(a)redhat.com> > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> Just a small nit: I believe that macros with multiple statements should be enclosed in a do-while block [1], even READ macros. I saw that you enclosed the WRITE macros on a do-while block, but not the READ macros. [1] https://www.kernel.org/doc/html/latest/process/coding-style.html#macros-enu… Best Regards, - Maíra Canal > --- > drivers/gpu/drm/vc4/vc4_crtc.c | 13 +++++++++++-- > drivers/gpu/drm/vc4/vc4_dpi.c | 13 +++++++++++-- > drivers/gpu/drm/vc4/vc4_drv.h | 29 +++++++++++++++++++++++++---- > drivers/gpu/drm/vc4/vc4_dsi.c | 9 ++++++++- > drivers/gpu/drm/vc4/vc4_hdmi_regs.h | 4 ++++ > drivers/gpu/drm/vc4/vc4_txp.c | 13 +++++++++++-- > drivers/gpu/drm/vc4/vc4_vec.c | 13 +++++++++++-- > 7 files changed, 81 insertions(+), 13 deletions(-) > > diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c > index 7d1a696477ce..a1a3465948c4 100644 > --- a/drivers/gpu/drm/vc4/vc4_crtc.c > +++ b/drivers/gpu/drm/vc4/vc4_crtc.c > @@ -50,8 +50,17 @@ > > #define HVS_FIFO_LATENCY_PIX 6 > > -#define CRTC_WRITE(offset, val) writel(val, vc4_crtc->regs + (offset)) > -#define CRTC_READ(offset) readl(vc4_crtc->regs + (offset)) > +#define CRTC_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, vc4_crtc->regs + (offset)); \ > + } while (0) > + > +#define CRTC_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(vc4_crtc->regs + (offset)); \ > + }) > > static const struct debugfs_reg32 crtc_regs[] = { > VC4_REG32(PV_CONTROL), > diff --git a/drivers/gpu/drm/vc4/vc4_dpi.c b/drivers/gpu/drm/vc4/vc4_dpi.c > index 1f8f44b7b5a5..0edf3c4c98c8 100644 > --- a/drivers/gpu/drm/vc4/vc4_dpi.c > +++ b/drivers/gpu/drm/vc4/vc4_dpi.c > @@ -103,8 +103,17 @@ to_vc4_dpi(struct drm_encoder *encoder) > return container_of(encoder, struct vc4_dpi, encoder.base); > } > > -#define DPI_READ(offset) readl(dpi->regs + (offset)) > -#define DPI_WRITE(offset, val) writel(val, dpi->regs + (offset)) > +#define DPI_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(dpi->regs + (offset)); \ > + }) > + > +#define DPI_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, dpi->regs + (offset)); \ > + } while (0) > > static const struct debugfs_reg32 dpi_regs[] = { > VC4_REG32(DPI_C), > diff --git a/drivers/gpu/drm/vc4/vc4_drv.h b/drivers/gpu/drm/vc4/vc4_drv.h > index 418f4f308e36..78fda5332cb3 100644 > --- a/drivers/gpu/drm/vc4/vc4_drv.h > +++ b/drivers/gpu/drm/vc4/vc4_drv.h > @@ -19,6 +19,8 @@ > #include <drm/drm_mm.h> > #include <drm/drm_modeset_lock.h> > > +#include <kunit/test-bug.h> > + > #include "uapi/drm/vc4_drm.h" > > struct drm_device; > @@ -645,10 +647,29 @@ to_vc4_crtc_state(const struct drm_crtc_state *crtc_state) > return container_of(crtc_state, struct vc4_crtc_state, base); > } > > -#define V3D_READ(offset) readl(vc4->v3d->regs + offset) > -#define V3D_WRITE(offset, val) writel(val, vc4->v3d->regs + offset) > -#define HVS_READ(offset) readl(hvs->regs + offset) > -#define HVS_WRITE(offset, val) writel(val, hvs->regs + offset) > +#define V3D_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(vc4->v3d->regs + (offset)); \ > + }) > + > +#define V3D_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, vc4->v3d->regs + (offset)); \ > + } while (0) > + > +#define HVS_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(hvs->regs + (offset)); \ > + }) > + > +#define HVS_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, hvs->regs + (offset)); \ > + } while (0) > > #define VC4_REG32(reg) { .name = #reg, .offset = reg } > > diff --git a/drivers/gpu/drm/vc4/vc4_dsi.c b/drivers/gpu/drm/vc4/vc4_dsi.c > index 878e05d79e81..2c9cb27903a0 100644 > --- a/drivers/gpu/drm/vc4/vc4_dsi.c > +++ b/drivers/gpu/drm/vc4/vc4_dsi.c > @@ -617,6 +617,8 @@ dsi_dma_workaround_write(struct vc4_dsi *dsi, u32 offset, u32 val) > dma_cookie_t cookie; > int ret; > > + kunit_fail_current_test("Accessing a register in a unit test!\n"); > + > /* DSI0 should be able to write normally. */ > if (!chan) { > writel(val, dsi->regs + offset); > @@ -645,7 +647,12 @@ dsi_dma_workaround_write(struct vc4_dsi *dsi, u32 offset, u32 val) > DRM_ERROR("Failed to wait for DMA: %d\n", ret); > } > > -#define DSI_READ(offset) readl(dsi->regs + (offset)) > +#define DSI_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(dsi->regs + (offset)); \ > + }) > + > #define DSI_WRITE(offset, val) dsi_dma_workaround_write(dsi, offset, val) > #define DSI_PORT_READ(offset) \ > DSI_READ(dsi->variant->port ? DSI1_##offset : DSI0_##offset) > diff --git a/drivers/gpu/drm/vc4/vc4_hdmi_regs.h b/drivers/gpu/drm/vc4/vc4_hdmi_regs.h > index 48db438550b1..b04b2fc8d831 100644 > --- a/drivers/gpu/drm/vc4/vc4_hdmi_regs.h > +++ b/drivers/gpu/drm/vc4/vc4_hdmi_regs.h > @@ -456,6 +456,8 @@ static inline u32 vc4_hdmi_read(struct vc4_hdmi *hdmi, > > WARN_ON(pm_runtime_status_suspended(&hdmi->pdev->dev)); > > + kunit_fail_current_test("Accessing an HDMI register in a unit test!\n"); > + > if (reg >= variant->num_registers) { > dev_warn(&hdmi->pdev->dev, > "Invalid register ID %u\n", reg); > @@ -486,6 +488,8 @@ static inline void vc4_hdmi_write(struct vc4_hdmi *hdmi, > > WARN_ON(pm_runtime_status_suspended(&hdmi->pdev->dev)); > > + kunit_fail_current_test("Accessing an HDMI register in a unit test!\n"); > + > if (reg >= variant->num_registers) { > dev_warn(&hdmi->pdev->dev, > "Invalid register ID %u\n", reg); > diff --git a/drivers/gpu/drm/vc4/vc4_txp.c b/drivers/gpu/drm/vc4/vc4_txp.c > index 2b69454b8534..ef5cab2a3aa9 100644 > --- a/drivers/gpu/drm/vc4/vc4_txp.c > +++ b/drivers/gpu/drm/vc4/vc4_txp.c > @@ -145,8 +145,17 @@ > /* Number of lines received and committed to memory. */ > #define TXP_PROGRESS 0x10 > > -#define TXP_READ(offset) readl(txp->regs + (offset)) > -#define TXP_WRITE(offset, val) writel(val, txp->regs + (offset)) > +#define TXP_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(txp->regs + (offset)); \ > + }) > + > +#define TXP_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, txp->regs + (offset)); \ > + } while (0) > > struct vc4_txp { > struct vc4_crtc base; > diff --git a/drivers/gpu/drm/vc4/vc4_vec.c b/drivers/gpu/drm/vc4/vc4_vec.c > index e270a4099be3..f589ab918f4d 100644 > --- a/drivers/gpu/drm/vc4/vc4_vec.c > +++ b/drivers/gpu/drm/vc4/vc4_vec.c > @@ -207,8 +207,17 @@ struct vc4_vec { > struct debugfs_regset32 regset; > }; > > -#define VEC_READ(offset) readl(vec->regs + (offset)) > -#define VEC_WRITE(offset, val) writel(val, vec->regs + (offset)) > +#define VEC_READ(offset) \ > + ({ \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + readl(vec->regs + (offset)); \ > + }) > + > +#define VEC_WRITE(offset, val) \ > + do { \ > + kunit_fail_current_test("Accessing a register in a unit test!\n"); \ > + writel(val, vec->regs + (offset)); \ > + } while (0) > > static inline struct vc4_vec * > encoder_to_vc4_vec(struct drm_encoder *encoder) >

2 years, 5 months

2
1
0 0

Re: [PATCH v3 19/20] drm/vc4: tests: Add unit test suite for the PV muxing

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > The HVS to PixelValve muxing code is fairly error prone and has a bunch > of arbitrary constraints due to the hardware setup. > > Let's create a test suite that makes sure that the possible combinations > work and the invalid ones don't. > > Reviewed-by: Javier Martinez Canillas <javierm(a)redhat.com> > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> Best Regards, - Maíra Canal > --- > drivers/gpu/drm/vc4/Makefile | 3 +- > drivers/gpu/drm/vc4/tests/vc4_mock.h | 9 +- > drivers/gpu/drm/vc4/tests/vc4_mock_output.c | 49 +- > drivers/gpu/drm/vc4/tests/vc4_test_pv_muxing.c | 1039 ++++++++++++++++++++++++ > 4 files changed, 1091 insertions(+), 9 deletions(-) > > diff --git a/drivers/gpu/drm/vc4/Makefile b/drivers/gpu/drm/vc4/Makefile > index f974a8c80e2f..c41f89a15a55 100644 > --- a/drivers/gpu/drm/vc4/Makefile > +++ b/drivers/gpu/drm/vc4/Makefile > @@ -29,7 +29,8 @@ vc4-$(CONFIG_DRM_VC4_KUNIT_TEST) += \ > tests/vc4_mock.o \ > tests/vc4_mock_crtc.o \ > tests/vc4_mock_output.o \ > - tests/vc4_mock_plane.o > + tests/vc4_mock_plane.o \ > + tests/vc4_test_pv_muxing.o > > vc4-$(CONFIG_DEBUG_FS) += vc4_debugfs.o > > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock.h b/drivers/gpu/drm/vc4/tests/vc4_mock.h > index ace5b2e00f4a..db8e9a141ef8 100644 > --- a/drivers/gpu/drm/vc4/tests/vc4_mock.h > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock.h > @@ -53,8 +53,11 @@ struct vc4_dummy_output *vc4_dummy_output(struct kunit *test, > struct vc4_dev *vc4_mock_device(struct kunit *test); > struct vc4_dev *vc5_mock_device(struct kunit *test); > > -int vc4_mock_atomic_add_output(struct kunit *test, struct drm_device *drm, > - enum vc4_encoder_type type, > - struct drm_atomic_state *state); > +int vc4_mock_atomic_add_output(struct kunit *test, > + struct drm_atomic_state *state, > + enum vc4_encoder_type type); > +int vc4_mock_atomic_del_output(struct kunit *test, > + struct drm_atomic_state *state, > + enum vc4_encoder_type type); > > #endif // VC4_MOCK_H_ > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock_output.c b/drivers/gpu/drm/vc4/tests/vc4_mock_output.c > index cb16ab4451f7..8d33be828d9a 100644 > --- a/drivers/gpu/drm/vc4/tests/vc4_mock_output.c > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock_output.c > @@ -61,16 +61,17 @@ static const struct drm_display_mode default_mode = { > DRM_SIMPLE_MODE(640, 480, 64, 48) > }; > > -int vc4_mock_atomic_add_output(struct kunit *test, struct drm_device *drm, > - enum vc4_encoder_type type, > - struct drm_atomic_state *state) > +int vc4_mock_atomic_add_output(struct kunit *test, > + struct drm_atomic_state *state, > + enum vc4_encoder_type type) > { > + struct drm_device *drm = state->dev; > + struct drm_connector_state *conn_state; > + struct drm_crtc_state *crtc_state; > struct vc4_dummy_output *output; > struct drm_connector *conn; > - struct drm_connector_state *conn_state; > struct drm_encoder *encoder; > struct drm_crtc *crtc; > - struct drm_crtc_state *crtc_state; > int ret; > > encoder = vc4_find_encoder_by_type(drm, type); > @@ -97,3 +98,41 @@ int vc4_mock_atomic_add_output(struct kunit *test, struct drm_device *drm, > > return 0; > } > + > +int vc4_mock_atomic_del_output(struct kunit *test, > + struct drm_atomic_state *state, > + enum vc4_encoder_type type) > +{ > + struct drm_device *drm = state->dev; > + struct drm_connector_state *conn_state; > + struct drm_crtc_state *crtc_state; > + struct vc4_dummy_output *output; > + struct drm_connector *conn; > + struct drm_encoder *encoder; > + struct drm_crtc *crtc; > + int ret; > + > + encoder = vc4_find_encoder_by_type(drm, type); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, encoder); > + > + crtc = vc4_find_crtc_for_encoder(test, drm, encoder); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc); > + > + crtc_state = drm_atomic_get_crtc_state(state, crtc); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); > + > + crtc_state->active = false; > + > + ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + output = container_of(encoder, struct vc4_dummy_output, encoder.base); > + conn = &output->connector; > + conn_state = drm_atomic_get_connector_state(state, conn); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state); > + > + ret = drm_atomic_set_crtc_for_connector(conn_state, NULL); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + return 0; > +} > diff --git a/drivers/gpu/drm/vc4/tests/vc4_test_pv_muxing.c b/drivers/gpu/drm/vc4/tests/vc4_test_pv_muxing.c > new file mode 100644 > index 000000000000..ae0bd0f81698 > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_test_pv_muxing.c > @@ -0,0 +1,1039 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include <drm/drm_atomic.h> > +#include <drm/drm_atomic_helper.h> > +#include <drm/drm_atomic_state_helper.h> > +#include <drm/drm_atomic_uapi.h> > +#include <drm/drm_crtc.h> > +#include <drm/drm_drv.h> > +#include <drm/drm_fourcc.h> > +#include <drm/drm_kunit_helpers.h> > +#include <drm/drm_mode.h> > +#include <drm/drm_modeset_helper_vtables.h> > +#include <drm/drm_plane.h> > + > +#include <kunit/test.h> > + > +#include "../vc4_drv.h" > + > +#include "vc4_mock.h" > + > +struct pv_muxing_priv { > + struct vc4_dev *vc4; > + struct drm_modeset_acquire_ctx ctx; > + struct drm_atomic_state *state; > +}; > + > +static bool check_fifo_conflict(struct kunit *test, > + const struct drm_atomic_state *state) > +{ > + struct vc4_hvs_state *hvs_state; > + unsigned int used_fifos = 0; > + unsigned int i; > + > + hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hvs_state); > + > + for (i = 0; i < HVS_NUM_CHANNELS; i++) { > + if (!hvs_state->fifo_state[i].in_use) > + continue; > + > + KUNIT_EXPECT_FALSE(test, used_fifos & BIT(i)); > + used_fifos |= BIT(i); > + } > + > + return true; > +} > + > +struct encoder_constraint { > + enum vc4_encoder_type type; > + unsigned int *channels; > + size_t nchannels; > +}; > + > +#define ENCODER_CONSTRAINT(_type, ...) \ > + { \ > + .type = _type, \ > + .channels = (unsigned int[]) { __VA_ARGS__ }, \ > + .nchannels = sizeof((unsigned int[]) { __VA_ARGS__ }) / \ > + sizeof(unsigned int), \ > + } > + > +static bool __check_encoder_constraints(const struct encoder_constraint *constraints, > + size_t nconstraints, > + enum vc4_encoder_type type, > + unsigned int channel) > +{ > + unsigned int i; > + > + for (i = 0; i < nconstraints; i++) { > + const struct encoder_constraint *constraint = &constraints[i]; > + unsigned int j; > + > + if (constraint->type != type) > + continue; > + > + for (j = 0; j < constraint->nchannels; j++) { > + unsigned int _channel = constraint->channels[j]; > + > + if (channel != _channel) > + continue; > + > + return true; > + } > + } > + > + return false; > +} > + > +static const struct encoder_constraint vc4_encoder_constraints[] = { > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DPI, 0), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DSI0, 0), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_HDMI0, 1), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_VEC, 1), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_TXP, 2), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DSI1, 2), > +}; > + > +static const struct encoder_constraint vc5_encoder_constraints[] = { > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DPI, 0), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DSI0, 0), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_VEC, 1), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_TXP, 0, 2), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_DSI1, 0, 1, 2), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_HDMI0, 0, 1, 2), > + ENCODER_CONSTRAINT(VC4_ENCODER_TYPE_HDMI1, 0, 1, 2), > +}; > + > +static bool check_vc4_encoder_constraints(enum vc4_encoder_type type, unsigned int channel) > +{ > + return __check_encoder_constraints(vc4_encoder_constraints, > + ARRAY_SIZE(vc4_encoder_constraints), > + type, channel); > +} > + > +static bool check_vc5_encoder_constraints(enum vc4_encoder_type type, unsigned int channel) > +{ > + return __check_encoder_constraints(vc5_encoder_constraints, > + ARRAY_SIZE(vc5_encoder_constraints), > + type, channel); > +} > + > +static struct vc4_crtc_state * > +get_vc4_crtc_state_for_encoder(struct kunit *test, > + const struct drm_atomic_state *state, > + enum vc4_encoder_type type) > +{ > + struct drm_device *drm = state->dev; > + struct drm_crtc_state *new_crtc_state; > + struct drm_encoder *encoder; > + struct drm_crtc *crtc; > + > + encoder = vc4_find_encoder_by_type(drm, type); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, encoder); > + > + crtc = vc4_find_crtc_for_encoder(test, drm, encoder); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc); > + > + new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc); > + if (!new_crtc_state) > + return NULL; > + > + return to_vc4_crtc_state(new_crtc_state); > +} > + > +static bool check_channel_for_encoder(struct kunit *test, > + const struct drm_atomic_state *state, > + enum vc4_encoder_type type, > + bool (*check_fn)(enum vc4_encoder_type type, unsigned int channel)) > +{ > + struct vc4_crtc_state *new_vc4_crtc_state; > + struct vc4_hvs_state *new_hvs_state; > + unsigned int channel; > + > + new_hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_hvs_state); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, type); > + KUNIT_ASSERT_NOT_NULL(test, new_vc4_crtc_state); > + > + channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_EXPECT_NE(test, channel, VC4_HVS_CHANNEL_DISABLED); > + > + KUNIT_EXPECT_TRUE(test, new_hvs_state->fifo_state[channel].in_use); > + > + KUNIT_EXPECT_TRUE(test, check_fn(type, channel)); > + > + return true; > +} > + > +struct pv_muxing_param { > + const char *name; > + struct vc4_dev *(*mock_fn)(struct kunit *test); > + bool (*check_fn)(enum vc4_encoder_type type, unsigned int channel); > + enum vc4_encoder_type *encoders; > + size_t nencoders; > +}; > + > +static void vc4_test_pv_muxing_desc(const struct pv_muxing_param *t, char *desc) > +{ > + strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE); > +} > + > +#define PV_MUXING_TEST(_name, _mock_fn, _check_fn, ...) \ > + { \ > + .name = _name, \ > + .mock_fn = &_mock_fn, \ > + .check_fn = &_check_fn, \ > + .encoders = (enum vc4_encoder_type[]) { __VA_ARGS__ }, \ > + .nencoders = sizeof((enum vc4_encoder_type[]) { __VA_ARGS__ }) / \ > + sizeof(enum vc4_encoder_type), \ > + } > + > +#define VC4_PV_MUXING_TEST(_name, ...) \ > + PV_MUXING_TEST(_name, vc4_mock_device, check_vc4_encoder_constraints, __VA_ARGS__) > + > +#define VC5_PV_MUXING_TEST(_name, ...) \ > + PV_MUXING_TEST(_name, vc5_mock_device, check_vc5_encoder_constraints, __VA_ARGS__) > + > +static const struct pv_muxing_param vc4_test_pv_muxing_params[] = { > + VC4_PV_MUXING_TEST("1 output: DSI0", > + VC4_ENCODER_TYPE_DSI0), > + VC4_PV_MUXING_TEST("1 output: DPI", > + VC4_ENCODER_TYPE_DPI), > + VC4_PV_MUXING_TEST("1 output: HDMI0", > + VC4_ENCODER_TYPE_HDMI0), > + VC4_PV_MUXING_TEST("1 output: VEC", > + VC4_ENCODER_TYPE_VEC), > + VC4_PV_MUXING_TEST("1 output: DSI1", > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("1 output: TXP", > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("2 outputs: DSI0, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0), > + VC4_PV_MUXING_TEST("2 outputs: DSI0, VEC", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC), > + VC4_PV_MUXING_TEST("2 outputs: DSI0, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("2 outputs: DSI0, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("2 outputs: DPI, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0), > + VC4_PV_MUXING_TEST("2 outputs: DPI, VEC", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC), > + VC4_PV_MUXING_TEST("2 outputs: DPI, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("2 outputs: DPI, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("2 outputs: HDMI0, DSI1", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("2 outputs: HDMI0, TXP", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("2 outputs: VEC, DSI1", > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("2 outputs: VEC, TXP", > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("3 outputs: DSI0, HDMI0, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("3 outputs: DSI0, HDMI0, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("3 outputs: DSI0, VEC, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("3 outputs: DSI0, VEC, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("3 outputs: DPI, HDMI0, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("3 outputs: DPI, HDMI0, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("3 outputs: DPI, VEC, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("3 outputs: DPI, VEC, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP), > +}; > + > +KUNIT_ARRAY_PARAM(vc4_test_pv_muxing, > + vc4_test_pv_muxing_params, > + vc4_test_pv_muxing_desc); > + > +static const struct pv_muxing_param vc4_test_pv_muxing_invalid_params[] = { > + VC4_PV_MUXING_TEST("DPI/DSI0 Conflict", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI0), > + VC4_PV_MUXING_TEST("TXP/DSI1 Conflict", > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1), > + VC4_PV_MUXING_TEST("HDMI0/VEC Conflict", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_VEC), > + VC4_PV_MUXING_TEST("More than 3 outputs: DSI0, HDMI0, DSI1, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, DSI1, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("More than 3 outputs: DPI, HDMI0, DSI1, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_TXP), > + VC4_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, DSI1, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_TXP), > +}; > + > +KUNIT_ARRAY_PARAM(vc4_test_pv_muxing_invalid, > + vc4_test_pv_muxing_invalid_params, > + vc4_test_pv_muxing_desc); > + > +static const struct pv_muxing_param vc5_test_pv_muxing_params[] = { > + VC5_PV_MUXING_TEST("1 output: DPI", > + VC4_ENCODER_TYPE_DPI), > + VC5_PV_MUXING_TEST("1 output: DSI0", > + VC4_ENCODER_TYPE_DSI0), > + VC5_PV_MUXING_TEST("1 output: DSI1", > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("1 output: HDMI0", > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("1 output: HDMI1", > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("1 output: VEC", > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: DPI, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("2 outputs: DPI, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("2 outputs: DPI, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("2 outputs: DPI, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("2 outputs: DPI, VEC", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: DPI, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, VEC", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: DSI0, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("2 outputs: DSI1, VEC", > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: DSI1, TXP", > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("2 outputs: DSI1, HDMI0", > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("2 outputs: DSI1, HDMI1", > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("2 outputs: HDMI0, VEC", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: HDMI0, TXP", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("2 outputs: HDMI0, HDMI1", > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("2 outputs: HDMI1, VEC", > + VC4_ENCODER_TYPE_HDMI1, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("2 outputs: HDMI1, TXP", > + VC4_ENCODER_TYPE_HDMI1, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("2 outputs: TXP, VEC", > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_VEC), > + VC5_PV_MUXING_TEST("3 outputs: DPI, VEC, TXP", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("3 outputs: DPI, VEC, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("3 outputs: DPI, VEC, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DPI, VEC, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DPI, TXP, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("3 outputs: DPI, TXP, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DPI, TXP, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DPI, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DPI, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DPI, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, VEC, TXP", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, VEC, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, VEC, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, VEC, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, TXP, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, TXP, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, TXP, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("3 outputs: DSI0, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > +}; > + > +KUNIT_ARRAY_PARAM(vc5_test_pv_muxing, > + vc5_test_pv_muxing_params, > + vc4_test_pv_muxing_desc); > + > +static const struct pv_muxing_param vc5_test_pv_muxing_invalid_params[] = { > + VC5_PV_MUXING_TEST("DPI/DSI0 Conflict", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, DSI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, TXP, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, TXP, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, TXP, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, TXP, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, DSI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, TXP, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, TXP, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, TXP, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, DSI1, HDMI0", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, DSI1, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, TXP, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: VEC, TXP, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DPI, VEC, TXP, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DPI, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > + VC5_PV_MUXING_TEST("More than 3 outputs: DSI0, VEC, TXP, DSI1, HDMI0, HDMI1", > + VC4_ENCODER_TYPE_DSI0, > + VC4_ENCODER_TYPE_VEC, > + VC4_ENCODER_TYPE_TXP, > + VC4_ENCODER_TYPE_DSI1, > + VC4_ENCODER_TYPE_HDMI0, > + VC4_ENCODER_TYPE_HDMI1), > +}; > + > +KUNIT_ARRAY_PARAM(vc5_test_pv_muxing_invalid, > + vc5_test_pv_muxing_invalid_params, > + vc4_test_pv_muxing_desc); > + > +static void drm_vc4_test_pv_muxing(struct kunit *test) > +{ > + const struct pv_muxing_param *params = test->param_value; > + const struct pv_muxing_priv *priv = test->priv; > + struct drm_atomic_state *state = priv->state; > + unsigned int i; > + int ret; > + > + for (i = 0; i < params->nencoders; i++) { > + enum vc4_encoder_type enc_type = params->encoders[i]; > + > + ret = vc4_mock_atomic_add_output(test, state, enc_type); > + KUNIT_ASSERT_EQ(test, ret, 0); > + } > + > + ret = drm_atomic_check_only(state); > + KUNIT_EXPECT_EQ(test, ret, 0); > + > + KUNIT_EXPECT_TRUE(test, > + check_fifo_conflict(test, state)); > + > + for (i = 0; i < params->nencoders; i++) { > + enum vc4_encoder_type enc_type = params->encoders[i]; > + > + KUNIT_EXPECT_TRUE(test, check_channel_for_encoder(test, state, enc_type, > + params->check_fn)); > + } > +} > + > +static void drm_vc4_test_pv_muxing_invalid(struct kunit *test) > +{ > + const struct pv_muxing_param *params = test->param_value; > + const struct pv_muxing_priv *priv = test->priv; > + struct drm_atomic_state *state = priv->state; > + unsigned int i; > + int ret; > + > + for (i = 0; i < params->nencoders; i++) { > + enum vc4_encoder_type enc_type = params->encoders[i]; > + > + ret = vc4_mock_atomic_add_output(test, state, enc_type); > + KUNIT_ASSERT_EQ(test, ret, 0); > + } > + > + ret = drm_atomic_check_only(state); > + KUNIT_EXPECT_LT(test, ret, 0); > +} > + > +static int vc4_pv_muxing_test_init(struct kunit *test) > +{ > + const struct pv_muxing_param *params = test->param_value; > + struct drm_atomic_state *state; > + struct pv_muxing_priv *priv; > + struct drm_device *drm; > + struct vc4_dev *vc4; > + > + priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); > + KUNIT_ASSERT_NOT_NULL(test, priv); > + test->priv = priv; > + > + vc4 = params->mock_fn(test); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); > + priv->vc4 = vc4; > + > + drm_modeset_acquire_init(&priv->ctx, 0); > + > + drm = &vc4->base; > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &priv->ctx; > + > + priv->state = state; > + > + return 0; > +} > + > +static void vc4_pv_muxing_test_exit(struct kunit *test) > +{ > + struct pv_muxing_priv *priv = test->priv; > + struct vc4_dev *vc4 = priv->vc4; > + struct drm_device *drm = &vc4->base; > + struct drm_atomic_state *state = priv->state; > + > + drm_atomic_state_put(state); > + drm_modeset_drop_locks(&priv->ctx); > + drm_modeset_acquire_fini(&priv->ctx); > + drm_dev_unregister(drm); > + drm_kunit_helper_free_device(test, vc4->dev); > +} > + > +static struct kunit_case vc4_pv_muxing_tests[] = { > + KUNIT_CASE_PARAM(drm_vc4_test_pv_muxing, > + vc4_test_pv_muxing_gen_params), > + KUNIT_CASE_PARAM(drm_vc4_test_pv_muxing_invalid, > + vc4_test_pv_muxing_invalid_gen_params), > + {} > +}; > + > +static struct kunit_suite vc4_pv_muxing_test_suite = { > + .name = "vc4-pv-muxing-combinations", > + .init = vc4_pv_muxing_test_init, > + .exit = vc4_pv_muxing_test_exit, > + .test_cases = vc4_pv_muxing_tests, > +}; > + > +static struct kunit_case vc5_pv_muxing_tests[] = { > + KUNIT_CASE_PARAM(drm_vc4_test_pv_muxing, > + vc5_test_pv_muxing_gen_params), > + KUNIT_CASE_PARAM(drm_vc4_test_pv_muxing_invalid, > + vc5_test_pv_muxing_invalid_gen_params), > + {} > +}; > + > +static struct kunit_suite vc5_pv_muxing_test_suite = { > + .name = "vc5-pv-muxing-combinations", > + .init = vc4_pv_muxing_test_init, > + .exit = vc4_pv_muxing_test_exit, > + .test_cases = vc5_pv_muxing_tests, > +}; > + > +/* See > + * https://lore.kernel.org/all/3e113525-aa89-b1e2-56b7-ca55bd41d057@samsung.co… > + * and > + * https://lore.kernel.org/dri-devel/20200917121623.42023-1-maxime@cerno.tech/ > + */ > +static void drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable(struct kunit *test) > +{ > + struct drm_modeset_acquire_ctx ctx; > + struct drm_atomic_state *state; > + struct vc4_crtc_state *new_vc4_crtc_state; > + struct vc4_hvs_state *new_hvs_state; > + unsigned int hdmi0_channel; > + unsigned int hdmi1_channel; > + struct drm_device *drm; > + struct vc4_dev *vc4; > + int ret; > + > + vc4 = vc5_mock_device(test); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); > + > + drm_modeset_acquire_init(&ctx, 0); > + > + drm = &vc4->base; > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + new_hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_hvs_state); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_NOT_NULL(test, new_vc4_crtc_state); > + > + hdmi0_channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_ASSERT_NE(test, hdmi0_channel, VC4_HVS_CHANNEL_DISABLED); > + KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[hdmi0_channel].in_use); > + > + ret = drm_atomic_helper_swap_state(state, false); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + drm_atomic_state_put(state); > + > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + new_hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_hvs_state); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI1); > + KUNIT_ASSERT_NOT_NULL(test, new_vc4_crtc_state); > + > + hdmi1_channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_ASSERT_NE(test, hdmi1_channel, VC4_HVS_CHANNEL_DISABLED); > + KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[hdmi1_channel].in_use); > + > + KUNIT_EXPECT_NE(test, hdmi0_channel, hdmi1_channel); > + > + drm_atomic_state_put(state); > + drm_modeset_drop_locks(&ctx); > + drm_modeset_acquire_fini(&ctx); > + drm_dev_unregister(drm); > + drm_kunit_helper_free_device(test, vc4->dev); > +} > + > +static void drm_test_vc5_pv_muxing_bugs_stable_fifo(struct kunit *test) > +{ > + struct drm_modeset_acquire_ctx ctx; > + struct drm_atomic_state *state; > + struct vc4_crtc_state *new_vc4_crtc_state; > + struct vc4_hvs_state *new_hvs_state; > + unsigned int old_hdmi0_channel; > + unsigned int old_hdmi1_channel; > + struct drm_device *drm; > + struct vc4_dev *vc4; > + int ret; > + > + vc4 = vc5_mock_device(test); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); > + > + drm_modeset_acquire_init(&ctx, 0); > + > + drm = &vc4->base; > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + new_hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_hvs_state); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_NOT_NULL(test, new_vc4_crtc_state); > + > + old_hdmi0_channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_ASSERT_NE(test, old_hdmi0_channel, VC4_HVS_CHANNEL_DISABLED); > + KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[old_hdmi0_channel].in_use); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI1); > + KUNIT_ASSERT_NOT_NULL(test, new_vc4_crtc_state); > + > + old_hdmi1_channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_ASSERT_NE(test, old_hdmi1_channel, VC4_HVS_CHANNEL_DISABLED); > + KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[old_hdmi1_channel].in_use); > + > + ret = drm_atomic_helper_swap_state(state, false); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + drm_atomic_state_put(state); > + > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_del_output(test, state, VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + new_hvs_state = vc4_hvs_get_new_global_state(state); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_hvs_state); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI1); > + > + if (new_vc4_crtc_state) { > + unsigned int hdmi1_channel; > + > + hdmi1_channel = new_vc4_crtc_state->assigned_channel; > + KUNIT_ASSERT_NE(test, hdmi1_channel, VC4_HVS_CHANNEL_DISABLED); > + KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[hdmi1_channel].in_use); > + > + KUNIT_EXPECT_EQ(test, old_hdmi1_channel, hdmi1_channel); > + } > + > + drm_atomic_state_put(state); > + drm_modeset_drop_locks(&ctx); > + drm_modeset_acquire_fini(&ctx); > + drm_dev_unregister(drm); > + drm_kunit_helper_free_device(test, vc4->dev); > +} > + > +static void > +drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable_too_many_crtc_state(struct kunit *test) > +{ > + struct drm_modeset_acquire_ctx ctx; > + struct drm_atomic_state *state; > + struct vc4_crtc_state *new_vc4_crtc_state; > + struct drm_device *drm; > + struct vc4_dev *vc4; > + int ret; > + > + vc4 = vc5_mock_device(test); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); > + > + drm_modeset_acquire_init(&ctx, 0); > + > + drm = &vc4->base; > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_helper_swap_state(state, false); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + drm_atomic_state_put(state); > + > + state = drm_atomic_state_alloc(drm); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); > + > + state->acquire_ctx = &ctx; > + > + ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_atomic_check_only(state); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, > + VC4_ENCODER_TYPE_HDMI0); > + KUNIT_EXPECT_NULL(test, new_vc4_crtc_state); > + > + drm_atomic_state_put(state); > + drm_modeset_drop_locks(&ctx); > + drm_modeset_acquire_fini(&ctx); > + drm_dev_unregister(drm); > + drm_kunit_helper_free_device(test, vc4->dev); > +} > + > +static struct kunit_case vc5_pv_muxing_bugs_tests[] = { > + KUNIT_CASE(drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable), > + KUNIT_CASE(drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable_too_many_crtc_state), > + KUNIT_CASE(drm_test_vc5_pv_muxing_bugs_stable_fifo), > + {} > +}; > + > +static struct kunit_suite vc5_pv_muxing_bugs_test_suite = { > + .name = "vc5-pv-muxing-bugs", > + .test_cases = vc5_pv_muxing_bugs_tests, > +}; > + > +kunit_test_suites( > + &vc4_pv_muxing_test_suite, > + &vc5_pv_muxing_test_suite, > + &vc5_pv_muxing_bugs_test_suite > +); >

2 years, 5 months

1
0
0 0

Re: [PATCH v3 17/20] drm/vc4: tests: Introduce a mocking infrastructure

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > In order to test the current atomic_check hooks we need to have a DRM > device that has roughly the same capabilities and layout that the actual > hardware. We'll also need a bunch of functions to create arbitrary > atomic states. > > Let's create some helpers to create a device that behaves like the real > one, and some helpers to maintain the atomic state we want to check. > > Reviewed-by: Javier Martinez Canillas <javierm(a)redhat.com> > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> But it would be nice if you could fix the checkpatch problems in the vc4/tests folder. Best Regards, - Maíra Canal > --- > drivers/gpu/drm/vc4/Kconfig | 16 +++ > drivers/gpu/drm/vc4/Makefile | 6 + > drivers/gpu/drm/vc4/tests/.kunitconfig | 13 ++ > drivers/gpu/drm/vc4/tests/vc4_mock.c | 200 ++++++++++++++++++++++++++++ > drivers/gpu/drm/vc4/tests/vc4_mock.h | 60 +++++++++ > drivers/gpu/drm/vc4/tests/vc4_mock_crtc.c | 41 ++++++ > drivers/gpu/drm/vc4/tests/vc4_mock_output.c | 99 ++++++++++++++ > drivers/gpu/drm/vc4/tests/vc4_mock_plane.c | 47 +++++++ > drivers/gpu/drm/vc4/vc4_crtc.c | 20 +-- > drivers/gpu/drm/vc4/vc4_drv.c | 4 +- > drivers/gpu/drm/vc4/vc4_drv.h | 16 +++ > drivers/gpu/drm/vc4/vc4_txp.c | 2 +- > 12 files changed, 511 insertions(+), 13 deletions(-) > > diff --git a/drivers/gpu/drm/vc4/Kconfig b/drivers/gpu/drm/vc4/Kconfig > index 246305d17a52..f423941c028d 100644 > --- a/drivers/gpu/drm/vc4/Kconfig > +++ b/drivers/gpu/drm/vc4/Kconfig > @@ -34,3 +34,19 @@ config DRM_VC4_HDMI_CEC > help > Choose this option if you have a Broadcom VC4 GPU > and want to use CEC. > + > +config DRM_VC4_KUNIT_TEST > + bool "KUnit tests for VC4" if !KUNIT_ALL_TESTS > + depends on DRM_VC4 && KUNIT > + select DRM_KUNIT_TEST_HELPERS > + default KUNIT_ALL_TESTS > + help > + This builds unit tests for the VC4 DRM/KMS driver. This option is > + not useful for distributions or general kernels, but only for kernel > + developers working on the VC4 driver. > + > + For more information on KUnit and unit tests in general, > + please refer to the KUnit documentation in > + Documentation/dev-tools/kunit/. > + > + If in doubt, say "N". > diff --git a/drivers/gpu/drm/vc4/Makefile b/drivers/gpu/drm/vc4/Makefile > index d0163e18e9ca..f974a8c80e2f 100644 > --- a/drivers/gpu/drm/vc4/Makefile > +++ b/drivers/gpu/drm/vc4/Makefile > @@ -25,6 +25,12 @@ vc4-y := \ > vc4_validate.o \ > vc4_validate_shaders.o > > +vc4-$(CONFIG_DRM_VC4_KUNIT_TEST) += \ > + tests/vc4_mock.o \ > + tests/vc4_mock_crtc.o \ > + tests/vc4_mock_output.o \ > + tests/vc4_mock_plane.o > + > vc4-$(CONFIG_DEBUG_FS) += vc4_debugfs.o > > obj-$(CONFIG_DRM_VC4) += vc4.o > diff --git a/drivers/gpu/drm/vc4/tests/.kunitconfig b/drivers/gpu/drm/vc4/tests/.kunitconfig > new file mode 100644 > index 000000000000..b503e9036c7f > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/.kunitconfig > @@ -0,0 +1,13 @@ > +CONFIG_ARCH_BCM=y > +CONFIG_ARCH_BCM2835=y > +CONFIG_BCM2835_MBOX=y > +CONFIG_KUNIT=y > +CONFIG_DRM=y > +CONFIG_DRM_VC4=y > +CONFIG_DRM_VC4_KUNIT_TEST=y > +CONFIG_MAILBOX=y > +CONFIG_RASPBERRYPI_FIRMWARE=y > +CONFIG_SND=y > +CONFIG_SND_SOC=y > +CONFIG_SOUND=y > +CONFIG_COMMON_CLK=y > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock.c b/drivers/gpu/drm/vc4/tests/vc4_mock.c > new file mode 100644 > index 000000000000..a4bed26af32f > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock.c > @@ -0,0 +1,200 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include <drm/drm_drv.h> > +#include <drm/drm_kunit_helpers.h> > + > +#include <kunit/test.h> > + > +#include "vc4_mock.h" > + > +struct vc4_mock_output_desc { > + enum vc4_encoder_type vc4_encoder_type; > + unsigned int encoder_type; > + unsigned int connector_type; > +}; > + > +#define VC4_MOCK_OUTPUT_DESC(_vc4_type, _etype, _ctype) \ > + { \ > + .vc4_encoder_type = _vc4_type, \ > + .encoder_type = _etype, \ > + .connector_type = _ctype, \ > + } > + > +struct vc4_mock_pipe_desc { > + const struct vc4_crtc_data *data; > + const struct vc4_mock_output_desc *outputs; > + unsigned int noutputs; > +}; > + > +#define VC4_MOCK_CRTC_DESC(_data, ...) \ > + { \ > + .data = _data, \ > + .outputs = (struct vc4_mock_output_desc[]) { __VA_ARGS__ }, \ > + .noutputs = sizeof((struct vc4_mock_output_desc[]) { __VA_ARGS__ }) / \ > + sizeof(struct vc4_mock_output_desc), \ > + } > + > +#define VC4_MOCK_PIXELVALVE_DESC(_data, ...) \ > + VC4_MOCK_CRTC_DESC(&(_data)->base, __VA_ARGS__) > + > +struct vc4_mock_desc { > + const struct vc4_mock_pipe_desc *pipes; > + unsigned int npipes; > +}; > + > +#define VC4_MOCK_DESC(...) \ > + { \ > + .pipes = (struct vc4_mock_pipe_desc[]) { __VA_ARGS__ }, \ > + .npipes = sizeof((struct vc4_mock_pipe_desc[]) { __VA_ARGS__ }) / \ > + sizeof(struct vc4_mock_pipe_desc), \ > + } > + > +static const struct vc4_mock_desc vc4_mock = > + VC4_MOCK_DESC( > + VC4_MOCK_CRTC_DESC(&vc4_txp_crtc_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_TXP, > + DRM_MODE_ENCODER_VIRTUAL, > + DRM_MODE_CONNECTOR_WRITEBACK)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2835_pv0_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DSI0, > + DRM_MODE_ENCODER_DSI, > + DRM_MODE_CONNECTOR_DSI), > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DPI, > + DRM_MODE_ENCODER_DPI, > + DRM_MODE_CONNECTOR_DPI)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2835_pv1_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DSI1, > + DRM_MODE_ENCODER_DSI, > + DRM_MODE_CONNECTOR_DSI)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2835_pv2_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_HDMI0, > + DRM_MODE_ENCODER_TMDS, > + DRM_MODE_CONNECTOR_HDMIA), > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_VEC, > + DRM_MODE_ENCODER_TVDAC, > + DRM_MODE_CONNECTOR_Composite)), > +); > + > +static const struct vc4_mock_desc vc5_mock = > + VC4_MOCK_DESC( > + VC4_MOCK_CRTC_DESC(&vc4_txp_crtc_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_TXP, > + DRM_MODE_ENCODER_VIRTUAL, > + DRM_MODE_CONNECTOR_WRITEBACK)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2711_pv0_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DSI0, > + DRM_MODE_ENCODER_DSI, > + DRM_MODE_CONNECTOR_DSI), > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DPI, > + DRM_MODE_ENCODER_DPI, > + DRM_MODE_CONNECTOR_DPI)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2711_pv1_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_DSI1, > + DRM_MODE_ENCODER_DSI, > + DRM_MODE_CONNECTOR_DSI)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2711_pv2_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_HDMI0, > + DRM_MODE_ENCODER_TMDS, > + DRM_MODE_CONNECTOR_HDMIA)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2711_pv3_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_VEC, > + DRM_MODE_ENCODER_TVDAC, > + DRM_MODE_CONNECTOR_Composite)), > + VC4_MOCK_PIXELVALVE_DESC(&bcm2711_pv4_data, > + VC4_MOCK_OUTPUT_DESC(VC4_ENCODER_TYPE_HDMI1, > + DRM_MODE_ENCODER_TMDS, > + DRM_MODE_CONNECTOR_HDMIA)), > +); > + > +static int __build_one_pipe(struct kunit *test, struct drm_device *drm, > + const struct vc4_mock_pipe_desc *pipe) > +{ > + struct vc4_dummy_plane *dummy_plane; > + struct drm_plane *plane; > + struct vc4_dummy_crtc *dummy_crtc; > + struct drm_crtc *crtc; > + unsigned int i; > + > + dummy_plane = vc4_dummy_plane(test, drm, DRM_PLANE_TYPE_PRIMARY); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dummy_plane); > + > + plane = &dummy_plane->plane.base; > + dummy_crtc = vc4_mock_pv(test, drm, plane, pipe->data); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dummy_crtc); > + > + crtc = &dummy_crtc->crtc.base; > + for (i = 0; i < pipe->noutputs; i++) { > + const struct vc4_mock_output_desc *mock_output = &pipe->outputs[i]; > + struct vc4_dummy_output *dummy_output; > + > + dummy_output = vc4_dummy_output(test, drm, crtc, > + mock_output->vc4_encoder_type, > + mock_output->encoder_type, > + mock_output->connector_type); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dummy_output); > + } > + > + return 0; > +} > + > +static int __build_mock(struct kunit *test, struct drm_device *drm, > + const struct vc4_mock_desc *mock) > +{ > + unsigned int i; > + > + for (i = 0; i < mock->npipes; i++) { > + const struct vc4_mock_pipe_desc *pipe = &mock->pipes[i]; > + int ret; > + > + ret = __build_one_pipe(test, drm, pipe); > + KUNIT_ASSERT_EQ(test, ret, 0); > + } > + > + return 0; > +} > + > +static struct vc4_dev *__mock_device(struct kunit *test, bool is_vc5) > +{ > + struct drm_device *drm; > + const struct drm_driver *drv = is_vc5 ? &vc5_drm_driver : &vc4_drm_driver; > + const struct vc4_mock_desc *desc = is_vc5 ? &vc5_mock : &vc4_mock; > + struct vc4_dev *vc4; > + struct device *dev; > + int ret; > + > + dev = drm_kunit_helper_alloc_device(test); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); > + > + vc4 = drm_kunit_helper_alloc_drm_device_with_driver(test, dev, > + struct vc4_dev, base, > + drv); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); > + > + vc4->dev = dev; > + vc4->is_vc5 = is_vc5; > + > + vc4->hvs = __vc4_hvs_alloc(vc4, NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4->hvs); > + > + drm = &vc4->base; > + ret = __build_mock(test, drm, desc); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = vc4_kms_load(drm); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + ret = drm_dev_register(drm, 0); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + return vc4; > +} > + > +struct vc4_dev *vc4_mock_device(struct kunit *test) > +{ > + return __mock_device(test, false); > +} > + > +struct vc4_dev *vc5_mock_device(struct kunit *test) > +{ > + return __mock_device(test, true); > +} > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock.h b/drivers/gpu/drm/vc4/tests/vc4_mock.h > new file mode 100644 > index 000000000000..ace5b2e00f4a > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock.h > @@ -0,0 +1,60 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > + > +#ifndef VC4_MOCK_H_ > +#define VC4_MOCK_H_ > + > +#include "../vc4_drv.h" > + > +static inline > +struct drm_crtc *vc4_find_crtc_for_encoder(struct kunit *test, > + struct drm_device *drm, > + struct drm_encoder *encoder) > +{ > + struct drm_crtc *crtc; > + > + KUNIT_ASSERT_EQ(test, hweight32(encoder->possible_crtcs), 1); > + > + drm_for_each_crtc(crtc, drm) > + if (encoder->possible_crtcs & drm_crtc_mask(crtc)) > + return crtc; > + > + return NULL; > +} > + > +struct vc4_dummy_plane { > + struct vc4_plane plane; > +}; > + > +struct vc4_dummy_plane *vc4_dummy_plane(struct kunit *test, > + struct drm_device *drm, > + enum drm_plane_type type); > + > +struct vc4_dummy_crtc { > + struct vc4_crtc crtc; > +}; > + > +struct vc4_dummy_crtc *vc4_mock_pv(struct kunit *test, > + struct drm_device *drm, > + struct drm_plane *plane, > + const struct vc4_crtc_data *data); > + > +struct vc4_dummy_output { > + struct vc4_encoder encoder; > + struct drm_connector connector; > +}; > + > +struct vc4_dummy_output *vc4_dummy_output(struct kunit *test, > + struct drm_device *drm, > + struct drm_crtc *crtc, > + enum vc4_encoder_type vc4_encoder_type, > + unsigned int kms_encoder_type, > + unsigned int connector_type); > + > +struct vc4_dev *vc4_mock_device(struct kunit *test); > +struct vc4_dev *vc5_mock_device(struct kunit *test); > + > +int vc4_mock_atomic_add_output(struct kunit *test, struct drm_device *drm, > + enum vc4_encoder_type type, > + struct drm_atomic_state *state); > + > +#endif // VC4_MOCK_H_ > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock_crtc.c b/drivers/gpu/drm/vc4/tests/vc4_mock_crtc.c > new file mode 100644 > index 000000000000..5d12d7beef0e > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock_crtc.c > @@ -0,0 +1,41 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include <drm/drm_atomic_state_helper.h> > +#include <drm/drm_modeset_helper_vtables.h> > + > +#include <kunit/test.h> > + > +#include "vc4_mock.h" > + > +static const struct drm_crtc_helper_funcs vc4_dummy_crtc_helper_funcs = { > + .atomic_check = vc4_crtc_atomic_check, > +}; > + > +static const struct drm_crtc_funcs vc4_dummy_crtc_funcs = { > + .atomic_destroy_state = vc4_crtc_destroy_state, > + .atomic_duplicate_state = vc4_crtc_duplicate_state, > + .reset = vc4_crtc_reset, > +}; > + > +struct vc4_dummy_crtc *vc4_mock_pv(struct kunit *test, > + struct drm_device *drm, > + struct drm_plane *plane, > + const struct vc4_crtc_data *data) > +{ > + struct vc4_dummy_crtc *dummy_crtc; > + struct vc4_crtc *vc4_crtc; > + int ret; > + > + dummy_crtc = kunit_kzalloc(test, sizeof(*dummy_crtc), GFP_KERNEL); > + KUNIT_ASSERT_NOT_NULL(test, dummy_crtc); > + > + vc4_crtc = &dummy_crtc->crtc; > + ret = __vc4_crtc_init(drm, NULL, > + vc4_crtc, data, plane, > + &vc4_dummy_crtc_funcs, > + &vc4_dummy_crtc_helper_funcs, > + false); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + return dummy_crtc; > +} > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock_output.c b/drivers/gpu/drm/vc4/tests/vc4_mock_output.c > new file mode 100644 > index 000000000000..cb16ab4451f7 > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock_output.c > @@ -0,0 +1,99 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include <drm/drm_atomic_state_helper.h> > +#include <drm/drm_atomic_uapi.h> > +#include <drm/drm_connector.h> > +#include <drm/drm_crtc.h> > +#include <drm/drm_encoder.h> > +#include <drm/drm_modeset_helper_vtables.h> > + > +#include <kunit/test.h> > + > +#include "vc4_mock.h" > + > +static const struct drm_connector_helper_funcs vc4_dummy_connector_helper_funcs = { > +}; > + > +static const struct drm_connector_funcs vc4_dummy_connector_funcs = { > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .reset = drm_atomic_helper_connector_reset, > +}; > + > +struct vc4_dummy_output *vc4_dummy_output(struct kunit *test, > + struct drm_device *drm, > + struct drm_crtc *crtc, > + enum vc4_encoder_type vc4_encoder_type, > + unsigned int kms_encoder_type, > + unsigned int connector_type) > +{ > + struct vc4_dummy_output *dummy_output; > + struct drm_connector *conn; > + struct drm_encoder *enc; > + int ret; > + > + dummy_output = kunit_kzalloc(test, sizeof(*dummy_output), GFP_KERNEL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dummy_output); > + dummy_output->encoder.type = vc4_encoder_type; > + > + enc = &dummy_output->encoder.base; > + ret = drmm_encoder_init(drm, enc, > + NULL, > + kms_encoder_type, > + NULL); > + KUNIT_ASSERT_EQ(test, ret, 0); > + enc->possible_crtcs = drm_crtc_mask(crtc); > + > + conn = &dummy_output->connector; > + ret = drmm_connector_init(drm, conn, > + &vc4_dummy_connector_funcs, > + connector_type, > + NULL); > + KUNIT_ASSERT_EQ(test, ret, 0); > + > + drm_connector_helper_add(conn, &vc4_dummy_connector_helper_funcs); > + drm_connector_attach_encoder(conn, enc); > + > + return dummy_output; > +} > + > +static const struct drm_display_mode default_mode = { > + DRM_SIMPLE_MODE(640, 480, 64, 48) > +}; > + > +int vc4_mock_atomic_add_output(struct kunit *test, struct drm_device *drm, > + enum vc4_encoder_type type, > + struct drm_atomic_state *state) > +{ > + struct vc4_dummy_output *output; > + struct drm_connector *conn; > + struct drm_connector_state *conn_state; > + struct drm_encoder *encoder; > + struct drm_crtc *crtc; > + struct drm_crtc_state *crtc_state; > + int ret; > + > + encoder = vc4_find_encoder_by_type(drm, type); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, encoder); > + > + crtc = vc4_find_crtc_for_encoder(test, drm, encoder); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc); > + > + output = container_of(encoder, struct vc4_dummy_output, encoder.base); > + conn = &output->connector; > + conn_state = drm_atomic_get_connector_state(state, conn); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state); > + > + ret = drm_atomic_set_crtc_for_connector(conn_state, crtc); > + KUNIT_EXPECT_EQ(test, ret, 0); > + > + crtc_state = drm_atomic_get_crtc_state(state, crtc); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); > + > + ret = drm_atomic_set_mode_for_crtc(crtc_state, &default_mode); > + KUNIT_EXPECT_EQ(test, ret, 0); > + > + crtc_state->active = true; > + > + return 0; > +} > diff --git a/drivers/gpu/drm/vc4/tests/vc4_mock_plane.c b/drivers/gpu/drm/vc4/tests/vc4_mock_plane.c > new file mode 100644 > index 000000000000..62b18f5f41db > --- /dev/null > +++ b/drivers/gpu/drm/vc4/tests/vc4_mock_plane.c > @@ -0,0 +1,47 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include <drm/drm_atomic_state_helper.h> > +#include <drm/drm_fourcc.h> > +#include <drm/drm_modeset_helper_vtables.h> > +#include <drm/drm_plane.h> > + > +#include <kunit/test.h> > + > +#include "vc4_mock.h" > + > +static const struct drm_plane_helper_funcs vc4_dummy_plane_helper_funcs = { > +}; > + > +static const struct drm_plane_funcs vc4_dummy_plane_funcs = { > + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, > + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, > + .reset = drm_atomic_helper_plane_reset, > +}; > + > +static const uint32_t vc4_dummy_plane_formats[] = { > + DRM_FORMAT_XRGB8888, > +}; > + > +struct vc4_dummy_plane *vc4_dummy_plane(struct kunit *test, > + struct drm_device *drm, > + enum drm_plane_type type) > +{ > + struct vc4_dummy_plane *dummy_plane; > + struct drm_plane *plane; > + > + dummy_plane = drmm_universal_plane_alloc(drm, > + struct vc4_dummy_plane, plane.base, > + 0, > + &vc4_dummy_plane_funcs, > + vc4_dummy_plane_formats, > + ARRAY_SIZE(vc4_dummy_plane_formats), > + NULL, > + DRM_PLANE_TYPE_PRIMARY, > + NULL); > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dummy_plane); > + > + plane = &dummy_plane->plane.base; > + drm_plane_helper_add(plane, &vc4_dummy_plane_helper_funcs); > + > + return dummy_plane; > +} > diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c > index 195d2b61839d..7d1a696477ce 100644 > --- a/drivers/gpu/drm/vc4/vc4_crtc.c > +++ b/drivers/gpu/drm/vc4/vc4_crtc.c > @@ -675,8 +675,8 @@ void vc4_crtc_get_margins(struct drm_crtc_state *state, > } > } > > -static int vc4_crtc_atomic_check(struct drm_crtc *crtc, > - struct drm_atomic_state *state) > +int vc4_crtc_atomic_check(struct drm_crtc *crtc, > + struct drm_atomic_state *state) > { > struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, > crtc); > @@ -1116,7 +1116,7 @@ static const struct drm_crtc_helper_funcs vc4_crtc_helper_funcs = { > .get_scanout_position = vc4_crtc_get_scanout_position, > }; > > -static const struct vc4_pv_data bcm2835_pv0_data = { > +const struct vc4_pv_data bcm2835_pv0_data = { > .base = { > .name = "pixelvalve-0", > .debugfs_name = "crtc0_regs", > @@ -1131,7 +1131,7 @@ static const struct vc4_pv_data bcm2835_pv0_data = { > }, > }; > > -static const struct vc4_pv_data bcm2835_pv1_data = { > +const struct vc4_pv_data bcm2835_pv1_data = { > .base = { > .name = "pixelvalve-1", > .debugfs_name = "crtc1_regs", > @@ -1146,7 +1146,7 @@ static const struct vc4_pv_data bcm2835_pv1_data = { > }, > }; > > -static const struct vc4_pv_data bcm2835_pv2_data = { > +const struct vc4_pv_data bcm2835_pv2_data = { > .base = { > .name = "pixelvalve-2", > .debugfs_name = "crtc2_regs", > @@ -1161,7 +1161,7 @@ static const struct vc4_pv_data bcm2835_pv2_data = { > }, > }; > > -static const struct vc4_pv_data bcm2711_pv0_data = { > +const struct vc4_pv_data bcm2711_pv0_data = { > .base = { > .name = "pixelvalve-0", > .debugfs_name = "crtc0_regs", > @@ -1176,7 +1176,7 @@ static const struct vc4_pv_data bcm2711_pv0_data = { > }, > }; > > -static const struct vc4_pv_data bcm2711_pv1_data = { > +const struct vc4_pv_data bcm2711_pv1_data = { > .base = { > .name = "pixelvalve-1", > .debugfs_name = "crtc1_regs", > @@ -1191,7 +1191,7 @@ static const struct vc4_pv_data bcm2711_pv1_data = { > }, > }; > > -static const struct vc4_pv_data bcm2711_pv2_data = { > +const struct vc4_pv_data bcm2711_pv2_data = { > .base = { > .name = "pixelvalve-2", > .debugfs_name = "crtc2_regs", > @@ -1205,7 +1205,7 @@ static const struct vc4_pv_data bcm2711_pv2_data = { > }, > }; > > -static const struct vc4_pv_data bcm2711_pv3_data = { > +const struct vc4_pv_data bcm2711_pv3_data = { > .base = { > .name = "pixelvalve-3", > .debugfs_name = "crtc3_regs", > @@ -1219,7 +1219,7 @@ static const struct vc4_pv_data bcm2711_pv3_data = { > }, > }; > > -static const struct vc4_pv_data bcm2711_pv4_data = { > +const struct vc4_pv_data bcm2711_pv4_data = { > .base = { > .name = "pixelvalve-4", > .debugfs_name = "crtc4_regs", > diff --git a/drivers/gpu/drm/vc4/vc4_drv.c b/drivers/gpu/drm/vc4/vc4_drv.c > index 5990d8f8c363..3b0ae2c3e33c 100644 > --- a/drivers/gpu/drm/vc4/vc4_drv.c > +++ b/drivers/gpu/drm/vc4/vc4_drv.c > @@ -196,7 +196,7 @@ static const struct drm_ioctl_desc vc4_drm_ioctls[] = { > DRM_IOCTL_DEF_DRV(VC4_PERFMON_GET_VALUES, vc4_perfmon_get_values_ioctl, DRM_RENDER_ALLOW), > }; > > -static const struct drm_driver vc4_drm_driver = { > +const struct drm_driver vc4_drm_driver = { > .driver_features = (DRIVER_MODESET | > DRIVER_ATOMIC | > DRIVER_GEM | > @@ -225,7 +225,7 @@ static const struct drm_driver vc4_drm_driver = { > .patchlevel = DRIVER_PATCHLEVEL, > }; > > -static const struct drm_driver vc5_drm_driver = { > +const struct drm_driver vc5_drm_driver = { > .driver_features = (DRIVER_MODESET | > DRIVER_ATOMIC | > DRIVER_GEM), > diff --git a/drivers/gpu/drm/vc4/vc4_drv.h b/drivers/gpu/drm/vc4/vc4_drv.h > index e0be7a81a24a..418f4f308e36 100644 > --- a/drivers/gpu/drm/vc4/vc4_drv.h > +++ b/drivers/gpu/drm/vc4/vc4_drv.h > @@ -24,6 +24,9 @@ > struct drm_device; > struct drm_gem_object; > > +extern const struct drm_driver vc4_drm_driver; > +extern const struct drm_driver vc5_drm_driver; > + > /* Don't forget to update vc4_bo.c: bo_type_names[] when adding to > * this. > */ > @@ -523,6 +526,8 @@ struct vc4_crtc_data { > int hvs_output; > }; > > +extern const struct vc4_crtc_data vc4_txp_crtc_data; > + > struct vc4_pv_data { > struct vc4_crtc_data base; > > @@ -535,6 +540,15 @@ struct vc4_pv_data { > enum vc4_encoder_type encoder_types[4]; > }; > > +extern const struct vc4_pv_data bcm2835_pv0_data; > +extern const struct vc4_pv_data bcm2835_pv1_data; > +extern const struct vc4_pv_data bcm2835_pv2_data; > +extern const struct vc4_pv_data bcm2711_pv0_data; > +extern const struct vc4_pv_data bcm2711_pv1_data; > +extern const struct vc4_pv_data bcm2711_pv2_data; > +extern const struct vc4_pv_data bcm2711_pv3_data; > +extern const struct vc4_pv_data bcm2711_pv4_data; > + > struct vc4_crtc { > struct drm_crtc base; > struct platform_device *pdev; > @@ -920,6 +934,8 @@ int vc4_page_flip(struct drm_crtc *crtc, > struct drm_pending_vblank_event *event, > uint32_t flags, > struct drm_modeset_acquire_ctx *ctx); > +int vc4_crtc_atomic_check(struct drm_crtc *crtc, > + struct drm_atomic_state *state); > struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc); > void vc4_crtc_destroy_state(struct drm_crtc *crtc, > struct drm_crtc_state *state); > diff --git a/drivers/gpu/drm/vc4/vc4_txp.c b/drivers/gpu/drm/vc4/vc4_txp.c > index 4f7ce5d3e8ad..2b69454b8534 100644 > --- a/drivers/gpu/drm/vc4/vc4_txp.c > +++ b/drivers/gpu/drm/vc4/vc4_txp.c > @@ -479,7 +479,7 @@ static irqreturn_t vc4_txp_interrupt(int irq, void *data) > return IRQ_HANDLED; > } > > -static const struct vc4_crtc_data vc4_txp_crtc_data = { > +const struct vc4_crtc_data vc4_txp_crtc_data = { > .name = "txp", > .debugfs_name = "txp_regs", > .hvs_available_channels = BIT(2), >

2 years, 5 months

1
0
0 0

Re: [PATCH v3 04/20] drm/tests: helpers: Switch to EXPORT_SYMBOL_GPL

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > drm_kunit_device_init() among other things will allocate a device and > wrap around root_device_register. This function is exported with > EXPORT_SYMBOL_GPL, so we can't really change the license. > > Fixes: 199557fab925 ("drm/tests: helpers: Add missing export") > Suggested-by: Javier Martinez Canillas <javierm(a)redhat.com> > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> Best Regards, - Maíra Canal > --- > drivers/gpu/drm/tests/drm_kunit_helpers.c | 2 +- > 1 file changed, 1 insertion(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/tests/drm_kunit_helpers.c b/drivers/gpu/drm/tests/drm_kunit_helpers.c > index 9ed3cfc2ac03..4fe131141718 100644 > --- a/drivers/gpu/drm/tests/drm_kunit_helpers.c > +++ b/drivers/gpu/drm/tests/drm_kunit_helpers.c > @@ -82,7 +82,7 @@ struct drm_device *drm_kunit_device_init(struct kunit *test, u32 features, char > > return drm; > } > -EXPORT_SYMBOL(drm_kunit_device_init); > +EXPORT_SYMBOL_GPL(drm_kunit_device_init); > > MODULE_AUTHOR("Maxime Ripard <maxime(a)cerno.tech>"); > MODULE_LICENSE("GPL"); >

2 years, 5 months

1
0
0 0

Re: [PATCH v3 02/20] drm/tests: Introduce a config option for the KUnit helpers

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > Driver-specific tests will need access to the helpers without pulling > every DRM framework test. Let's create an intermediate Kconfig options > for the helpers. > > Suggested-by: Maíra Canal <mcanal(a)igalia.com> > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> Best Regards, - Maíra Canal > --- > drivers/gpu/drm/Kconfig | 7 +++++++ > drivers/gpu/drm/Makefile | 2 +- > drivers/gpu/drm/tests/Makefile | 4 +++- > 3 files changed, 11 insertions(+), 2 deletions(-) > > diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > index 315cbdf61979..9f019cd053e1 100644 > --- a/drivers/gpu/drm/Kconfig > +++ b/drivers/gpu/drm/Kconfig > @@ -63,6 +63,12 @@ config DRM_USE_DYNAMIC_DEBUG > bytes per callsite, the .data costs can be substantial, and > are therefore configurable. > > +config DRM_KUNIT_TEST_HELPERS > + tristate > + depends on DRM && KUNIT > + help > + KUnit Helpers for KMS drivers. > + > config DRM_KUNIT_TEST > tristate "KUnit tests for DRM" if !KUNIT_ALL_TESTS > depends on DRM && KUNIT > @@ -73,6 +79,7 @@ config DRM_KUNIT_TEST > select DRM_KMS_HELPER > select DRM_BUDDY > select DRM_EXPORT_FOR_TESTS if m > + select DRM_KUNIT_TEST_HELPERS > default KUNIT_ALL_TESTS > help > This builds unit tests for DRM. This option is not useful for > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index f92cd7892711..8d61fbdfdfac 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -125,7 +125,7 @@ obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o > # Drivers and the rest > # > > -obj-$(CONFIG_DRM_KUNIT_TEST) += tests/ > +obj-y += tests/ > > obj-$(CONFIG_DRM_MIPI_DBI) += drm_mipi_dbi.o > obj-$(CONFIG_DRM_MIPI_DSI) += drm_mipi_dsi.o > diff --git a/drivers/gpu/drm/tests/Makefile b/drivers/gpu/drm/tests/Makefile > index 94fe546d937d..ef14bd481139 100644 > --- a/drivers/gpu/drm/tests/Makefile > +++ b/drivers/gpu/drm/tests/Makefile > @@ -1,5 +1,8 @@ > # SPDX-License-Identifier: GPL-2.0 > > +obj-$(CONFIG_DRM_KUNIT_TEST_HELPERS) += \ > + drm_kunit_helpers.o > + > obj-$(CONFIG_DRM_KUNIT_TEST) += \ > drm_buddy_test.o \ > drm_cmdline_parser_test.o \ > @@ -9,7 +12,6 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \ > drm_format_helper_test.o \ > drm_format_test.o \ > drm_framebuffer_test.o \ > - drm_kunit_helpers.o \ > drm_mm_test.o \ > drm_modes_test.o \ > drm_plane_helper_test.o \ >

2 years, 5 months

1
0
0 0

Re: [PATCH v3 20/20] Documentation: gpu: vc4: Add KUnit Tests Section

by Maíra Canal

On 12/1/22 12:11, Maxime Ripard wrote: > Now that we have VC4-specific tests in place, let's document them > properly. > > Signed-off-by: Maxime Ripard <maxime(a)cerno.tech> Reviewed-by: Maíra Canal <mcanal(a)igalia.com> Just a small nit below. > --- > Documentation/gpu/vc4.rst | 16 ++++++++++++++++ > 1 file changed, 16 insertions(+) > > diff --git a/Documentation/gpu/vc4.rst b/Documentation/gpu/vc4.rst > index 5df1d98b9544..a2375f1584e6 100644 > --- a/Documentation/gpu/vc4.rst > +++ b/Documentation/gpu/vc4.rst > @@ -54,6 +54,22 @@ VEC (Composite TV out) encoder > .. kernel-doc:: drivers/gpu/drm/vc4/vc4_vec.c > :doc: VC4 SDTV module > > +KUnit Tests > +=========== > + > +The VC4 Driver uses KUnit to perform driver-specific unit and > +integration tests. > + > +These tests are using a mock driver and can be ran using the > +command:: > + ./tools/testing/kunit/kunit.py run \ > + --kunitconfig=drivers/gpu/drm/vc4/tests/.kunitconfig \ > + --cross_compile aarch64-linux-gnu- --arch arm64 I believe you could use a code block here, like: .. code-block:: bash $ ./tools/testing/kunit/kunit.py run \ --kunitconfig=drivers/gpu/drm/vc4/tests/.kunitconfig \ --cross_compile aarch64-linux-gnu- --arch arm64 You could also mention that you can run the tests with --arch arm. Best Regards, - Maíra Canal > + > +Parts of the driver that are currently covered by tests are: > + * The HVS to PixelValve dynamic FIFO assignment, for the BCM2835-7 > + and BCM2711. > + > Memory Management and 3D Command Submission > =========================================== > >

2 years, 5 months

1
0
0 0

[PATCH RESEND] Documentation: dev-tools: Clarify requirements for result description

by Mark Brown

Currently the KTAP specification says that a test result line is <result> <number> [<description>][ # [<directive>] [<diagnostic data>]] and the description of a test can be "any sequence of words (can't include #)" which specifies that there may be more than one word but does not specify anything other than those words which might be used to separate the words which probably isn't what we want. Given that practically we have tests using a range of separators for words including combinations of spaces and combinations of other symbols like underscores or punctuation let's just clarify that the description can contain any character other than # (marking the start of the directive/diagnostic) or newline (marking the end of this test result). Signed-off-by: Mark Brown <broonie(a)kernel.org> Reviewed-by: Kees Cook <keescook(a)chromium.org> Reviewed-by: David Gow <davidgow(a)google.com> --- Documentation/dev-tools/ktap.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Documentation/dev-tools/ktap.rst b/Documentation/dev-tools/ktap.rst index d0a9565b0f44..414c105b10a9 100644 --- a/Documentation/dev-tools/ktap.rst +++ b/Documentation/dev-tools/ktap.rst @@ -80,8 +80,8 @@ have the number 1 and the number then must increase by 1 for each additional subtest within the same test at the same nesting level. The description is a description of the test, generally the name of -the test, and can be any string of words (can't include #). The -description is optional, but recommended. +the test, and can be any string of characters other than # or a +newline. The description is optional, but recommended. The directive and any diagnostic data is optional. If either are present, they must follow a hash sign, "#". -- 2.30.2

2 years, 5 months

2
1
0 0

[PATCH] selftests: Fix spelling mistake "allright" -> "alright"

by Colin Ian King

There are spelling mistakes in messages in the prctl tests. Fix these. Note: One can use "all right", or "alright", I'm fixing this to use the slightly more informal and more modern form of the spelling for the fix. Signed-off-by: Colin Ian King <colin.i.king(a)gmail.com> --- tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c | 2 +- tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c b/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c index 62a93cc61b7c..868f37fd1d5e 100644 --- a/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c +++ b/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c @@ -79,7 +79,7 @@ int main(void) { int n_tasks = 100, i; - fprintf(stderr, "[No further output means we're allright]\n"); + fprintf(stderr, "[No further output means we're alright]\n"); for (i=0; i<n_tasks; i++) if (fork() == 0) diff --git a/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c b/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c index 79950f9a26fd..3822532fc0c6 100644 --- a/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c +++ b/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c @@ -83,7 +83,7 @@ int main(void) { int n_tasks = 100, i; - fprintf(stderr, "[No further output means we're allright]\n"); + fprintf(stderr, "[No further output means we're alright]\n"); for (i=0; i<n_tasks; i++) if (fork() == 0) -- 2.38.1

2 years, 5 months

1
0
0 0

[PATCH v2] Documentation: kunit: Fix "How Do I Use This" / "Next Steps" sections

by David Gow

The "How Do I Use This" section of index.rst and "Next Steps" section of start.rst were just copies of the table of contents, and therefore weren't really useful either when looking a sphinx generated output (which already had the TOC visible) or when reading the source (where it's just a list of files that ls could give you). Instead, provide a small number of concrete next steps, and a bit more description about what the pages contain. This also removes the broken reference to 'tips.rst', which was previously removed. Fixes: 4399c737a97d ("Documentation: kunit: Remove redundant 'tips.rst' page") Signed-off-by: David Gow <davidgow(a)google.com> --- Thanks everyone for reviewing v1. Since this is pretty much a complete rewrite, I've left Reviewed-by tags off, as I don't feel the previous reviews totally apply. Feel free to review again if you have any comments. Cheers, -- David Changes since v1: https://lore.kernel.org/linux-kselftest/20221129094732.306449-1-davidgow@go… - Totally rewrite both sections to only include (and provide more context for) the most concrete next steps. - Thanks Bagas for pointing out that this basically duplicates the TOC as-is. --- Documentation/dev-tools/kunit/index.rst | 19 ++++++++----------- Documentation/dev-tools/kunit/start.rst | 19 +++++++++---------- 2 files changed, 17 insertions(+), 21 deletions(-) diff --git a/Documentation/dev-tools/kunit/index.rst b/Documentation/dev-tools/kunit/index.rst index d5629817cd72..b3593ae29ace 100644 --- a/Documentation/dev-tools/kunit/index.rst +++ b/Documentation/dev-tools/kunit/index.rst @@ -99,14 +99,11 @@ Read also :ref:`kinds-of-tests`. How do I use it? ================ -* Documentation/dev-tools/kunit/start.rst - for KUnit new users. -* Documentation/dev-tools/kunit/architecture.rst - KUnit architecture. -* Documentation/dev-tools/kunit/run_wrapper.rst - run kunit_tool. -* Documentation/dev-tools/kunit/run_manual.rst - run tests without kunit_tool. -* Documentation/dev-tools/kunit/usage.rst - write tests. -* Documentation/dev-tools/kunit/tips.rst - best practices with - examples. -* Documentation/dev-tools/kunit/api/index.rst - KUnit APIs - used for testing. -* Documentation/dev-tools/kunit/faq.rst - KUnit common questions and - answers. +You can find a step-by-step guide to writing and running KUnit tests in +Documentation/dev-tools/kunit/start.rst + +Alternatively, feel free to look through the rest of the KUnit documentation, +or to experiment with tools/testing/kunit/kunit.py and the example test under +lib/kunit/kunit-example-test.c + +Happy testing! diff --git a/Documentation/dev-tools/kunit/start.rst b/Documentation/dev-tools/kunit/start.rst index f4f504f1fb15..224387a43543 100644 --- a/Documentation/dev-tools/kunit/start.rst +++ b/Documentation/dev-tools/kunit/start.rst @@ -294,13 +294,12 @@ Congrats! You just wrote your first KUnit test. Next Steps ========== -* Documentation/dev-tools/kunit/architecture.rst - KUnit architecture. -* Documentation/dev-tools/kunit/run_wrapper.rst - run kunit_tool. -* Documentation/dev-tools/kunit/run_manual.rst - run tests without kunit_tool. -* Documentation/dev-tools/kunit/usage.rst - write tests. -* Documentation/dev-tools/kunit/tips.rst - best practices with - examples. -* Documentation/dev-tools/kunit/api/index.rst - KUnit APIs - used for testing. -* Documentation/dev-tools/kunit/faq.rst - KUnit common questions and - answers. +If you're interested in using some of the more advanced features of kunit.py, +take a look at Documentation/dev-tools/kunit/run_wrapper.rst + +If you'd like to run tests without using kunit.py, check out +Documentation/dev-tools/kunit/run_manual.rst + +For more information on writing KUnit tests (including some common techniques +for testing different things), see Documentation/dev-tools/kunit/usage.rst + -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

3
2
0 0

[PATCH bpf-next v3 0/4] bpf: Support kernel function call in 32-bit ARM

by Yang Jihong

1. Patch1 is dependent patch to fix zext extension error in 32-bit ARM. 2. Patch2 supports bpf fkunc in 32-bit ARM for EABI. 3. Patch3 is used to add test cases to cover some parameter scenarios states by AAPCS. 4. Patch4 fix a comment error. The following is the test_progs result in the 32-bit ARM environment: # uname -m armv7l # echo 1 > /proc/sys/net/core/bpf_jit_enable # ./test_progs -t kfunc_call #1/1 kfunc_call/kfunc_syscall_test_fail:OK #1/2 kfunc_call/kfunc_syscall_test_null_fail:OK #1/3 kfunc_call/kfunc_call_test_get_mem_fail_rdonly:OK #1/4 kfunc_call/kfunc_call_test_get_mem_fail_use_after_free:OK #1/5 kfunc_call/kfunc_call_test_get_mem_fail_oob:OK #1/6 kfunc_call/kfunc_call_test_get_mem_fail_not_const:OK #1/7 kfunc_call/kfunc_call_test_mem_acquire_fail:OK #1/8 kfunc_call/kfunc_call_test1:OK #1/9 kfunc_call/kfunc_call_test2:OK #1/10 kfunc_call/kfunc_call_test4:OK #1/11 kfunc_call/kfunc_call_test5:OK #1/12 kfunc_call/kfunc_call_test6:OK #1/13 kfunc_call/kfunc_call_test_ref_btf_id:OK #1/14 kfunc_call/kfunc_call_test_get_mem:OK #1/15 kfunc_call/kfunc_syscall_test:OK #1/16 kfunc_call/kfunc_syscall_test_null:OK #1/19 kfunc_call/destructive:OK --- Changes since v2: - Remove patches to adjust sk size check for CO_RE in 32-bit arch. - Add check of kfunc's return value in insn_def_regno. - Adjust is_reg64 for insn_def_regno. - The check of CONFIG_AEABI is moved from emit_kfunc_call to bpf_jit_supports_kfunc_call. - Fix a comment error in fixup_kfunc_call. Yang Jihong (4): bpf: Adapt 32-bit return value kfunc for 32-bit ARM when zext extension bpf: Add kernel function call support in 32-bit ARM for EABI bpf:selftests: Add kfunc_call test for mixing 32-bit and 64-bit parameters bpf: Fix comment error in fixup_kfunc_call function arch/arm/net/bpf_jit_32.c | 137 ++++++++++++++++++ kernel/bpf/verifier.c | 46 +++++- net/bpf/test_run.c | 18 +++ .../selftests/bpf/prog_tests/kfunc_call.c | 3 + .../selftests/bpf/progs/kfunc_call_test.c | 52 +++++++ 5 files changed, 252 insertions(+), 4 deletions(-) -- 2.30.GIT

2 years, 5 months

2
11
0 0

[PATCH] KVM: selftests: Fix build for memstress.[ch] rename

by Mark Brown

Today's -next fails to build the KVM selftests on at least arm64 due to commit 9fda6753c9dd ("KVM: selftests: Rename perf_test_util.[ch] to memstress.[ch]") interacting poorly with commit a93871d0ea9f ("KVM: selftests: Add a userfaultfd library") which adds a new user of perf_test_util.h. Do the rename in the new user. Fixes: 9fda6753c9dd ("KVM: selftests: Rename perf_test_util.[ch] to memstress.[ch]") Fixes: a93871d0ea9f ("KVM: selftests: Add a userfaultfd library") Signed-off-by: Mark Brown <broonie(a)kernel.org> Cc: Ricardo Koller <ricarkol(a)google.com> Cc: Marc Zyngier <maz(a)kernel.org> Cc: David Matlack <dmatlack(a)google.com> Cc: Sean Christopherson <seanjc(a)google.com> Cc: Paolo Bonzini <pbonzini(a)redhat.com> Cc: Stephen Rothwell <sfr(a)canb.auug.org.au> --- tools/testing/selftests/kvm/lib/userfaultfd_util.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/kvm/lib/userfaultfd_util.c b/tools/testing/selftests/kvm/lib/userfaultfd_util.c index 3b44846fc277..92cef20902f1 100644 --- a/tools/testing/selftests/kvm/lib/userfaultfd_util.c +++ b/tools/testing/selftests/kvm/lib/userfaultfd_util.c @@ -20,7 +20,7 @@ #include "kvm_util.h" #include "test_util.h" -#include "perf_test_util.h" +#include "memstress.h" #include "userfaultfd_util.h" #ifdef __NR_userfaultfd -- 2.30.2

2 years, 5 months

5
4
0 0

[PATCH v3 0/2] kunit: add macro to allow conditionally exposing static symbols to tests

by Rae Moar

Currently in order to test a static function, tests must be included in the same translation unit as the function. However, this can cause issues with including implementation and test code in the same file. As an alternative, the first patch in this series creates a macro that will set a function to be static or not depending on whether CONFIG_KUNIT is enabled. This allows the function to be visible during testing and static otherwise. As an example, the current status quo to test static functions is: === test.c === static void test_case(struct kunit *test) { KUNIT_EXPECT_EQ(test, my_func_to_test(), 2); } Then the tests are included in the implementation file as a workaround to the issue of testing static functions: === implementation.c === static int my_func_to_test() {...} ... #include "test.c" Instead, the function could be defined with this new macro: === implementation.c === VISIBLE_IF_KUNIT int my_func_to_test() {...} The first patch also creates a macro that will export a symbol into a kunit testing namespace only if CONFIG_KUNIT is enabled. This follows the logic above and allows symbols to be conditionally exported based on the testing status. The second patch in the series updates the policy_unpack test in AppArmor to show an example of how to use both of these macros in order to address the issue of testing static functions. Additionally, the patch allows the policy_unpack test to be built as a module. Changes since v2: - Add mention of namespacing symbols to the commit message of the second patch. - Change module name in the second patch from policy_unpack_test to apparmor_policy_unpack_test. Changes since v1: - Changed the namespace of exported symbols for the apparmor policy_unpack_test by adding the aa_ prefix. - Separated the documentation comments for macros in include/kunit/visibility.h. - Changed copyright date and author for include/kunit/visibility.h. Rae Moar (2): kunit: add macro to allow conditionally exposing static symbols to tests apparmor: test: make static symbols visible during kunit testing include/kunit/visibility.h | 33 +++ security/apparmor/Kconfig | 4 +- security/apparmor/Makefile | 3 + security/apparmor/include/policy_unpack.h | 50 +++++ security/apparmor/policy_unpack.c | 238 ++++++++++------------ security/apparmor/policy_unpack_test.c | 69 ++++--- 6 files changed, 229 insertions(+), 168 deletions(-) create mode 100644 include/kunit/visibility.h base-commit: 0f08f3e2a0186dfb8e33cb46105228eb18448a0e -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

3
4
0 0

[PATCH v5 0/6] mm/memfd: introduce MFD_NOEXEC_SEAL and MFD_EXEC

by jeffxu＠chromium.org

From: Jeff Xu <jeffxu(a)chromium.org> Since Linux introduced the memfd feature, memfd have always had their execute bit set, and the memfd_create() syscall doesn't allow setting it differently. However, in a secure by default system, such as ChromeOS, (where all executables should come from the rootfs, which is protected by Verified boot), this executable nature of memfd opens a door for NoExec bypass and enables “confused deputy attack”. E.g, in VRP bug [1]: cros_vm process created a memfd to share the content with an external process, however the memfd is overwritten and used for executing arbitrary code and root escalation. [2] lists more VRP in this kind. On the other hand, executable memfd has its legit use, runc uses memfd’s seal and executable feature to copy the contents of the binary then execute them, for such system, we need a solution to differentiate runc's use of executable memfds and an attacker's [3]. To address those above, this set of patches add following: 1> Let memfd_create() set X bit at creation time. 2> Let memfd to be sealed for modifying X bit. 3> A new pid namespace sysctl: vm.memfd_noexec to control behavior of X bit. For example, if a container has vm.memfd_noexec=2, then memfd_create() without MFD_NOEXEC_SEAL will be rejected. 4> A new security hook in memfd_create(). This make it possible to a new LSM, which rejects or allows executable memfd based on its security policy. This is V4 version of patch: see [4] [5] [6] for previous versions. [1] https://crbug.com/1305411 [2] https://bugs.chromium.org/p/chromium/issues/list?q=type%3Dbug-security%20me… [3] https://lwn.net/Articles/781013/ [4] https://lwn.net/Articles/890096/ [5] https://lore.kernel.org/lkml/20220805222126.142525-1-jeffxu@chromium.org/ [6] https://lore.kernel.org/lkml/20221202013404.163143-1-jeffxu@chromium.org/ Daniel Verkamp (2): mm/memfd: add F_SEAL_EXEC selftests/memfd: add tests for F_SEAL_EXEC Jeff Xu (4): mm/memfd: add MFD_NOEXEC_SEAL and MFD_EXEC mm/memfd: Add write seals when apply SEAL_EXEC to executable memfd selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC mm/memfd: security hook for memfd_create include/linux/lsm_hook_defs.h | 1 + include/linux/lsm_hooks.h | 4 + include/linux/pid_namespace.h | 19 ++ include/linux/security.h | 6 + include/uapi/linux/fcntl.h | 1 + include/uapi/linux/memfd.h | 4 + kernel/pid_namespace.c | 48 ++++ mm/memfd.c | 61 ++++- mm/shmem.c | 6 + security/security.c | 13 + tools/testing/selftests/memfd/fuse_test.c | 1 + tools/testing/selftests/memfd/memfd_test.c | 304 ++++++++++++++++++++- 12 files changed, 465 insertions(+), 3 deletions(-) base-commit: eb7081409f94a9a8608593d0fb63a1aa3d6f95d8 -- 2.39.0.rc0.267.gcb52ba06e7-goog

2 years, 5 months

4
12
0 0

[PATCH] KVM: selftests: Fix build due to ucall_uninit() removal

by Mark Brown

Today's -next fails to build on arm64 due to: In file included from include/kvm_util.h:11, from aarch64/page_fault_test.c:15: include/ucall_common.h:36:47: note: expected ‘vm_paddr_t’ {aka ‘long unsigned int’} but argument is of type ‘void *’ 36 | void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa); | ~~~~~~~~~~~^~~~~~~~ aarch64/page_fault_test.c:725:2: warning: implicit declaration of function ‘ucall_uninit’; did you mean ‘ucall_init’? [-Wimplicit-function-declaration] 725 | ucall_uninit(vm); | ^~~~~~~~~~~~ | ucall_init which is caused by commit interacting poorly with commit 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") As is done for other ucall_uninit() users remove the call in the newly added page_fault_test.c. Fixes: 28a65567acb5 ("KVM: selftests: Drop now-unnecessary ucall_uninit()") Fixes: 35c581015712 ("KVM: selftests: aarch64: Add aarch64/page_fault_test") Signed-off-by: Mark Brown <broonie(a)kernel.org> Cc: Sean Christopherson <seanjc(a)google.com> Cc: Ricardo Koller <ricarkol(a)google.com> Cc: Marc Zyngier <maz(a)kernel.org> --- tools/testing/selftests/kvm/aarch64/page_fault_test.c | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c index 05bb6a6369c2..4ef89c57a937 100644 --- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c +++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c @@ -722,7 +722,6 @@ static void run_test(enum vm_guest_mode mode, void *arg) vcpu_run_loop(vm, vcpu, test); - ucall_uninit(vm); kvm_vm_free(vm); free_uffd(test, pt_uffd, data_uffd); -- 2.30.2

2 years, 5 months

2
1
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror