tests/qtest/e1000e-test.c

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