test/dm/eth.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2015 National Instruments
   4  *
   5  * (C) Copyright 2015
   6  * Joe Hershberger <joe.hershberger@ni.com>
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <env.h>
  12 #include <fdtdec.h>
  13 #include <malloc.h>
  14 #include <net.h>
  15 #include <dm/test.h>
  16 #include <dm/device-internal.h>
  17 #include <dm/uclass-internal.h>
  18 #include <asm/eth.h>
  19 #include <test/ut.h>
  20
  21 #define DM_TEST_ETH_NUM         4
  22
  23 static int dm_test_eth(struct unit_test_state *uts)
  24 {
  25         net_ping_ip = string_to_ip("1.1.2.2");
  26
  27         env_set("ethact", "eth@10002000");
  28         ut_assertok(net_loop(PING));
  29         ut_asserteq_str("eth@10002000", env_get("ethact"));
  30
  31         env_set("ethact", "eth@10003000");
  32         ut_assertok(net_loop(PING));
  33         ut_asserteq_str("eth@10003000", env_get("ethact"));
  34
  35         env_set("ethact", "eth@10004000");
  36         ut_assertok(net_loop(PING));
  37         ut_asserteq_str("eth@10004000", env_get("ethact"));
  38
  39         return 0;
  40 }
  41 DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT);
  42
  43 static int dm_test_eth_alias(struct unit_test_state *uts)
  44 {
  45         net_ping_ip = string_to_ip("1.1.2.2");
  46         env_set("ethact", "eth0");
  47         ut_assertok(net_loop(PING));
  48         ut_asserteq_str("eth@10002000", env_get("ethact"));
  49
  50         env_set("ethact", "eth1");
  51         ut_assertok(net_loop(PING));
  52         ut_asserteq_str("eth@10004000", env_get("ethact"));
  53
  54         /* Expected to fail since eth2 is not defined in the device tree */
  55         env_set("ethact", "eth2");
  56         ut_assertok(net_loop(PING));
  57         ut_asserteq_str("eth@10002000", env_get("ethact"));
  58
  59         env_set("ethact", "eth5");
  60         ut_assertok(net_loop(PING));
  61         ut_asserteq_str("eth@10003000", env_get("ethact"));
  62
  63         return 0;
  64 }
  65 DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT);
  66
  67 static int dm_test_eth_prime(struct unit_test_state *uts)
  68 {
  69         net_ping_ip = string_to_ip("1.1.2.2");
  70
  71         /* Expected to be "eth@10003000" because of ethprime variable */
  72         env_set("ethact", NULL);
  73         env_set("ethprime", "eth5");
  74         ut_assertok(net_loop(PING));
  75         ut_asserteq_str("eth@10003000", env_get("ethact"));
  76
  77         /* Expected to be "eth@10002000" because it is first */
  78         env_set("ethact", NULL);
  79         env_set("ethprime", NULL);
  80         ut_assertok(net_loop(PING));
  81         ut_asserteq_str("eth@10002000", env_get("ethact"));
  82
  83         return 0;
  84 }
  85 DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT);
  86
  87 /**
  88  * This test case is trying to test the following scenario:
  89  *      - All ethernet devices are not probed
  90  *      - "ethaddr" for all ethernet devices are not set
  91  *      - "ethact" is set to a valid ethernet device name
  92  *
  93  * With Sandbox default test configuration, all ethernet devices are
  94  * probed after power-up, so we have to manually create such scenario:
  95  *      - Remove all ethernet devices
  96  *      - Remove all "ethaddr" environment variables
  97  *      - Set "ethact" to the first ethernet device
  98  *
  99  * Do a ping test to see if anything goes wrong.
 100  */
 101 static int dm_test_eth_act(struct unit_test_state *uts)
 102 {
 103         struct udevice *dev[DM_TEST_ETH_NUM];
 104         const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000",
 105                                                 "sbe5", "eth@10004000"};
 106         const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr",
 107                                                  "eth3addr", "eth1addr"};
 108         char ethaddr[DM_TEST_ETH_NUM][18];
 109         int i;
 110
 111         memset(ethaddr, '\0', sizeof(ethaddr));
 112         net_ping_ip = string_to_ip("1.1.2.2");
 113
 114         /* Prepare the test scenario */
 115         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 116                 ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
 117                                                        ethname[i], &dev[i]));
 118                 ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
 119
 120                 /* Invalidate MAC address */
 121                 strncpy(ethaddr[i], env_get(addrname[i]), 17);
 122                 /* Must disable access protection for ethaddr before clearing */
 123                 env_set(".flags", addrname[i]);
 124                 env_set(addrname[i], NULL);
 125         }
 126
 127         /* Set ethact to "eth@10002000" */
 128         env_set("ethact", ethname[0]);
 129
 130         /* Segment fault might happen if something is wrong */
 131         ut_asserteq(-ENODEV, net_loop(PING));
 132
 133         for (i = 0; i < DM_TEST_ETH_NUM; i++) {
 134                 /* Restore the env */
 135                 env_set(".flags", addrname[i]);
 136                 env_set(addrname[i], ethaddr[i]);
 137
 138                 /* Probe the device again */
 139                 ut_assertok(device_probe(dev[i]));
 140         }
 141         env_set(".flags", NULL);
 142         env_set("ethact", NULL);
 143
 144         return 0;
 145 }
 146 DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
 147
 148 /* The asserts include a return on fail; cleanup in the caller */
 149 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
 150 {
 151         /* Make sure that the default is to rotate to the next interface */
 152         env_set("ethact", "eth@10004000");
 153         ut_assertok(net_loop(PING));
 154         ut_asserteq_str("eth@10002000", env_get("ethact"));
 155
 156         /* If ethrotate is no, then we should fail on a bad MAC */
 157         env_set("ethact", "eth@10004000");
 158         env_set("ethrotate", "no");
 159         ut_asserteq(-EINVAL, net_loop(PING));
 160         ut_asserteq_str("eth@10004000", env_get("ethact"));
 161
 162         return 0;
 163 }
 164
 165 static int _dm_test_eth_rotate2(struct unit_test_state *uts)
 166 {
 167         /* Make sure we can skip invalid devices */
 168         env_set("ethact", "eth@10004000");
 169         ut_assertok(net_loop(PING));
 170         ut_asserteq_str("eth@10004000", env_get("ethact"));
 171
 172         /* Make sure we can handle device name which is not eth# */
 173         env_set("ethact", "sbe5");
 174         ut_assertok(net_loop(PING));
 175         ut_asserteq_str("sbe5", env_get("ethact"));
 176
 177         return 0;
 178 }
 179
 180 static int dm_test_eth_rotate(struct unit_test_state *uts)
 181 {
 182         char ethaddr[18];
 183         int retval;
 184
 185         /* Set target IP to mock ping */
 186         net_ping_ip = string_to_ip("1.1.2.2");
 187
 188         /* Invalidate eth1's MAC address */
 189         memset(ethaddr, '\0', sizeof(ethaddr));
 190         strncpy(ethaddr, env_get("eth1addr"), 17);
 191         /* Must disable access protection for eth1addr before clearing */
 192         env_set(".flags", "eth1addr");
 193         env_set("eth1addr", NULL);
 194
 195         retval = _dm_test_eth_rotate1(uts);
 196
 197         /* Restore the env */
 198         env_set("eth1addr", ethaddr);
 199         env_set("ethrotate", NULL);
 200
 201         if (!retval) {
 202                 /* Invalidate eth0's MAC address */
 203                 strncpy(ethaddr, env_get("ethaddr"), 17);
 204                 /* Must disable access protection for ethaddr before clearing */
 205                 env_set(".flags", "ethaddr");
 206                 env_set("ethaddr", NULL);
 207
 208                 retval = _dm_test_eth_rotate2(uts);
 209
 210                 /* Restore the env */
 211                 env_set("ethaddr", ethaddr);
 212         }
 213         /* Restore the env */
 214         env_set(".flags", NULL);
 215
 216         return retval;
 217 }
 218 DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT);
 219
 220 /* The asserts include a return on fail; cleanup in the caller */
 221 static int _dm_test_net_retry(struct unit_test_state *uts)
 222 {
 223         /*
 224          * eth1 is disabled and netretry is yes, so the ping should succeed and
 225          * the active device should be eth0
 226          */
 227         sandbox_eth_disable_response(1, true);
 228         env_set("ethact", "eth@10004000");
 229         env_set("netretry", "yes");
 230         sandbox_eth_skip_timeout();
 231         ut_assertok(net_loop(PING));
 232         ut_asserteq_str("eth@10002000", env_get("ethact"));
 233
 234         /*
 235          * eth1 is disabled and netretry is no, so the ping should fail and the
 236          * active device should be eth1
 237          */
 238         env_set("ethact", "eth@10004000");
 239         env_set("netretry", "no");
 240         sandbox_eth_skip_timeout();
 241         ut_asserteq(-ENONET, net_loop(PING));
 242         ut_asserteq_str("eth@10004000", env_get("ethact"));
 243
 244         return 0;
 245 }
 246
 247 static int dm_test_net_retry(struct unit_test_state *uts)
 248 {
 249         int retval;
 250
 251         net_ping_ip = string_to_ip("1.1.2.2");
 252
 253         retval = _dm_test_net_retry(uts);
 254
 255         /* Restore the env */
 256         env_set("netretry", NULL);
 257         sandbox_eth_disable_response(1, false);
 258
 259         return retval;
 260 }
 261 DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT);
 262
 263 static int sb_check_arp_reply(struct udevice *dev, void *packet,
 264                               unsigned int len)
 265 {
 266         struct eth_sandbox_priv *priv = dev_get_priv(dev);
 267         struct ethernet_hdr *eth = packet;
 268         struct arp_hdr *arp;
 269         /* Used by all of the ut_assert macros */
 270         struct unit_test_state *uts = priv->priv;
 271
 272         if (ntohs(eth->et_protlen) != PROT_ARP)
 273                 return 0;
 274
 275         arp = packet + ETHER_HDR_SIZE;
 276
 277         if (ntohs(arp->ar_op) != ARPOP_REPLY)
 278                 return 0;
 279
 280         /* This test would be worthless if we are not waiting */
 281         ut_assert(arp_is_waiting());
 282
 283         /* Validate response */
 284         ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0);
 285         ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0);
 286         ut_assert(eth->et_protlen == htons(PROT_ARP));
 287
 288         ut_assert(arp->ar_hrd == htons(ARP_ETHER));
 289         ut_assert(arp->ar_pro == htons(PROT_IP));
 290         ut_assert(arp->ar_hln == ARP_HLEN);
 291         ut_assert(arp->ar_pln == ARP_PLEN);
 292         ut_assert(memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) == 0);
 293         ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr);
 294         ut_assert(memcmp(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN) == 0);
 295         ut_assert(net_read_ip(&arp->ar_tpa).s_addr ==
 296                   string_to_ip("1.1.2.4").s_addr);
 297
 298         return 0;
 299 }
 300
 301 static int sb_with_async_arp_handler(struct udevice *dev, void *packet,
 302                                      unsigned int len)
 303 {
 304         struct eth_sandbox_priv *priv = dev_get_priv(dev);
 305         struct ethernet_hdr *eth = packet;
 306         struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
 307         int ret;
 308
 309         /*
 310          * If we are about to generate a reply to ARP, first inject a request
 311          * from another host
 312          */
 313         if (ntohs(eth->et_protlen) == PROT_ARP &&
 314             ntohs(arp->ar_op) == ARPOP_REQUEST) {
 315                 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
 316                 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
 317
 318                 ret = sandbox_eth_recv_arp_req(dev);
 319                 if (ret)
 320                         return ret;
 321         }
 322
 323         sandbox_eth_arp_req_to_reply(dev, packet, len);
 324         sandbox_eth_ping_req_to_reply(dev, packet, len);
 325
 326         return sb_check_arp_reply(dev, packet, len);
 327 }
 328
 329 static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
 330 {
 331         net_ping_ip = string_to_ip("1.1.2.2");
 332
 333         sandbox_eth_set_tx_handler(0, sb_with_async_arp_handler);
 334         /* Used by all of the ut_assert macros in the tx_handler */
 335         sandbox_eth_set_priv(0, uts);
 336
 337         env_set("ethact", "eth@10002000");
 338         ut_assertok(net_loop(PING));
 339         ut_asserteq_str("eth@10002000", env_get("ethact"));
 340
 341         sandbox_eth_set_tx_handler(0, NULL);
 342
 343         return 0;
 344 }
 345
 346 DM_TEST(dm_test_eth_async_arp_reply, DM_TESTF_SCAN_FDT);
 347
 348 static int sb_check_ping_reply(struct udevice *dev, void *packet,
 349                                unsigned int len)
 350 {
 351         struct eth_sandbox_priv *priv = dev_get_priv(dev);
 352         struct ethernet_hdr *eth = packet;
 353         struct ip_udp_hdr *ip;
 354         struct icmp_hdr *icmp;
 355         /* Used by all of the ut_assert macros */
 356         struct unit_test_state *uts = priv->priv;
 357
 358         if (ntohs(eth->et_protlen) != PROT_IP)
 359                 return 0;
 360
 361         ip = packet + ETHER_HDR_SIZE;
 362
 363         if (ip->ip_p != IPPROTO_ICMP)
 364                 return 0;
 365
 366         icmp = (struct icmp_hdr *)&ip->udp_src;
 367
 368         if (icmp->type != ICMP_ECHO_REPLY)
 369                 return 0;
 370
 371         /* This test would be worthless if we are not waiting */
 372         ut_assert(arp_is_waiting());
 373
 374         /* Validate response */
 375         ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0);
 376         ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0);
 377         ut_assert(eth->et_protlen == htons(PROT_IP));
 378
 379         ut_assert(net_read_ip(&ip->ip_src).s_addr == net_ip.s_addr);
 380         ut_assert(net_read_ip(&ip->ip_dst).s_addr ==
 381                   string_to_ip("1.1.2.4").s_addr);
 382
 383         return 0;
 384 }
 385
 386 static int sb_with_async_ping_handler(struct udevice *dev, void *packet,
 387                                       unsigned int len)
 388 {
 389         struct eth_sandbox_priv *priv = dev_get_priv(dev);
 390         struct ethernet_hdr *eth = packet;
 391         struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
 392         int ret;
 393
 394         /*
 395          * If we are about to generate a reply to ARP, first inject a request
 396          * from another host
 397          */
 398         if (ntohs(eth->et_protlen) == PROT_ARP &&
 399             ntohs(arp->ar_op) == ARPOP_REQUEST) {
 400                 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
 401                 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
 402
 403                 ret = sandbox_eth_recv_ping_req(dev);
 404                 if (ret)
 405                         return ret;
 406         }
 407
 408         sandbox_eth_arp_req_to_reply(dev, packet, len);
 409         sandbox_eth_ping_req_to_reply(dev, packet, len);
 410
 411         return sb_check_ping_reply(dev, packet, len);
 412 }
 413
 414 static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
 415 {
 416         net_ping_ip = string_to_ip("1.1.2.2");
 417
 418         sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler);
 419         /* Used by all of the ut_assert macros in the tx_handler */
 420         sandbox_eth_set_priv(0, uts);
 421
 422         env_set("ethact", "eth@10002000");
 423         ut_assertok(net_loop(PING));
 424         ut_asserteq_str("eth@10002000", env_get("ethact"));
 425
 426         sandbox_eth_set_tx_handler(0, NULL);
 427
 428         return 0;
 429 }
 430
 431 DM_TEST(dm_test_eth_async_ping_reply, DM_TESTF_SCAN_FDT);