1 /* 2 * Copyright (c) 2009, Microsoft Corporation. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License along with 14 * this program; if not, see <http://www.gnu.org/licenses/>. 15 * 16 * Authors: 17 * Haiyang Zhang <haiyangz@microsoft.com> 18 * Hank Janssen <hjanssen@microsoft.com> 19 */ 20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 21 22 #include <linux/init.h> 23 #include <linux/atomic.h> 24 #include <linux/module.h> 25 #include <linux/highmem.h> 26 #include <linux/device.h> 27 #include <linux/io.h> 28 #include <linux/delay.h> 29 #include <linux/netdevice.h> 30 #include <linux/inetdevice.h> 31 #include <linux/etherdevice.h> 32 #include <linux/skbuff.h> 33 #include <linux/if_vlan.h> 34 #include <linux/in.h> 35 #include <linux/slab.h> 36 #include <net/arp.h> 37 #include <net/route.h> 38 #include <net/sock.h> 39 #include <net/pkt_sched.h> 40 41 #include "hyperv_net.h" 42 43 44 #define RING_SIZE_MIN 64 45 #define LINKCHANGE_INT (2 * HZ) 46 #define NETVSC_HW_FEATURES (NETIF_F_RXCSUM | \ 47 NETIF_F_SG | \ 48 NETIF_F_TSO | \ 49 NETIF_F_TSO6 | \ 50 NETIF_F_HW_CSUM) 51 static int ring_size = 128; 52 module_param(ring_size, int, S_IRUGO); 53 MODULE_PARM_DESC(ring_size, "Ring buffer size (# of pages)"); 54 55 static int max_num_vrss_chns = 8; 56 57 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | 58 NETIF_MSG_LINK | NETIF_MSG_IFUP | 59 NETIF_MSG_IFDOWN | NETIF_MSG_RX_ERR | 60 NETIF_MSG_TX_ERR; 61 62 static int debug = -1; 63 module_param(debug, int, S_IRUGO); 64 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); 65 66 static void do_set_multicast(struct work_struct *w) 67 { 68 struct net_device_context *ndevctx = 69 container_of(w, struct net_device_context, work); 70 struct hv_device *device_obj = ndevctx->device_ctx; 71 struct net_device *ndev = hv_get_drvdata(device_obj); 72 struct netvsc_device *nvdev = ndevctx->nvdev; 73 struct rndis_device *rdev; 74 75 if (!nvdev) 76 return; 77 78 rdev = nvdev->extension; 79 if (rdev == NULL) 80 return; 81 82 if (ndev->flags & IFF_PROMISC) 83 rndis_filter_set_packet_filter(rdev, 84 NDIS_PACKET_TYPE_PROMISCUOUS); 85 else 86 rndis_filter_set_packet_filter(rdev, 87 NDIS_PACKET_TYPE_BROADCAST | 88 NDIS_PACKET_TYPE_ALL_MULTICAST | 89 NDIS_PACKET_TYPE_DIRECTED); 90 } 91 92 static void netvsc_set_multicast_list(struct net_device *net) 93 { 94 struct net_device_context *net_device_ctx = netdev_priv(net); 95 96 schedule_work(&net_device_ctx->work); 97 } 98 99 static int netvsc_open(struct net_device *net) 100 { 101 struct net_device_context *net_device_ctx = netdev_priv(net); 102 struct hv_device *device_obj = net_device_ctx->device_ctx; 103 struct netvsc_device *nvdev = net_device_ctx->nvdev; 104 struct rndis_device *rdev; 105 int ret = 0; 106 107 netif_carrier_off(net); 108 109 /* Open up the device */ 110 ret = rndis_filter_open(device_obj); 111 if (ret != 0) { 112 netdev_err(net, "unable to open device (ret %d).\n", ret); 113 return ret; 114 } 115 116 netif_tx_wake_all_queues(net); 117 118 rdev = nvdev->extension; 119 if (!rdev->link_state) 120 netif_carrier_on(net); 121 122 return ret; 123 } 124 125 static int netvsc_close(struct net_device *net) 126 { 127 struct net_device_context *net_device_ctx = netdev_priv(net); 128 struct hv_device *device_obj = net_device_ctx->device_ctx; 129 struct netvsc_device *nvdev = net_device_ctx->nvdev; 130 int ret; 131 u32 aread, awrite, i, msec = 10, retry = 0, retry_max = 20; 132 struct vmbus_channel *chn; 133 134 netif_tx_disable(net); 135 136 /* Make sure netvsc_set_multicast_list doesn't re-enable filter! */ 137 cancel_work_sync(&net_device_ctx->work); 138 ret = rndis_filter_close(device_obj); 139 if (ret != 0) { 140 netdev_err(net, "unable to close device (ret %d).\n", ret); 141 return ret; 142 } 143 144 /* Ensure pending bytes in ring are read */ 145 while (true) { 146 aread = 0; 147 for (i = 0; i < nvdev->num_chn; i++) { 148 chn = nvdev->chn_table[i]; 149 if (!chn) 150 continue; 151 152 hv_get_ringbuffer_availbytes(&chn->inbound, &aread, 153 &awrite); 154 155 if (aread) 156 break; 157 158 hv_get_ringbuffer_availbytes(&chn->outbound, &aread, 159 &awrite); 160 161 if (aread) 162 break; 163 } 164 165 retry++; 166 if (retry > retry_max || aread == 0) 167 break; 168 169 msleep(msec); 170 171 if (msec < 1000) 172 msec *= 2; 173 } 174 175 if (aread) { 176 netdev_err(net, "Ring buffer not empty after closing rndis\n"); 177 ret = -ETIMEDOUT; 178 } 179 180 return ret; 181 } 182 183 static void *init_ppi_data(struct rndis_message *msg, u32 ppi_size, 184 int pkt_type) 185 { 186 struct rndis_packet *rndis_pkt; 187 struct rndis_per_packet_info *ppi; 188 189 rndis_pkt = &msg->msg.pkt; 190 rndis_pkt->data_offset += ppi_size; 191 192 ppi = (struct rndis_per_packet_info *)((void *)rndis_pkt + 193 rndis_pkt->per_pkt_info_offset + rndis_pkt->per_pkt_info_len); 194 195 ppi->size = ppi_size; 196 ppi->type = pkt_type; 197 ppi->ppi_offset = sizeof(struct rndis_per_packet_info); 198 199 rndis_pkt->per_pkt_info_len += ppi_size; 200 201 return ppi; 202 } 203 204 static u16 netvsc_select_queue(struct net_device *ndev, struct sk_buff *skb, 205 void *accel_priv, select_queue_fallback_t fallback) 206 { 207 struct net_device_context *net_device_ctx = netdev_priv(ndev); 208 struct netvsc_device *nvsc_dev = net_device_ctx->nvdev; 209 u32 hash; 210 u16 q_idx = 0; 211 212 if (nvsc_dev == NULL || ndev->real_num_tx_queues <= 1) 213 return 0; 214 215 hash = skb_get_hash(skb); 216 q_idx = nvsc_dev->send_table[hash % VRSS_SEND_TAB_SIZE] % 217 ndev->real_num_tx_queues; 218 219 if (!nvsc_dev->chn_table[q_idx]) 220 q_idx = 0; 221 222 return q_idx; 223 } 224 225 static u32 fill_pg_buf(struct page *page, u32 offset, u32 len, 226 struct hv_page_buffer *pb) 227 { 228 int j = 0; 229 230 /* Deal with compund pages by ignoring unused part 231 * of the page. 232 */ 233 page += (offset >> PAGE_SHIFT); 234 offset &= ~PAGE_MASK; 235 236 while (len > 0) { 237 unsigned long bytes; 238 239 bytes = PAGE_SIZE - offset; 240 if (bytes > len) 241 bytes = len; 242 pb[j].pfn = page_to_pfn(page); 243 pb[j].offset = offset; 244 pb[j].len = bytes; 245 246 offset += bytes; 247 len -= bytes; 248 249 if (offset == PAGE_SIZE && len) { 250 page++; 251 offset = 0; 252 j++; 253 } 254 } 255 256 return j + 1; 257 } 258 259 static u32 init_page_array(void *hdr, u32 len, struct sk_buff *skb, 260 struct hv_netvsc_packet *packet, 261 struct hv_page_buffer **page_buf) 262 { 263 struct hv_page_buffer *pb = *page_buf; 264 u32 slots_used = 0; 265 char *data = skb->data; 266 int frags = skb_shinfo(skb)->nr_frags; 267 int i; 268 269 /* The packet is laid out thus: 270 * 1. hdr: RNDIS header and PPI 271 * 2. skb linear data 272 * 3. skb fragment data 273 */ 274 if (hdr != NULL) 275 slots_used += fill_pg_buf(virt_to_page(hdr), 276 offset_in_page(hdr), 277 len, &pb[slots_used]); 278 279 packet->rmsg_size = len; 280 packet->rmsg_pgcnt = slots_used; 281 282 slots_used += fill_pg_buf(virt_to_page(data), 283 offset_in_page(data), 284 skb_headlen(skb), &pb[slots_used]); 285 286 for (i = 0; i < frags; i++) { 287 skb_frag_t *frag = skb_shinfo(skb)->frags + i; 288 289 slots_used += fill_pg_buf(skb_frag_page(frag), 290 frag->page_offset, 291 skb_frag_size(frag), &pb[slots_used]); 292 } 293 return slots_used; 294 } 295 296 static int count_skb_frag_slots(struct sk_buff *skb) 297 { 298 int i, frags = skb_shinfo(skb)->nr_frags; 299 int pages = 0; 300 301 for (i = 0; i < frags; i++) { 302 skb_frag_t *frag = skb_shinfo(skb)->frags + i; 303 unsigned long size = skb_frag_size(frag); 304 unsigned long offset = frag->page_offset; 305 306 /* Skip unused frames from start of page */ 307 offset &= ~PAGE_MASK; 308 pages += PFN_UP(offset + size); 309 } 310 return pages; 311 } 312 313 static int netvsc_get_slots(struct sk_buff *skb) 314 { 315 char *data = skb->data; 316 unsigned int offset = offset_in_page(data); 317 unsigned int len = skb_headlen(skb); 318 int slots; 319 int frag_slots; 320 321 slots = DIV_ROUND_UP(offset + len, PAGE_SIZE); 322 frag_slots = count_skb_frag_slots(skb); 323 return slots + frag_slots; 324 } 325 326 static u32 get_net_transport_info(struct sk_buff *skb, u32 *trans_off) 327 { 328 u32 ret_val = TRANSPORT_INFO_NOT_IP; 329 330 if ((eth_hdr(skb)->h_proto != htons(ETH_P_IP)) && 331 (eth_hdr(skb)->h_proto != htons(ETH_P_IPV6))) { 332 goto not_ip; 333 } 334 335 *trans_off = skb_transport_offset(skb); 336 337 if ((eth_hdr(skb)->h_proto == htons(ETH_P_IP))) { 338 struct iphdr *iphdr = ip_hdr(skb); 339 340 if (iphdr->protocol == IPPROTO_TCP) 341 ret_val = TRANSPORT_INFO_IPV4_TCP; 342 else if (iphdr->protocol == IPPROTO_UDP) 343 ret_val = TRANSPORT_INFO_IPV4_UDP; 344 } else { 345 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) 346 ret_val = TRANSPORT_INFO_IPV6_TCP; 347 else if (ipv6_hdr(skb)->nexthdr == IPPROTO_UDP) 348 ret_val = TRANSPORT_INFO_IPV6_UDP; 349 } 350 351 not_ip: 352 return ret_val; 353 } 354 355 static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net) 356 { 357 struct net_device_context *net_device_ctx = netdev_priv(net); 358 struct hv_netvsc_packet *packet = NULL; 359 int ret; 360 unsigned int num_data_pgs; 361 struct rndis_message *rndis_msg; 362 struct rndis_packet *rndis_pkt; 363 u32 rndis_msg_size; 364 bool isvlan; 365 bool linear = false; 366 struct rndis_per_packet_info *ppi; 367 struct ndis_tcp_ip_checksum_info *csum_info; 368 struct ndis_tcp_lso_info *lso_info; 369 int hdr_offset; 370 u32 net_trans_info; 371 u32 hash; 372 u32 skb_length; 373 struct hv_page_buffer page_buf[MAX_PAGE_BUFFER_COUNT]; 374 struct hv_page_buffer *pb = page_buf; 375 struct netvsc_stats *tx_stats = this_cpu_ptr(net_device_ctx->tx_stats); 376 377 /* We will atmost need two pages to describe the rndis 378 * header. We can only transmit MAX_PAGE_BUFFER_COUNT number 379 * of pages in a single packet. If skb is scattered around 380 * more pages we try linearizing it. 381 */ 382 383 check_size: 384 skb_length = skb->len; 385 num_data_pgs = netvsc_get_slots(skb) + 2; 386 if (num_data_pgs > MAX_PAGE_BUFFER_COUNT && linear) { 387 net_alert_ratelimited("packet too big: %u pages (%u bytes)\n", 388 num_data_pgs, skb->len); 389 ret = -EFAULT; 390 goto drop; 391 } else if (num_data_pgs > MAX_PAGE_BUFFER_COUNT) { 392 if (skb_linearize(skb)) { 393 net_alert_ratelimited("failed to linearize skb\n"); 394 ret = -ENOMEM; 395 goto drop; 396 } 397 linear = true; 398 goto check_size; 399 } 400 401 /* 402 * Place the rndis header in the skb head room and 403 * the skb->cb will be used for hv_netvsc_packet 404 * structure. 405 */ 406 ret = skb_cow_head(skb, RNDIS_AND_PPI_SIZE); 407 if (ret) { 408 netdev_err(net, "unable to alloc hv_netvsc_packet\n"); 409 ret = -ENOMEM; 410 goto drop; 411 } 412 /* Use the skb control buffer for building up the packet */ 413 BUILD_BUG_ON(sizeof(struct hv_netvsc_packet) > 414 FIELD_SIZEOF(struct sk_buff, cb)); 415 packet = (struct hv_netvsc_packet *)skb->cb; 416 417 418 packet->q_idx = skb_get_queue_mapping(skb); 419 420 packet->total_data_buflen = skb->len; 421 422 rndis_msg = (struct rndis_message *)skb->head; 423 424 memset(rndis_msg, 0, RNDIS_AND_PPI_SIZE); 425 426 isvlan = skb->vlan_tci & VLAN_TAG_PRESENT; 427 428 /* Add the rndis header */ 429 rndis_msg->ndis_msg_type = RNDIS_MSG_PACKET; 430 rndis_msg->msg_len = packet->total_data_buflen; 431 rndis_pkt = &rndis_msg->msg.pkt; 432 rndis_pkt->data_offset = sizeof(struct rndis_packet); 433 rndis_pkt->data_len = packet->total_data_buflen; 434 rndis_pkt->per_pkt_info_offset = sizeof(struct rndis_packet); 435 436 rndis_msg_size = RNDIS_MESSAGE_SIZE(struct rndis_packet); 437 438 hash = skb_get_hash_raw(skb); 439 if (hash != 0 && net->real_num_tx_queues > 1) { 440 rndis_msg_size += NDIS_HASH_PPI_SIZE; 441 ppi = init_ppi_data(rndis_msg, NDIS_HASH_PPI_SIZE, 442 NBL_HASH_VALUE); 443 *(u32 *)((void *)ppi + ppi->ppi_offset) = hash; 444 } 445 446 if (isvlan) { 447 struct ndis_pkt_8021q_info *vlan; 448 449 rndis_msg_size += NDIS_VLAN_PPI_SIZE; 450 ppi = init_ppi_data(rndis_msg, NDIS_VLAN_PPI_SIZE, 451 IEEE_8021Q_INFO); 452 vlan = (struct ndis_pkt_8021q_info *)((void *)ppi + 453 ppi->ppi_offset); 454 vlan->vlanid = skb->vlan_tci & VLAN_VID_MASK; 455 vlan->pri = (skb->vlan_tci & VLAN_PRIO_MASK) >> 456 VLAN_PRIO_SHIFT; 457 } 458 459 net_trans_info = get_net_transport_info(skb, &hdr_offset); 460 if (net_trans_info == TRANSPORT_INFO_NOT_IP) 461 goto do_send; 462 463 /* 464 * Setup the sendside checksum offload only if this is not a 465 * GSO packet. 466 */ 467 if (skb_is_gso(skb)) 468 goto do_lso; 469 470 if ((skb->ip_summed == CHECKSUM_NONE) || 471 (skb->ip_summed == CHECKSUM_UNNECESSARY)) 472 goto do_send; 473 474 rndis_msg_size += NDIS_CSUM_PPI_SIZE; 475 ppi = init_ppi_data(rndis_msg, NDIS_CSUM_PPI_SIZE, 476 TCPIP_CHKSUM_PKTINFO); 477 478 csum_info = (struct ndis_tcp_ip_checksum_info *)((void *)ppi + 479 ppi->ppi_offset); 480 481 if (net_trans_info & (INFO_IPV4 << 16)) 482 csum_info->transmit.is_ipv4 = 1; 483 else 484 csum_info->transmit.is_ipv6 = 1; 485 486 if (net_trans_info & INFO_TCP) { 487 csum_info->transmit.tcp_checksum = 1; 488 csum_info->transmit.tcp_header_offset = hdr_offset; 489 } else if (net_trans_info & INFO_UDP) { 490 /* UDP checksum offload is not supported on ws2008r2. 491 * Furthermore, on ws2012 and ws2012r2, there are some 492 * issues with udp checksum offload from Linux guests. 493 * (these are host issues). 494 * For now compute the checksum here. 495 */ 496 struct udphdr *uh; 497 u16 udp_len; 498 499 ret = skb_cow_head(skb, 0); 500 if (ret) 501 goto drop; 502 503 uh = udp_hdr(skb); 504 udp_len = ntohs(uh->len); 505 uh->check = 0; 506 uh->check = csum_tcpudp_magic(ip_hdr(skb)->saddr, 507 ip_hdr(skb)->daddr, 508 udp_len, IPPROTO_UDP, 509 csum_partial(uh, udp_len, 0)); 510 if (uh->check == 0) 511 uh->check = CSUM_MANGLED_0; 512 513 csum_info->transmit.udp_checksum = 0; 514 } 515 goto do_send; 516 517 do_lso: 518 rndis_msg_size += NDIS_LSO_PPI_SIZE; 519 ppi = init_ppi_data(rndis_msg, NDIS_LSO_PPI_SIZE, 520 TCP_LARGESEND_PKTINFO); 521 522 lso_info = (struct ndis_tcp_lso_info *)((void *)ppi + 523 ppi->ppi_offset); 524 525 lso_info->lso_v2_transmit.type = NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE; 526 if (net_trans_info & (INFO_IPV4 << 16)) { 527 lso_info->lso_v2_transmit.ip_version = 528 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4; 529 ip_hdr(skb)->tot_len = 0; 530 ip_hdr(skb)->check = 0; 531 tcp_hdr(skb)->check = 532 ~csum_tcpudp_magic(ip_hdr(skb)->saddr, 533 ip_hdr(skb)->daddr, 0, IPPROTO_TCP, 0); 534 } else { 535 lso_info->lso_v2_transmit.ip_version = 536 NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6; 537 ipv6_hdr(skb)->payload_len = 0; 538 tcp_hdr(skb)->check = 539 ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 540 &ipv6_hdr(skb)->daddr, 0, IPPROTO_TCP, 0); 541 } 542 lso_info->lso_v2_transmit.tcp_header_offset = hdr_offset; 543 lso_info->lso_v2_transmit.mss = skb_shinfo(skb)->gso_size; 544 545 do_send: 546 /* Start filling in the page buffers with the rndis hdr */ 547 rndis_msg->msg_len += rndis_msg_size; 548 packet->total_data_buflen = rndis_msg->msg_len; 549 packet->page_buf_cnt = init_page_array(rndis_msg, rndis_msg_size, 550 skb, packet, &pb); 551 552 /* timestamp packet in software */ 553 skb_tx_timestamp(skb); 554 ret = netvsc_send(net_device_ctx->device_ctx, packet, 555 rndis_msg, &pb, skb); 556 557 drop: 558 if (ret == 0) { 559 u64_stats_update_begin(&tx_stats->syncp); 560 tx_stats->packets++; 561 tx_stats->bytes += skb_length; 562 u64_stats_update_end(&tx_stats->syncp); 563 } else { 564 if (ret != -EAGAIN) { 565 dev_kfree_skb_any(skb); 566 net->stats.tx_dropped++; 567 } 568 } 569 570 return (ret == -EAGAIN) ? NETDEV_TX_BUSY : NETDEV_TX_OK; 571 } 572 573 /* 574 * netvsc_linkstatus_callback - Link up/down notification 575 */ 576 void netvsc_linkstatus_callback(struct hv_device *device_obj, 577 struct rndis_message *resp) 578 { 579 struct rndis_indicate_status *indicate = &resp->msg.indicate_status; 580 struct net_device *net; 581 struct net_device_context *ndev_ctx; 582 struct netvsc_reconfig *event; 583 unsigned long flags; 584 585 /* Handle link change statuses only */ 586 if (indicate->status != RNDIS_STATUS_NETWORK_CHANGE && 587 indicate->status != RNDIS_STATUS_MEDIA_CONNECT && 588 indicate->status != RNDIS_STATUS_MEDIA_DISCONNECT) 589 return; 590 591 net = hv_get_drvdata(device_obj); 592 593 if (!net || net->reg_state != NETREG_REGISTERED) 594 return; 595 596 ndev_ctx = netdev_priv(net); 597 598 event = kzalloc(sizeof(*event), GFP_ATOMIC); 599 if (!event) 600 return; 601 event->event = indicate->status; 602 603 spin_lock_irqsave(&ndev_ctx->lock, flags); 604 list_add_tail(&event->list, &ndev_ctx->reconfig_events); 605 spin_unlock_irqrestore(&ndev_ctx->lock, flags); 606 607 schedule_delayed_work(&ndev_ctx->dwork, 0); 608 } 609 610 611 static struct sk_buff *netvsc_alloc_recv_skb(struct net_device *net, 612 struct hv_netvsc_packet *packet, 613 struct ndis_tcp_ip_checksum_info *csum_info, 614 void *data, u16 vlan_tci) 615 { 616 struct sk_buff *skb; 617 618 skb = netdev_alloc_skb_ip_align(net, packet->total_data_buflen); 619 if (!skb) 620 return skb; 621 622 /* 623 * Copy to skb. This copy is needed here since the memory pointed by 624 * hv_netvsc_packet cannot be deallocated 625 */ 626 memcpy(skb_put(skb, packet->total_data_buflen), data, 627 packet->total_data_buflen); 628 629 skb->protocol = eth_type_trans(skb, net); 630 if (csum_info) { 631 /* We only look at the IP checksum here. 632 * Should we be dropping the packet if checksum 633 * failed? How do we deal with other checksums - TCP/UDP? 634 */ 635 if (csum_info->receive.ip_checksum_succeeded) 636 skb->ip_summed = CHECKSUM_UNNECESSARY; 637 else 638 skb->ip_summed = CHECKSUM_NONE; 639 } 640 641 if (vlan_tci & VLAN_TAG_PRESENT) 642 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), 643 vlan_tci); 644 645 return skb; 646 } 647 648 /* 649 * netvsc_recv_callback - Callback when we receive a packet from the 650 * "wire" on the specified device. 651 */ 652 int netvsc_recv_callback(struct hv_device *device_obj, 653 struct hv_netvsc_packet *packet, 654 void **data, 655 struct ndis_tcp_ip_checksum_info *csum_info, 656 struct vmbus_channel *channel, 657 u16 vlan_tci) 658 { 659 struct net_device *net = hv_get_drvdata(device_obj); 660 struct net_device_context *net_device_ctx = netdev_priv(net); 661 struct sk_buff *skb; 662 struct sk_buff *vf_skb; 663 struct netvsc_stats *rx_stats; 664 struct netvsc_device *netvsc_dev = net_device_ctx->nvdev; 665 u32 bytes_recvd = packet->total_data_buflen; 666 int ret = 0; 667 668 if (!net || net->reg_state != NETREG_REGISTERED) 669 return NVSP_STAT_FAIL; 670 671 if (READ_ONCE(netvsc_dev->vf_inject)) { 672 atomic_inc(&netvsc_dev->vf_use_cnt); 673 if (!READ_ONCE(netvsc_dev->vf_inject)) { 674 /* 675 * We raced; just move on. 676 */ 677 atomic_dec(&netvsc_dev->vf_use_cnt); 678 goto vf_injection_done; 679 } 680 681 /* 682 * Inject this packet into the VF inerface. 683 * On Hyper-V, multicast and brodcast packets 684 * are only delivered on the synthetic interface 685 * (after subjecting these to policy filters on 686 * the host). Deliver these via the VF interface 687 * in the guest. 688 */ 689 vf_skb = netvsc_alloc_recv_skb(netvsc_dev->vf_netdev, packet, 690 csum_info, *data, vlan_tci); 691 if (vf_skb != NULL) { 692 ++netvsc_dev->vf_netdev->stats.rx_packets; 693 netvsc_dev->vf_netdev->stats.rx_bytes += bytes_recvd; 694 netif_receive_skb(vf_skb); 695 } else { 696 ++net->stats.rx_dropped; 697 ret = NVSP_STAT_FAIL; 698 } 699 atomic_dec(&netvsc_dev->vf_use_cnt); 700 return ret; 701 } 702 703 vf_injection_done: 704 net_device_ctx = netdev_priv(net); 705 rx_stats = this_cpu_ptr(net_device_ctx->rx_stats); 706 707 /* Allocate a skb - TODO direct I/O to pages? */ 708 skb = netvsc_alloc_recv_skb(net, packet, csum_info, *data, vlan_tci); 709 if (unlikely(!skb)) { 710 ++net->stats.rx_dropped; 711 return NVSP_STAT_FAIL; 712 } 713 skb_record_rx_queue(skb, channel-> 714 offermsg.offer.sub_channel_index); 715 716 u64_stats_update_begin(&rx_stats->syncp); 717 rx_stats->packets++; 718 rx_stats->bytes += packet->total_data_buflen; 719 u64_stats_update_end(&rx_stats->syncp); 720 721 /* 722 * Pass the skb back up. Network stack will deallocate the skb when it 723 * is done. 724 * TODO - use NAPI? 725 */ 726 netif_rx(skb); 727 728 return 0; 729 } 730 731 static void netvsc_get_drvinfo(struct net_device *net, 732 struct ethtool_drvinfo *info) 733 { 734 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver)); 735 strlcpy(info->fw_version, "N/A", sizeof(info->fw_version)); 736 } 737 738 static void netvsc_get_channels(struct net_device *net, 739 struct ethtool_channels *channel) 740 { 741 struct net_device_context *net_device_ctx = netdev_priv(net); 742 struct netvsc_device *nvdev = net_device_ctx->nvdev; 743 744 if (nvdev) { 745 channel->max_combined = nvdev->max_chn; 746 channel->combined_count = nvdev->num_chn; 747 } 748 } 749 750 static int netvsc_set_channels(struct net_device *net, 751 struct ethtool_channels *channels) 752 { 753 struct net_device_context *net_device_ctx = netdev_priv(net); 754 struct hv_device *dev = net_device_ctx->device_ctx; 755 struct netvsc_device *nvdev = net_device_ctx->nvdev; 756 struct netvsc_device_info device_info; 757 u32 num_chn; 758 u32 max_chn; 759 int ret = 0; 760 bool recovering = false; 761 762 if (net_device_ctx->start_remove || !nvdev || nvdev->destroy) 763 return -ENODEV; 764 765 num_chn = nvdev->num_chn; 766 max_chn = min_t(u32, nvdev->max_chn, num_online_cpus()); 767 768 if (nvdev->nvsp_version < NVSP_PROTOCOL_VERSION_5) { 769 pr_info("vRSS unsupported before NVSP Version 5\n"); 770 return -EINVAL; 771 } 772 773 /* We do not support rx, tx, or other */ 774 if (!channels || 775 channels->rx_count || 776 channels->tx_count || 777 channels->other_count || 778 (channels->combined_count < 1)) 779 return -EINVAL; 780 781 if (channels->combined_count > max_chn) { 782 pr_info("combined channels too high, using %d\n", max_chn); 783 channels->combined_count = max_chn; 784 } 785 786 ret = netvsc_close(net); 787 if (ret) 788 goto out; 789 790 do_set: 791 net_device_ctx->start_remove = true; 792 rndis_filter_device_remove(dev); 793 794 nvdev->num_chn = channels->combined_count; 795 796 memset(&device_info, 0, sizeof(device_info)); 797 device_info.num_chn = nvdev->num_chn; /* passed to RNDIS */ 798 device_info.ring_size = ring_size; 799 device_info.max_num_vrss_chns = max_num_vrss_chns; 800 801 ret = rndis_filter_device_add(dev, &device_info); 802 if (ret) { 803 if (recovering) { 804 netdev_err(net, "unable to add netvsc device (ret %d)\n", ret); 805 return ret; 806 } 807 goto recover; 808 } 809 810 nvdev = net_device_ctx->nvdev; 811 812 ret = netif_set_real_num_tx_queues(net, nvdev->num_chn); 813 if (ret) { 814 if (recovering) { 815 netdev_err(net, "could not set tx queue count (ret %d)\n", ret); 816 return ret; 817 } 818 goto recover; 819 } 820 821 ret = netif_set_real_num_rx_queues(net, nvdev->num_chn); 822 if (ret) { 823 if (recovering) { 824 netdev_err(net, "could not set rx queue count (ret %d)\n", ret); 825 return ret; 826 } 827 goto recover; 828 } 829 830 out: 831 netvsc_open(net); 832 net_device_ctx->start_remove = false; 833 /* We may have missed link change notifications */ 834 schedule_delayed_work(&net_device_ctx->dwork, 0); 835 836 return ret; 837 838 recover: 839 /* If the above failed, we attempt to recover through the same 840 * process but with the original number of channels. 841 */ 842 netdev_err(net, "could not set channels, recovering\n"); 843 recovering = true; 844 channels->combined_count = num_chn; 845 goto do_set; 846 } 847 848 static bool netvsc_validate_ethtool_ss_cmd(const struct ethtool_cmd *cmd) 849 { 850 struct ethtool_cmd diff1 = *cmd; 851 struct ethtool_cmd diff2 = {}; 852 853 ethtool_cmd_speed_set(&diff1, 0); 854 diff1.duplex = 0; 855 /* advertising and cmd are usually set */ 856 diff1.advertising = 0; 857 diff1.cmd = 0; 858 /* We set port to PORT_OTHER */ 859 diff2.port = PORT_OTHER; 860 861 return !memcmp(&diff1, &diff2, sizeof(diff1)); 862 } 863 864 static void netvsc_init_settings(struct net_device *dev) 865 { 866 struct net_device_context *ndc = netdev_priv(dev); 867 868 ndc->speed = SPEED_UNKNOWN; 869 ndc->duplex = DUPLEX_UNKNOWN; 870 } 871 872 static int netvsc_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 873 { 874 struct net_device_context *ndc = netdev_priv(dev); 875 876 ethtool_cmd_speed_set(cmd, ndc->speed); 877 cmd->duplex = ndc->duplex; 878 cmd->port = PORT_OTHER; 879 880 return 0; 881 } 882 883 static int netvsc_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 884 { 885 struct net_device_context *ndc = netdev_priv(dev); 886 u32 speed; 887 888 speed = ethtool_cmd_speed(cmd); 889 if (!ethtool_validate_speed(speed) || 890 !ethtool_validate_duplex(cmd->duplex) || 891 !netvsc_validate_ethtool_ss_cmd(cmd)) 892 return -EINVAL; 893 894 ndc->speed = speed; 895 ndc->duplex = cmd->duplex; 896 897 return 0; 898 } 899 900 static int netvsc_change_mtu(struct net_device *ndev, int mtu) 901 { 902 struct net_device_context *ndevctx = netdev_priv(ndev); 903 struct netvsc_device *nvdev = ndevctx->nvdev; 904 struct hv_device *hdev = ndevctx->device_ctx; 905 struct netvsc_device_info device_info; 906 int limit = ETH_DATA_LEN; 907 u32 num_chn; 908 int ret = 0; 909 910 if (ndevctx->start_remove || !nvdev || nvdev->destroy) 911 return -ENODEV; 912 913 if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2) 914 limit = NETVSC_MTU - ETH_HLEN; 915 916 if (mtu < NETVSC_MTU_MIN || mtu > limit) 917 return -EINVAL; 918 919 ret = netvsc_close(ndev); 920 if (ret) 921 goto out; 922 923 num_chn = nvdev->num_chn; 924 925 ndevctx->start_remove = true; 926 rndis_filter_device_remove(hdev); 927 928 ndev->mtu = mtu; 929 930 memset(&device_info, 0, sizeof(device_info)); 931 device_info.ring_size = ring_size; 932 device_info.num_chn = num_chn; 933 device_info.max_num_vrss_chns = max_num_vrss_chns; 934 rndis_filter_device_add(hdev, &device_info); 935 936 out: 937 netvsc_open(ndev); 938 ndevctx->start_remove = false; 939 940 /* We may have missed link change notifications */ 941 schedule_delayed_work(&ndevctx->dwork, 0); 942 943 return ret; 944 } 945 946 static struct rtnl_link_stats64 *netvsc_get_stats64(struct net_device *net, 947 struct rtnl_link_stats64 *t) 948 { 949 struct net_device_context *ndev_ctx = netdev_priv(net); 950 int cpu; 951 952 for_each_possible_cpu(cpu) { 953 struct netvsc_stats *tx_stats = per_cpu_ptr(ndev_ctx->tx_stats, 954 cpu); 955 struct netvsc_stats *rx_stats = per_cpu_ptr(ndev_ctx->rx_stats, 956 cpu); 957 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 958 unsigned int start; 959 960 do { 961 start = u64_stats_fetch_begin_irq(&tx_stats->syncp); 962 tx_packets = tx_stats->packets; 963 tx_bytes = tx_stats->bytes; 964 } while (u64_stats_fetch_retry_irq(&tx_stats->syncp, start)); 965 966 do { 967 start = u64_stats_fetch_begin_irq(&rx_stats->syncp); 968 rx_packets = rx_stats->packets; 969 rx_bytes = rx_stats->bytes; 970 } while (u64_stats_fetch_retry_irq(&rx_stats->syncp, start)); 971 972 t->tx_bytes += tx_bytes; 973 t->tx_packets += tx_packets; 974 t->rx_bytes += rx_bytes; 975 t->rx_packets += rx_packets; 976 } 977 978 t->tx_dropped = net->stats.tx_dropped; 979 t->tx_errors = net->stats.tx_dropped; 980 981 t->rx_dropped = net->stats.rx_dropped; 982 t->rx_errors = net->stats.rx_errors; 983 984 return t; 985 } 986 987 static int netvsc_set_mac_addr(struct net_device *ndev, void *p) 988 { 989 struct net_device_context *ndevctx = netdev_priv(ndev); 990 struct hv_device *hdev = ndevctx->device_ctx; 991 struct sockaddr *addr = p; 992 char save_adr[ETH_ALEN]; 993 unsigned char save_aatype; 994 int err; 995 996 memcpy(save_adr, ndev->dev_addr, ETH_ALEN); 997 save_aatype = ndev->addr_assign_type; 998 999 err = eth_mac_addr(ndev, p); 1000 if (err != 0) 1001 return err; 1002 1003 err = rndis_filter_set_device_mac(hdev, addr->sa_data); 1004 if (err != 0) { 1005 /* roll back to saved MAC */ 1006 memcpy(ndev->dev_addr, save_adr, ETH_ALEN); 1007 ndev->addr_assign_type = save_aatype; 1008 } 1009 1010 return err; 1011 } 1012 1013 #ifdef CONFIG_NET_POLL_CONTROLLER 1014 static void netvsc_poll_controller(struct net_device *net) 1015 { 1016 /* As netvsc_start_xmit() works synchronous we don't have to 1017 * trigger anything here. 1018 */ 1019 } 1020 #endif 1021 1022 static const struct ethtool_ops ethtool_ops = { 1023 .get_drvinfo = netvsc_get_drvinfo, 1024 .get_link = ethtool_op_get_link, 1025 .get_channels = netvsc_get_channels, 1026 .set_channels = netvsc_set_channels, 1027 .get_ts_info = ethtool_op_get_ts_info, 1028 .get_settings = netvsc_get_settings, 1029 .set_settings = netvsc_set_settings, 1030 }; 1031 1032 static const struct net_device_ops device_ops = { 1033 .ndo_open = netvsc_open, 1034 .ndo_stop = netvsc_close, 1035 .ndo_start_xmit = netvsc_start_xmit, 1036 .ndo_set_rx_mode = netvsc_set_multicast_list, 1037 .ndo_change_mtu = netvsc_change_mtu, 1038 .ndo_validate_addr = eth_validate_addr, 1039 .ndo_set_mac_address = netvsc_set_mac_addr, 1040 .ndo_select_queue = netvsc_select_queue, 1041 .ndo_get_stats64 = netvsc_get_stats64, 1042 #ifdef CONFIG_NET_POLL_CONTROLLER 1043 .ndo_poll_controller = netvsc_poll_controller, 1044 #endif 1045 }; 1046 1047 /* 1048 * Handle link status changes. For RNDIS_STATUS_NETWORK_CHANGE emulate link 1049 * down/up sequence. In case of RNDIS_STATUS_MEDIA_CONNECT when carrier is 1050 * present send GARP packet to network peers with netif_notify_peers(). 1051 */ 1052 static void netvsc_link_change(struct work_struct *w) 1053 { 1054 struct net_device_context *ndev_ctx = 1055 container_of(w, struct net_device_context, dwork.work); 1056 struct hv_device *device_obj = ndev_ctx->device_ctx; 1057 struct net_device *net = hv_get_drvdata(device_obj); 1058 struct netvsc_device *net_device; 1059 struct rndis_device *rdev; 1060 struct netvsc_reconfig *event = NULL; 1061 bool notify = false, reschedule = false; 1062 unsigned long flags, next_reconfig, delay; 1063 1064 rtnl_lock(); 1065 if (ndev_ctx->start_remove) 1066 goto out_unlock; 1067 1068 net_device = ndev_ctx->nvdev; 1069 rdev = net_device->extension; 1070 1071 next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT; 1072 if (time_is_after_jiffies(next_reconfig)) { 1073 /* link_watch only sends one notification with current state 1074 * per second, avoid doing reconfig more frequently. Handle 1075 * wrap around. 1076 */ 1077 delay = next_reconfig - jiffies; 1078 delay = delay < LINKCHANGE_INT ? delay : LINKCHANGE_INT; 1079 schedule_delayed_work(&ndev_ctx->dwork, delay); 1080 goto out_unlock; 1081 } 1082 ndev_ctx->last_reconfig = jiffies; 1083 1084 spin_lock_irqsave(&ndev_ctx->lock, flags); 1085 if (!list_empty(&ndev_ctx->reconfig_events)) { 1086 event = list_first_entry(&ndev_ctx->reconfig_events, 1087 struct netvsc_reconfig, list); 1088 list_del(&event->list); 1089 reschedule = !list_empty(&ndev_ctx->reconfig_events); 1090 } 1091 spin_unlock_irqrestore(&ndev_ctx->lock, flags); 1092 1093 if (!event) 1094 goto out_unlock; 1095 1096 switch (event->event) { 1097 /* Only the following events are possible due to the check in 1098 * netvsc_linkstatus_callback() 1099 */ 1100 case RNDIS_STATUS_MEDIA_CONNECT: 1101 if (rdev->link_state) { 1102 rdev->link_state = false; 1103 netif_carrier_on(net); 1104 netif_tx_wake_all_queues(net); 1105 } else { 1106 notify = true; 1107 } 1108 kfree(event); 1109 break; 1110 case RNDIS_STATUS_MEDIA_DISCONNECT: 1111 if (!rdev->link_state) { 1112 rdev->link_state = true; 1113 netif_carrier_off(net); 1114 netif_tx_stop_all_queues(net); 1115 } 1116 kfree(event); 1117 break; 1118 case RNDIS_STATUS_NETWORK_CHANGE: 1119 /* Only makes sense if carrier is present */ 1120 if (!rdev->link_state) { 1121 rdev->link_state = true; 1122 netif_carrier_off(net); 1123 netif_tx_stop_all_queues(net); 1124 event->event = RNDIS_STATUS_MEDIA_CONNECT; 1125 spin_lock_irqsave(&ndev_ctx->lock, flags); 1126 list_add(&event->list, &ndev_ctx->reconfig_events); 1127 spin_unlock_irqrestore(&ndev_ctx->lock, flags); 1128 reschedule = true; 1129 } 1130 break; 1131 } 1132 1133 rtnl_unlock(); 1134 1135 if (notify) 1136 netdev_notify_peers(net); 1137 1138 /* link_watch only sends one notification with current state per 1139 * second, handle next reconfig event in 2 seconds. 1140 */ 1141 if (reschedule) 1142 schedule_delayed_work(&ndev_ctx->dwork, LINKCHANGE_INT); 1143 1144 return; 1145 1146 out_unlock: 1147 rtnl_unlock(); 1148 } 1149 1150 static void netvsc_free_netdev(struct net_device *netdev) 1151 { 1152 struct net_device_context *net_device_ctx = netdev_priv(netdev); 1153 1154 free_percpu(net_device_ctx->tx_stats); 1155 free_percpu(net_device_ctx->rx_stats); 1156 free_netdev(netdev); 1157 } 1158 1159 static void netvsc_notify_peers(struct work_struct *wrk) 1160 { 1161 struct garp_wrk *gwrk; 1162 1163 gwrk = container_of(wrk, struct garp_wrk, dwrk); 1164 1165 netdev_notify_peers(gwrk->netdev); 1166 1167 atomic_dec(&gwrk->netvsc_dev->vf_use_cnt); 1168 } 1169 1170 static struct net_device *get_netvsc_net_device(char *mac) 1171 { 1172 struct net_device *dev, *found = NULL; 1173 int rtnl_locked; 1174 1175 rtnl_locked = rtnl_trylock(); 1176 1177 for_each_netdev(&init_net, dev) { 1178 if (memcmp(dev->dev_addr, mac, ETH_ALEN) == 0) { 1179 if (dev->netdev_ops != &device_ops) 1180 continue; 1181 found = dev; 1182 break; 1183 } 1184 } 1185 if (rtnl_locked) 1186 rtnl_unlock(); 1187 1188 return found; 1189 } 1190 1191 static int netvsc_register_vf(struct net_device *vf_netdev) 1192 { 1193 struct net_device *ndev; 1194 struct net_device_context *net_device_ctx; 1195 struct netvsc_device *netvsc_dev; 1196 const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops; 1197 1198 if (eth_ops == NULL || eth_ops == ðtool_ops) 1199 return NOTIFY_DONE; 1200 1201 /* 1202 * We will use the MAC address to locate the synthetic interface to 1203 * associate with the VF interface. If we don't find a matching 1204 * synthetic interface, move on. 1205 */ 1206 ndev = get_netvsc_net_device(vf_netdev->dev_addr); 1207 if (!ndev) 1208 return NOTIFY_DONE; 1209 1210 net_device_ctx = netdev_priv(ndev); 1211 netvsc_dev = net_device_ctx->nvdev; 1212 if (netvsc_dev == NULL) 1213 return NOTIFY_DONE; 1214 1215 netdev_info(ndev, "VF registering: %s\n", vf_netdev->name); 1216 /* 1217 * Take a reference on the module. 1218 */ 1219 try_module_get(THIS_MODULE); 1220 netvsc_dev->vf_netdev = vf_netdev; 1221 return NOTIFY_OK; 1222 } 1223 1224 1225 static int netvsc_vf_up(struct net_device *vf_netdev) 1226 { 1227 struct net_device *ndev; 1228 struct netvsc_device *netvsc_dev; 1229 const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops; 1230 struct net_device_context *net_device_ctx; 1231 1232 if (eth_ops == ðtool_ops) 1233 return NOTIFY_DONE; 1234 1235 ndev = get_netvsc_net_device(vf_netdev->dev_addr); 1236 if (!ndev) 1237 return NOTIFY_DONE; 1238 1239 net_device_ctx = netdev_priv(ndev); 1240 netvsc_dev = net_device_ctx->nvdev; 1241 1242 if ((netvsc_dev == NULL) || (netvsc_dev->vf_netdev == NULL)) 1243 return NOTIFY_DONE; 1244 1245 netdev_info(ndev, "VF up: %s\n", vf_netdev->name); 1246 netvsc_dev->vf_inject = true; 1247 1248 /* 1249 * Open the device before switching data path. 1250 */ 1251 rndis_filter_open(net_device_ctx->device_ctx); 1252 1253 /* 1254 * notify the host to switch the data path. 1255 */ 1256 netvsc_switch_datapath(ndev, true); 1257 netdev_info(ndev, "Data path switched to VF: %s\n", vf_netdev->name); 1258 1259 netif_carrier_off(ndev); 1260 1261 /* 1262 * Now notify peers. We are scheduling work to 1263 * notify peers; take a reference to prevent 1264 * the VF interface from vanishing. 1265 */ 1266 atomic_inc(&netvsc_dev->vf_use_cnt); 1267 net_device_ctx->gwrk.netdev = vf_netdev; 1268 net_device_ctx->gwrk.netvsc_dev = netvsc_dev; 1269 schedule_work(&net_device_ctx->gwrk.dwrk); 1270 1271 return NOTIFY_OK; 1272 } 1273 1274 1275 static int netvsc_vf_down(struct net_device *vf_netdev) 1276 { 1277 struct net_device *ndev; 1278 struct netvsc_device *netvsc_dev; 1279 struct net_device_context *net_device_ctx; 1280 const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops; 1281 1282 if (eth_ops == ðtool_ops) 1283 return NOTIFY_DONE; 1284 1285 ndev = get_netvsc_net_device(vf_netdev->dev_addr); 1286 if (!ndev) 1287 return NOTIFY_DONE; 1288 1289 net_device_ctx = netdev_priv(ndev); 1290 netvsc_dev = net_device_ctx->nvdev; 1291 1292 if ((netvsc_dev == NULL) || (netvsc_dev->vf_netdev == NULL)) 1293 return NOTIFY_DONE; 1294 1295 netdev_info(ndev, "VF down: %s\n", vf_netdev->name); 1296 netvsc_dev->vf_inject = false; 1297 /* 1298 * Wait for currently active users to 1299 * drain out. 1300 */ 1301 1302 while (atomic_read(&netvsc_dev->vf_use_cnt) != 0) 1303 udelay(50); 1304 netvsc_switch_datapath(ndev, false); 1305 netdev_info(ndev, "Data path switched from VF: %s\n", vf_netdev->name); 1306 rndis_filter_close(net_device_ctx->device_ctx); 1307 netif_carrier_on(ndev); 1308 /* 1309 * Notify peers. 1310 */ 1311 atomic_inc(&netvsc_dev->vf_use_cnt); 1312 net_device_ctx->gwrk.netdev = ndev; 1313 net_device_ctx->gwrk.netvsc_dev = netvsc_dev; 1314 schedule_work(&net_device_ctx->gwrk.dwrk); 1315 1316 return NOTIFY_OK; 1317 } 1318 1319 1320 static int netvsc_unregister_vf(struct net_device *vf_netdev) 1321 { 1322 struct net_device *ndev; 1323 struct netvsc_device *netvsc_dev; 1324 const struct ethtool_ops *eth_ops = vf_netdev->ethtool_ops; 1325 struct net_device_context *net_device_ctx; 1326 1327 if (eth_ops == ðtool_ops) 1328 return NOTIFY_DONE; 1329 1330 ndev = get_netvsc_net_device(vf_netdev->dev_addr); 1331 if (!ndev) 1332 return NOTIFY_DONE; 1333 1334 net_device_ctx = netdev_priv(ndev); 1335 netvsc_dev = net_device_ctx->nvdev; 1336 if (netvsc_dev == NULL) 1337 return NOTIFY_DONE; 1338 netdev_info(ndev, "VF unregistering: %s\n", vf_netdev->name); 1339 1340 netvsc_dev->vf_netdev = NULL; 1341 module_put(THIS_MODULE); 1342 return NOTIFY_OK; 1343 } 1344 1345 static int netvsc_probe(struct hv_device *dev, 1346 const struct hv_vmbus_device_id *dev_id) 1347 { 1348 struct net_device *net = NULL; 1349 struct net_device_context *net_device_ctx; 1350 struct netvsc_device_info device_info; 1351 struct netvsc_device *nvdev; 1352 int ret; 1353 1354 net = alloc_etherdev_mq(sizeof(struct net_device_context), 1355 num_online_cpus()); 1356 if (!net) 1357 return -ENOMEM; 1358 1359 netif_carrier_off(net); 1360 1361 net_device_ctx = netdev_priv(net); 1362 net_device_ctx->device_ctx = dev; 1363 net_device_ctx->msg_enable = netif_msg_init(debug, default_msg); 1364 if (netif_msg_probe(net_device_ctx)) 1365 netdev_dbg(net, "netvsc msg_enable: %d\n", 1366 net_device_ctx->msg_enable); 1367 1368 net_device_ctx->tx_stats = netdev_alloc_pcpu_stats(struct netvsc_stats); 1369 if (!net_device_ctx->tx_stats) { 1370 free_netdev(net); 1371 return -ENOMEM; 1372 } 1373 net_device_ctx->rx_stats = netdev_alloc_pcpu_stats(struct netvsc_stats); 1374 if (!net_device_ctx->rx_stats) { 1375 free_percpu(net_device_ctx->tx_stats); 1376 free_netdev(net); 1377 return -ENOMEM; 1378 } 1379 1380 hv_set_drvdata(dev, net); 1381 1382 net_device_ctx->start_remove = false; 1383 1384 INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change); 1385 INIT_WORK(&net_device_ctx->work, do_set_multicast); 1386 INIT_WORK(&net_device_ctx->gwrk.dwrk, netvsc_notify_peers); 1387 1388 spin_lock_init(&net_device_ctx->lock); 1389 INIT_LIST_HEAD(&net_device_ctx->reconfig_events); 1390 1391 net->netdev_ops = &device_ops; 1392 1393 net->hw_features = NETVSC_HW_FEATURES; 1394 net->features = NETVSC_HW_FEATURES | NETIF_F_HW_VLAN_CTAG_TX; 1395 1396 net->ethtool_ops = ðtool_ops; 1397 SET_NETDEV_DEV(net, &dev->device); 1398 1399 /* We always need headroom for rndis header */ 1400 net->needed_headroom = RNDIS_AND_PPI_SIZE; 1401 1402 /* Notify the netvsc driver of the new device */ 1403 memset(&device_info, 0, sizeof(device_info)); 1404 device_info.ring_size = ring_size; 1405 device_info.max_num_vrss_chns = max_num_vrss_chns; 1406 ret = rndis_filter_device_add(dev, &device_info); 1407 if (ret != 0) { 1408 netdev_err(net, "unable to add netvsc device (ret %d)\n", ret); 1409 netvsc_free_netdev(net); 1410 hv_set_drvdata(dev, NULL); 1411 return ret; 1412 } 1413 memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN); 1414 1415 nvdev = net_device_ctx->nvdev; 1416 netif_set_real_num_tx_queues(net, nvdev->num_chn); 1417 netif_set_real_num_rx_queues(net, nvdev->num_chn); 1418 1419 netvsc_init_settings(net); 1420 1421 ret = register_netdev(net); 1422 if (ret != 0) { 1423 pr_err("Unable to register netdev.\n"); 1424 rndis_filter_device_remove(dev); 1425 netvsc_free_netdev(net); 1426 } 1427 1428 return ret; 1429 } 1430 1431 static int netvsc_remove(struct hv_device *dev) 1432 { 1433 struct net_device *net; 1434 struct net_device_context *ndev_ctx; 1435 struct netvsc_device *net_device; 1436 1437 net = hv_get_drvdata(dev); 1438 1439 if (net == NULL) { 1440 dev_err(&dev->device, "No net device to remove\n"); 1441 return 0; 1442 } 1443 1444 1445 ndev_ctx = netdev_priv(net); 1446 net_device = ndev_ctx->nvdev; 1447 1448 /* Avoid racing with netvsc_change_mtu()/netvsc_set_channels() 1449 * removing the device. 1450 */ 1451 rtnl_lock(); 1452 ndev_ctx->start_remove = true; 1453 rtnl_unlock(); 1454 1455 cancel_delayed_work_sync(&ndev_ctx->dwork); 1456 cancel_work_sync(&ndev_ctx->work); 1457 1458 /* Stop outbound asap */ 1459 netif_tx_disable(net); 1460 1461 unregister_netdev(net); 1462 1463 /* 1464 * Call to the vsc driver to let it know that the device is being 1465 * removed 1466 */ 1467 rndis_filter_device_remove(dev); 1468 1469 hv_set_drvdata(dev, NULL); 1470 1471 netvsc_free_netdev(net); 1472 return 0; 1473 } 1474 1475 static const struct hv_vmbus_device_id id_table[] = { 1476 /* Network guid */ 1477 { HV_NIC_GUID, }, 1478 { }, 1479 }; 1480 1481 MODULE_DEVICE_TABLE(vmbus, id_table); 1482 1483 /* The one and only one */ 1484 static struct hv_driver netvsc_drv = { 1485 .name = KBUILD_MODNAME, 1486 .id_table = id_table, 1487 .probe = netvsc_probe, 1488 .remove = netvsc_remove, 1489 }; 1490 1491 1492 /* 1493 * On Hyper-V, every VF interface is matched with a corresponding 1494 * synthetic interface. The synthetic interface is presented first 1495 * to the guest. When the corresponding VF instance is registered, 1496 * we will take care of switching the data path. 1497 */ 1498 static int netvsc_netdev_event(struct notifier_block *this, 1499 unsigned long event, void *ptr) 1500 { 1501 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr); 1502 1503 switch (event) { 1504 case NETDEV_REGISTER: 1505 return netvsc_register_vf(event_dev); 1506 case NETDEV_UNREGISTER: 1507 return netvsc_unregister_vf(event_dev); 1508 case NETDEV_UP: 1509 return netvsc_vf_up(event_dev); 1510 case NETDEV_DOWN: 1511 return netvsc_vf_down(event_dev); 1512 default: 1513 return NOTIFY_DONE; 1514 } 1515 } 1516 1517 static struct notifier_block netvsc_netdev_notifier = { 1518 .notifier_call = netvsc_netdev_event, 1519 }; 1520 1521 static void __exit netvsc_drv_exit(void) 1522 { 1523 unregister_netdevice_notifier(&netvsc_netdev_notifier); 1524 vmbus_driver_unregister(&netvsc_drv); 1525 } 1526 1527 static int __init netvsc_drv_init(void) 1528 { 1529 int ret; 1530 1531 if (ring_size < RING_SIZE_MIN) { 1532 ring_size = RING_SIZE_MIN; 1533 pr_info("Increased ring_size to %d (min allowed)\n", 1534 ring_size); 1535 } 1536 ret = vmbus_driver_register(&netvsc_drv); 1537 1538 if (ret) 1539 return ret; 1540 1541 register_netdevice_notifier(&netvsc_netdev_notifier); 1542 return 0; 1543 } 1544 1545 MODULE_LICENSE("GPL"); 1546 MODULE_DESCRIPTION("Microsoft Hyper-V network driver"); 1547 1548 module_init(netvsc_drv_init); 1549 module_exit(netvsc_drv_exit); 1550