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 "qemu-common.h" 29 #include "libqtest-single.h" 30 #include "qemu-common.h" 31 #include "libqos/pci-pc.h" 32 #include "qemu/sockets.h" 33 #include "qemu/iov.h" 34 #include "qemu/module.h" 35 #include "qemu/bitops.h" 36 #include "libqos/malloc.h" 37 #include "libqos/e1000e.h" 38 39 static void e1000e_send_verify(QE1000E *d, int *test_sockets, QGuestAllocator *alloc) 40 { 41 struct { 42 uint64_t buffer_addr; 43 union { 44 uint32_t data; 45 struct { 46 uint16_t length; 47 uint8_t cso; 48 uint8_t cmd; 49 } flags; 50 } lower; 51 union { 52 uint32_t data; 53 struct { 54 uint8_t status; 55 uint8_t css; 56 uint16_t special; 57 } fields; 58 } upper; 59 } descr; 60 61 static const uint32_t dtyp_data = BIT(20); 62 static const uint32_t dtyp_ext = BIT(29); 63 static const uint32_t dcmd_rs = BIT(27); 64 static const uint32_t dcmd_eop = BIT(24); 65 static const uint32_t dsta_dd = BIT(0); 66 static const int data_len = 64; 67 char buffer[64]; 68 int ret; 69 uint32_t recv_len; 70 71 /* Prepare test data buffer */ 72 uint64_t data = guest_alloc(alloc, data_len); 73 memwrite(data, "TEST", 5); 74 75 /* Prepare TX descriptor */ 76 memset(&descr, 0, sizeof(descr)); 77 descr.buffer_addr = cpu_to_le64(data); 78 descr.lower.data = cpu_to_le32(dcmd_rs | 79 dcmd_eop | 80 dtyp_ext | 81 dtyp_data | 82 data_len); 83 84 /* Put descriptor to the ring */ 85 e1000e_tx_ring_push(d, &descr); 86 87 /* Wait for TX WB interrupt */ 88 e1000e_wait_isr(d, E1000E_TX0_MSG_ID); 89 90 /* Check DD bit */ 91 g_assert_cmphex(le32_to_cpu(descr.upper.data) & dsta_dd, ==, dsta_dd); 92 93 /* Check data sent to the backend */ 94 ret = qemu_recv(test_sockets[0], &recv_len, sizeof(recv_len), 0); 95 g_assert_cmpint(ret, == , sizeof(recv_len)); 96 ret = qemu_recv(test_sockets[0], buffer, 64, 0); 97 g_assert_cmpint(ret, >=, 5); 98 g_assert_cmpstr(buffer, == , "TEST"); 99 100 /* Free test data buffer */ 101 guest_free(alloc, data); 102 } 103 104 static void e1000e_receive_verify(QE1000E *d, int *test_sockets, QGuestAllocator *alloc) 105 { 106 union { 107 struct { 108 uint64_t buffer_addr; 109 uint64_t reserved; 110 } read; 111 struct { 112 struct { 113 uint32_t mrq; 114 union { 115 uint32_t rss; 116 struct { 117 uint16_t ip_id; 118 uint16_t csum; 119 } csum_ip; 120 } hi_dword; 121 } lower; 122 struct { 123 uint32_t status_error; 124 uint16_t length; 125 uint16_t vlan; 126 } upper; 127 } wb; 128 } descr; 129 130 static const uint32_t esta_dd = BIT(0); 131 132 char test[] = "TEST"; 133 int len = htonl(sizeof(test)); 134 struct iovec iov[] = { 135 { 136 .iov_base = &len, 137 .iov_len = sizeof(len), 138 },{ 139 .iov_base = test, 140 .iov_len = sizeof(test), 141 }, 142 }; 143 144 static const int data_len = 64; 145 char buffer[64]; 146 int ret; 147 148 /* Send a dummy packet to device's socket*/ 149 ret = iov_send(test_sockets[0], iov, 2, 0, sizeof(len) + sizeof(test)); 150 g_assert_cmpint(ret, == , sizeof(test) + sizeof(len)); 151 152 /* Prepare test data buffer */ 153 uint64_t data = guest_alloc(alloc, data_len); 154 155 /* Prepare RX descriptor */ 156 memset(&descr, 0, sizeof(descr)); 157 descr.read.buffer_addr = cpu_to_le64(data); 158 159 /* Put descriptor to the ring */ 160 e1000e_rx_ring_push(d, &descr); 161 162 /* Wait for TX WB interrupt */ 163 e1000e_wait_isr(d, E1000E_RX0_MSG_ID); 164 165 /* Check DD bit */ 166 g_assert_cmphex(le32_to_cpu(descr.wb.upper.status_error) & 167 esta_dd, ==, esta_dd); 168 169 /* Check data sent to the backend */ 170 memread(data, buffer, sizeof(buffer)); 171 g_assert_cmpstr(buffer, == , "TEST"); 172 173 /* Free test data buffer */ 174 guest_free(alloc, data); 175 } 176 177 static void test_e1000e_init(void *obj, void *data, QGuestAllocator * alloc) 178 { 179 /* init does nothing */ 180 } 181 182 static void test_e1000e_tx(void *obj, void *data, QGuestAllocator * alloc) 183 { 184 QE1000E_PCI *e1000e = obj; 185 QE1000E *d = &e1000e->e1000e; 186 QOSGraphObject *e_object = obj; 187 QPCIDevice *dev = e_object->get_driver(e_object, "pci-device"); 188 189 /* FIXME: add spapr support */ 190 if (qpci_check_buggy_msi(dev)) { 191 return; 192 } 193 194 e1000e_send_verify(d, data, alloc); 195 } 196 197 static void test_e1000e_rx(void *obj, void *data, QGuestAllocator * alloc) 198 { 199 QE1000E_PCI *e1000e = obj; 200 QE1000E *d = &e1000e->e1000e; 201 QOSGraphObject *e_object = obj; 202 QPCIDevice *dev = e_object->get_driver(e_object, "pci-device"); 203 204 /* FIXME: add spapr support */ 205 if (qpci_check_buggy_msi(dev)) { 206 return; 207 } 208 209 e1000e_receive_verify(d, data, alloc); 210 } 211 212 static void test_e1000e_multiple_transfers(void *obj, void *data, 213 QGuestAllocator *alloc) 214 { 215 static const long iterations = 4 * 1024; 216 long i; 217 218 QE1000E_PCI *e1000e = obj; 219 QE1000E *d = &e1000e->e1000e; 220 QOSGraphObject *e_object = obj; 221 QPCIDevice *dev = e_object->get_driver(e_object, "pci-device"); 222 223 /* FIXME: add spapr support */ 224 if (qpci_check_buggy_msi(dev)) { 225 return; 226 } 227 228 for (i = 0; i < iterations; i++) { 229 e1000e_send_verify(d, data, alloc); 230 e1000e_receive_verify(d, data, alloc); 231 } 232 233 } 234 235 static void test_e1000e_hotplug(void *obj, void *data, QGuestAllocator * alloc) 236 { 237 QTestState *qts = global_qtest; /* TODO: get rid of global_qtest here */ 238 239 qtest_qmp_device_add(qts, "e1000e", "e1000e_net", "{'addr': '0x06'}"); 240 qpci_unplug_acpi_device_test(qts, "e1000e_net", 0x06); 241 } 242 243 static void data_test_clear(void *sockets) 244 { 245 int *test_sockets = sockets; 246 247 close(test_sockets[0]); 248 qos_invalidate_command_line(); 249 close(test_sockets[1]); 250 g_free(test_sockets); 251 } 252 253 static void *data_test_init(GString *cmd_line, void *arg) 254 { 255 int *test_sockets = g_new(int, 2); 256 int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, test_sockets); 257 g_assert_cmpint(ret, != , -1); 258 259 g_string_append_printf(cmd_line, " -netdev socket,fd=%d,id=hs0 ", 260 test_sockets[1]); 261 262 g_test_queue_destroy(data_test_clear, test_sockets); 263 return test_sockets; 264 } 265 266 static void register_e1000e_test(void) 267 { 268 QOSGraphTestOptions opts = { 269 .before = data_test_init, 270 }; 271 272 qos_add_test("init", "e1000e", test_e1000e_init, &opts); 273 qos_add_test("tx", "e1000e", test_e1000e_tx, &opts); 274 qos_add_test("rx", "e1000e", test_e1000e_rx, &opts); 275 qos_add_test("multiple_transfers", "e1000e", 276 test_e1000e_multiple_transfers, &opts); 277 qos_add_test("hotplug", "e1000e", test_e1000e_hotplug, &opts); 278 } 279 280 libqos_init(register_e1000e_test); 281