1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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#include <linux/rtnetlink.h>
32
33#include "hyperv_net.h"
34
35static void rndis_set_multicast(struct work_struct *w);
36
37#define RNDIS_EXT_LEN PAGE_SIZE
38struct rndis_request {
39 struct list_head list_ent;
40 struct completion wait_event;
41
42 struct rndis_message response_msg;
43
44
45
46
47
48
49 u8 response_ext[RNDIS_EXT_LEN];
50
51
52 struct hv_netvsc_packet pkt;
53
54 struct rndis_message request_msg;
55
56
57
58
59 u8 request_ext[RNDIS_EXT_LEN];
60};
61
62static const u8 netvsc_hash_key[NETVSC_HASH_KEYLEN] = {
63 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
64 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
65 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
66 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
67 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
68};
69
70static struct rndis_device *get_rndis_device(void)
71{
72 struct rndis_device *device;
73
74 device = kzalloc(sizeof(struct rndis_device), GFP_KERNEL);
75 if (!device)
76 return NULL;
77
78 spin_lock_init(&device->request_lock);
79
80 INIT_LIST_HEAD(&device->req_list);
81 INIT_WORK(&device->mcast_work, rndis_set_multicast);
82
83 device->state = RNDIS_DEV_UNINITIALIZED;
84
85 return device;
86}
87
88static struct rndis_request *get_rndis_request(struct rndis_device *dev,
89 u32 msg_type,
90 u32 msg_len)
91{
92 struct rndis_request *request;
93 struct rndis_message *rndis_msg;
94 struct rndis_set_request *set;
95 unsigned long flags;
96
97 request = kzalloc(sizeof(struct rndis_request), GFP_KERNEL);
98 if (!request)
99 return NULL;
100
101 init_completion(&request->wait_event);
102
103 rndis_msg = &request->request_msg;
104 rndis_msg->ndis_msg_type = msg_type;
105 rndis_msg->msg_len = msg_len;
106
107 request->pkt.q_idx = 0;
108
109
110
111
112
113
114 set = &rndis_msg->msg.set_req;
115 set->req_id = atomic_inc_return(&dev->new_req_id);
116
117
118 spin_lock_irqsave(&dev->request_lock, flags);
119 list_add_tail(&request->list_ent, &dev->req_list);
120 spin_unlock_irqrestore(&dev->request_lock, flags);
121
122 return request;
123}
124
125static void put_rndis_request(struct rndis_device *dev,
126 struct rndis_request *req)
127{
128 unsigned long flags;
129
130 spin_lock_irqsave(&dev->request_lock, flags);
131 list_del(&req->list_ent);
132 spin_unlock_irqrestore(&dev->request_lock, flags);
133
134 kfree(req);
135}
136
137static void dump_rndis_message(struct hv_device *hv_dev,
138 const struct rndis_message *rndis_msg)
139{
140 struct net_device *netdev = hv_get_drvdata(hv_dev);
141
142 switch (rndis_msg->ndis_msg_type) {
143 case RNDIS_MSG_PACKET:
144 netdev_dbg(netdev, "RNDIS_MSG_PACKET (len %u, "
145 "data offset %u data len %u, # oob %u, "
146 "oob offset %u, oob len %u, pkt offset %u, "
147 "pkt len %u\n",
148 rndis_msg->msg_len,
149 rndis_msg->msg.pkt.data_offset,
150 rndis_msg->msg.pkt.data_len,
151 rndis_msg->msg.pkt.num_oob_data_elements,
152 rndis_msg->msg.pkt.oob_data_offset,
153 rndis_msg->msg.pkt.oob_data_len,
154 rndis_msg->msg.pkt.per_pkt_info_offset,
155 rndis_msg->msg.pkt.per_pkt_info_len);
156 break;
157
158 case RNDIS_MSG_INIT_C:
159 netdev_dbg(netdev, "RNDIS_MSG_INIT_C "
160 "(len %u, id 0x%x, status 0x%x, major %d, minor %d, "
161 "device flags %d, max xfer size 0x%x, max pkts %u, "
162 "pkt aligned %u)\n",
163 rndis_msg->msg_len,
164 rndis_msg->msg.init_complete.req_id,
165 rndis_msg->msg.init_complete.status,
166 rndis_msg->msg.init_complete.major_ver,
167 rndis_msg->msg.init_complete.minor_ver,
168 rndis_msg->msg.init_complete.dev_flags,
169 rndis_msg->msg.init_complete.max_xfer_size,
170 rndis_msg->msg.init_complete.
171 max_pkt_per_msg,
172 rndis_msg->msg.init_complete.
173 pkt_alignment_factor);
174 break;
175
176 case RNDIS_MSG_QUERY_C:
177 netdev_dbg(netdev, "RNDIS_MSG_QUERY_C "
178 "(len %u, id 0x%x, status 0x%x, buf len %u, "
179 "buf offset %u)\n",
180 rndis_msg->msg_len,
181 rndis_msg->msg.query_complete.req_id,
182 rndis_msg->msg.query_complete.status,
183 rndis_msg->msg.query_complete.
184 info_buflen,
185 rndis_msg->msg.query_complete.
186 info_buf_offset);
187 break;
188
189 case RNDIS_MSG_SET_C:
190 netdev_dbg(netdev,
191 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
192 rndis_msg->msg_len,
193 rndis_msg->msg.set_complete.req_id,
194 rndis_msg->msg.set_complete.status);
195 break;
196
197 case RNDIS_MSG_INDICATE:
198 netdev_dbg(netdev, "RNDIS_MSG_INDICATE "
199 "(len %u, status 0x%x, buf len %u, buf offset %u)\n",
200 rndis_msg->msg_len,
201 rndis_msg->msg.indicate_status.status,
202 rndis_msg->msg.indicate_status.status_buflen,
203 rndis_msg->msg.indicate_status.status_buf_offset);
204 break;
205
206 default:
207 netdev_dbg(netdev, "0x%x (len %u)\n",
208 rndis_msg->ndis_msg_type,
209 rndis_msg->msg_len);
210 break;
211 }
212}
213
214static int rndis_filter_send_request(struct rndis_device *dev,
215 struct rndis_request *req)
216{
217 struct hv_netvsc_packet *packet;
218 struct hv_page_buffer page_buf[2];
219 struct hv_page_buffer *pb = page_buf;
220 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
221 int ret;
222
223
224 packet = &req->pkt;
225
226 packet->total_data_buflen = req->request_msg.msg_len;
227 packet->page_buf_cnt = 1;
228
229 pb[0].pfn = virt_to_phys(&req->request_msg) >>
230 PAGE_SHIFT;
231 pb[0].len = req->request_msg.msg_len;
232 pb[0].offset =
233 (unsigned long)&req->request_msg & (PAGE_SIZE - 1);
234
235
236 if (pb[0].offset + pb[0].len > PAGE_SIZE) {
237 packet->page_buf_cnt++;
238 pb[0].len = PAGE_SIZE -
239 pb[0].offset;
240 pb[1].pfn = virt_to_phys((void *)&req->request_msg
241 + pb[0].len) >> PAGE_SHIFT;
242 pb[1].offset = 0;
243 pb[1].len = req->request_msg.msg_len -
244 pb[0].len;
245 }
246
247 rcu_read_lock_bh();
248 ret = netvsc_send(net_device_ctx, packet, NULL, pb, NULL);
249 rcu_read_unlock_bh();
250
251 return ret;
252}
253
254static void rndis_set_link_state(struct rndis_device *rdev,
255 struct rndis_request *request)
256{
257 u32 link_status;
258 struct rndis_query_complete *query_complete;
259
260 query_complete = &request->response_msg.msg.query_complete;
261
262 if (query_complete->status == RNDIS_STATUS_SUCCESS &&
263 query_complete->info_buflen == sizeof(u32)) {
264 memcpy(&link_status, (void *)((unsigned long)query_complete +
265 query_complete->info_buf_offset), sizeof(u32));
266 rdev->link_state = link_status != 0;
267 }
268}
269
270static void rndis_filter_receive_response(struct rndis_device *dev,
271 struct rndis_message *resp)
272{
273 struct rndis_request *request = NULL;
274 bool found = false;
275 unsigned long flags;
276 struct net_device *ndev = dev->ndev;
277
278 spin_lock_irqsave(&dev->request_lock, flags);
279 list_for_each_entry(request, &dev->req_list, list_ent) {
280
281
282
283
284 if (request->request_msg.msg.init_req.req_id
285 == resp->msg.init_complete.req_id) {
286 found = true;
287 break;
288 }
289 }
290 spin_unlock_irqrestore(&dev->request_lock, flags);
291
292 if (found) {
293 if (resp->msg_len <=
294 sizeof(struct rndis_message) + RNDIS_EXT_LEN) {
295 memcpy(&request->response_msg, resp,
296 resp->msg_len);
297 if (request->request_msg.ndis_msg_type ==
298 RNDIS_MSG_QUERY && request->request_msg.msg.
299 query_req.oid == RNDIS_OID_GEN_MEDIA_CONNECT_STATUS)
300 rndis_set_link_state(dev, request);
301 } else {
302 netdev_err(ndev,
303 "rndis response buffer overflow "
304 "detected (size %u max %zu)\n",
305 resp->msg_len,
306 sizeof(struct rndis_message));
307
308 if (resp->ndis_msg_type ==
309 RNDIS_MSG_RESET_C) {
310
311 request->response_msg.msg.reset_complete.
312 status = RNDIS_STATUS_BUFFER_OVERFLOW;
313 } else {
314 request->response_msg.msg.
315 init_complete.status =
316 RNDIS_STATUS_BUFFER_OVERFLOW;
317 }
318 }
319
320 complete(&request->wait_event);
321 } else {
322 netdev_err(ndev,
323 "no rndis request found for this response "
324 "(id 0x%x res type 0x%x)\n",
325 resp->msg.init_complete.req_id,
326 resp->ndis_msg_type);
327 }
328}
329
330
331
332
333
334static inline void *rndis_get_ppi(struct rndis_packet *rpkt, u32 type)
335{
336 struct rndis_per_packet_info *ppi;
337 int len;
338
339 if (rpkt->per_pkt_info_offset == 0)
340 return NULL;
341
342 ppi = (struct rndis_per_packet_info *)((ulong)rpkt +
343 rpkt->per_pkt_info_offset);
344 len = rpkt->per_pkt_info_len;
345
346 while (len > 0) {
347 if (ppi->type == type)
348 return (void *)((ulong)ppi + ppi->ppi_offset);
349 len -= ppi->size;
350 ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size);
351 }
352
353 return NULL;
354}
355
356static int rndis_filter_receive_data(struct net_device *ndev,
357 struct rndis_device *dev,
358 struct rndis_message *msg,
359 struct vmbus_channel *channel,
360 void *data, u32 data_buflen)
361{
362 struct rndis_packet *rndis_pkt = &msg->msg.pkt;
363 const struct ndis_tcp_ip_checksum_info *csum_info;
364 const struct ndis_pkt_8021q_info *vlan;
365 u32 data_offset;
366
367
368 data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset;
369
370 data_buflen -= data_offset;
371
372
373
374
375
376 if (unlikely(data_buflen < rndis_pkt->data_len)) {
377 netdev_err(dev->ndev, "rndis message buffer "
378 "overflow detected (got %u, min %u)"
379 "...dropping this message!\n",
380 data_buflen, rndis_pkt->data_len);
381 return NVSP_STAT_FAIL;
382 }
383
384 vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO);
385
386
387
388
389
390
391 data = (void *)((unsigned long)data + data_offset);
392 csum_info = rndis_get_ppi(rndis_pkt, TCPIP_CHKSUM_PKTINFO);
393 return netvsc_recv_callback(ndev, channel,
394 data, rndis_pkt->data_len,
395 csum_info, vlan);
396}
397
398int rndis_filter_receive(struct net_device *ndev,
399 struct netvsc_device *net_dev,
400 struct hv_device *dev,
401 struct vmbus_channel *channel,
402 void *data, u32 buflen)
403{
404 struct net_device_context *net_device_ctx = netdev_priv(ndev);
405 struct rndis_device *rndis_dev = net_dev->extension;
406 struct rndis_message *rndis_msg = data;
407
408
409 if (unlikely(!rndis_dev)) {
410 netif_err(net_device_ctx, rx_err, ndev,
411 "got rndis message but no rndis device!\n");
412 return NVSP_STAT_FAIL;
413 }
414
415 if (unlikely(rndis_dev->state == RNDIS_DEV_UNINITIALIZED)) {
416 netif_err(net_device_ctx, rx_err, ndev,
417 "got rndis message uninitialized\n");
418 return NVSP_STAT_FAIL;
419 }
420
421 if (netif_msg_rx_status(net_device_ctx))
422 dump_rndis_message(dev, rndis_msg);
423
424 switch (rndis_msg->ndis_msg_type) {
425 case RNDIS_MSG_PACKET:
426 return rndis_filter_receive_data(ndev, rndis_dev, rndis_msg,
427 channel, data, buflen);
428 case RNDIS_MSG_INIT_C:
429 case RNDIS_MSG_QUERY_C:
430 case RNDIS_MSG_SET_C:
431
432 rndis_filter_receive_response(rndis_dev, rndis_msg);
433 break;
434
435 case RNDIS_MSG_INDICATE:
436
437 netvsc_linkstatus_callback(dev, rndis_msg);
438 break;
439 default:
440 netdev_err(ndev,
441 "unhandled rndis message (type %u len %u)\n",
442 rndis_msg->ndis_msg_type,
443 rndis_msg->msg_len);
444 break;
445 }
446
447 return 0;
448}
449
450static int rndis_filter_query_device(struct rndis_device *dev,
451 struct netvsc_device *nvdev,
452 u32 oid, void *result, u32 *result_size)
453{
454 struct rndis_request *request;
455 u32 inresult_size = *result_size;
456 struct rndis_query_request *query;
457 struct rndis_query_complete *query_complete;
458 int ret = 0;
459
460 if (!result)
461 return -EINVAL;
462
463 *result_size = 0;
464 request = get_rndis_request(dev, RNDIS_MSG_QUERY,
465 RNDIS_MESSAGE_SIZE(struct rndis_query_request));
466 if (!request) {
467 ret = -ENOMEM;
468 goto cleanup;
469 }
470
471
472 query = &request->request_msg.msg.query_req;
473 query->oid = oid;
474 query->info_buf_offset = sizeof(struct rndis_query_request);
475 query->info_buflen = 0;
476 query->dev_vc_handle = 0;
477
478 if (oid == OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES) {
479 struct ndis_offload *hwcaps;
480 u32 nvsp_version = nvdev->nvsp_version;
481 u8 ndis_rev;
482 size_t size;
483
484 if (nvsp_version >= NVSP_PROTOCOL_VERSION_5) {
485 ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
486 size = NDIS_OFFLOAD_SIZE;
487 } else if (nvsp_version >= NVSP_PROTOCOL_VERSION_4) {
488 ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_2;
489 size = NDIS_OFFLOAD_SIZE_6_1;
490 } else {
491 ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_1;
492 size = NDIS_OFFLOAD_SIZE_6_0;
493 }
494
495 request->request_msg.msg_len += size;
496 query->info_buflen = size;
497 hwcaps = (struct ndis_offload *)
498 ((unsigned long)query + query->info_buf_offset);
499
500 hwcaps->header.type = NDIS_OBJECT_TYPE_OFFLOAD;
501 hwcaps->header.revision = ndis_rev;
502 hwcaps->header.size = size;
503
504 } else if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) {
505 struct ndis_recv_scale_cap *cap;
506
507 request->request_msg.msg_len +=
508 sizeof(struct ndis_recv_scale_cap);
509 query->info_buflen = sizeof(struct ndis_recv_scale_cap);
510 cap = (struct ndis_recv_scale_cap *)((unsigned long)query +
511 query->info_buf_offset);
512 cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES;
513 cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2;
514 cap->hdr.size = sizeof(struct ndis_recv_scale_cap);
515 }
516
517 ret = rndis_filter_send_request(dev, request);
518 if (ret != 0)
519 goto cleanup;
520
521 wait_for_completion(&request->wait_event);
522
523
524 query_complete = &request->response_msg.msg.query_complete;
525
526 if (query_complete->info_buflen > inresult_size) {
527 ret = -1;
528 goto cleanup;
529 }
530
531 memcpy(result,
532 (void *)((unsigned long)query_complete +
533 query_complete->info_buf_offset),
534 query_complete->info_buflen);
535
536 *result_size = query_complete->info_buflen;
537
538cleanup:
539 if (request)
540 put_rndis_request(dev, request);
541
542 return ret;
543}
544
545
546static int
547rndis_query_hwcaps(struct rndis_device *dev, struct netvsc_device *net_device,
548 struct ndis_offload *caps)
549{
550 u32 caps_len = sizeof(*caps);
551 int ret;
552
553 memset(caps, 0, sizeof(*caps));
554
555 ret = rndis_filter_query_device(dev, net_device,
556 OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES,
557 caps, &caps_len);
558 if (ret)
559 return ret;
560
561 if (caps->header.type != NDIS_OBJECT_TYPE_OFFLOAD) {
562 netdev_warn(dev->ndev, "invalid NDIS objtype %#x\n",
563 caps->header.type);
564 return -EINVAL;
565 }
566
567 if (caps->header.revision < NDIS_OFFLOAD_PARAMETERS_REVISION_1) {
568 netdev_warn(dev->ndev, "invalid NDIS objrev %x\n",
569 caps->header.revision);
570 return -EINVAL;
571 }
572
573 if (caps->header.size > caps_len ||
574 caps->header.size < NDIS_OFFLOAD_SIZE_6_0) {
575 netdev_warn(dev->ndev,
576 "invalid NDIS objsize %u, data size %u\n",
577 caps->header.size, caps_len);
578 return -EINVAL;
579 }
580
581 return 0;
582}
583
584static int rndis_filter_query_device_mac(struct rndis_device *dev,
585 struct netvsc_device *net_device)
586{
587 u32 size = ETH_ALEN;
588
589 return rndis_filter_query_device(dev, net_device,
590 RNDIS_OID_802_3_PERMANENT_ADDRESS,
591 dev->hw_mac_adr, &size);
592}
593
594#define NWADR_STR "NetworkAddress"
595#define NWADR_STRLEN 14
596
597int rndis_filter_set_device_mac(struct netvsc_device *nvdev,
598 const char *mac)
599{
600 struct rndis_device *rdev = nvdev->extension;
601 struct rndis_request *request;
602 struct rndis_set_request *set;
603 struct rndis_config_parameter_info *cpi;
604 wchar_t *cfg_nwadr, *cfg_mac;
605 struct rndis_set_complete *set_complete;
606 char macstr[2*ETH_ALEN+1];
607 u32 extlen = sizeof(struct rndis_config_parameter_info) +
608 2*NWADR_STRLEN + 4*ETH_ALEN;
609 int ret;
610
611 request = get_rndis_request(rdev, RNDIS_MSG_SET,
612 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
613 if (!request)
614 return -ENOMEM;
615
616 set = &request->request_msg.msg.set_req;
617 set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER;
618 set->info_buflen = extlen;
619 set->info_buf_offset = sizeof(struct rndis_set_request);
620 set->dev_vc_handle = 0;
621
622 cpi = (struct rndis_config_parameter_info *)((ulong)set +
623 set->info_buf_offset);
624 cpi->parameter_name_offset =
625 sizeof(struct rndis_config_parameter_info);
626
627 cpi->parameter_name_length = 2*NWADR_STRLEN;
628 cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING;
629 cpi->parameter_value_offset =
630 cpi->parameter_name_offset + cpi->parameter_name_length;
631
632 cpi->parameter_value_length = 4*ETH_ALEN;
633
634 cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset);
635 cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset);
636 ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, UTF16_HOST_ENDIAN,
637 cfg_nwadr, NWADR_STRLEN);
638 if (ret < 0)
639 goto cleanup;
640 snprintf(macstr, 2*ETH_ALEN+1, "%pm", mac);
641 ret = utf8s_to_utf16s(macstr, 2*ETH_ALEN, UTF16_HOST_ENDIAN,
642 cfg_mac, 2*ETH_ALEN);
643 if (ret < 0)
644 goto cleanup;
645
646 ret = rndis_filter_send_request(rdev, request);
647 if (ret != 0)
648 goto cleanup;
649
650 wait_for_completion(&request->wait_event);
651
652 set_complete = &request->response_msg.msg.set_complete;
653 if (set_complete->status != RNDIS_STATUS_SUCCESS)
654 ret = -EIO;
655
656cleanup:
657 put_rndis_request(rdev, request);
658 return ret;
659}
660
661static int
662rndis_filter_set_offload_params(struct net_device *ndev,
663 struct netvsc_device *nvdev,
664 struct ndis_offload_params *req_offloads)
665{
666 struct rndis_device *rdev = nvdev->extension;
667 struct rndis_request *request;
668 struct rndis_set_request *set;
669 struct ndis_offload_params *offload_params;
670 struct rndis_set_complete *set_complete;
671 u32 extlen = sizeof(struct ndis_offload_params);
672 int ret;
673 u32 vsp_version = nvdev->nvsp_version;
674
675 if (vsp_version <= NVSP_PROTOCOL_VERSION_4) {
676 extlen = VERSION_4_OFFLOAD_SIZE;
677
678
679
680 req_offloads->udp_ip_v4_csum = 0;
681 req_offloads->udp_ip_v6_csum = 0;
682 }
683
684 request = get_rndis_request(rdev, RNDIS_MSG_SET,
685 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
686 if (!request)
687 return -ENOMEM;
688
689 set = &request->request_msg.msg.set_req;
690 set->oid = OID_TCP_OFFLOAD_PARAMETERS;
691 set->info_buflen = extlen;
692 set->info_buf_offset = sizeof(struct rndis_set_request);
693 set->dev_vc_handle = 0;
694
695 offload_params = (struct ndis_offload_params *)((ulong)set +
696 set->info_buf_offset);
697 *offload_params = *req_offloads;
698 offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT;
699 offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3;
700 offload_params->header.size = extlen;
701
702 ret = rndis_filter_send_request(rdev, request);
703 if (ret != 0)
704 goto cleanup;
705
706 wait_for_completion(&request->wait_event);
707 set_complete = &request->response_msg.msg.set_complete;
708 if (set_complete->status != RNDIS_STATUS_SUCCESS) {
709 netdev_err(ndev, "Fail to set offload on host side:0x%x\n",
710 set_complete->status);
711 ret = -EINVAL;
712 }
713
714cleanup:
715 put_rndis_request(rdev, request);
716 return ret;
717}
718
719int rndis_filter_set_rss_param(struct rndis_device *rdev,
720 const u8 *rss_key)
721{
722 struct net_device *ndev = rdev->ndev;
723 struct rndis_request *request;
724 struct rndis_set_request *set;
725 struct rndis_set_complete *set_complete;
726 u32 extlen = sizeof(struct ndis_recv_scale_param) +
727 4 * ITAB_NUM + NETVSC_HASH_KEYLEN;
728 struct ndis_recv_scale_param *rssp;
729 u32 *itab;
730 u8 *keyp;
731 int i, ret;
732
733 request = get_rndis_request(
734 rdev, RNDIS_MSG_SET,
735 RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen);
736 if (!request)
737 return -ENOMEM;
738
739 set = &request->request_msg.msg.set_req;
740 set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS;
741 set->info_buflen = extlen;
742 set->info_buf_offset = sizeof(struct rndis_set_request);
743 set->dev_vc_handle = 0;
744
745 rssp = (struct ndis_recv_scale_param *)(set + 1);
746 rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
747 rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
748 rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
749 rssp->flag = 0;
750 rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
751 NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
752 NDIS_HASH_TCP_IPV6;
753 rssp->indirect_tabsize = 4*ITAB_NUM;
754 rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param);
755 rssp->hashkey_size = NETVSC_HASH_KEYLEN;
756 rssp->kashkey_offset = rssp->indirect_taboffset +
757 rssp->indirect_tabsize;
758
759
760 itab = (u32 *)(rssp + 1);
761 for (i = 0; i < ITAB_NUM; i++)
762 itab[i] = rdev->ind_table[i];
763
764
765 keyp = (u8 *)((unsigned long)rssp + rssp->kashkey_offset);
766 memcpy(keyp, rss_key, NETVSC_HASH_KEYLEN);
767
768 ret = rndis_filter_send_request(rdev, request);
769 if (ret != 0)
770 goto cleanup;
771
772 wait_for_completion(&request->wait_event);
773 set_complete = &request->response_msg.msg.set_complete;
774 if (set_complete->status == RNDIS_STATUS_SUCCESS)
775 memcpy(rdev->rss_key, rss_key, NETVSC_HASH_KEYLEN);
776 else {
777 netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
778 set_complete->status);
779 ret = -EINVAL;
780 }
781
782cleanup:
783 put_rndis_request(rdev, request);
784 return ret;
785}
786
787static int rndis_filter_query_device_link_status(struct rndis_device *dev,
788 struct netvsc_device *net_device)
789{
790 u32 size = sizeof(u32);
791 u32 link_status;
792
793 return rndis_filter_query_device(dev, net_device,
794 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
795 &link_status, &size);
796}
797
798static int rndis_filter_query_link_speed(struct rndis_device *dev,
799 struct netvsc_device *net_device)
800{
801 u32 size = sizeof(u32);
802 u32 link_speed;
803 struct net_device_context *ndc;
804 int ret;
805
806 ret = rndis_filter_query_device(dev, net_device,
807 RNDIS_OID_GEN_LINK_SPEED,
808 &link_speed, &size);
809
810 if (!ret) {
811 ndc = netdev_priv(dev->ndev);
812
813
814
815
816 ndc->speed = link_speed / 10000;
817 }
818
819 return ret;
820}
821
822static int rndis_filter_set_packet_filter(struct rndis_device *dev,
823 u32 new_filter)
824{
825 struct rndis_request *request;
826 struct rndis_set_request *set;
827 int ret;
828
829 request = get_rndis_request(dev, RNDIS_MSG_SET,
830 RNDIS_MESSAGE_SIZE(struct rndis_set_request) +
831 sizeof(u32));
832 if (!request)
833 return -ENOMEM;
834
835
836
837 set = &request->request_msg.msg.set_req;
838 set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
839 set->info_buflen = sizeof(u32);
840 set->info_buf_offset = sizeof(struct rndis_set_request);
841
842 memcpy((void *)(unsigned long)set + sizeof(struct rndis_set_request),
843 &new_filter, sizeof(u32));
844
845 ret = rndis_filter_send_request(dev, request);
846 if (ret == 0)
847 wait_for_completion(&request->wait_event);
848
849 put_rndis_request(dev, request);
850
851 return ret;
852}
853
854static void rndis_set_multicast(struct work_struct *w)
855{
856 struct rndis_device *rdev
857 = container_of(w, struct rndis_device, mcast_work);
858
859 if (rdev->ndev->flags & IFF_PROMISC)
860 rndis_filter_set_packet_filter(rdev,
861 NDIS_PACKET_TYPE_PROMISCUOUS);
862 else
863 rndis_filter_set_packet_filter(rdev,
864 NDIS_PACKET_TYPE_BROADCAST |
865 NDIS_PACKET_TYPE_ALL_MULTICAST |
866 NDIS_PACKET_TYPE_DIRECTED);
867}
868
869void rndis_filter_update(struct netvsc_device *nvdev)
870{
871 struct rndis_device *rdev = nvdev->extension;
872
873 schedule_work(&rdev->mcast_work);
874}
875
876static int rndis_filter_init_device(struct rndis_device *dev,
877 struct netvsc_device *nvdev)
878{
879 struct rndis_request *request;
880 struct rndis_initialize_request *init;
881 struct rndis_initialize_complete *init_complete;
882 u32 status;
883 int ret;
884
885 request = get_rndis_request(dev, RNDIS_MSG_INIT,
886 RNDIS_MESSAGE_SIZE(struct rndis_initialize_request));
887 if (!request) {
888 ret = -ENOMEM;
889 goto cleanup;
890 }
891
892
893 init = &request->request_msg.msg.init_req;
894 init->major_ver = RNDIS_MAJOR_VERSION;
895 init->minor_ver = RNDIS_MINOR_VERSION;
896 init->max_xfer_size = 0x4000;
897
898 dev->state = RNDIS_DEV_INITIALIZING;
899
900 ret = rndis_filter_send_request(dev, request);
901 if (ret != 0) {
902 dev->state = RNDIS_DEV_UNINITIALIZED;
903 goto cleanup;
904 }
905
906 wait_for_completion(&request->wait_event);
907
908 init_complete = &request->response_msg.msg.init_complete;
909 status = init_complete->status;
910 if (status == RNDIS_STATUS_SUCCESS) {
911 dev->state = RNDIS_DEV_INITIALIZED;
912 nvdev->max_pkt = init_complete->max_pkt_per_msg;
913 nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor;
914 ret = 0;
915 } else {
916 dev->state = RNDIS_DEV_UNINITIALIZED;
917 ret = -EINVAL;
918 }
919
920cleanup:
921 if (request)
922 put_rndis_request(dev, request);
923
924 return ret;
925}
926
927static bool netvsc_device_idle(const struct netvsc_device *nvdev)
928{
929 int i;
930
931 for (i = 0; i < nvdev->num_chn; i++) {
932 const struct netvsc_channel *nvchan = &nvdev->chan_table[i];
933
934 if (nvchan->mrc.first != nvchan->mrc.next)
935 return false;
936
937 if (atomic_read(&nvchan->queue_sends) > 0)
938 return false;
939 }
940
941 return true;
942}
943
944static void rndis_filter_halt_device(struct rndis_device *dev)
945{
946 struct rndis_request *request;
947 struct rndis_halt_request *halt;
948 struct net_device_context *net_device_ctx = netdev_priv(dev->ndev);
949 struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
950
951
952 request = get_rndis_request(dev, RNDIS_MSG_HALT,
953 RNDIS_MESSAGE_SIZE(struct rndis_halt_request));
954 if (!request)
955 goto cleanup;
956
957
958 halt = &request->request_msg.msg.halt_req;
959 halt->req_id = atomic_inc_return(&dev->new_req_id);
960
961
962 rndis_filter_send_request(dev, request);
963
964 dev->state = RNDIS_DEV_UNINITIALIZED;
965
966cleanup:
967 nvdev->destroy = true;
968
969
970 wmb();
971
972
973 wait_event(nvdev->wait_drain, netvsc_device_idle(nvdev));
974
975 if (request)
976 put_rndis_request(dev, request);
977}
978
979static int rndis_filter_open_device(struct rndis_device *dev)
980{
981 int ret;
982
983 if (dev->state != RNDIS_DEV_INITIALIZED)
984 return 0;
985
986 ret = rndis_filter_set_packet_filter(dev,
987 NDIS_PACKET_TYPE_BROADCAST |
988 NDIS_PACKET_TYPE_ALL_MULTICAST |
989 NDIS_PACKET_TYPE_DIRECTED);
990 if (ret == 0)
991 dev->state = RNDIS_DEV_DATAINITIALIZED;
992
993 return ret;
994}
995
996static int rndis_filter_close_device(struct rndis_device *dev)
997{
998 int ret;
999
1000 if (dev->state != RNDIS_DEV_DATAINITIALIZED)
1001 return 0;
1002
1003
1004 cancel_work_sync(&dev->mcast_work);
1005
1006 ret = rndis_filter_set_packet_filter(dev, 0);
1007 if (ret == -ENODEV)
1008 ret = 0;
1009
1010 if (ret == 0)
1011 dev->state = RNDIS_DEV_INITIALIZED;
1012
1013 return ret;
1014}
1015
1016static void netvsc_sc_open(struct vmbus_channel *new_sc)
1017{
1018 struct net_device *ndev =
1019 hv_get_drvdata(new_sc->primary_channel->device_obj);
1020 struct net_device_context *ndev_ctx = netdev_priv(ndev);
1021 struct netvsc_device *nvscdev;
1022 u16 chn_index = new_sc->offermsg.offer.sub_channel_index;
1023 struct netvsc_channel *nvchan;
1024 int ret;
1025
1026
1027
1028
1029 nvscdev = rcu_dereference_raw(ndev_ctx->nvdev);
1030 if (!nvscdev || chn_index >= nvscdev->num_chn)
1031 return;
1032
1033 nvchan = nvscdev->chan_table + chn_index;
1034
1035
1036
1037
1038 set_channel_read_mode(new_sc, HV_CALL_ISR);
1039
1040
1041 nvchan->channel = new_sc;
1042
1043 ret = vmbus_open(new_sc, nvscdev->ring_size * PAGE_SIZE,
1044 nvscdev->ring_size * PAGE_SIZE, NULL, 0,
1045 netvsc_channel_cb, nvchan);
1046 if (ret == 0)
1047 napi_enable(&nvchan->napi);
1048 else
1049 netdev_notice(ndev, "sub channel open failed: %d\n", ret);
1050
1051 if (atomic_inc_return(&nvscdev->open_chn) == nvscdev->num_chn)
1052 wake_up(&nvscdev->subchan_open);
1053}
1054
1055
1056
1057
1058
1059void rndis_set_subchannel(struct work_struct *w)
1060{
1061 struct netvsc_device *nvdev
1062 = container_of(w, struct netvsc_device, subchan_work);
1063 struct nvsp_message *init_packet = &nvdev->channel_init_pkt;
1064 struct net_device_context *ndev_ctx;
1065 struct rndis_device *rdev;
1066 struct net_device *ndev;
1067 struct hv_device *hv_dev;
1068 int i, ret;
1069
1070 if (!rtnl_trylock()) {
1071 schedule_work(w);
1072 return;
1073 }
1074
1075 rdev = nvdev->extension;
1076 if (!rdev)
1077 goto unlock;
1078
1079 ndev = rdev->ndev;
1080 ndev_ctx = netdev_priv(ndev);
1081 hv_dev = ndev_ctx->device_ctx;
1082
1083 memset(init_packet, 0, sizeof(struct nvsp_message));
1084 init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL;
1085 init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE;
1086 init_packet->msg.v5_msg.subchn_req.num_subchannels =
1087 nvdev->num_chn - 1;
1088 ret = vmbus_sendpacket(hv_dev->channel, init_packet,
1089 sizeof(struct nvsp_message),
1090 (unsigned long)init_packet,
1091 VM_PKT_DATA_INBAND,
1092 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1093 if (ret) {
1094 netdev_err(ndev, "sub channel allocate send failed: %d\n", ret);
1095 goto failed;
1096 }
1097
1098 wait_for_completion(&nvdev->channel_init_wait);
1099 if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) {
1100 netdev_err(ndev, "sub channel request failed\n");
1101 goto failed;
1102 }
1103
1104 nvdev->num_chn = 1 +
1105 init_packet->msg.v5_msg.subchn_comp.num_subchannels;
1106
1107
1108 wait_event(nvdev->subchan_open,
1109 atomic_read(&nvdev->open_chn) == nvdev->num_chn);
1110
1111
1112 rndis_filter_set_rss_param(rdev, netvsc_hash_key);
1113
1114 netif_set_real_num_tx_queues(ndev, nvdev->num_chn);
1115 netif_set_real_num_rx_queues(ndev, nvdev->num_chn);
1116
1117 rtnl_unlock();
1118 return;
1119
1120failed:
1121
1122 for (i = 1; i < nvdev->num_chn; i++)
1123 netif_napi_del(&nvdev->chan_table[i].napi);
1124
1125 nvdev->max_chn = 1;
1126 nvdev->num_chn = 1;
1127unlock:
1128 rtnl_unlock();
1129}
1130
1131struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
1132 struct netvsc_device_info *device_info)
1133{
1134 struct net_device *net = hv_get_drvdata(dev);
1135 struct net_device_context *net_device_ctx = netdev_priv(net);
1136 struct netvsc_device *net_device;
1137 struct rndis_device *rndis_device;
1138 struct ndis_offload hwcaps;
1139 struct ndis_offload_params offloads;
1140 struct ndis_recv_scale_cap rsscap;
1141 u32 rsscap_size = sizeof(struct ndis_recv_scale_cap);
1142 unsigned int gso_max_size = GSO_MAX_SIZE;
1143 u32 mtu, size;
1144 const struct cpumask *node_cpu_mask;
1145 u32 num_possible_rss_qs;
1146 int i, ret;
1147
1148 rndis_device = get_rndis_device();
1149 if (!rndis_device)
1150 return ERR_PTR(-ENODEV);
1151
1152
1153
1154
1155
1156
1157 net_device = netvsc_device_add(dev, device_info);
1158 if (IS_ERR(net_device)) {
1159 kfree(rndis_device);
1160 return net_device;
1161 }
1162
1163
1164 net_device->max_chn = 1;
1165 net_device->num_chn = 1;
1166
1167 net_device->extension = rndis_device;
1168 rndis_device->ndev = net;
1169
1170
1171 ret = rndis_filter_init_device(rndis_device, net_device);
1172 if (ret != 0)
1173 goto err_dev_remv;
1174
1175
1176 size = sizeof(u32);
1177 ret = rndis_filter_query_device(rndis_device, net_device,
1178 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE,
1179 &mtu, &size);
1180 if (ret == 0 && size == sizeof(u32) && mtu < net->mtu)
1181 net->mtu = mtu;
1182
1183
1184 ret = rndis_filter_query_device_mac(rndis_device, net_device);
1185 if (ret != 0)
1186 goto err_dev_remv;
1187
1188 memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN);
1189
1190
1191 ret = rndis_query_hwcaps(rndis_device, net_device, &hwcaps);
1192 if (ret != 0)
1193 goto err_dev_remv;
1194
1195
1196 memset(&offloads, 0, sizeof(struct ndis_offload_params));
1197
1198
1199 offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_DISABLED;
1200
1201
1202 net->hw_features = NETIF_F_RXCSUM;
1203
1204 if ((hwcaps.csum.ip4_txcsum & NDIS_TXCSUM_ALL_TCP4) == NDIS_TXCSUM_ALL_TCP4) {
1205
1206 net->hw_features |= NETIF_F_IP_CSUM;
1207 net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV4_TCP;
1208
1209 offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1210
1211 if (hwcaps.lsov2.ip4_encap & NDIS_OFFLOAD_ENCAP_8023) {
1212 offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1213 net->hw_features |= NETIF_F_TSO;
1214
1215 if (hwcaps.lsov2.ip4_maxsz < gso_max_size)
1216 gso_max_size = hwcaps.lsov2.ip4_maxsz;
1217 }
1218
1219 if (hwcaps.csum.ip4_txcsum & NDIS_TXCSUM_CAP_UDP4) {
1220 offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1221 net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV4_UDP;
1222 }
1223 }
1224
1225 if ((hwcaps.csum.ip6_txcsum & NDIS_TXCSUM_ALL_TCP6) == NDIS_TXCSUM_ALL_TCP6) {
1226 net->hw_features |= NETIF_F_IPV6_CSUM;
1227
1228 offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1229 net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV6_TCP;
1230
1231 if ((hwcaps.lsov2.ip6_encap & NDIS_OFFLOAD_ENCAP_8023) &&
1232 (hwcaps.lsov2.ip6_opts & NDIS_LSOV2_CAP_IP6) == NDIS_LSOV2_CAP_IP6) {
1233 offloads.lso_v2_ipv6 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED;
1234 net->hw_features |= NETIF_F_TSO6;
1235
1236 if (hwcaps.lsov2.ip6_maxsz < gso_max_size)
1237 gso_max_size = hwcaps.lsov2.ip6_maxsz;
1238 }
1239
1240 if (hwcaps.csum.ip6_txcsum & NDIS_TXCSUM_CAP_UDP6) {
1241 offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;
1242 net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV6_UDP;
1243 }
1244 }
1245
1246 netif_set_gso_max_size(net, gso_max_size);
1247
1248 ret = rndis_filter_set_offload_params(net, net_device, &offloads);
1249 if (ret)
1250 goto err_dev_remv;
1251
1252 rndis_filter_query_device_link_status(rndis_device, net_device);
1253
1254 netdev_dbg(net, "Device MAC %pM link state %s\n",
1255 rndis_device->hw_mac_adr,
1256 rndis_device->link_state ? "down" : "up");
1257
1258 if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5)
1259 return net_device;
1260
1261 rndis_filter_query_link_speed(rndis_device, net_device);
1262
1263
1264 memset(&rsscap, 0, rsscap_size);
1265 ret = rndis_filter_query_device(rndis_device, net_device,
1266 OID_GEN_RECEIVE_SCALE_CAPABILITIES,
1267 &rsscap, &rsscap_size);
1268 if (ret || rsscap.num_recv_que < 2)
1269 goto out;
1270
1271
1272
1273
1274
1275
1276
1277 node_cpu_mask = cpumask_of_node(cpu_to_node(dev->channel->target_cpu));
1278 num_possible_rss_qs = min_t(u32, cpumask_weight(node_cpu_mask),
1279 rsscap.num_recv_que);
1280
1281 net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, num_possible_rss_qs);
1282
1283
1284 net_device->num_chn = min(net_device->max_chn, device_info->num_chn);
1285
1286 for (i = 0; i < ITAB_NUM; i++)
1287 rndis_device->ind_table[i] = ethtool_rxfh_indir_default(i,
1288 net_device->num_chn);
1289
1290 atomic_set(&net_device->open_chn, 1);
1291 vmbus_set_sc_create_callback(dev->channel, netvsc_sc_open);
1292
1293 for (i = 1; i < net_device->num_chn; i++) {
1294 ret = netvsc_alloc_recv_comp_ring(net_device, i);
1295 if (ret) {
1296 while (--i != 0)
1297 vfree(net_device->chan_table[i].mrc.slots);
1298 goto out;
1299 }
1300 }
1301
1302 for (i = 1; i < net_device->num_chn; i++)
1303 netif_napi_add(net, &net_device->chan_table[i].napi,
1304 netvsc_poll, NAPI_POLL_WEIGHT);
1305
1306 if (net_device->num_chn > 1)
1307 schedule_work(&net_device->subchan_work);
1308
1309out:
1310
1311 if (ret) {
1312 net_device->max_chn = 1;
1313 net_device->num_chn = 1;
1314 }
1315
1316 return net_device;
1317
1318err_dev_remv:
1319 rndis_filter_device_remove(dev, net_device);
1320 return ERR_PTR(ret);
1321}
1322
1323void rndis_filter_device_remove(struct hv_device *dev,
1324 struct netvsc_device *net_dev)
1325{
1326 struct rndis_device *rndis_dev = net_dev->extension;
1327
1328
1329 rndis_filter_halt_device(rndis_dev);
1330
1331 net_dev->extension = NULL;
1332
1333 netvsc_device_remove(dev);
1334 kfree(rndis_dev);
1335}
1336
1337int rndis_filter_open(struct netvsc_device *nvdev)
1338{
1339 if (!nvdev)
1340 return -EINVAL;
1341
1342 if (atomic_inc_return(&nvdev->open_cnt) != 1)
1343 return 0;
1344
1345 return rndis_filter_open_device(nvdev->extension);
1346}
1347
1348int rndis_filter_close(struct netvsc_device *nvdev)
1349{
1350 if (!nvdev)
1351 return -EINVAL;
1352
1353 if (atomic_dec_return(&nvdev->open_cnt) != 0)
1354 return 0;
1355
1356 return rndis_filter_close_device(nvdev->extension);
1357}
1358
1359bool rndis_filter_opened(const struct netvsc_device *nvdev)
1360{
1361 return atomic_read(&nvdev->open_cnt) > 0;
1362}
1363
