1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016-2018 Microsoft Corporation
3 * Copyright(c) 2013-2016 Brocade Communications Systems, Inc.
4 * All rights reserved.
5 */
6
7 #include <stdint.h>
8 #include <string.h>
9 #include <stdio.h>
10 #include <errno.h>
11 #include <unistd.h>
12 #include <dirent.h>
13 #include <net/if.h>
14 #include <net/if_arp.h>
15 #include <netinet/in.h>
16 #include <sys/ioctl.h>
17
18 #include <rte_ethdev.h>
19 #include <rte_memcpy.h>
20 #include <rte_string_fns.h>
21 #include <rte_memzone.h>
22 #include <rte_devargs.h>
23 #include <rte_malloc.h>
24 #include <rte_kvargs.h>
25 #include <rte_atomic.h>
26 #include <rte_branch_prediction.h>
27 #include <rte_ether.h>
28 #include <ethdev_driver.h>
29 #include <rte_cycles.h>
30 #include <rte_errno.h>
31 #include <rte_memory.h>
32 #include <rte_eal.h>
33 #include <rte_dev.h>
34 #include <rte_bus_vmbus.h>
35 #include <rte_alarm.h>
36
37 #include "hn_logs.h"
38 #include "hn_var.h"
39 #include "hn_rndis.h"
40 #include "hn_nvs.h"
41 #include "ndis.h"
42
43 #define HN_TX_OFFLOAD_CAPS (RTE_ETH_TX_OFFLOAD_IPV4_CKSUM | \
44 RTE_ETH_TX_OFFLOAD_TCP_CKSUM | \
45 RTE_ETH_TX_OFFLOAD_UDP_CKSUM | \
46 RTE_ETH_TX_OFFLOAD_TCP_TSO | \
47 RTE_ETH_TX_OFFLOAD_MULTI_SEGS | \
48 RTE_ETH_TX_OFFLOAD_VLAN_INSERT)
49
50 #define HN_RX_OFFLOAD_CAPS (RTE_ETH_RX_OFFLOAD_CHECKSUM | \
51 RTE_ETH_RX_OFFLOAD_VLAN_STRIP | \
52 RTE_ETH_RX_OFFLOAD_RSS_HASH)
53
54 #define NETVSC_ARG_LATENCY "latency"
55 #define NETVSC_ARG_RXBREAK "rx_copybreak"
56 #define NETVSC_ARG_TXBREAK "tx_copybreak"
57 #define NETVSC_ARG_RX_EXTMBUF_ENABLE "rx_extmbuf_enable"
58
59 /* The max number of retry when hot adding a VF device */
60 #define NETVSC_MAX_HOTADD_RETRY 10
61
62 struct hn_xstats_name_off {
63 char name[RTE_ETH_XSTATS_NAME_SIZE];
64 unsigned int offset;
65 };
66
67 static const struct hn_xstats_name_off hn_stat_strings[] = {
68 { "good_packets", offsetof(struct hn_stats, packets) },
69 { "good_bytes", offsetof(struct hn_stats, bytes) },
70 { "errors", offsetof(struct hn_stats, errors) },
71 { "ring full", offsetof(struct hn_stats, ring_full) },
72 { "channel full", offsetof(struct hn_stats, channel_full) },
73 { "multicast_packets", offsetof(struct hn_stats, multicast) },
74 { "broadcast_packets", offsetof(struct hn_stats, broadcast) },
75 { "undersize_packets", offsetof(struct hn_stats, size_bins[0]) },
76 { "size_64_packets", offsetof(struct hn_stats, size_bins[1]) },
77 { "size_65_127_packets", offsetof(struct hn_stats, size_bins[2]) },
78 { "size_128_255_packets", offsetof(struct hn_stats, size_bins[3]) },
79 { "size_256_511_packets", offsetof(struct hn_stats, size_bins[4]) },
80 { "size_512_1023_packets", offsetof(struct hn_stats, size_bins[5]) },
81 { "size_1024_1518_packets", offsetof(struct hn_stats, size_bins[6]) },
82 { "size_1519_max_packets", offsetof(struct hn_stats, size_bins[7]) },
83 };
84
85 /* The default RSS key.
86 * This value is the same as MLX5 so that flows will be
87 * received on same path for both VF and synthetic NIC.
88 */
89 static const uint8_t rss_default_key[NDIS_HASH_KEYSIZE_TOEPLITZ] = {
90 0x2c, 0xc6, 0x81, 0xd1, 0x5b, 0xdb, 0xf4, 0xf7,
91 0xfc, 0xa2, 0x83, 0x19, 0xdb, 0x1a, 0x3e, 0x94,
92 0x6b, 0x9e, 0x38, 0xd9, 0x2c, 0x9c, 0x03, 0xd1,
93 0xad, 0x99, 0x44, 0xa7, 0xd9, 0x56, 0x3d, 0x59,
94 0x06, 0x3c, 0x25, 0xf3, 0xfc, 0x1f, 0xdc, 0x2a,
95 };
96
97 static struct rte_eth_dev *
eth_dev_vmbus_allocate(struct rte_vmbus_device * dev,size_t private_data_size)98 eth_dev_vmbus_allocate(struct rte_vmbus_device *dev, size_t private_data_size)
99 {
100 struct rte_eth_dev *eth_dev;
101 const char *name;
102
103 if (!dev)
104 return NULL;
105
106 name = dev->device.name;
107
108 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
109 eth_dev = rte_eth_dev_allocate(name);
110 if (!eth_dev) {
111 PMD_DRV_LOG(NOTICE, "can not allocate rte ethdev");
112 return NULL;
113 }
114
115 if (private_data_size) {
116 eth_dev->data->dev_private =
117 rte_zmalloc_socket(name, private_data_size,
118 RTE_CACHE_LINE_SIZE, dev->device.numa_node);
119 if (!eth_dev->data->dev_private) {
120 PMD_DRV_LOG(NOTICE, "can not allocate driver data");
121 rte_eth_dev_release_port(eth_dev);
122 return NULL;
123 }
124 }
125 } else {
126 eth_dev = rte_eth_dev_attach_secondary(name);
127 if (!eth_dev) {
128 PMD_DRV_LOG(NOTICE, "can not attach secondary");
129 return NULL;
130 }
131 }
132
133 eth_dev->device = &dev->device;
134
135 /* interrupt is simulated */
136 rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_EXT);
137 eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
138 eth_dev->intr_handle = dev->intr_handle;
139
140 return eth_dev;
141 }
142
143 static void
eth_dev_vmbus_release(struct rte_eth_dev * eth_dev)144 eth_dev_vmbus_release(struct rte_eth_dev *eth_dev)
145 {
146 /* free ether device */
147 rte_eth_dev_release_port(eth_dev);
148
149 eth_dev->device = NULL;
150 eth_dev->intr_handle = NULL;
151 }
152
hn_set_parameter(const char * key,const char * value,void * opaque)153 static int hn_set_parameter(const char *key, const char *value, void *opaque)
154 {
155 struct hn_data *hv = opaque;
156 char *endp = NULL;
157 unsigned long v;
158
159 v = strtoul(value, &endp, 0);
160 if (*value == '\0' || *endp != '\0') {
161 PMD_DRV_LOG(ERR, "invalid parameter %s=%s", key, value);
162 return -EINVAL;
163 }
164
165 if (!strcmp(key, NETVSC_ARG_LATENCY)) {
166 /* usec to nsec */
167 hv->latency = v * 1000;
168 PMD_DRV_LOG(DEBUG, "set latency %u usec", hv->latency);
169 } else if (!strcmp(key, NETVSC_ARG_RXBREAK)) {
170 hv->rx_copybreak = v;
171 PMD_DRV_LOG(DEBUG, "rx copy break set to %u",
172 hv->rx_copybreak);
173 } else if (!strcmp(key, NETVSC_ARG_TXBREAK)) {
174 hv->tx_copybreak = v;
175 PMD_DRV_LOG(DEBUG, "tx copy break set to %u",
176 hv->tx_copybreak);
177 } else if (!strcmp(key, NETVSC_ARG_RX_EXTMBUF_ENABLE)) {
178 hv->rx_extmbuf_enable = v;
179 PMD_DRV_LOG(DEBUG, "rx extmbuf enable set to %u",
180 hv->rx_extmbuf_enable);
181 }
182
183 return 0;
184 }
185
186 /* Parse device arguments */
hn_parse_args(const struct rte_eth_dev * dev)187 static int hn_parse_args(const struct rte_eth_dev *dev)
188 {
189 struct hn_data *hv = dev->data->dev_private;
190 struct rte_devargs *devargs = dev->device->devargs;
191 static const char * const valid_keys[] = {
192 NETVSC_ARG_LATENCY,
193 NETVSC_ARG_RXBREAK,
194 NETVSC_ARG_TXBREAK,
195 NETVSC_ARG_RX_EXTMBUF_ENABLE,
196 NULL
197 };
198 struct rte_kvargs *kvlist;
199 int ret;
200
201 if (!devargs)
202 return 0;
203
204 PMD_INIT_LOG(DEBUG, "device args %s %s",
205 devargs->name, devargs->args);
206
207 kvlist = rte_kvargs_parse(devargs->args, valid_keys);
208 if (!kvlist) {
209 PMD_DRV_LOG(ERR, "invalid parameters");
210 return -EINVAL;
211 }
212
213 ret = rte_kvargs_process(kvlist, NULL, hn_set_parameter, hv);
214 rte_kvargs_free(kvlist);
215
216 return ret;
217 }
218
219 /* Update link status.
220 * Note: the DPDK definition of "wait_to_complete"
221 * means block this call until link is up.
222 * which is not worth supporting.
223 */
224 int
hn_dev_link_update(struct rte_eth_dev * dev,int wait_to_complete __rte_unused)225 hn_dev_link_update(struct rte_eth_dev *dev,
226 int wait_to_complete __rte_unused)
227 {
228 struct hn_data *hv = dev->data->dev_private;
229 struct rte_eth_link link, old;
230 int error;
231
232 old = dev->data->dev_link;
233
234 error = hn_rndis_get_linkstatus(hv);
235 if (error)
236 return error;
237
238 hn_rndis_get_linkspeed(hv);
239
240 link = (struct rte_eth_link) {
241 .link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
242 .link_autoneg = RTE_ETH_LINK_SPEED_FIXED,
243 .link_speed = hv->link_speed / 10000,
244 };
245
246 if (hv->link_status == NDIS_MEDIA_STATE_CONNECTED)
247 link.link_status = RTE_ETH_LINK_UP;
248 else
249 link.link_status = RTE_ETH_LINK_DOWN;
250
251 if (old.link_status == link.link_status)
252 return 0;
253
254 PMD_INIT_LOG(DEBUG, "Port %d is %s", dev->data->port_id,
255 (link.link_status == RTE_ETH_LINK_UP) ? "up" : "down");
256
257 return rte_eth_linkstatus_set(dev, &link);
258 }
259
hn_dev_info_get(struct rte_eth_dev * dev,struct rte_eth_dev_info * dev_info)260 static int hn_dev_info_get(struct rte_eth_dev *dev,
261 struct rte_eth_dev_info *dev_info)
262 {
263 struct hn_data *hv = dev->data->dev_private;
264 int rc;
265
266 dev_info->speed_capa = RTE_ETH_LINK_SPEED_10G;
267 dev_info->min_rx_bufsize = HN_MIN_RX_BUF_SIZE;
268 dev_info->max_rx_pktlen = HN_MAX_XFER_LEN;
269 dev_info->max_mac_addrs = 1;
270
271 dev_info->hash_key_size = NDIS_HASH_KEYSIZE_TOEPLITZ;
272 dev_info->flow_type_rss_offloads = hv->rss_offloads;
273 dev_info->reta_size = RTE_ETH_RSS_RETA_SIZE_128;
274
275 dev_info->max_rx_queues = hv->max_queues;
276 dev_info->max_tx_queues = hv->max_queues;
277
278 dev_info->tx_desc_lim.nb_min = 1;
279 dev_info->tx_desc_lim.nb_max = 4096;
280
281 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
282 return 0;
283
284 /* fills in rx and tx offload capability */
285 rc = hn_rndis_get_offload(hv, dev_info);
286 if (rc != 0)
287 return rc;
288
289 /* merges the offload and queues of vf */
290 return hn_vf_info_get(hv, dev_info);
291 }
292
hn_rss_reta_update(struct rte_eth_dev * dev,struct rte_eth_rss_reta_entry64 * reta_conf,uint16_t reta_size)293 static int hn_rss_reta_update(struct rte_eth_dev *dev,
294 struct rte_eth_rss_reta_entry64 *reta_conf,
295 uint16_t reta_size)
296 {
297 struct hn_data *hv = dev->data->dev_private;
298 unsigned int i;
299 int err;
300
301 PMD_INIT_FUNC_TRACE();
302
303 if (reta_size != NDIS_HASH_INDCNT) {
304 PMD_DRV_LOG(ERR, "Hash lookup table size does not match NDIS");
305 return -EINVAL;
306 }
307
308 for (i = 0; i < NDIS_HASH_INDCNT; i++) {
309 uint16_t idx = i / RTE_ETH_RETA_GROUP_SIZE;
310 uint16_t shift = i % RTE_ETH_RETA_GROUP_SIZE;
311 uint64_t mask = (uint64_t)1 << shift;
312
313 if (reta_conf[idx].mask & mask)
314 hv->rss_ind[i] = reta_conf[idx].reta[shift];
315 }
316
317 err = hn_rndis_conf_rss(hv, NDIS_RSS_FLAG_DISABLE);
318 if (err) {
319 PMD_DRV_LOG(NOTICE,
320 "rss disable failed");
321 return err;
322 }
323
324 err = hn_rndis_conf_rss(hv, 0);
325 if (err) {
326 PMD_DRV_LOG(NOTICE,
327 "reta reconfig failed");
328 return err;
329 }
330
331 return hn_vf_reta_hash_update(dev, reta_conf, reta_size);
332 }
333
hn_rss_reta_query(struct rte_eth_dev * dev,struct rte_eth_rss_reta_entry64 * reta_conf,uint16_t reta_size)334 static int hn_rss_reta_query(struct rte_eth_dev *dev,
335 struct rte_eth_rss_reta_entry64 *reta_conf,
336 uint16_t reta_size)
337 {
338 struct hn_data *hv = dev->data->dev_private;
339 unsigned int i;
340
341 PMD_INIT_FUNC_TRACE();
342
343 if (reta_size != NDIS_HASH_INDCNT) {
344 PMD_DRV_LOG(ERR, "Hash lookup table size does not match NDIS");
345 return -EINVAL;
346 }
347
348 for (i = 0; i < NDIS_HASH_INDCNT; i++) {
349 uint16_t idx = i / RTE_ETH_RETA_GROUP_SIZE;
350 uint16_t shift = i % RTE_ETH_RETA_GROUP_SIZE;
351 uint64_t mask = (uint64_t)1 << shift;
352
353 if (reta_conf[idx].mask & mask)
354 reta_conf[idx].reta[shift] = hv->rss_ind[i];
355 }
356 return 0;
357 }
358
hn_rss_hash_init(struct hn_data * hv,const struct rte_eth_rss_conf * rss_conf)359 static void hn_rss_hash_init(struct hn_data *hv,
360 const struct rte_eth_rss_conf *rss_conf)
361 {
362 /* Convert from DPDK RSS hash flags to NDIS hash flags */
363 hv->rss_hash = NDIS_HASH_FUNCTION_TOEPLITZ;
364
365 if (rss_conf->rss_hf & RTE_ETH_RSS_IPV4)
366 hv->rss_hash |= NDIS_HASH_IPV4;
367 if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_TCP)
368 hv->rss_hash |= NDIS_HASH_TCP_IPV4;
369 if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6)
370 hv->rss_hash |= NDIS_HASH_IPV6;
371 if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6_EX)
372 hv->rss_hash |= NDIS_HASH_IPV6_EX;
373 if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_TCP)
374 hv->rss_hash |= NDIS_HASH_TCP_IPV6;
375 if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6_TCP_EX)
376 hv->rss_hash |= NDIS_HASH_TCP_IPV6_EX;
377
378 memcpy(hv->rss_key, rss_conf->rss_key ? : rss_default_key,
379 NDIS_HASH_KEYSIZE_TOEPLITZ);
380 }
381
hn_rss_hash_update(struct rte_eth_dev * dev,struct rte_eth_rss_conf * rss_conf)382 static int hn_rss_hash_update(struct rte_eth_dev *dev,
383 struct rte_eth_rss_conf *rss_conf)
384 {
385 struct hn_data *hv = dev->data->dev_private;
386 int err;
387
388 PMD_INIT_FUNC_TRACE();
389
390 err = hn_rndis_conf_rss(hv, NDIS_RSS_FLAG_DISABLE);
391 if (err) {
392 PMD_DRV_LOG(NOTICE,
393 "rss disable failed");
394 return err;
395 }
396
397 hn_rss_hash_init(hv, rss_conf);
398
399 if (rss_conf->rss_hf != 0) {
400 err = hn_rndis_conf_rss(hv, 0);
401 if (err) {
402 PMD_DRV_LOG(NOTICE,
403 "rss reconfig failed (RSS disabled)");
404 return err;
405 }
406 }
407
408 return hn_vf_rss_hash_update(dev, rss_conf);
409 }
410
hn_rss_hash_conf_get(struct rte_eth_dev * dev,struct rte_eth_rss_conf * rss_conf)411 static int hn_rss_hash_conf_get(struct rte_eth_dev *dev,
412 struct rte_eth_rss_conf *rss_conf)
413 {
414 struct hn_data *hv = dev->data->dev_private;
415
416 PMD_INIT_FUNC_TRACE();
417
418 if (hv->ndis_ver < NDIS_VERSION_6_20) {
419 PMD_DRV_LOG(DEBUG, "RSS not supported on this host");
420 return -EOPNOTSUPP;
421 }
422
423 rss_conf->rss_key_len = NDIS_HASH_KEYSIZE_TOEPLITZ;
424 if (rss_conf->rss_key)
425 memcpy(rss_conf->rss_key, hv->rss_key,
426 NDIS_HASH_KEYSIZE_TOEPLITZ);
427
428 rss_conf->rss_hf = 0;
429 if (hv->rss_hash & NDIS_HASH_IPV4)
430 rss_conf->rss_hf |= RTE_ETH_RSS_IPV4;
431
432 if (hv->rss_hash & NDIS_HASH_TCP_IPV4)
433 rss_conf->rss_hf |= RTE_ETH_RSS_NONFRAG_IPV4_TCP;
434
435 if (hv->rss_hash & NDIS_HASH_IPV6)
436 rss_conf->rss_hf |= RTE_ETH_RSS_IPV6;
437
438 if (hv->rss_hash & NDIS_HASH_IPV6_EX)
439 rss_conf->rss_hf |= RTE_ETH_RSS_IPV6_EX;
440
441 if (hv->rss_hash & NDIS_HASH_TCP_IPV6)
442 rss_conf->rss_hf |= RTE_ETH_RSS_NONFRAG_IPV6_TCP;
443
444 if (hv->rss_hash & NDIS_HASH_TCP_IPV6_EX)
445 rss_conf->rss_hf |= RTE_ETH_RSS_IPV6_TCP_EX;
446
447 return 0;
448 }
449
450 static int
hn_dev_promiscuous_enable(struct rte_eth_dev * dev)451 hn_dev_promiscuous_enable(struct rte_eth_dev *dev)
452 {
453 struct hn_data *hv = dev->data->dev_private;
454
455 hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_PROMISCUOUS);
456 return hn_vf_promiscuous_enable(dev);
457 }
458
459 static int
hn_dev_promiscuous_disable(struct rte_eth_dev * dev)460 hn_dev_promiscuous_disable(struct rte_eth_dev *dev)
461 {
462 struct hn_data *hv = dev->data->dev_private;
463 uint32_t filter;
464
465 filter = NDIS_PACKET_TYPE_DIRECTED | NDIS_PACKET_TYPE_BROADCAST;
466 if (dev->data->all_multicast)
467 filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
468 hn_rndis_set_rxfilter(hv, filter);
469 return hn_vf_promiscuous_disable(dev);
470 }
471
472 static int
hn_dev_allmulticast_enable(struct rte_eth_dev * dev)473 hn_dev_allmulticast_enable(struct rte_eth_dev *dev)
474 {
475 struct hn_data *hv = dev->data->dev_private;
476
477 hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_DIRECTED |
478 NDIS_PACKET_TYPE_ALL_MULTICAST |
479 NDIS_PACKET_TYPE_BROADCAST);
480 return hn_vf_allmulticast_enable(dev);
481 }
482
483 static int
hn_dev_allmulticast_disable(struct rte_eth_dev * dev)484 hn_dev_allmulticast_disable(struct rte_eth_dev *dev)
485 {
486 struct hn_data *hv = dev->data->dev_private;
487
488 hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_DIRECTED |
489 NDIS_PACKET_TYPE_BROADCAST);
490 return hn_vf_allmulticast_disable(dev);
491 }
492
493 static int
hn_dev_mc_addr_list(struct rte_eth_dev * dev,struct rte_ether_addr * mc_addr_set,uint32_t nb_mc_addr)494 hn_dev_mc_addr_list(struct rte_eth_dev *dev,
495 struct rte_ether_addr *mc_addr_set,
496 uint32_t nb_mc_addr)
497 {
498 /* No filtering on the synthetic path, but can do it on VF */
499 return hn_vf_mc_addr_list(dev, mc_addr_set, nb_mc_addr);
500 }
501
502 /* Setup shared rx/tx queue data */
hn_subchan_configure(struct hn_data * hv,uint32_t subchan)503 static int hn_subchan_configure(struct hn_data *hv,
504 uint32_t subchan)
505 {
506 struct vmbus_channel *primary = hn_primary_chan(hv);
507 int err;
508 unsigned int retry = 0;
509
510 PMD_DRV_LOG(DEBUG,
511 "open %u subchannels", subchan);
512
513 /* Send create sub channels command */
514 err = hn_nvs_alloc_subchans(hv, &subchan);
515 if (err)
516 return err;
517
518 while (subchan > 0) {
519 struct vmbus_channel *new_sc;
520 uint16_t chn_index;
521
522 err = rte_vmbus_subchan_open(primary, &new_sc);
523 if (err == -ENOENT && ++retry < 1000) {
524 /* This can happen if not ready yet */
525 rte_delay_ms(10);
526 continue;
527 }
528
529 if (err) {
530 PMD_DRV_LOG(ERR,
531 "open subchannel failed: %d", err);
532 return err;
533 }
534
535 rte_vmbus_set_latency(hv->vmbus, new_sc, hv->latency);
536
537 retry = 0;
538 chn_index = rte_vmbus_sub_channel_index(new_sc);
539 if (chn_index == 0 || chn_index > hv->max_queues) {
540 PMD_DRV_LOG(ERR,
541 "Invalid subchannel offermsg channel %u",
542 chn_index);
543 return -EIO;
544 }
545
546 PMD_DRV_LOG(DEBUG, "new sub channel %u", chn_index);
547 hv->channels[chn_index] = new_sc;
548 --subchan;
549 }
550
551 return err;
552 }
553
netvsc_hotplug_retry(void * args)554 static void netvsc_hotplug_retry(void *args)
555 {
556 int ret;
557 struct hv_hotadd_context *hot_ctx = args;
558 struct hn_data *hv = hot_ctx->hv;
559 struct rte_eth_dev *dev = &rte_eth_devices[hv->port_id];
560 struct rte_devargs *d = &hot_ctx->da;
561 char buf[256];
562
563 DIR *di;
564 struct dirent *dir;
565 struct ifreq req;
566 struct rte_ether_addr eth_addr;
567 int s;
568
569 PMD_DRV_LOG(DEBUG, "%s: retry count %d",
570 __func__, hot_ctx->eal_hot_plug_retry);
571
572 if (hot_ctx->eal_hot_plug_retry++ > NETVSC_MAX_HOTADD_RETRY) {
573 PMD_DRV_LOG(NOTICE, "Failed to parse PCI device retry=%d",
574 hot_ctx->eal_hot_plug_retry);
575 goto free_hotadd_ctx;
576 }
577
578 snprintf(buf, sizeof(buf), "/sys/bus/pci/devices/%s/net", d->name);
579 di = opendir(buf);
580 if (!di) {
581 PMD_DRV_LOG(DEBUG, "%s: can't open directory %s, "
582 "retrying in 1 second", __func__, buf);
583 goto retry;
584 }
585
586 while ((dir = readdir(di))) {
587 /* Skip . and .. directories */
588 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
589 continue;
590
591 /* trying to get mac address if this is a network device*/
592 s = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
593 if (s == -1) {
594 PMD_DRV_LOG(ERR, "Failed to create socket errno %d",
595 errno);
596 break;
597 }
598 strlcpy(req.ifr_name, dir->d_name, sizeof(req.ifr_name));
599 ret = ioctl(s, SIOCGIFHWADDR, &req);
600 close(s);
601 if (ret == -1) {
602 PMD_DRV_LOG(ERR,
603 "Failed to send SIOCGIFHWADDR for device %s",
604 dir->d_name);
605 break;
606 }
607 if (req.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
608 closedir(di);
609 goto free_hotadd_ctx;
610 }
611 memcpy(eth_addr.addr_bytes, req.ifr_hwaddr.sa_data,
612 RTE_DIM(eth_addr.addr_bytes));
613
614 if (rte_is_same_ether_addr(ð_addr, dev->data->mac_addrs)) {
615 PMD_DRV_LOG(NOTICE,
616 "Found matching MAC address, adding device %s network name %s",
617 d->name, dir->d_name);
618
619 /* If this device has been hot removed from this
620 * parent device, restore its args.
621 */
622 ret = rte_eal_hotplug_add(d->bus->name, d->name,
623 hv->vf_devargs ?
624 hv->vf_devargs : "");
625 if (ret) {
626 PMD_DRV_LOG(ERR,
627 "Failed to add PCI device %s",
628 d->name);
629 break;
630 }
631 }
632 /* When the code reaches here, we either have already added
633 * the device, or its MAC address did not match.
634 */
635 closedir(di);
636 goto free_hotadd_ctx;
637 }
638 closedir(di);
639 retry:
640 /* The device is still being initialized, retry after 1 second */
641 rte_eal_alarm_set(1000000, netvsc_hotplug_retry, hot_ctx);
642 return;
643
644 free_hotadd_ctx:
645 rte_spinlock_lock(&hv->hotadd_lock);
646 LIST_REMOVE(hot_ctx, list);
647 rte_spinlock_unlock(&hv->hotadd_lock);
648
649 rte_free(hot_ctx);
650 }
651
652 static void
netvsc_hotadd_callback(const char * device_name,enum rte_dev_event_type type,void * arg)653 netvsc_hotadd_callback(const char *device_name, enum rte_dev_event_type type,
654 void *arg)
655 {
656 struct hn_data *hv = arg;
657 struct hv_hotadd_context *hot_ctx;
658 struct rte_devargs *d;
659 int ret;
660
661 PMD_DRV_LOG(INFO, "Device notification type=%d device_name=%s",
662 type, device_name);
663
664 switch (type) {
665 case RTE_DEV_EVENT_ADD:
666 /* if we already has a VF, don't check on hot add */
667 if (hv->vf_ctx.vf_state > vf_removed)
668 break;
669
670 hot_ctx = rte_zmalloc("NETVSC-HOTADD", sizeof(*hot_ctx),
671 rte_mem_page_size());
672
673 if (!hot_ctx) {
674 PMD_DRV_LOG(ERR, "Failed to allocate hotadd context");
675 return;
676 }
677
678 hot_ctx->hv = hv;
679 d = &hot_ctx->da;
680
681 ret = rte_devargs_parse(d, device_name);
682 if (ret) {
683 PMD_DRV_LOG(ERR,
684 "devargs parsing failed ret=%d", ret);
685 goto free_ctx;
686 }
687
688 if (!strcmp(d->bus->name, "pci")) {
689 /* Start the process of figuring out if this
690 * PCI device is a VF device
691 */
692 rte_spinlock_lock(&hv->hotadd_lock);
693 LIST_INSERT_HEAD(&hv->hotadd_list, hot_ctx, list);
694 rte_spinlock_unlock(&hv->hotadd_lock);
695 rte_eal_alarm_set(1000000, netvsc_hotplug_retry, hot_ctx);
696 return;
697 }
698
699 /* We will switch to VF on RDNIS configure message
700 * sent from VSP
701 */
702 free_ctx:
703 rte_free(hot_ctx);
704 break;
705
706 default:
707 break;
708 }
709 }
710
hn_dev_configure(struct rte_eth_dev * dev)711 static int hn_dev_configure(struct rte_eth_dev *dev)
712 {
713 struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
714 struct rte_eth_rss_conf *rss_conf = &dev_conf->rx_adv_conf.rss_conf;
715 const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
716 const struct rte_eth_txmode *txmode = &dev_conf->txmode;
717 struct hn_data *hv = dev->data->dev_private;
718 uint64_t unsupported;
719 int i, err, subchan;
720
721 PMD_INIT_FUNC_TRACE();
722
723 if (dev_conf->rxmode.mq_mode & RTE_ETH_MQ_RX_RSS_FLAG)
724 dev_conf->rxmode.offloads |= RTE_ETH_RX_OFFLOAD_RSS_HASH;
725
726 unsupported = txmode->offloads & ~HN_TX_OFFLOAD_CAPS;
727 if (unsupported) {
728 PMD_DRV_LOG(NOTICE,
729 "unsupported TX offload: %#" PRIx64,
730 unsupported);
731 return -EINVAL;
732 }
733
734 unsupported = rxmode->offloads & ~HN_RX_OFFLOAD_CAPS;
735 if (unsupported) {
736 PMD_DRV_LOG(NOTICE,
737 "unsupported RX offload: %#" PRIx64,
738 rxmode->offloads);
739 return -EINVAL;
740 }
741
742 hv->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
743
744 err = hn_rndis_conf_offload(hv, txmode->offloads,
745 rxmode->offloads);
746 if (err) {
747 PMD_DRV_LOG(NOTICE,
748 "offload configure failed");
749 return err;
750 }
751
752 hv->num_queues = RTE_MAX(dev->data->nb_rx_queues,
753 dev->data->nb_tx_queues);
754
755 for (i = 0; i < NDIS_HASH_INDCNT; i++)
756 hv->rss_ind[i] = i % dev->data->nb_rx_queues;
757
758 hn_rss_hash_init(hv, rss_conf);
759
760 subchan = hv->num_queues - 1;
761 if (subchan > 0) {
762 err = hn_subchan_configure(hv, subchan);
763 if (err) {
764 PMD_DRV_LOG(NOTICE,
765 "subchannel configuration failed");
766 return err;
767 }
768
769 err = hn_rndis_conf_rss(hv, NDIS_RSS_FLAG_DISABLE);
770 if (err) {
771 PMD_DRV_LOG(NOTICE,
772 "rss disable failed");
773 return err;
774 }
775
776 if (rss_conf->rss_hf != 0) {
777 err = hn_rndis_conf_rss(hv, 0);
778 if (err) {
779 PMD_DRV_LOG(NOTICE,
780 "initial RSS config failed");
781 return err;
782 }
783 }
784 }
785
786 return hn_vf_configure_locked(dev, dev_conf);
787 }
788
hn_dev_stats_get(struct rte_eth_dev * dev,struct rte_eth_stats * stats)789 static int hn_dev_stats_get(struct rte_eth_dev *dev,
790 struct rte_eth_stats *stats)
791 {
792 unsigned int i;
793
794 hn_vf_stats_get(dev, stats);
795
796 for (i = 0; i < dev->data->nb_tx_queues; i++) {
797 const struct hn_tx_queue *txq = dev->data->tx_queues[i];
798
799 if (!txq)
800 continue;
801
802 stats->opackets += txq->stats.packets;
803 stats->obytes += txq->stats.bytes;
804 stats->oerrors += txq->stats.errors;
805
806 if (i < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
807 stats->q_opackets[i] = txq->stats.packets;
808 stats->q_obytes[i] = txq->stats.bytes;
809 }
810 }
811
812 for (i = 0; i < dev->data->nb_rx_queues; i++) {
813 const struct hn_rx_queue *rxq = dev->data->rx_queues[i];
814
815 if (!rxq)
816 continue;
817
818 stats->ipackets += rxq->stats.packets;
819 stats->ibytes += rxq->stats.bytes;
820 stats->ierrors += rxq->stats.errors;
821 stats->imissed += rxq->stats.ring_full;
822
823 if (i < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
824 stats->q_ipackets[i] = rxq->stats.packets;
825 stats->q_ibytes[i] = rxq->stats.bytes;
826 }
827 }
828
829 stats->rx_nombuf = dev->data->rx_mbuf_alloc_failed;
830 return 0;
831 }
832
833 static int
hn_dev_stats_reset(struct rte_eth_dev * dev)834 hn_dev_stats_reset(struct rte_eth_dev *dev)
835 {
836 unsigned int i;
837
838 PMD_INIT_FUNC_TRACE();
839
840 for (i = 0; i < dev->data->nb_tx_queues; i++) {
841 struct hn_tx_queue *txq = dev->data->tx_queues[i];
842
843 if (!txq)
844 continue;
845 memset(&txq->stats, 0, sizeof(struct hn_stats));
846 }
847
848 for (i = 0; i < dev->data->nb_rx_queues; i++) {
849 struct hn_rx_queue *rxq = dev->data->rx_queues[i];
850
851 if (!rxq)
852 continue;
853
854 memset(&rxq->stats, 0, sizeof(struct hn_stats));
855 }
856
857 return 0;
858 }
859
860 static int
hn_dev_xstats_reset(struct rte_eth_dev * dev)861 hn_dev_xstats_reset(struct rte_eth_dev *dev)
862 {
863 int ret;
864
865 ret = hn_dev_stats_reset(dev);
866 if (ret != 0)
867 return 0;
868
869 return hn_vf_xstats_reset(dev);
870 }
871
872 static int
hn_dev_xstats_count(struct rte_eth_dev * dev)873 hn_dev_xstats_count(struct rte_eth_dev *dev)
874 {
875 int ret, count;
876
877 count = dev->data->nb_tx_queues * RTE_DIM(hn_stat_strings);
878 count += dev->data->nb_rx_queues * RTE_DIM(hn_stat_strings);
879
880 ret = hn_vf_xstats_get_names(dev, NULL, 0);
881 if (ret < 0)
882 return ret;
883
884 return count + ret;
885 }
886
887 static int
hn_dev_xstats_get_names(struct rte_eth_dev * dev,struct rte_eth_xstat_name * xstats_names,unsigned int limit)888 hn_dev_xstats_get_names(struct rte_eth_dev *dev,
889 struct rte_eth_xstat_name *xstats_names,
890 unsigned int limit)
891 {
892 unsigned int i, t, count = 0;
893 int ret;
894
895 if (!xstats_names)
896 return hn_dev_xstats_count(dev);
897
898 /* Note: limit checked in rte_eth_xstats_names() */
899 for (i = 0; i < dev->data->nb_tx_queues; i++) {
900 const struct hn_tx_queue *txq = dev->data->tx_queues[i];
901
902 if (!txq)
903 continue;
904
905 if (count >= limit)
906 break;
907
908 for (t = 0; t < RTE_DIM(hn_stat_strings); t++)
909 snprintf(xstats_names[count++].name,
910 RTE_ETH_XSTATS_NAME_SIZE,
911 "tx_q%u_%s", i, hn_stat_strings[t].name);
912 }
913
914 for (i = 0; i < dev->data->nb_rx_queues; i++) {
915 const struct hn_rx_queue *rxq = dev->data->rx_queues[i];
916
917 if (!rxq)
918 continue;
919
920 if (count >= limit)
921 break;
922
923 for (t = 0; t < RTE_DIM(hn_stat_strings); t++)
924 snprintf(xstats_names[count++].name,
925 RTE_ETH_XSTATS_NAME_SIZE,
926 "rx_q%u_%s", i,
927 hn_stat_strings[t].name);
928 }
929
930 ret = hn_vf_xstats_get_names(dev, xstats_names + count,
931 limit - count);
932 if (ret < 0)
933 return ret;
934
935 return count + ret;
936 }
937
938 static int
hn_dev_xstats_get(struct rte_eth_dev * dev,struct rte_eth_xstat * xstats,unsigned int n)939 hn_dev_xstats_get(struct rte_eth_dev *dev,
940 struct rte_eth_xstat *xstats,
941 unsigned int n)
942 {
943 unsigned int i, t, count = 0;
944 const unsigned int nstats = hn_dev_xstats_count(dev);
945 const char *stats;
946 int ret;
947
948 PMD_INIT_FUNC_TRACE();
949
950 if (n < nstats)
951 return nstats;
952
953 for (i = 0; i < dev->data->nb_tx_queues; i++) {
954 const struct hn_tx_queue *txq = dev->data->tx_queues[i];
955
956 if (!txq)
957 continue;
958
959 stats = (const char *)&txq->stats;
960 for (t = 0; t < RTE_DIM(hn_stat_strings); t++, count++) {
961 xstats[count].id = count;
962 xstats[count].value = *(const uint64_t *)
963 (stats + hn_stat_strings[t].offset);
964 }
965 }
966
967 for (i = 0; i < dev->data->nb_rx_queues; i++) {
968 const struct hn_rx_queue *rxq = dev->data->rx_queues[i];
969
970 if (!rxq)
971 continue;
972
973 stats = (const char *)&rxq->stats;
974 for (t = 0; t < RTE_DIM(hn_stat_strings); t++, count++) {
975 xstats[count].id = count;
976 xstats[count].value = *(const uint64_t *)
977 (stats + hn_stat_strings[t].offset);
978 }
979 }
980
981 ret = hn_vf_xstats_get(dev, xstats, count, n);
982 if (ret < 0)
983 return ret;
984
985 return count + ret;
986 }
987
988 static int
hn_dev_start(struct rte_eth_dev * dev)989 hn_dev_start(struct rte_eth_dev *dev)
990 {
991 struct hn_data *hv = dev->data->dev_private;
992 int error;
993
994 PMD_INIT_FUNC_TRACE();
995
996 /* Register to monitor hot plug events */
997 error = rte_dev_event_callback_register(NULL, netvsc_hotadd_callback,
998 hv);
999 if (error) {
1000 PMD_DRV_LOG(ERR, "failed to register device event callback");
1001 return error;
1002 }
1003
1004 error = hn_rndis_set_rxfilter(hv,
1005 NDIS_PACKET_TYPE_BROADCAST |
1006 NDIS_PACKET_TYPE_ALL_MULTICAST |
1007 NDIS_PACKET_TYPE_DIRECTED);
1008 if (error)
1009 return error;
1010
1011 error = hn_vf_start(dev);
1012 if (error)
1013 hn_rndis_set_rxfilter(hv, 0);
1014
1015 /* Initialize Link state */
1016 if (error == 0)
1017 hn_dev_link_update(dev, 0);
1018
1019 return error;
1020 }
1021
1022 static int
hn_dev_stop(struct rte_eth_dev * dev)1023 hn_dev_stop(struct rte_eth_dev *dev)
1024 {
1025 struct hn_data *hv = dev->data->dev_private;
1026
1027 PMD_INIT_FUNC_TRACE();
1028 dev->data->dev_started = 0;
1029
1030 rte_dev_event_callback_unregister(NULL, netvsc_hotadd_callback, hv);
1031 hn_rndis_set_rxfilter(hv, 0);
1032 return hn_vf_stop(dev);
1033 }
1034
1035 static int
hn_dev_close(struct rte_eth_dev * dev)1036 hn_dev_close(struct rte_eth_dev *dev)
1037 {
1038 int ret;
1039 struct hn_data *hv = dev->data->dev_private;
1040 struct hv_hotadd_context *hot_ctx;
1041
1042 PMD_INIT_FUNC_TRACE();
1043 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1044 return 0;
1045
1046 rte_spinlock_lock(&hv->hotadd_lock);
1047 while (!LIST_EMPTY(&hv->hotadd_list)) {
1048 hot_ctx = LIST_FIRST(&hv->hotadd_list);
1049 rte_eal_alarm_cancel(netvsc_hotplug_retry, hot_ctx);
1050 LIST_REMOVE(hot_ctx, list);
1051 rte_free(hot_ctx);
1052 }
1053 rte_spinlock_unlock(&hv->hotadd_lock);
1054
1055 ret = hn_vf_close(dev);
1056 hn_dev_free_queues(dev);
1057
1058 return ret;
1059 }
1060
1061 static const struct eth_dev_ops hn_eth_dev_ops = {
1062 .dev_configure = hn_dev_configure,
1063 .dev_start = hn_dev_start,
1064 .dev_stop = hn_dev_stop,
1065 .dev_close = hn_dev_close,
1066 .dev_infos_get = hn_dev_info_get,
1067 .txq_info_get = hn_dev_tx_queue_info,
1068 .rxq_info_get = hn_dev_rx_queue_info,
1069 .dev_supported_ptypes_get = hn_vf_supported_ptypes,
1070 .promiscuous_enable = hn_dev_promiscuous_enable,
1071 .promiscuous_disable = hn_dev_promiscuous_disable,
1072 .allmulticast_enable = hn_dev_allmulticast_enable,
1073 .allmulticast_disable = hn_dev_allmulticast_disable,
1074 .set_mc_addr_list = hn_dev_mc_addr_list,
1075 .reta_update = hn_rss_reta_update,
1076 .reta_query = hn_rss_reta_query,
1077 .rss_hash_update = hn_rss_hash_update,
1078 .rss_hash_conf_get = hn_rss_hash_conf_get,
1079 .tx_queue_setup = hn_dev_tx_queue_setup,
1080 .tx_queue_release = hn_dev_tx_queue_release,
1081 .tx_done_cleanup = hn_dev_tx_done_cleanup,
1082 .rx_queue_setup = hn_dev_rx_queue_setup,
1083 .rx_queue_release = hn_dev_rx_queue_release,
1084 .link_update = hn_dev_link_update,
1085 .stats_get = hn_dev_stats_get,
1086 .stats_reset = hn_dev_stats_reset,
1087 .xstats_get = hn_dev_xstats_get,
1088 .xstats_get_names = hn_dev_xstats_get_names,
1089 .xstats_reset = hn_dev_xstats_reset,
1090 };
1091
1092 /*
1093 * Setup connection between PMD and kernel.
1094 */
1095 static int
hn_attach(struct hn_data * hv,unsigned int mtu)1096 hn_attach(struct hn_data *hv, unsigned int mtu)
1097 {
1098 int error;
1099
1100 /* Attach NVS */
1101 error = hn_nvs_attach(hv, mtu);
1102 if (error)
1103 goto failed_nvs;
1104
1105 /* Attach RNDIS */
1106 error = hn_rndis_attach(hv);
1107 if (error)
1108 goto failed_rndis;
1109
1110 /*
1111 * NOTE:
1112 * Under certain conditions on certain versions of Hyper-V,
1113 * the RNDIS rxfilter is _not_ zero on the hypervisor side
1114 * after the successful RNDIS initialization.
1115 */
1116 hn_rndis_set_rxfilter(hv, NDIS_PACKET_TYPE_NONE);
1117 return 0;
1118 failed_rndis:
1119 hn_nvs_detach(hv);
1120 failed_nvs:
1121 return error;
1122 }
1123
1124 static void
hn_detach(struct hn_data * hv)1125 hn_detach(struct hn_data *hv)
1126 {
1127 hn_nvs_detach(hv);
1128 hn_rndis_detach(hv);
1129 }
1130
1131 static int
eth_hn_dev_init(struct rte_eth_dev * eth_dev)1132 eth_hn_dev_init(struct rte_eth_dev *eth_dev)
1133 {
1134 struct hn_data *hv = eth_dev->data->dev_private;
1135 struct rte_device *device = eth_dev->device;
1136 struct rte_vmbus_device *vmbus;
1137 unsigned int rxr_cnt;
1138 int err, max_chan;
1139
1140 PMD_INIT_FUNC_TRACE();
1141
1142 rte_spinlock_init(&hv->hotadd_lock);
1143 LIST_INIT(&hv->hotadd_list);
1144
1145 vmbus = container_of(device, struct rte_vmbus_device, device);
1146 eth_dev->dev_ops = &hn_eth_dev_ops;
1147 eth_dev->rx_queue_count = hn_dev_rx_queue_count;
1148 eth_dev->rx_descriptor_status = hn_dev_rx_queue_status;
1149 eth_dev->tx_descriptor_status = hn_dev_tx_descriptor_status;
1150 eth_dev->tx_pkt_burst = &hn_xmit_pkts;
1151 eth_dev->rx_pkt_burst = &hn_recv_pkts;
1152
1153 /*
1154 * for secondary processes, we don't initialize any further as primary
1155 * has already done this work.
1156 */
1157 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1158 return 0;
1159
1160 eth_dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
1161
1162 /* Since Hyper-V only supports one MAC address */
1163 eth_dev->data->mac_addrs = rte_calloc("hv_mac", HN_MAX_MAC_ADDRS,
1164 sizeof(struct rte_ether_addr), 0);
1165 if (eth_dev->data->mac_addrs == NULL) {
1166 PMD_INIT_LOG(ERR,
1167 "Failed to allocate memory store MAC addresses");
1168 return -ENOMEM;
1169 }
1170
1171 hv->vmbus = vmbus;
1172 hv->rxbuf_res = &vmbus->resource[HV_RECV_BUF_MAP];
1173 hv->chim_res = &vmbus->resource[HV_SEND_BUF_MAP];
1174 hv->port_id = eth_dev->data->port_id;
1175 hv->latency = HN_CHAN_LATENCY_NS;
1176 hv->rx_copybreak = HN_RXCOPY_THRESHOLD;
1177 hv->tx_copybreak = HN_TXCOPY_THRESHOLD;
1178 hv->rx_extmbuf_enable = HN_RX_EXTMBUF_ENABLE;
1179 hv->max_queues = 1;
1180
1181 rte_rwlock_init(&hv->vf_lock);
1182 hv->vf_ctx.vf_vsc_switched = false;
1183 hv->vf_ctx.vf_vsp_reported = false;
1184 hv->vf_ctx.vf_attached = false;
1185 hv->vf_ctx.vf_state = vf_unknown;
1186
1187 err = hn_parse_args(eth_dev);
1188 if (err)
1189 return err;
1190
1191 strlcpy(hv->owner.name, eth_dev->device->name,
1192 RTE_ETH_MAX_OWNER_NAME_LEN);
1193 err = rte_eth_dev_owner_new(&hv->owner.id);
1194 if (err) {
1195 PMD_INIT_LOG(ERR, "Can not get owner id");
1196 return err;
1197 }
1198
1199 /* Initialize primary channel input for control operations */
1200 err = rte_vmbus_chan_open(vmbus, &hv->channels[0]);
1201 if (err)
1202 return err;
1203
1204 rte_vmbus_set_latency(hv->vmbus, hv->channels[0], hv->latency);
1205
1206 hv->primary = hn_rx_queue_alloc(hv, 0,
1207 eth_dev->device->numa_node);
1208
1209 if (!hv->primary)
1210 return -ENOMEM;
1211
1212 err = hn_attach(hv, RTE_ETHER_MTU);
1213 if (err)
1214 goto failed;
1215
1216 err = hn_chim_init(eth_dev);
1217 if (err)
1218 goto failed;
1219
1220 err = hn_rndis_get_eaddr(hv, eth_dev->data->mac_addrs->addr_bytes);
1221 if (err)
1222 goto failed;
1223
1224 /* Multi queue requires later versions of windows server */
1225 if (hv->nvs_ver < NVS_VERSION_5)
1226 return 0;
1227
1228 max_chan = rte_vmbus_max_channels(vmbus);
1229 PMD_INIT_LOG(DEBUG, "VMBus max channels %d", max_chan);
1230 if (max_chan <= 0)
1231 goto failed;
1232
1233 if (hn_rndis_query_rsscaps(hv, &rxr_cnt) != 0)
1234 rxr_cnt = 1;
1235
1236 hv->max_queues = RTE_MIN(rxr_cnt, (unsigned int)max_chan);
1237
1238 /* If VF was reported but not added, do it now */
1239 if (hv->vf_ctx.vf_vsp_reported && !hv->vf_ctx.vf_vsc_switched) {
1240 PMD_INIT_LOG(DEBUG, "Adding VF device");
1241
1242 err = hn_vf_add(eth_dev, hv);
1243 }
1244
1245 return 0;
1246
1247 failed:
1248 PMD_INIT_LOG(NOTICE, "device init failed");
1249
1250 hn_chim_uninit(eth_dev);
1251 hn_detach(hv);
1252 return err;
1253 }
1254
1255 static int
eth_hn_dev_uninit(struct rte_eth_dev * eth_dev)1256 eth_hn_dev_uninit(struct rte_eth_dev *eth_dev)
1257 {
1258 struct hn_data *hv = eth_dev->data->dev_private;
1259 int ret, ret_stop;
1260
1261 PMD_INIT_FUNC_TRACE();
1262
1263 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1264 return 0;
1265
1266 ret_stop = hn_dev_stop(eth_dev);
1267 hn_dev_close(eth_dev);
1268
1269 free(hv->vf_devargs);
1270 hv->vf_devargs = NULL;
1271
1272 hn_detach(hv);
1273 hn_chim_uninit(eth_dev);
1274 rte_vmbus_chan_close(hv->primary->chan);
1275 rte_free(hv->primary);
1276 ret = rte_eth_dev_owner_delete(hv->owner.id);
1277 if (ret != 0)
1278 return ret;
1279
1280 return ret_stop;
1281 }
1282
eth_hn_probe(struct rte_vmbus_driver * drv __rte_unused,struct rte_vmbus_device * dev)1283 static int eth_hn_probe(struct rte_vmbus_driver *drv __rte_unused,
1284 struct rte_vmbus_device *dev)
1285 {
1286 struct rte_eth_dev *eth_dev;
1287 int ret;
1288
1289 PMD_INIT_FUNC_TRACE();
1290
1291 ret = rte_dev_event_monitor_start();
1292 if (ret) {
1293 PMD_DRV_LOG(ERR, "Failed to start device event monitoring");
1294 return ret;
1295 }
1296
1297 eth_dev = eth_dev_vmbus_allocate(dev, sizeof(struct hn_data));
1298 if (!eth_dev)
1299 return -ENOMEM;
1300
1301 ret = eth_hn_dev_init(eth_dev);
1302 if (ret) {
1303 eth_dev_vmbus_release(eth_dev);
1304 rte_dev_event_monitor_stop();
1305 } else {
1306 rte_eth_dev_probing_finish(eth_dev);
1307 }
1308
1309 return ret;
1310 }
1311
eth_hn_remove(struct rte_vmbus_device * dev)1312 static int eth_hn_remove(struct rte_vmbus_device *dev)
1313 {
1314 struct rte_eth_dev *eth_dev;
1315 int ret;
1316
1317 PMD_INIT_FUNC_TRACE();
1318
1319 eth_dev = rte_eth_dev_allocated(dev->device.name);
1320 if (!eth_dev)
1321 return 0; /* port already released */
1322
1323 ret = eth_hn_dev_uninit(eth_dev);
1324 if (ret)
1325 return ret;
1326
1327 eth_dev_vmbus_release(eth_dev);
1328 rte_dev_event_monitor_stop();
1329 return 0;
1330 }
1331
1332 /* Network device GUID */
1333 static const rte_uuid_t hn_net_ids[] = {
1334 /* f8615163-df3e-46c5-913f-f2d2f965ed0e */
1335 RTE_UUID_INIT(0xf8615163, 0xdf3e, 0x46c5, 0x913f, 0xf2d2f965ed0eULL),
1336 { 0 }
1337 };
1338
1339 static struct rte_vmbus_driver rte_netvsc_pmd = {
1340 .id_table = hn_net_ids,
1341 .probe = eth_hn_probe,
1342 .remove = eth_hn_remove,
1343 };
1344
1345 RTE_PMD_REGISTER_VMBUS(net_netvsc, rte_netvsc_pmd);
1346 RTE_PMD_REGISTER_KMOD_DEP(net_netvsc, "* uio_hv_generic");
1347 RTE_LOG_REGISTER_SUFFIX(hn_logtype_init, init, NOTICE);
1348 RTE_LOG_REGISTER_SUFFIX(hn_logtype_driver, driver, NOTICE);
1349 RTE_PMD_REGISTER_PARAM_STRING(net_netvsc,
1350 NETVSC_ARG_LATENCY "=<uint32> "
1351 NETVSC_ARG_RXBREAK "=<uint32> "
1352 NETVSC_ARG_TXBREAK "=<uint32> "
1353 NETVSC_ARG_RX_EXTMBUF_ENABLE "=<0|1>");
1354