tests/qtest/igb-test.c

   1 /*
   2  * QTest testcase for igb NIC
   3  *
   4  * Copyright (c) 2022-2023 Red Hat, Inc.
   5  * Copyright (c) 2015 Ravello Systems LTD (http://ravellosystems.com)
   6  * Developed by Daynix Computing LTD (http://www.daynix.com)
   7  *
   8  * Authors:
   9  * Akihiko Odaki <akihiko.odaki@daynix.com>
  10  * Dmitry Fleytman <dmitry@daynix.com>
  11  * Leonid Bloch <leonid@daynix.com>
  12  * Yan Vugenfirer <yan@daynix.com>
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  26  */
  27
  28
  29 #include "qemu/osdep.h"
  30 #include "libqtest-single.h"
  31 #include "libqos/pci-pc.h"
  32 #include "net/eth.h"
  33 #include "qemu/sockets.h"
  34 #include "qemu/iov.h"
  35 #include "qemu/module.h"
  36 #include "qemu/bitops.h"
  37 #include "libqos/libqos-malloc.h"
  38 #include "libqos/e1000e.h"
  39 #include "hw/net/igb_regs.h"
  40
  41 #ifndef _WIN32
  42
  43 static const struct eth_header packet = {
  44     .h_dest = E1000E_ADDRESS,
  45     .h_source = E1000E_ADDRESS,
  46 };
  47
  48 static void igb_send_verify(QE1000E *d, int *test_sockets, QGuestAllocator *alloc)
  49 {
  50     union e1000_adv_tx_desc descr;
  51     char buffer[64];
  52     int ret;
  53     uint32_t recv_len;
  54
  55     /* Prepare test data buffer */
  56     uint64_t data = guest_alloc(alloc, sizeof(buffer));
  57     memwrite(data, &packet, sizeof(packet));
  58
  59     /* Prepare TX descriptor */
  60     memset(&descr, 0, sizeof(descr));
  61     descr.read.buffer_addr = cpu_to_le64(data);
  62     descr.read.cmd_type_len = cpu_to_le32(E1000_TXD_CMD_RS   |
  63                                           E1000_TXD_CMD_EOP  |
  64                                           E1000_TXD_DTYP_D   |
  65                                           sizeof(buffer));
  66
  67     /* Put descriptor to the ring */
  68     e1000e_tx_ring_push(d, &descr);
  69
  70     /* Wait for TX WB interrupt */
  71     e1000e_wait_isr(d, E1000E_TX0_MSG_ID);
  72
  73     /* Check DD bit */
  74     g_assert_cmphex(le32_to_cpu(descr.wb.status) & E1000_TXD_STAT_DD, ==,
  75                     E1000_TXD_STAT_DD);
  76
  77     /* Check data sent to the backend */
  78     ret = recv(test_sockets[0], &recv_len, sizeof(recv_len), 0);
  79     g_assert_cmpint(ret, == , sizeof(recv_len));
  80     ret = recv(test_sockets[0], buffer, sizeof(buffer), 0);
  81     g_assert_cmpint(ret, ==, sizeof(buffer));
  82     g_assert_false(memcmp(buffer, &packet, sizeof(packet)));
  83
  84     /* Free test data buffer */
  85     guest_free(alloc, data);
  86 }
  87
  88 static void igb_receive_verify(QE1000E *d, int *test_sockets, QGuestAllocator *alloc)
  89 {
  90     union e1000_adv_rx_desc descr;
  91
  92     struct eth_header test_iov = packet;
  93     int len = htonl(sizeof(packet));
  94     struct iovec iov[] = {
  95         {
  96             .iov_base = &len,
  97             .iov_len = sizeof(len),
  98         },{
  99             .iov_base = &test_iov,
 100             .iov_len = sizeof(packet),
 101         },
 102     };
 103
 104     char buffer[64];
 105     int ret;
 106
 107     /* Send a dummy packet to device's socket*/
 108     ret = iov_send(test_sockets[0], iov, 2, 0, sizeof(len) + sizeof(packet));
 109     g_assert_cmpint(ret, == , sizeof(packet) + sizeof(len));
 110
 111     /* Prepare test data buffer */
 112     uint64_t data = guest_alloc(alloc, sizeof(buffer));
 113
 114     /* Prepare RX descriptor */
 115     memset(&descr, 0, sizeof(descr));
 116     descr.read.pkt_addr = cpu_to_le64(data);
 117
 118     /* Put descriptor to the ring */
 119     e1000e_rx_ring_push(d, &descr);
 120
 121     /* Wait for TX WB interrupt */
 122     e1000e_wait_isr(d, E1000E_RX0_MSG_ID);
 123
 124     /* Check DD bit */
 125     g_assert_cmphex(le32_to_cpu(descr.wb.upper.status_error) &
 126         E1000_RXD_STAT_DD, ==, E1000_RXD_STAT_DD);
 127
 128     /* Check data sent to the backend */
 129     memread(data, buffer, sizeof(buffer));
 130     g_assert_false(memcmp(buffer, &packet, sizeof(packet)));
 131
 132     /* Free test data buffer */
 133     guest_free(alloc, data);
 134 }
 135
 136 static void test_e1000e_init(void *obj, void *data, QGuestAllocator * alloc)
 137 {
 138     /* init does nothing */
 139 }
 140
 141 static void test_igb_tx(void *obj, void *data, QGuestAllocator * alloc)
 142 {
 143     QE1000E_PCI *e1000e = obj;
 144     QE1000E *d = &e1000e->e1000e;
 145     QOSGraphObject *e_object = obj;
 146     QPCIDevice *dev = e_object->get_driver(e_object, "pci-device");
 147
 148     /* FIXME: add spapr support */
 149     if (qpci_check_buggy_msi(dev)) {
 150         return;
 151     }
 152
 153     igb_send_verify(d, data, alloc);
 154 }
 155
 156 static void test_igb_rx(void *obj, void *data, QGuestAllocator * alloc)
 157 {
 158     QE1000E_PCI *e1000e = obj;
 159     QE1000E *d = &e1000e->e1000e;
 160     QOSGraphObject *e_object = obj;
 161     QPCIDevice *dev = e_object->get_driver(e_object, "pci-device");
 162
 163     /* FIXME: add spapr support */
 164     if (qpci_check_buggy_msi(dev)) {
 165         return;
 166     }
 167
 168     igb_receive_verify(d, data, alloc);
 169 }
 170
 171 static void test_igb_multiple_transfers(void *obj, void *data,
 172                                         QGuestAllocator *alloc)
 173 {
 174     static const long iterations = 4 * 1024;
 175     long i;
 176
 177     QE1000E_PCI *e1000e = obj;
 178     QE1000E *d = &e1000e->e1000e;
 179     QOSGraphObject *e_object = obj;
 180     QPCIDevice *dev = e_object->get_driver(e_object, "pci-device");
 181
 182     /* FIXME: add spapr support */
 183     if (qpci_check_buggy_msi(dev)) {
 184         return;
 185     }
 186
 187     for (i = 0; i < iterations; i++) {
 188         igb_send_verify(d, data, alloc);
 189         igb_receive_verify(d, data, alloc);
 190     }
 191
 192 }
 193
 194 static void data_test_clear(void *sockets)
 195 {
 196     int *test_sockets = sockets;
 197
 198     close(test_sockets[0]);
 199     qos_invalidate_command_line();
 200     close(test_sockets[1]);
 201     g_free(test_sockets);
 202 }
 203
 204 static void *data_test_init(GString *cmd_line, void *arg)
 205 {
 206     int *test_sockets = g_new(int, 2);
 207     int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, test_sockets);
 208     g_assert_cmpint(ret, != , -1);
 209
 210     g_string_append_printf(cmd_line, " -netdev socket,fd=%d,id=hs0 ",
 211                            test_sockets[1]);
 212
 213     g_test_queue_destroy(data_test_clear, test_sockets);
 214     return test_sockets;
 215 }
 216
 217 #endif
 218
 219 static void *data_test_init_no_socket(GString *cmd_line, void *arg)
 220 {
 221     g_string_append(cmd_line, " -netdev hubport,hubid=0,id=hs0 ");
 222     return arg;
 223 }
 224
 225 static void test_igb_hotplug(void *obj, void *data, QGuestAllocator * alloc)
 226 {
 227     QTestState *qts = global_qtest;  /* TODO: get rid of global_qtest here */
 228     QE1000E_PCI *dev = obj;
 229
 230     if (dev->pci_dev.bus->not_hotpluggable) {
 231         g_test_skip("pci bus does not support hotplug");
 232         return;
 233     }
 234
 235     qtest_qmp_device_add(qts, "igb", "igb_net", "{'addr': '0x06'}");
 236     qpci_unplug_acpi_device_test(qts, "igb_net", 0x06);
 237 }
 238
 239 static void register_igb_test(void)
 240 {
 241     QOSGraphTestOptions opts = { 0 };
 242
 243 #ifndef _WIN32
 244     opts.before = data_test_init,
 245     qos_add_test("init", "igb", test_e1000e_init, &opts);
 246     qos_add_test("tx", "igb", test_igb_tx, &opts);
 247     qos_add_test("rx", "igb", test_igb_rx, &opts);
 248     qos_add_test("multiple_transfers", "igb",
 249                  test_igb_multiple_transfers, &opts);
 250 #endif
 251
 252     opts.before = data_test_init_no_socket;
 253     qos_add_test("hotplug", "igb", test_igb_hotplug, &opts);
 254 }
 255
 256 libqos_init(register_igb_test);