X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=test%2Fdm%2Feth.c;h=6e002b8dce954dfca681393a0bea9f01d6224ea8;hb=e3b4fc9598388f47632a8c802aaa68b1154526f2;hp=f31f6b322d7c64cf1725b1ac6a1caeb05e1e4ad8;hpb=73c2bbeea3d09bb8c81adc8769fc53493b6c0351;p=oweals%2Fu-boot.git diff --git a/test/dm/eth.c b/test/dm/eth.c index f31f6b322d..6e002b8dce 100644 --- a/test/dm/eth.c +++ b/test/dm/eth.c @@ -1,161 +1,430 @@ +// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2015 National Instruments * * (C) Copyright 2015 * Joe Hershberger - * - * SPDX-License-Identifier: GPL-2.0 */ #include #include -#include -#include #include #include #include +#include +#include +#include #include +#include -DECLARE_GLOBAL_DATA_PTR; +#define DM_TEST_ETH_NUM 4 -static int dm_test_eth(struct dm_test_state *dms) +static int dm_test_eth(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); - setenv("ethact", "eth@10002000"); + env_set("ethact", "eth@10002000"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); - setenv("ethact", "eth@10003000"); + env_set("ethact", "eth@10003000"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10003000", getenv("ethact")); + ut_asserteq_str("eth@10003000", env_get("ethact")); - setenv("ethact", "eth@10004000"); + env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10004000", getenv("ethact")); + ut_asserteq_str("eth@10004000", env_get("ethact")); return 0; } DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT); -static int dm_test_eth_alias(struct dm_test_state *dms) +static int dm_test_eth_alias(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); - setenv("ethact", "eth0"); + env_set("ethact", "eth0"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); - setenv("ethact", "eth1"); + env_set("ethact", "eth1"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10004000", getenv("ethact")); + ut_asserteq_str("eth@10004000", env_get("ethact")); /* Expected to fail since eth2 is not defined in the device tree */ - setenv("ethact", "eth2"); + env_set("ethact", "eth2"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); - setenv("ethact", "eth5"); + env_set("ethact", "eth5"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10003000", getenv("ethact")); + ut_asserteq_str("eth@10003000", env_get("ethact")); return 0; } DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT); -static int dm_test_eth_prime(struct dm_test_state *dms) +static int dm_test_eth_prime(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); /* Expected to be "eth@10003000" because of ethprime variable */ - setenv("ethact", NULL); - setenv("ethprime", "eth5"); + env_set("ethact", NULL); + env_set("ethprime", "eth5"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10003000", getenv("ethact")); + ut_asserteq_str("eth@10003000", env_get("ethact")); /* Expected to be "eth@10002000" because it is first */ - setenv("ethact", NULL); - setenv("ethprime", NULL); + env_set("ethact", NULL); + env_set("ethprime", NULL); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); return 0; } DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT); -static int dm_test_eth_rotate(struct dm_test_state *dms) +/** + * This test case is trying to test the following scenario: + * - All ethernet devices are not probed + * - "ethaddr" for all ethernet devices are not set + * - "ethact" is set to a valid ethernet device name + * + * With Sandbox default test configuration, all ethernet devices are + * probed after power-up, so we have to manually create such scenario: + * - Remove all ethernet devices + * - Remove all "ethaddr" environment variables + * - Set "ethact" to the first ethernet device + * + * Do a ping test to see if anything goes wrong. + */ +static int dm_test_eth_act(struct unit_test_state *uts) { - char ethaddr[18]; + struct udevice *dev[DM_TEST_ETH_NUM]; + const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000", + "sbe5", "eth@10004000"}; + const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr", + "eth3addr", "eth1addr"}; + char ethaddr[DM_TEST_ETH_NUM][18]; + int i; - /* Invalidate eth1's MAC address */ + memset(ethaddr, '\0', sizeof(ethaddr)); net_ping_ip = string_to_ip("1.1.2.2"); - strcpy(ethaddr, getenv("eth1addr")); - /* Must disable access protection for eth1addr before clearing */ - setenv(".flags", "eth1addr"); - setenv("eth1addr", NULL); + /* Prepare the test scenario */ + for (i = 0; i < DM_TEST_ETH_NUM; i++) { + ut_assertok(uclass_find_device_by_name(UCLASS_ETH, + ethname[i], &dev[i])); + ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL)); + + /* Invalidate MAC address */ + strncpy(ethaddr[i], env_get(addrname[i]), 17); + /* Must disable access protection for ethaddr before clearing */ + env_set(".flags", addrname[i]); + env_set(addrname[i], NULL); + } + + /* Set ethact to "eth@10002000" */ + env_set("ethact", ethname[0]); + + /* Segment fault might happen if something is wrong */ + ut_asserteq(-ENODEV, net_loop(PING)); + + for (i = 0; i < DM_TEST_ETH_NUM; i++) { + /* Restore the env */ + env_set(".flags", addrname[i]); + env_set(addrname[i], ethaddr[i]); + + /* Probe the device again */ + ut_assertok(device_probe(dev[i])); + } + env_set(".flags", NULL); + env_set("ethact", NULL); + + return 0; +} +DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT); + +/* The asserts include a return on fail; cleanup in the caller */ +static int _dm_test_eth_rotate1(struct unit_test_state *uts) +{ /* Make sure that the default is to rotate to the next interface */ - setenv("ethact", "eth@10004000"); + env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); /* If ethrotate is no, then we should fail on a bad MAC */ - setenv("ethact", "eth@10004000"); - setenv("ethrotate", "no"); + env_set("ethact", "eth@10004000"); + env_set("ethrotate", "no"); ut_asserteq(-EINVAL, net_loop(PING)); - ut_asserteq_str("eth@10004000", getenv("ethact")); + ut_asserteq_str("eth@10004000", env_get("ethact")); - /* Restore the env */ - setenv("eth1addr", ethaddr); - setenv("ethrotate", NULL); - - /* Invalidate eth0's MAC address */ - strcpy(ethaddr, getenv("ethaddr")); - /* Must disable access protection for ethaddr before clearing */ - setenv(".flags", "ethaddr"); - setenv("ethaddr", NULL); + return 0; +} +static int _dm_test_eth_rotate2(struct unit_test_state *uts) +{ /* Make sure we can skip invalid devices */ - setenv("ethact", "eth@10004000"); + env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10004000", getenv("ethact")); + ut_asserteq_str("eth@10004000", env_get("ethact")); - /* Restore the env */ - setenv("ethaddr", ethaddr); - setenv(".flags", NULL); + /* Make sure we can handle device name which is not eth# */ + env_set("ethact", "sbe5"); + ut_assertok(net_loop(PING)); + ut_asserteq_str("sbe5", env_get("ethact")); return 0; } -DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT); -static int dm_test_net_retry(struct dm_test_state *dms) +static int dm_test_eth_rotate(struct unit_test_state *uts) { + char ethaddr[18]; + int retval; + + /* Set target IP to mock ping */ net_ping_ip = string_to_ip("1.1.2.2"); + /* Invalidate eth1's MAC address */ + memset(ethaddr, '\0', sizeof(ethaddr)); + strncpy(ethaddr, env_get("eth1addr"), 17); + /* Must disable access protection for eth1addr before clearing */ + env_set(".flags", "eth1addr"); + env_set("eth1addr", NULL); + + retval = _dm_test_eth_rotate1(uts); + + /* Restore the env */ + env_set("eth1addr", ethaddr); + env_set("ethrotate", NULL); + + if (!retval) { + /* Invalidate eth0's MAC address */ + strncpy(ethaddr, env_get("ethaddr"), 17); + /* Must disable access protection for ethaddr before clearing */ + env_set(".flags", "ethaddr"); + env_set("ethaddr", NULL); + + retval = _dm_test_eth_rotate2(uts); + + /* Restore the env */ + env_set("ethaddr", ethaddr); + } + /* Restore the env */ + env_set(".flags", NULL); + + return retval; +} +DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT); + +/* The asserts include a return on fail; cleanup in the caller */ +static int _dm_test_net_retry(struct unit_test_state *uts) +{ /* * eth1 is disabled and netretry is yes, so the ping should succeed and * the active device should be eth0 */ sandbox_eth_disable_response(1, true); - setenv("ethact", "eth@10004000"); - setenv("netretry", "yes"); + env_set("ethact", "eth@10004000"); + env_set("netretry", "yes"); sandbox_eth_skip_timeout(); ut_assertok(net_loop(PING)); - ut_asserteq_str("eth@10002000", getenv("ethact")); + ut_asserteq_str("eth@10002000", env_get("ethact")); /* * eth1 is disabled and netretry is no, so the ping should fail and the * active device should be eth1 */ - setenv("ethact", "eth@10004000"); - setenv("netretry", "no"); + env_set("ethact", "eth@10004000"); + env_set("netretry", "no"); sandbox_eth_skip_timeout(); - ut_asserteq(-ETIMEDOUT, net_loop(PING)); - ut_asserteq_str("eth@10004000", getenv("ethact")); + ut_asserteq(-ENONET, net_loop(PING)); + ut_asserteq_str("eth@10004000", env_get("ethact")); + + return 0; +} + +static int dm_test_net_retry(struct unit_test_state *uts) +{ + int retval; + + net_ping_ip = string_to_ip("1.1.2.2"); + + retval = _dm_test_net_retry(uts); /* Restore the env */ - setenv("netretry", NULL); + env_set("netretry", NULL); sandbox_eth_disable_response(1, false); - return 0; + return retval; } DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT); + +static int sb_check_arp_reply(struct udevice *dev, void *packet, + unsigned int len) +{ + struct eth_sandbox_priv *priv = dev_get_priv(dev); + struct ethernet_hdr *eth = packet; + struct arp_hdr *arp; + /* Used by all of the ut_assert macros */ + struct unit_test_state *uts = priv->priv; + + if (ntohs(eth->et_protlen) != PROT_ARP) + return 0; + + arp = packet + ETHER_HDR_SIZE; + + if (ntohs(arp->ar_op) != ARPOP_REPLY) + return 0; + + /* This test would be worthless if we are not waiting */ + ut_assert(arp_is_waiting()); + + /* Validate response */ + ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0); + ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0); + ut_assert(eth->et_protlen == htons(PROT_ARP)); + + ut_assert(arp->ar_hrd == htons(ARP_ETHER)); + ut_assert(arp->ar_pro == htons(PROT_IP)); + ut_assert(arp->ar_hln == ARP_HLEN); + ut_assert(arp->ar_pln == ARP_PLEN); + ut_assert(memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) == 0); + ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr); + ut_assert(memcmp(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN) == 0); + ut_assert(net_read_ip(&arp->ar_tpa).s_addr == + string_to_ip("1.1.2.4").s_addr); + + return 0; +} + +static int sb_with_async_arp_handler(struct udevice *dev, void *packet, + unsigned int len) +{ + struct eth_sandbox_priv *priv = dev_get_priv(dev); + struct ethernet_hdr *eth = packet; + struct arp_hdr *arp = packet + ETHER_HDR_SIZE; + int ret; + + /* + * If we are about to generate a reply to ARP, first inject a request + * from another host + */ + if (ntohs(eth->et_protlen) == PROT_ARP && + ntohs(arp->ar_op) == ARPOP_REQUEST) { + /* Make sure sandbox_eth_recv_arp_req() knows who is asking */ + priv->fake_host_ipaddr = string_to_ip("1.1.2.4"); + + ret = sandbox_eth_recv_arp_req(dev); + if (ret) + return ret; + } + + sandbox_eth_arp_req_to_reply(dev, packet, len); + sandbox_eth_ping_req_to_reply(dev, packet, len); + + return sb_check_arp_reply(dev, packet, len); +} + +static int dm_test_eth_async_arp_reply(struct unit_test_state *uts) +{ + net_ping_ip = string_to_ip("1.1.2.2"); + + sandbox_eth_set_tx_handler(0, sb_with_async_arp_handler); + /* Used by all of the ut_assert macros in the tx_handler */ + sandbox_eth_set_priv(0, uts); + + env_set("ethact", "eth@10002000"); + ut_assertok(net_loop(PING)); + ut_asserteq_str("eth@10002000", env_get("ethact")); + + sandbox_eth_set_tx_handler(0, NULL); + + return 0; +} + +DM_TEST(dm_test_eth_async_arp_reply, DM_TESTF_SCAN_FDT); + +static int sb_check_ping_reply(struct udevice *dev, void *packet, + unsigned int len) +{ + struct eth_sandbox_priv *priv = dev_get_priv(dev); + struct ethernet_hdr *eth = packet; + struct ip_udp_hdr *ip; + struct icmp_hdr *icmp; + /* Used by all of the ut_assert macros */ + struct unit_test_state *uts = priv->priv; + + if (ntohs(eth->et_protlen) != PROT_IP) + return 0; + + ip = packet + ETHER_HDR_SIZE; + + if (ip->ip_p != IPPROTO_ICMP) + return 0; + + icmp = (struct icmp_hdr *)&ip->udp_src; + + if (icmp->type != ICMP_ECHO_REPLY) + return 0; + + /* This test would be worthless if we are not waiting */ + ut_assert(arp_is_waiting()); + + /* Validate response */ + ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0); + ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0); + ut_assert(eth->et_protlen == htons(PROT_IP)); + + ut_assert(net_read_ip(&ip->ip_src).s_addr == net_ip.s_addr); + ut_assert(net_read_ip(&ip->ip_dst).s_addr == + string_to_ip("1.1.2.4").s_addr); + + return 0; +} + +static int sb_with_async_ping_handler(struct udevice *dev, void *packet, + unsigned int len) +{ + struct eth_sandbox_priv *priv = dev_get_priv(dev); + struct ethernet_hdr *eth = packet; + struct arp_hdr *arp = packet + ETHER_HDR_SIZE; + int ret; + + /* + * If we are about to generate a reply to ARP, first inject a request + * from another host + */ + if (ntohs(eth->et_protlen) == PROT_ARP && + ntohs(arp->ar_op) == ARPOP_REQUEST) { + /* Make sure sandbox_eth_recv_arp_req() knows who is asking */ + priv->fake_host_ipaddr = string_to_ip("1.1.2.4"); + + ret = sandbox_eth_recv_ping_req(dev); + if (ret) + return ret; + } + + sandbox_eth_arp_req_to_reply(dev, packet, len); + sandbox_eth_ping_req_to_reply(dev, packet, len); + + return sb_check_ping_reply(dev, packet, len); +} + +static int dm_test_eth_async_ping_reply(struct unit_test_state *uts) +{ + net_ping_ip = string_to_ip("1.1.2.2"); + + sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler); + /* Used by all of the ut_assert macros in the tx_handler */ + sandbox_eth_set_priv(0, uts); + + env_set("ethact", "eth@10002000"); + ut_assertok(net_loop(PING)); + ut_asserteq_str("eth@10002000", env_get("ethact")); + + sandbox_eth_set_tx_handler(0, NULL); + + return 0; +} + +DM_TEST(dm_test_eth_async_ping_reply, DM_TESTF_SCAN_FDT);