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 #include <linux/kernel.h> 21 #include <linux/sched.h> 22 #include <linux/wait.h> 23 #include <linux/highmem.h> 24 #include <linux/slab.h> 25 #include <linux/io.h> 26 #include <linux/if_ether.h> 27 #include <linux/netdevice.h> 28 #include <linux/if_vlan.h> 29 #include <linux/nls.h> 30 #include <linux/vmalloc.h> 31 32 #include "hyperv_net.h" 33 34 35 #define RNDIS_EXT_LEN PAGE_SIZE 36 struct rndis_request { 37 struct list_head list_ent; 38 struct completion wait_event; 39 40 struct rndis_message response_msg; 41 /* 42 * The buffer for extended info after the RNDIS response message. It's 43 * referenced based on the data offset in the RNDIS message. Its size 44 * is enough for current needs, and should be sufficient for the near 45 * future. 46 */ 47 u8 response_ext[RNDIS_EXT_LEN]; 48 49 /* Simplify allocation by having a netvsc packet inline */ 50 struct hv_netvsc_packet pkt; 51 52 struct rndis_message request_msg; 53 /* 54 * The buffer for the extended info after the RNDIS request message. 55 * It is referenced and sized in a similar way as response_ext. 56 */ 57 u8 request_ext[RNDIS_EXT_LEN]; 58 }; 59 60 static struct rndis_device *get_rndis_device(void) 61 { 62 struct rndis_device *device; 63 64 device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL); 65 if (!device) 66 return NULL; 67 68 spin_lock_init(&device->request_lock); 69 70 INIT_LIST_HEAD(&device->req_list); 71 72 device->state = RNDIS_DEV_UNINITIALIZED; 73 74 return device; 75 } 76 77 static struct rndis_request *get_rndis_request(struct rndis_device *dev, 78 u32 msg_type, 79 u32 msg_len) 80 { 81 struct rndis_request *request; 82 struct rndis_message *rndis_msg; 83 struct rndis_set_request *set; 84 unsigned long flags; 85 86 request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL); 87 if (!request) 88 return NULL; 89 90 init_completion(&request->wait_event); 91 92 rndis_msg = &request->request_msg; 93 rndis_msg->ndis_msg_type = msg_type; 94 rndis_msg->msg_len = msg_len; 95 96 request->pkt.q_idx = 0; 97 98 /* 99 * Set the request id. This field is always after the rndis header for 100 * request/response packet types so we just used the SetRequest as a 101 * template 102 */ 103 set = &rndis_msg->msg.set_req; 104 set->req_id = atomic_inc_return(&dev->new_req_id); 105 106 /* Add to the request list */ 107 spin_lock_irqsave(&dev->request_lock, flags); 108 list_add_tail(&request->list_ent, &dev->req_list); 109 spin_unlock_irqrestore(&dev->request_lock, flags); 110 111 return request; 112 } 113 114 static void put_rndis_request(struct rndis_device *dev, 115 struct rndis_request *req) 116 { 117 unsigned long flags; 118 119 spin_lock_irqsave(&dev->request_lock, flags); 120 list_del(&req->list_ent); 121 spin_unlock_irqrestore(&dev->request_lock, flags); 122 123 kfree(req); 124 } 125 126 static void dump_rndis_message(struct hv_device *hv_dev, 127 struct rndis_message *rndis_msg) 128 { 129 struct net_device *netdev = hv_get_drvdata(hv_dev); 130 131 switch (rndis_msg->ndis_msg_type) { 132 case RNDIS_MSG_PACKET: 133 netdev_dbg(netdev, "RNDIS_MSG_PACKET (len %u, " 134 "data offset %u data len %u, # oob %u, " 135 "oob offset %u, oob len %u, pkt offset %u, " 136 "pkt len %u\n", 137 rndis_msg->msg_len, 138 rndis_msg->msg.pkt.data_offset, 139 rndis_msg->msg.pkt.data_len, 140 rndis_msg->msg.pkt.num_oob_data_elements, 141 rndis_msg->msg.pkt.oob_data_offset, 142 rndis_msg->msg.pkt.oob_data_len, 143 rndis_msg->msg.pkt.per_pkt_info_offset, 144 rndis_msg->msg.pkt.per_pkt_info_len); 145 break; 146 147 case RNDIS_MSG_INIT_C: 148 netdev_dbg(netdev, "RNDIS_MSG_INIT_C " 149 "(len %u, id 0x%x, status 0x%x, major %d, minor %d, " 150 "device flags %d, max xfer size 0x%x, max pkts %u, " 151 "pkt aligned %u)\n", 152 rndis_msg->msg_len, 153 rndis_msg->msg.init_complete.req_id, 154 rndis_msg->msg.init_complete.status, 155 rndis_msg->msg.init_complete.major_ver, 156 rndis_msg->msg.init_complete.minor_ver, 157 rndis_msg->msg.init_complete.dev_flags, 158 rndis_msg->msg.init_complete.max_xfer_size, 159 rndis_msg->msg.init_complete. 160 max_pkt_per_msg, 161 rndis_msg->msg.init_complete. 162 pkt_alignment_factor); 163 break; 164 165 case RNDIS_MSG_QUERY_C: 166 netdev_dbg(netdev, "RNDIS_MSG_QUERY_C " 167 "(len %u, id 0x%x, status 0x%x, buf len %u, " 168 "buf offset %u)\n", 169 rndis_msg->msg_len, 170 rndis_msg->msg.query_complete.req_id, 171 rndis_msg->msg.query_complete.status, 172 rndis_msg->msg.query_complete. 173 info_buflen, 174 rndis_msg->msg.query_complete. 175 info_buf_offset); 176 break; 177 178 case RNDIS_MSG_SET_C: 179 netdev_dbg(netdev, 180 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n", 181 rndis_msg->msg_len, 182 rndis_msg->msg.set_complete.req_id, 183 rndis_msg->msg.set_complete.status); 184 break; 185 186 case RNDIS_MSG_INDICATE: 187 netdev_dbg(netdev, "RNDIS_MSG_INDICATE " 188 "(len %u, status 0x%x, buf len %u, buf offset %u)\n", 189 rndis_msg->msg_len, 190 rndis_msg->msg.indicate_status.status, 191 rndis_msg->msg.indicate_status.status_buflen, 192 rndis_msg->msg.indicate_status.status_buf_offset); 193 break; 194 195 default: 196 netdev_dbg(netdev, "0x%x (len %u)\n", 197 rndis_msg->ndis_msg_type, 198 rndis_msg->msg_len); 199 break; 200 } 201 } 202 203 static int rndis_filter_send_request(struct rndis_device *dev, 204 struct rndis_request *req) 205 { 206 int ret; 207 struct hv_netvsc_packet *packet; 208 struct hv_page_buffer page_buf[2]; 209 struct hv_page_buffer *pb = page_buf; 210 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev); 211 212 /* Setup the packet to send it */ 213 packet = &req->pkt; 214 215 packet->total_data_buflen = req->request_msg.msg_len; 216 packet->page_buf_cnt = 1; 217 218 pb[0].pfn = virt_to_phys(&req->request_msg) >> 219 PAGE_SHIFT; 220 pb[0].len = req->request_msg.msg_len; 221 pb[0].offset = 222 (unsigned long)&req->request_msg & (PAGE_SIZE - 1); 223 224 /* Add one page_buf when request_msg crossing page boundary */ 225 if (pb[0].offset + pb[0].len > PAGE_SIZE) { 226 packet->page_buf_cnt++; 227 pb[0].len = PAGE_SIZE - 228 pb[0].offset; 229 pb[1].pfn = virt_to_phys((void *)&req->request_msg 230 + pb[0].len) >> PAGE_SHIFT; 231 pb[1].offset = 0; 232 pb[1].len = req->request_msg.msg_len - 233 pb[0].len; 234 } 235 236 ret = netvsc_send(net_device_ctx->device_ctx, packet, NULL, &pb, NULL); 237 return ret; 238 } 239 240 static void rndis_set_link_state(struct rndis_device *rdev, 241 struct rndis_request *request) 242 { 243 u32 link_status; 244 struct rndis_query_complete *query_complete; 245 246 query_complete = &request->response_msg.msg.query_complete; 247 248 if (query_complete->status == RNDIS_STATUS_SUCCESS && 249 query_complete->info_buflen == sizeof(u32)) { 250 memcpy(&link_status, (void *)((unsigned long)query_complete + 251 query_complete->info_buf_offset), sizeof(u32)); 252 rdev->link_state = link_status != 0; 253 } 254 } 255 256 static void rndis_filter_receive_response(struct rndis_device *dev, 257 struct rndis_message *resp) 258 { 259 struct rndis_request *request = NULL; 260 bool found = false; 261 unsigned long flags; 262 struct net_device *ndev = dev->ndev; 263 264 spin_lock_irqsave(&dev->request_lock, flags); 265 list_for_each_entry(request, &dev->req_list, list_ent) { 266 /* 267 * All request/response message contains RequestId as the 1st 268 * field 269 */ 270 if (request->request_msg.msg.init_req.req_id 271 == resp->msg.init_complete.req_id) { 272 found = true; 273 break; 274 } 275 } 276 spin_unlock_irqrestore(&dev->request_lock, flags); 277 278 if (found) { 279 if (resp->msg_len <= 280 sizeof(struct rndis_message) + RNDIS_EXT_LEN) { 281 memcpy(&request->response_msg, resp, 282 resp->msg_len); 283 if (request->request_msg.ndis_msg_type == 284 RNDIS_MSG_QUERY && request->request_msg.msg. 285 query_req.oid == RNDIS_OID_GEN_MEDIA_CONNECT_STATUS) 286 rndis_set_link_state(dev, request); 287 } else { 288 netdev_err(ndev, 289 "rndis response buffer overflow " 290 "detected (size %u max %zu)\n", 291 resp->msg_len, 292 sizeof(struct rndis_message)); 293 294 if (resp->ndis_msg_type == 295 RNDIS_MSG_RESET_C) { 296 /* does not have a request id field */ 297 request->response_msg.msg.reset_complete. 298 status = RNDIS_STATUS_BUFFER_OVERFLOW; 299 } else { 300 request->response_msg.msg. 301 init_complete.status = 302 RNDIS_STATUS_BUFFER_OVERFLOW; 303 } 304 } 305 306 complete(&request->wait_event); 307 } else { 308 netdev_err(ndev, 309 "no rndis request found for this response " 310 "(id 0x%x res type 0x%x)\n", 311 resp->msg.init_complete.req_id, 312 resp->ndis_msg_type); 313 } 314 } 315 316 /* 317 * Get the Per-Packet-Info with the specified type 318 * return NULL if not found. 319 */ 320 static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type) 321 { 322 struct rndis_per_packet_info *ppi; 323 int len; 324 325 if (rpkt->per_pkt_info_offset == 0) 326 return NULL; 327 328 ppi = (struct rndis_per_packet_info *)((ulong)rpkt + 329 rpkt->per_pkt_info_offset); 330 len = rpkt->per_pkt_info_len; 331 332 while (len > 0) { 333 if (ppi->type == type) 334 return (void *)((ulong)ppi + ppi->ppi_offset); 335 len -= ppi->size; 336 ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size); 337 } 338 339 return NULL; 340 } 341 342 static int rndis_filter_receive_data(struct rndis_device *dev, 343 struct rndis_message *msg, 344 struct hv_netvsc_packet *pkt, 345 void **data, 346 struct vmbus_channel *channel) 347 { 348 struct rndis_packet *rndis_pkt; 349 u32 data_offset; 350 struct ndis_pkt_8021q_info *vlan; 351 struct ndis_tcp_ip_checksum_info *csum_info; 352 u16 vlan_tci = 0; 353 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev); 354 355 rndis_pkt = &msg->msg.pkt; 356 357 /* Remove the rndis header and pass it back up the stack */ 358 data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset; 359 360 pkt->total_data_buflen -= data_offset; 361 362 /* 363 * Make sure we got a valid RNDIS message, now total_data_buflen 364 * should be the data packet size plus the trailer padding size 365 */ 366 if (pkt->total_data_buflen < rndis_pkt->data_len) { 367 netdev_err(dev->ndev, "rndis message buffer " 368 "overflow detected (got %u, min %u)" 369 "...dropping this message!\n", 370 pkt->total_data_buflen, rndis_pkt->data_len); 371 return NVSP_STAT_FAIL; 372 } 373 374 /* 375 * Remove the rndis trailer padding from rndis packet message 376 * rndis_pkt->data_len tell us the real data length, we only copy 377 * the data packet to the stack, without the rndis trailer padding 378 */ 379 pkt->total_data_buflen = rndis_pkt->data_len; 380 *data = (void *)((unsigned long)(*data) + data_offset); 381 382 vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO); 383 if (vlan) { 384 vlan_tci = VLAN_TAG_PRESENT | vlan->vlanid | 385 (vlan->pri << VLAN_PRIO_SHIFT); 386 } 387 388 csum_info = rndis_get_ppi(rndis_pkt, TCPIP_CHKSUM_PKTINFO); 389 return netvsc_recv_callback(net_device_ctx->device_ctx, pkt, data, 390 csum_info, channel, vlan_tci); 391 } 392 393 int rndis_filter_receive(struct hv_device *dev, 394 struct hv_netvsc_packet *pkt, 395 void **data, 396 struct vmbus_channel *channel) 397 { 398 struct net_device *ndev = hv_get_drvdata(dev); 399 struct net_device_context *net_device_ctx = netdev_priv(ndev); 400 struct netvsc_device *net_dev = net_device_ctx->nvdev; 401 struct rndis_device *rndis_dev; 402 struct rndis_message *rndis_msg; 403 int ret = 0; 404 405 if (!net_dev) { 406 ret = NVSP_STAT_FAIL; 407 goto exit; 408 } 409 410 /* Make sure the rndis device state is initialized */ 411 if (!net_dev->extension) { 412 netdev_err(ndev, "got rndis message but no rndis device - " 413 "dropping this message!\n"); 414 ret = NVSP_STAT_FAIL; 415 goto exit; 416 } 417 418 rndis_dev = (struct rndis_device *)net_dev->extension; 419 if (rndis_dev->state == RNDIS_DEV_UNINITIALIZED) { 420 netdev_err(ndev, "got rndis message but rndis device " 421 "uninitialized...dropping this message!\n"); 422 ret = NVSP_STAT_FAIL; 423 goto exit; 424 } 425 426 rndis_msg = *data; 427 428 if (netif_msg_rx_err(net_device_ctx)) 429 dump_rndis_message(dev, rndis_msg); 430 431 switch (rndis_msg->ndis_msg_type) { 432 case RNDIS_MSG_PACKET: 433 /* data msg */ 434 ret = rndis_filter_receive_data(rndis_dev, rndis_msg, pkt, 435 data, channel); 436 break; 437 438 case RNDIS_MSG_INIT_C: 439 case RNDIS_MSG_QUERY_C: 440 case RNDIS_MSG_SET_C: 441 /* completion msgs */ 442 rndis_filter_receive_response(rndis_dev, rndis_msg); 443 break; 444 445 case RNDIS_MSG_INDICATE: 446 /* notification msgs */ 447 netvsc_linkstatus_callback(dev, rndis_msg); 448 break; 449 default: 450 netdev_err(ndev, 451 "unhandled rndis message (type %u len %u)\n", 452 rndis_msg->ndis_msg_type, 453 rndis_msg->msg_len); 454 break; 455 } 456 457 exit: 458 return ret; 459 } 460 461 static int rndis_filter_query_device(struct rndis_device *dev, u32 oid, 462 void *result, u32 *result_size) 463 { 464 struct rndis_request *request; 465 u32 inresult_size = *result_size; 466 struct rndis_query_request *query; 467 struct rndis_query_complete *query_complete; 468 int ret = 0; 469 unsigned long t; 470 471 if (!result) 472 return -EINVAL; 473 474 *result_size = 0; 475 request = get_rndis_request(dev, RNDIS_MSG_QUERY, 476 RNDIS_MESSAGE_SIZE(struct rndis_query_request)); 477 if (!request) { 478 ret = -ENOMEM; 479 goto cleanup; 480 } 481 482 /* Setup the rndis query */ 483 query = &request->request_msg.msg.query_req; 484 query->oid = oid; 485 query->info_buf_offset = sizeof(struct rndis_query_request); 486 query->info_buflen = 0; 487 query->dev_vc_handle = 0; 488 489 if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) { 490 struct ndis_recv_scale_cap *cap; 491 492 request->request_msg.msg_len += 493 sizeof(struct ndis_recv_scale_cap); 494 query->info_buflen = sizeof(struct ndis_recv_scale_cap); 495 cap = (struct ndis_recv_scale_cap *)((unsigned long)query + 496 query->info_buf_offset); 497 cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES; 498 cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2; 499 cap->hdr.size = sizeof(struct ndis_recv_scale_cap); 500 } 501 502 ret = rndis_filter_send_request(dev, request); 503 if (ret != 0) 504 goto cleanup; 505 506 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 507 if (t == 0) { 508 ret = -ETIMEDOUT; 509 goto cleanup; 510 } 511 512 /* Copy the response back */ 513 query_complete = &request->response_msg.msg.query_complete; 514 515 if (query_complete->info_buflen > inresult_size) { 516 ret = -1; 517 goto cleanup; 518 } 519 520 memcpy(result, 521 (void *)((unsigned long)query_complete + 522 query_complete->info_buf_offset), 523 query_complete->info_buflen); 524 525 *result_size = query_complete->info_buflen; 526 527 cleanup: 528 if (request) 529 put_rndis_request(dev, request); 530 531 return ret; 532 } 533 534 static int rndis_filter_query_device_mac(struct rndis_device *dev) 535 { 536 u32 size = ETH_ALEN; 537 538 return rndis_filter_query_device(dev, 539 RNDIS_OID_802_3_PERMANENT_ADDRESS, 540 dev->hw_mac_adr, &size); 541 } 542 543 #define NWADR_STR "NetworkAddress" 544 #define NWADR_STRLEN 14 545 546 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac) 547 { 548 struct net_device *ndev = hv_get_drvdata(hdev); 549 struct net_device_context *net_device_ctx = netdev_priv(ndev); 550 struct netvsc_device *nvdev = net_device_ctx->nvdev; 551 struct rndis_device *rdev = nvdev->extension; 552 struct rndis_request *request; 553 struct rndis_set_request *set; 554 struct rndis_config_parameter_info *cpi; 555 wchar_t *cfg_nwadr, *cfg_mac; 556 struct rndis_set_complete *set_complete; 557 char macstr[2*ETH_ALEN+1]; 558 u32 extlen = sizeof(struct rndis_config_parameter_info) + 559 2*NWADR_STRLEN + 4*ETH_ALEN; 560 int ret; 561 unsigned long t; 562 563 request = get_rndis_request(rdev, RNDIS_MSG_SET, 564 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); 565 if (!request) 566 return -ENOMEM; 567 568 set = &request->request_msg.msg.set_req; 569 set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER; 570 set->info_buflen = extlen; 571 set->info_buf_offset = sizeof(struct rndis_set_request); 572 set->dev_vc_handle = 0; 573 574 cpi = (struct rndis_config_parameter_info *)((ulong)set + 575 set->info_buf_offset); 576 cpi->parameter_name_offset = 577 sizeof(struct rndis_config_parameter_info); 578 /* Multiply by 2 because host needs 2 bytes (utf16) for each char */ 579 cpi->parameter_name_length = 2*NWADR_STRLEN; 580 cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING; 581 cpi->parameter_value_offset = 582 cpi->parameter_name_offset + cpi->parameter_name_length; 583 /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */ 584 cpi->parameter_value_length = 4*ETH_ALEN; 585 586 cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset); 587 cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset); 588 ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN, 589 cfg_nwadr, NWADR_STRLEN); 590 if (ret < 0) 591 goto cleanup; 592 snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac); 593 ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN, 594 cfg_mac, 2*ETH_ALEN); 595 if (ret < 0) 596 goto cleanup; 597 598 ret = rndis_filter_send_request(rdev, request); 599 if (ret != 0) 600 goto cleanup; 601 602 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 603 if (t == 0) { 604 netdev_err(ndev, "timeout before we got a set response...\n"); 605 /* 606 * can't put_rndis_request, since we may still receive a 607 * send-completion. 608 */ 609 return -EBUSY; 610 } else { 611 set_complete = &request->response_msg.msg.set_complete; 612 if (set_complete->status != RNDIS_STATUS_SUCCESS) { 613 netdev_err(ndev, "Fail to set MAC on host side:0x%x\n", 614 set_complete->status); 615 ret = -EINVAL; 616 } 617 } 618 619 cleanup: 620 put_rndis_request(rdev, request); 621 return ret; 622 } 623 624 static int 625 rndis_filter_set_offload_params(struct hv_device *hdev, 626 struct ndis_offload_params *req_offloads) 627 { 628 struct net_device *ndev = hv_get_drvdata(hdev); 629 struct net_device_context *net_device_ctx = netdev_priv(ndev); 630 struct netvsc_device *nvdev = net_device_ctx->nvdev; 631 struct rndis_device *rdev = nvdev->extension; 632 struct rndis_request *request; 633 struct rndis_set_request *set; 634 struct ndis_offload_params *offload_params; 635 struct rndis_set_complete *set_complete; 636 u32 extlen = sizeof(struct ndis_offload_params); 637 int ret; 638 unsigned long t; 639 u32 vsp_version = nvdev->nvsp_version; 640 641 if (vsp_version <= NVSP_PROTOCOL_VERSION_4) { 642 extlen = VERSION_4_OFFLOAD_SIZE; 643 /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support 644 * UDP checksum offload. 645 */ 646 req_offloads->udp_ip_v4_csum = 0; 647 req_offloads->udp_ip_v6_csum = 0; 648 } 649 650 request = get_rndis_request(rdev, RNDIS_MSG_SET, 651 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); 652 if (!request) 653 return -ENOMEM; 654 655 set = &request->request_msg.msg.set_req; 656 set->oid = OID_TCP_OFFLOAD_PARAMETERS; 657 set->info_buflen = extlen; 658 set->info_buf_offset = sizeof(struct rndis_set_request); 659 set->dev_vc_handle = 0; 660 661 offload_params = (struct ndis_offload_params *)((ulong)set + 662 set->info_buf_offset); 663 *offload_params = *req_offloads; 664 offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT; 665 offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3; 666 offload_params->header.size = extlen; 667 668 ret = rndis_filter_send_request(rdev, request); 669 if (ret != 0) 670 goto cleanup; 671 672 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 673 if (t == 0) { 674 netdev_err(ndev, "timeout before we got aOFFLOAD set response...\n"); 675 /* can't put_rndis_request, since we may still receive a 676 * send-completion. 677 */ 678 return -EBUSY; 679 } else { 680 set_complete = &request->response_msg.msg.set_complete; 681 if (set_complete->status != RNDIS_STATUS_SUCCESS) { 682 netdev_err(ndev, "Fail to set offload on host side:0x%x\n", 683 set_complete->status); 684 ret = -EINVAL; 685 } 686 } 687 688 cleanup: 689 put_rndis_request(rdev, request); 690 return ret; 691 } 692 693 u8 netvsc_hash_key[HASH_KEYLEN] = { 694 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2, 695 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0, 696 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4, 697 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c, 698 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa 699 }; 700 701 static int rndis_filter_set_rss_param(struct rndis_device *rdev, int num_queue) 702 { 703 struct net_device *ndev = rdev->ndev; 704 struct rndis_request *request; 705 struct rndis_set_request *set; 706 struct rndis_set_complete *set_complete; 707 u32 extlen = sizeof(struct ndis_recv_scale_param) + 708 4*ITAB_NUM + HASH_KEYLEN; 709 struct ndis_recv_scale_param *rssp; 710 u32 *itab; 711 u8 *keyp; 712 int i, ret; 713 unsigned long t; 714 715 request = get_rndis_request( 716 rdev, RNDIS_MSG_SET, 717 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); 718 if (!request) 719 return -ENOMEM; 720 721 set = &request->request_msg.msg.set_req; 722 set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS; 723 set->info_buflen = extlen; 724 set->info_buf_offset = sizeof(struct rndis_set_request); 725 set->dev_vc_handle = 0; 726 727 rssp = (struct ndis_recv_scale_param *)(set + 1); 728 rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS; 729 rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2; 730 rssp->hdr.size = sizeof(struct ndis_recv_scale_param); 731 rssp->flag = 0; 732 rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 | 733 NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 | 734 NDIS_HASH_TCP_IPV6; 735 rssp->indirect_tabsize = 4*ITAB_NUM; 736 rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param); 737 rssp->hashkey_size = HASH_KEYLEN; 738 rssp->kashkey_offset = rssp->indirect_taboffset + 739 rssp->indirect_tabsize; 740 741 /* Set indirection table entries */ 742 itab = (u32 *)(rssp + 1); 743 for (i = 0; i < ITAB_NUM; i++) 744 itab[i] = i % num_queue; 745 746 /* Set hask key values */ 747 keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset); 748 for (i = 0; i < HASH_KEYLEN; i++) 749 keyp[i] = netvsc_hash_key[i]; 750 751 752 ret = rndis_filter_send_request(rdev, request); 753 if (ret != 0) 754 goto cleanup; 755 756 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 757 if (t == 0) { 758 netdev_err(ndev, "timeout before we got a set response...\n"); 759 /* can't put_rndis_request, since we may still receive a 760 * send-completion. 761 */ 762 return -ETIMEDOUT; 763 } else { 764 set_complete = &request->response_msg.msg.set_complete; 765 if (set_complete->status != RNDIS_STATUS_SUCCESS) { 766 netdev_err(ndev, "Fail to set RSS parameters:0x%x\n", 767 set_complete->status); 768 ret = -EINVAL; 769 } 770 } 771 772 cleanup: 773 put_rndis_request(rdev, request); 774 return ret; 775 } 776 777 778 static int rndis_filter_query_device_link_status(struct rndis_device *dev) 779 { 780 u32 size = sizeof(u32); 781 u32 link_status; 782 int ret; 783 784 ret = rndis_filter_query_device(dev, 785 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS, 786 &link_status, &size); 787 788 return ret; 789 } 790 791 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter) 792 { 793 struct rndis_request *request; 794 struct rndis_set_request *set; 795 struct rndis_set_complete *set_complete; 796 u32 status; 797 int ret; 798 unsigned long t; 799 struct net_device *ndev = dev->ndev; 800 801 request = get_rndis_request(dev, RNDIS_MSG_SET, 802 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + 803 sizeof(u32)); 804 if (!request) { 805 ret = -ENOMEM; 806 goto cleanup; 807 } 808 809 /* Setup the rndis set */ 810 set = &request->request_msg.msg.set_req; 811 set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER; 812 set->info_buflen = sizeof(u32); 813 set->info_buf_offset = sizeof(struct rndis_set_request); 814 815 memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request), 816 &new_filter, sizeof(u32)); 817 818 ret = rndis_filter_send_request(dev, request); 819 if (ret != 0) 820 goto cleanup; 821 822 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 823 824 if (t == 0) { 825 netdev_err(ndev, 826 "timeout before we got a set response...\n"); 827 ret = -ETIMEDOUT; 828 /* 829 * We can't deallocate the request since we may still receive a 830 * send completion for it. 831 */ 832 goto exit; 833 } else { 834 set_complete = &request->response_msg.msg.set_complete; 835 status = set_complete->status; 836 } 837 838 cleanup: 839 if (request) 840 put_rndis_request(dev, request); 841 exit: 842 return ret; 843 } 844 845 846 static int rndis_filter_init_device(struct rndis_device *dev) 847 { 848 struct rndis_request *request; 849 struct rndis_initialize_request *init; 850 struct rndis_initialize_complete *init_complete; 851 u32 status; 852 int ret; 853 unsigned long t; 854 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev); 855 struct netvsc_device *nvdev = net_device_ctx->nvdev; 856 857 request = get_rndis_request(dev, RNDIS_MSG_INIT, 858 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request)); 859 if (!request) { 860 ret = -ENOMEM; 861 goto cleanup; 862 } 863 864 /* Setup the rndis set */ 865 init = &request->request_msg.msg.init_req; 866 init->major_ver = RNDIS_MAJOR_VERSION; 867 init->minor_ver = RNDIS_MINOR_VERSION; 868 init->max_xfer_size = 0x4000; 869 870 dev->state = RNDIS_DEV_INITIALIZING; 871 872 ret = rndis_filter_send_request(dev, request); 873 if (ret != 0) { 874 dev->state = RNDIS_DEV_UNINITIALIZED; 875 goto cleanup; 876 } 877 878 t = wait_for_completion_timeout(&request->wait_event, 5*HZ); 879 880 if (t == 0) { 881 ret = -ETIMEDOUT; 882 goto cleanup; 883 } 884 885 init_complete = &request->response_msg.msg.init_complete; 886 status = init_complete->status; 887 if (status == RNDIS_STATUS_SUCCESS) { 888 dev->state = RNDIS_DEV_INITIALIZED; 889 nvdev->max_pkt = init_complete->max_pkt_per_msg; 890 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor; 891 ret = 0; 892 } else { 893 dev->state = RNDIS_DEV_UNINITIALIZED; 894 ret = -EINVAL; 895 } 896 897 cleanup: 898 if (request) 899 put_rndis_request(dev, request); 900 901 return ret; 902 } 903 904 static void rndis_filter_halt_device(struct rndis_device *dev) 905 { 906 struct rndis_request *request; 907 struct rndis_halt_request *halt; 908 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev); 909 struct netvsc_device *nvdev = net_device_ctx->nvdev; 910 struct hv_device *hdev = net_device_ctx->device_ctx; 911 ulong flags; 912 913 /* Attempt to do a rndis device halt */ 914 request = get_rndis_request(dev, RNDIS_MSG_HALT, 915 RNDIS_MESSAGE_SIZE(struct rndis_halt_request)); 916 if (!request) 917 goto cleanup; 918 919 /* Setup the rndis set */ 920 halt = &request->request_msg.msg.halt_req; 921 halt->req_id = atomic_inc_return(&dev->new_req_id); 922 923 /* Ignore return since this msg is optional. */ 924 rndis_filter_send_request(dev, request); 925 926 dev->state = RNDIS_DEV_UNINITIALIZED; 927 928 cleanup: 929 spin_lock_irqsave(&hdev->channel->inbound_lock, flags); 930 nvdev->destroy = true; 931 spin_unlock_irqrestore(&hdev->channel->inbound_lock, flags); 932 933 /* Wait for all send completions */ 934 wait_event(nvdev->wait_drain, 935 atomic_read(&nvdev->num_outstanding_sends) == 0); 936 937 if (request) 938 put_rndis_request(dev, request); 939 return; 940 } 941 942 static int rndis_filter_open_device(struct rndis_device *dev) 943 { 944 int ret; 945 946 if (dev->state != RNDIS_DEV_INITIALIZED) 947 return 0; 948 949 ret = rndis_filter_set_packet_filter(dev, 950 NDIS_PACKET_TYPE_BROADCAST | 951 NDIS_PACKET_TYPE_ALL_MULTICAST | 952 NDIS_PACKET_TYPE_DIRECTED); 953 if (ret == 0) 954 dev->state = RNDIS_DEV_DATAINITIALIZED; 955 956 return ret; 957 } 958 959 static int rndis_filter_close_device(struct rndis_device *dev) 960 { 961 int ret; 962 963 if (dev->state != RNDIS_DEV_DATAINITIALIZED) 964 return 0; 965 966 ret = rndis_filter_set_packet_filter(dev, 0); 967 if (ret == -ENODEV) 968 ret = 0; 969 970 if (ret == 0) 971 dev->state = RNDIS_DEV_INITIALIZED; 972 973 return ret; 974 } 975 976 static void netvsc_sc_open(struct vmbus_channel *new_sc) 977 { 978 struct net_device *ndev = 979 hv_get_drvdata(new_sc->primary_channel->device_obj); 980 struct net_device_context *net_device_ctx = netdev_priv(ndev); 981 struct netvsc_device *nvscdev = net_device_ctx->nvdev; 982 u16 chn_index = new_sc->offermsg.offer.sub_channel_index; 983 int ret; 984 unsigned long flags; 985 986 if (chn_index >= nvscdev->num_chn) 987 return; 988 989 set_per_channel_state(new_sc, nvscdev->sub_cb_buf + (chn_index - 1) * 990 NETVSC_PACKET_SIZE); 991 992 ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE, 993 nvscdev->ring_size * PAGE_SIZE, NULL, 0, 994 netvsc_channel_cb, new_sc); 995 996 if (ret == 0) 997 nvscdev->chn_table[chn_index] = new_sc; 998 999 spin_lock_irqsave(&nvscdev->sc_lock, flags); 1000 nvscdev->num_sc_offered--; 1001 spin_unlock_irqrestore(&nvscdev->sc_lock, flags); 1002 if (nvscdev->num_sc_offered == 0) 1003 complete(&nvscdev->channel_init_wait); 1004 } 1005 1006 int rndis_filter_device_add(struct hv_device *dev, 1007 void *additional_info) 1008 { 1009 int ret; 1010 struct net_device *net = hv_get_drvdata(dev); 1011 struct net_device_context *net_device_ctx = netdev_priv(net); 1012 struct netvsc_device *net_device; 1013 struct rndis_device *rndis_device; 1014 struct netvsc_device_info *device_info = additional_info; 1015 struct ndis_offload_params offloads; 1016 struct nvsp_message *init_packet; 1017 unsigned long t; 1018 struct ndis_recv_scale_cap rsscap; 1019 u32 rsscap_size = sizeof(struct ndis_recv_scale_cap); 1020 u32 mtu, size; 1021 u32 num_rss_qs; 1022 u32 sc_delta; 1023 const struct cpumask *node_cpu_mask; 1024 u32 num_possible_rss_qs; 1025 unsigned long flags; 1026 1027 rndis_device = get_rndis_device(); 1028 if (!rndis_device) 1029 return -ENODEV; 1030 1031 /* 1032 * Let the inner driver handle this first to create the netvsc channel 1033 * NOTE! Once the channel is created, we may get a receive callback 1034 * (RndisFilterOnReceive()) before this call is completed 1035 */ 1036 ret = netvsc_device_add(dev, additional_info); 1037 if (ret != 0) { 1038 kfree(rndis_device); 1039 return ret; 1040 } 1041 1042 /* Initialize the rndis device */ 1043 net_device = net_device_ctx->nvdev; 1044 net_device->max_chn = 1; 1045 net_device->num_chn = 1; 1046 1047 spin_lock_init(&net_device->sc_lock); 1048 1049 net_device->extension = rndis_device; 1050 rndis_device->ndev = net; 1051 1052 /* Send the rndis initialization message */ 1053 ret = rndis_filter_init_device(rndis_device); 1054 if (ret != 0) { 1055 rndis_filter_device_remove(dev); 1056 return ret; 1057 } 1058 1059 /* Get the MTU from the host */ 1060 size = sizeof(u32); 1061 ret = rndis_filter_query_device(rndis_device, 1062 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE, 1063 &mtu, &size); 1064 if (ret == 0 && size == sizeof(u32) && mtu < net->mtu) 1065 net->mtu = mtu; 1066 1067 /* Get the mac address */ 1068 ret = rndis_filter_query_device_mac(rndis_device); 1069 if (ret != 0) { 1070 rndis_filter_device_remove(dev); 1071 return ret; 1072 } 1073 1074 memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN); 1075 1076 /* Turn on the offloads; the host supports all of the relevant 1077 * offloads. 1078 */ 1079 memset(&offloads, 0, sizeof(struct ndis_offload_params)); 1080 /* A value of zero means "no change"; now turn on what we 1081 * want. 1082 */ 1083 offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; 1084 offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; 1085 offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; 1086 offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; 1087 offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; 1088 offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED; 1089 1090 1091 ret = rndis_filter_set_offload_params(dev, &offloads); 1092 if (ret) 1093 goto err_dev_remv; 1094 1095 rndis_filter_query_device_link_status(rndis_device); 1096 1097 device_info->link_state = rndis_device->link_state; 1098 1099 dev_info(&dev->device, "Device MAC %pM link state %s\n", 1100 rndis_device->hw_mac_adr, 1101 device_info->link_state ? "down" : "up"); 1102 1103 if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5) 1104 return 0; 1105 1106 /* vRSS setup */ 1107 memset(&rsscap, 0, rsscap_size); 1108 ret = rndis_filter_query_device(rndis_device, 1109 OID_GEN_RECEIVE_SCALE_CAPABILITIES, 1110 &rsscap, &rsscap_size); 1111 if (ret || rsscap.num_recv_que < 2) 1112 goto out; 1113 1114 net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que); 1115 1116 num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn); 1117 1118 /* 1119 * We will limit the VRSS channels to the number CPUs in the NUMA node 1120 * the primary channel is currently bound to. 1121 */ 1122 node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu)); 1123 num_possible_rss_qs = cpumask_weight(node_cpu_mask); 1124 1125 /* We will use the given number of channels if available. */ 1126 if (device_info->num_chn && device_info->num_chn < net_device->max_chn) 1127 net_device->num_chn = device_info->num_chn; 1128 else 1129 net_device->num_chn = min(num_possible_rss_qs, num_rss_qs); 1130 1131 num_rss_qs = net_device->num_chn - 1; 1132 net_device->num_sc_offered = num_rss_qs; 1133 1134 if (net_device->num_chn == 1) 1135 goto out; 1136 1137 net_device->sub_cb_buf = vzalloc((net_device->num_chn - 1) * 1138 NETVSC_PACKET_SIZE); 1139 if (!net_device->sub_cb_buf) { 1140 net_device->num_chn = 1; 1141 dev_info(&dev->device, "No memory for subchannels.\n"); 1142 goto out; 1143 } 1144 1145 vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open); 1146 1147 init_packet = &net_device->channel_init_pkt; 1148 memset(init_packet, 0, sizeof(struct nvsp_message)); 1149 init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL; 1150 init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE; 1151 init_packet->msg.v5_msg.subchn_req.num_subchannels = 1152 net_device->num_chn - 1; 1153 ret = vmbus_sendpacket(dev->channel, init_packet, 1154 sizeof(struct nvsp_message), 1155 (unsigned long)init_packet, 1156 VM_PKT_DATA_INBAND, 1157 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); 1158 if (ret) 1159 goto out; 1160 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ); 1161 if (t == 0) { 1162 ret = -ETIMEDOUT; 1163 goto out; 1164 } 1165 if (init_packet->msg.v5_msg.subchn_comp.status != 1166 NVSP_STAT_SUCCESS) { 1167 ret = -ENODEV; 1168 goto out; 1169 } 1170 net_device->num_chn = 1 + 1171 init_packet->msg.v5_msg.subchn_comp.num_subchannels; 1172 1173 ret = rndis_filter_set_rss_param(rndis_device, net_device->num_chn); 1174 1175 /* 1176 * Set the number of sub-channels to be received. 1177 */ 1178 spin_lock_irqsave(&net_device->sc_lock, flags); 1179 sc_delta = num_rss_qs - (net_device->num_chn - 1); 1180 net_device->num_sc_offered -= sc_delta; 1181 spin_unlock_irqrestore(&net_device->sc_lock, flags); 1182 1183 out: 1184 if (ret) { 1185 net_device->max_chn = 1; 1186 net_device->num_chn = 1; 1187 net_device->num_sc_offered = 0; 1188 } 1189 1190 return 0; /* return 0 because primary channel can be used alone */ 1191 1192 err_dev_remv: 1193 rndis_filter_device_remove(dev); 1194 return ret; 1195 } 1196 1197 void rndis_filter_device_remove(struct hv_device *dev) 1198 { 1199 struct net_device *ndev = hv_get_drvdata(dev); 1200 struct net_device_context *net_device_ctx = netdev_priv(ndev); 1201 struct netvsc_device *net_dev = net_device_ctx->nvdev; 1202 struct rndis_device *rndis_dev = net_dev->extension; 1203 unsigned long t; 1204 1205 /* If not all subchannel offers are complete, wait for them until 1206 * completion to avoid race. 1207 */ 1208 while (net_dev->num_sc_offered > 0) { 1209 t = wait_for_completion_timeout(&net_dev->channel_init_wait, 1210 10 * HZ); 1211 if (t == 0) 1212 WARN(1, "Netvsc: Waiting for sub-channel processing"); 1213 } 1214 1215 /* Halt and release the rndis device */ 1216 rndis_filter_halt_device(rndis_dev); 1217 1218 kfree(rndis_dev); 1219 net_dev->extension = NULL; 1220 1221 netvsc_device_remove(dev); 1222 } 1223 1224 1225 int rndis_filter_open(struct hv_device *dev) 1226 { 1227 struct net_device *ndev = hv_get_drvdata(dev); 1228 struct net_device_context *net_device_ctx = netdev_priv(ndev); 1229 struct netvsc_device *net_device = net_device_ctx->nvdev; 1230 1231 if (!net_device) 1232 return -EINVAL; 1233 1234 if (atomic_inc_return(&net_device->open_cnt) != 1) 1235 return 0; 1236 1237 return rndis_filter_open_device(net_device->extension); 1238 } 1239 1240 int rndis_filter_close(struct hv_device *dev) 1241 { 1242 struct net_device *ndev = hv_get_drvdata(dev); 1243 struct net_device_context *net_device_ctx = netdev_priv(ndev); 1244 struct netvsc_device *nvdev = net_device_ctx->nvdev; 1245 1246 if (!nvdev) 1247 return -EINVAL; 1248 1249 if (atomic_dec_return(&nvdev->open_cnt) != 0) 1250 return 0; 1251 1252 return rndis_filter_close_device(nvdev->extension); 1253 } 1254