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