projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lightnvm: NVM should depend on HAS_DMA
[deliverable/linux.git] / drivers / net / hyperv / netvsc.c
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/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/wait.h>
25 #include <linux/mm.h>
26 #include <linux/delay.h>
27 #include <linux/io.h>
28 #include <linux/slab.h>
29 #include <linux/netdevice.h>
30 #include <linux/if_ether.h>
31 #include <linux/vmalloc.h>
32 #include <asm/sync_bitops.h>
33
34 #include "hyperv_net.h"
35
36 /*
37 * Switch the data path from the synthetic interface to the VF
38 * interface.
39 */
40 void netvsc_switch_datapath(struct net_device *ndev, bool vf)
41 {
42 struct net_device_context *net_device_ctx = netdev_priv(ndev);
43 struct hv_device *dev = net_device_ctx->device_ctx;
44 struct netvsc_device *nv_dev = net_device_ctx->nvdev;
45 struct nvsp_message *init_pkt = &nv_dev->channel_init_pkt;
46
47 memset(init_pkt, 0, sizeof(struct nvsp_message));
48 init_pkt->hdr.msg_type = NVSP_MSG4_TYPE_SWITCH_DATA_PATH;
49 if (vf)
50 init_pkt->msg.v4_msg.active_dp.active_datapath =
51 NVSP_DATAPATH_VF;
52 else
53 init_pkt->msg.v4_msg.active_dp.active_datapath =
54 NVSP_DATAPATH_SYNTHETIC;
55
56 vmbus_sendpacket(dev->channel, init_pkt,
57 sizeof(struct nvsp_message),
58 (unsigned long)init_pkt,
59 VM_PKT_DATA_INBAND, 0);
60 }
61
62
63 static struct netvsc_device *alloc_net_device(void)
64 {
65 struct netvsc_device *net_device;
66
67 net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
68 if (!net_device)
69 return NULL;
70
71 net_device->cb_buffer = kzalloc(NETVSC_PACKET_SIZE, GFP_KERNEL);
72 if (!net_device->cb_buffer) {
73 kfree(net_device);
74 return NULL;
75 }
76
77 init_waitqueue_head(&net_device->wait_drain);
78 net_device->destroy = false;
79 atomic_set(&net_device->open_cnt, 0);
80 net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT;
81 net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT;
82
83 return net_device;
84 }
85
86 static void free_netvsc_device(struct netvsc_device *nvdev)
87 {
88 kfree(nvdev->cb_buffer);
89 kfree(nvdev);
90 }
91
92 static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
93 {
94 struct netvsc_device *net_device = hv_device_to_netvsc_device(device);
95
96 if (net_device && net_device->destroy)
97 net_device = NULL;
98
99 return net_device;
100 }
101
102 static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
103 {
104 struct netvsc_device *net_device = hv_device_to_netvsc_device(device);
105
106 if (!net_device)
107 goto get_in_err;
108
109 if (net_device->destroy &&
110 atomic_read(&net_device->num_outstanding_sends) == 0)
111 net_device = NULL;
112
113 get_in_err:
114 return net_device;
115 }
116
117
118 static int netvsc_destroy_buf(struct hv_device *device)
119 {
120 struct nvsp_message *revoke_packet;
121 int ret = 0;
122 struct net_device *ndev = hv_get_drvdata(device);
123 struct netvsc_device *net_device = net_device_to_netvsc_device(ndev);
124
125 /*
126 * If we got a section count, it means we received a
127 * SendReceiveBufferComplete msg (ie sent
128 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
129 * to send a revoke msg here
130 */
131 if (net_device->recv_section_cnt) {
132 /* Send the revoke receive buffer */
133 revoke_packet = &net_device->revoke_packet;
134 memset(revoke_packet, 0, sizeof(struct nvsp_message));
135
136 revoke_packet->hdr.msg_type =
137 NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
138 revoke_packet->msg.v1_msg.
139 revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
140
141 ret = vmbus_sendpacket(device->channel,
142 revoke_packet,
143 sizeof(struct nvsp_message),
144 (unsigned long)revoke_packet,
145 VM_PKT_DATA_INBAND, 0);
146 /*
147 * If we failed here, we might as well return and
148 * have a leak rather than continue and a bugchk
149 */
150 if (ret != 0) {
151 netdev_err(ndev, "unable to send "
152 "revoke receive buffer to netvsp\n");
153 return ret;
154 }
155 }
156
157 /* Teardown the gpadl on the vsp end */
158 if (net_device->recv_buf_gpadl_handle) {
159 ret = vmbus_teardown_gpadl(device->channel,
160 net_device->recv_buf_gpadl_handle);
161
162 /* If we failed here, we might as well return and have a leak
163 * rather than continue and a bugchk
164 */
165 if (ret != 0) {
166 netdev_err(ndev,
167 "unable to teardown receive buffer's gpadl\n");
168 return ret;
169 }
170 net_device->recv_buf_gpadl_handle = 0;
171 }
172
173 if (net_device->recv_buf) {
174 /* Free up the receive buffer */
175 vfree(net_device->recv_buf);
176 net_device->recv_buf = NULL;
177 }
178
179 if (net_device->recv_section) {
180 net_device->recv_section_cnt = 0;
181 kfree(net_device->recv_section);
182 net_device->recv_section = NULL;
183 }
184
185 /* Deal with the send buffer we may have setup.
186 * If we got a send section size, it means we received a
187 * NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE msg (ie sent
188 * NVSP_MSG1_TYPE_SEND_SEND_BUF msg) therefore, we need
189 * to send a revoke msg here
190 */
191 if (net_device->send_section_size) {
192 /* Send the revoke receive buffer */
193 revoke_packet = &net_device->revoke_packet;
194 memset(revoke_packet, 0, sizeof(struct nvsp_message));
195
196 revoke_packet->hdr.msg_type =
197 NVSP_MSG1_TYPE_REVOKE_SEND_BUF;
198 revoke_packet->msg.v1_msg.revoke_send_buf.id =
199 NETVSC_SEND_BUFFER_ID;
200
201 ret = vmbus_sendpacket(device->channel,
202 revoke_packet,
203 sizeof(struct nvsp_message),
204 (unsigned long)revoke_packet,
205 VM_PKT_DATA_INBAND, 0);
206 /* If we failed here, we might as well return and
207 * have a leak rather than continue and a bugchk
208 */
209 if (ret != 0) {
210 netdev_err(ndev, "unable to send "
211 "revoke send buffer to netvsp\n");
212 return ret;
213 }
214 }
215 /* Teardown the gpadl on the vsp end */
216 if (net_device->send_buf_gpadl_handle) {
217 ret = vmbus_teardown_gpadl(device->channel,
218 net_device->send_buf_gpadl_handle);
219
220 /* If we failed here, we might as well return and have a leak
221 * rather than continue and a bugchk
222 */
223 if (ret != 0) {
224 netdev_err(ndev,
225 "unable to teardown send buffer's gpadl\n");
226 return ret;
227 }
228 net_device->send_buf_gpadl_handle = 0;
229 }
230 if (net_device->send_buf) {
231 /* Free up the send buffer */
232 vfree(net_device->send_buf);
233 net_device->send_buf = NULL;
234 }
235 kfree(net_device->send_section_map);
236
237 return ret;
238 }
239
240 static int netvsc_init_buf(struct hv_device *device)
241 {
242 int ret = 0;
243 struct netvsc_device *net_device;
244 struct nvsp_message *init_packet;
245 struct net_device *ndev;
246 int node;
247
248 net_device = get_outbound_net_device(device);
249 if (!net_device)
250 return -ENODEV;
251 ndev = hv_get_drvdata(device);
252
253 node = cpu_to_node(device->channel->target_cpu);
254 net_device->recv_buf = vzalloc_node(net_device->recv_buf_size, node);
255 if (!net_device->recv_buf)
256 net_device->recv_buf = vzalloc(net_device->recv_buf_size);
257
258 if (!net_device->recv_buf) {
259 netdev_err(ndev, "unable to allocate receive "
260 "buffer of size %d\n", net_device->recv_buf_size);
261 ret = -ENOMEM;
262 goto cleanup;
263 }
264
265 /*
266 * Establish the gpadl handle for this buffer on this
267 * channel. Note: This call uses the vmbus connection rather
268 * than the channel to establish the gpadl handle.
269 */
270 ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
271 net_device->recv_buf_size,
272 &net_device->recv_buf_gpadl_handle);
273 if (ret != 0) {
274 netdev_err(ndev,
275 "unable to establish receive buffer's gpadl\n");
276 goto cleanup;
277 }
278
279
280 /* Notify the NetVsp of the gpadl handle */
281 init_packet = &net_device->channel_init_pkt;
282
283 memset(init_packet, 0, sizeof(struct nvsp_message));
284
285 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
286 init_packet->msg.v1_msg.send_recv_buf.
287 gpadl_handle = net_device->recv_buf_gpadl_handle;
288 init_packet->msg.v1_msg.
289 send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
290
291 /* Send the gpadl notification request */
292 ret = vmbus_sendpacket(device->channel, init_packet,
293 sizeof(struct nvsp_message),
294 (unsigned long)init_packet,
295 VM_PKT_DATA_INBAND,
296 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
297 if (ret != 0) {
298 netdev_err(ndev,
299 "unable to send receive buffer's gpadl to netvsp\n");
300 goto cleanup;
301 }
302
303 wait_for_completion(&net_device->channel_init_wait);
304
305 /* Check the response */
306 if (init_packet->msg.v1_msg.
307 send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
308 netdev_err(ndev, "Unable to complete receive buffer "
309 "initialization with NetVsp - status %d\n",
310 init_packet->msg.v1_msg.
311 send_recv_buf_complete.status);
312 ret = -EINVAL;
313 goto cleanup;
314 }
315
316 /* Parse the response */
317
318 net_device->recv_section_cnt = init_packet->msg.
319 v1_msg.send_recv_buf_complete.num_sections;
320
321 net_device->recv_section = kmemdup(
322 init_packet->msg.v1_msg.send_recv_buf_complete.sections,
323 net_device->recv_section_cnt *
324 sizeof(struct nvsp_1_receive_buffer_section),
325 GFP_KERNEL);
326 if (net_device->recv_section == NULL) {
327 ret = -EINVAL;
328 goto cleanup;
329 }
330
331 /*
332 * For 1st release, there should only be 1 section that represents the
333 * entire receive buffer
334 */
335 if (net_device->recv_section_cnt != 1 ||
336 net_device->recv_section->offset != 0) {
337 ret = -EINVAL;
338 goto cleanup;
339 }
340
341 /* Now setup the send buffer.
342 */
343 net_device->send_buf = vzalloc_node(net_device->send_buf_size, node);
344 if (!net_device->send_buf)
345 net_device->send_buf = vzalloc(net_device->send_buf_size);
346 if (!net_device->send_buf) {
347 netdev_err(ndev, "unable to allocate send "
348 "buffer of size %d\n", net_device->send_buf_size);
349 ret = -ENOMEM;
350 goto cleanup;
351 }
352
353 /* Establish the gpadl handle for this buffer on this
354 * channel. Note: This call uses the vmbus connection rather
355 * than the channel to establish the gpadl handle.
356 */
357 ret = vmbus_establish_gpadl(device->channel, net_device->send_buf,
358 net_device->send_buf_size,
359 &net_device->send_buf_gpadl_handle);
360 if (ret != 0) {
361 netdev_err(ndev,
362 "unable to establish send buffer's gpadl\n");
363 goto cleanup;
364 }
365
366 /* Notify the NetVsp of the gpadl handle */
367 init_packet = &net_device->channel_init_pkt;
368 memset(init_packet, 0, sizeof(struct nvsp_message));
369 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF;
370 init_packet->msg.v1_msg.send_send_buf.gpadl_handle =
371 net_device->send_buf_gpadl_handle;
372 init_packet->msg.v1_msg.send_send_buf.id = NETVSC_SEND_BUFFER_ID;
373
374 /* Send the gpadl notification request */
375 ret = vmbus_sendpacket(device->channel, init_packet,
376 sizeof(struct nvsp_message),
377 (unsigned long)init_packet,
378 VM_PKT_DATA_INBAND,
379 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
380 if (ret != 0) {
381 netdev_err(ndev,
382 "unable to send send buffer's gpadl to netvsp\n");
383 goto cleanup;
384 }
385
386 wait_for_completion(&net_device->channel_init_wait);
387
388 /* Check the response */
389 if (init_packet->msg.v1_msg.
390 send_send_buf_complete.status != NVSP_STAT_SUCCESS) {
391 netdev_err(ndev, "Unable to complete send buffer "
392 "initialization with NetVsp - status %d\n",
393 init_packet->msg.v1_msg.
394 send_send_buf_complete.status);
395 ret = -EINVAL;
396 goto cleanup;
397 }
398
399 /* Parse the response */
400 net_device->send_section_size = init_packet->msg.
401 v1_msg.send_send_buf_complete.section_size;
402
403 /* Section count is simply the size divided by the section size.
404 */
405 net_device->send_section_cnt =
406 net_device->send_buf_size/net_device->send_section_size;
407
408 dev_info(&device->device, "Send section size: %d, Section count:%d\n",
409 net_device->send_section_size, net_device->send_section_cnt);
410
411 /* Setup state for managing the send buffer. */
412 net_device->map_words = DIV_ROUND_UP(net_device->send_section_cnt,
413 BITS_PER_LONG);
414
415 net_device->send_section_map =
416 kzalloc(net_device->map_words * sizeof(ulong), GFP_KERNEL);
417 if (net_device->send_section_map == NULL) {
418 ret = -ENOMEM;
419 goto cleanup;
420 }
421
422 goto exit;
423
424 cleanup:
425 netvsc_destroy_buf(device);
426
427 exit:
428 return ret;
429 }
430
431
432 /* Negotiate NVSP protocol version */
433 static int negotiate_nvsp_ver(struct hv_device *device,
434 struct netvsc_device *net_device,
435 struct nvsp_message *init_packet,
436 u32 nvsp_ver)
437 {
438 struct net_device *ndev = hv_get_drvdata(device);
439 int ret;
440
441 memset(init_packet, 0, sizeof(struct nvsp_message));
442 init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
443 init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
444 init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
445
446 /* Send the init request */
447 ret = vmbus_sendpacket(device->channel, init_packet,
448 sizeof(struct nvsp_message),
449 (unsigned long)init_packet,
450 VM_PKT_DATA_INBAND,
451 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
452
453 if (ret != 0)
454 return ret;
455
456 wait_for_completion(&net_device->channel_init_wait);
457
458 if (init_packet->msg.init_msg.init_complete.status !=
459 NVSP_STAT_SUCCESS)
460 return -EINVAL;
461
462 if (nvsp_ver == NVSP_PROTOCOL_VERSION_1)
463 return 0;
464
465 /* NVSPv2 or later: Send NDIS config */
466 memset(init_packet, 0, sizeof(struct nvsp_message));
467 init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
468 init_packet->msg.v2_msg.send_ndis_config.mtu = ndev->mtu + ETH_HLEN;
469 init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
470
471 if (nvsp_ver >= NVSP_PROTOCOL_VERSION_5)
472 init_packet->msg.v2_msg.send_ndis_config.capability.sriov = 1;
473
474 ret = vmbus_sendpacket(device->channel, init_packet,
475 sizeof(struct nvsp_message),
476 (unsigned long)init_packet,
477 VM_PKT_DATA_INBAND, 0);
478
479 return ret;
480 }
481
482 static int netvsc_connect_vsp(struct hv_device *device)
483 {
484 int ret;
485 struct netvsc_device *net_device;
486 struct nvsp_message *init_packet;
487 int ndis_version;
488 u32 ver_list[] = { NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2,
489 NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5 };
490 int i, num_ver = 4; /* number of different NVSP versions */
491
492 net_device = get_outbound_net_device(device);
493 if (!net_device)
494 return -ENODEV;
495
496 init_packet = &net_device->channel_init_pkt;
497
498 /* Negotiate the latest NVSP protocol supported */
499 for (i = num_ver - 1; i >= 0; i--)
500 if (negotiate_nvsp_ver(device, net_device, init_packet,
501 ver_list[i]) == 0) {
502 net_device->nvsp_version = ver_list[i];
503 break;
504 }
505
506 if (i < 0) {
507 ret = -EPROTO;
508 goto cleanup;
509 }
510
511 pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
512
513 /* Send the ndis version */
514 memset(init_packet, 0, sizeof(struct nvsp_message));
515
516 if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4)
517 ndis_version = 0x00060001;
518 else
519 ndis_version = 0x0006001e;
520
521 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
522 init_packet->msg.v1_msg.
523 send_ndis_ver.ndis_major_ver =
524 (ndis_version & 0xFFFF0000) >> 16;
525 init_packet->msg.v1_msg.
526 send_ndis_ver.ndis_minor_ver =
527 ndis_version & 0xFFFF;
528
529 /* Send the init request */
530 ret = vmbus_sendpacket(device->channel, init_packet,
531 sizeof(struct nvsp_message),
532 (unsigned long)init_packet,
533 VM_PKT_DATA_INBAND, 0);
534 if (ret != 0)
535 goto cleanup;
536
537 /* Post the big receive buffer to NetVSP */
538 if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2)
539 net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY;
540 else
541 net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
542 net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE;
543
544 ret = netvsc_init_buf(device);
545
546 cleanup:
547 return ret;
548 }
549
550 static void netvsc_disconnect_vsp(struct hv_device *device)
551 {
552 netvsc_destroy_buf(device);
553 }
554
555 /*
556 * netvsc_device_remove - Callback when the root bus device is removed
557 */
558 int netvsc_device_remove(struct hv_device *device)
559 {
560 struct net_device *ndev = hv_get_drvdata(device);
561 struct net_device_context *net_device_ctx = netdev_priv(ndev);
562 struct netvsc_device *net_device = net_device_ctx->nvdev;
563
564 netvsc_disconnect_vsp(device);
565
566 net_device_ctx->nvdev = NULL;
567
568 /*
569 * At this point, no one should be accessing net_device
570 * except in here
571 */
572 dev_notice(&device->device, "net device safe to remove\n");
573
574 /* Now, we can close the channel safely */
575 vmbus_close(device->channel);
576
577 /* Release all resources */
578 vfree(net_device->sub_cb_buf);
579 free_netvsc_device(net_device);
580 return 0;
581 }
582
583
584 #define RING_AVAIL_PERCENT_HIWATER 20
585 #define RING_AVAIL_PERCENT_LOWATER 10
586
587 /*
588 * Get the percentage of available bytes to write in the ring.
589 * The return value is in range from 0 to 100.
590 */
591 static inline u32 hv_ringbuf_avail_percent(
592 struct hv_ring_buffer_info *ring_info)
593 {
594 u32 avail_read, avail_write;
595
596 hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
597
598 return avail_write * 100 / ring_info->ring_datasize;
599 }
600
601 static inline void netvsc_free_send_slot(struct netvsc_device *net_device,
602 u32 index)
603 {
604 sync_change_bit(index, net_device->send_section_map);
605 }
606
607 static void netvsc_send_completion(struct netvsc_device *net_device,
608 struct vmbus_channel *incoming_channel,
609 struct hv_device *device,
610 struct vmpacket_descriptor *packet)
611 {
612 struct nvsp_message *nvsp_packet;
613 struct hv_netvsc_packet *nvsc_packet;
614 struct net_device *ndev = hv_get_drvdata(device);
615 struct net_device_context *net_device_ctx = netdev_priv(ndev);
616 u32 send_index;
617 struct sk_buff *skb;
618
619 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
620 (packet->offset8 << 3));
621
622 if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
623 (nvsp_packet->hdr.msg_type ==
624 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
625 (nvsp_packet->hdr.msg_type ==
626 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE) ||
627 (nvsp_packet->hdr.msg_type ==
628 NVSP_MSG5_TYPE_SUBCHANNEL)) {
629 /* Copy the response back */
630 memcpy(&net_device->channel_init_pkt, nvsp_packet,
631 sizeof(struct nvsp_message));
632 complete(&net_device->channel_init_wait);
633 } else if (nvsp_packet->hdr.msg_type ==
634 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
635 int num_outstanding_sends;
636 u16 q_idx = 0;
637 struct vmbus_channel *channel = device->channel;
638 int queue_sends;
639
640 /* Get the send context */
641 skb = (struct sk_buff *)(unsigned long)packet->trans_id;
642
643 /* Notify the layer above us */
644 if (skb) {
645 nvsc_packet = (struct hv_netvsc_packet *) skb->cb;
646 send_index = nvsc_packet->send_buf_index;
647 if (send_index != NETVSC_INVALID_INDEX)
648 netvsc_free_send_slot(net_device, send_index);
649 q_idx = nvsc_packet->q_idx;
650 channel = incoming_channel;
651 dev_kfree_skb_any(skb);
652 }
653
654 num_outstanding_sends =
655 atomic_dec_return(&net_device->num_outstanding_sends);
656 queue_sends = atomic_dec_return(&net_device->
657 queue_sends[q_idx]);
658
659 if (net_device->destroy && num_outstanding_sends == 0)
660 wake_up(&net_device->wait_drain);
661
662 if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
663 !net_device_ctx->start_remove &&
664 (hv_ringbuf_avail_percent(&channel->outbound) >
665 RING_AVAIL_PERCENT_HIWATER || queue_sends < 1))
666 netif_tx_wake_queue(netdev_get_tx_queue(
667 ndev, q_idx));
668 } else {
669 netdev_err(ndev, "Unknown send completion packet type- "
670 "%d received!!\n", nvsp_packet->hdr.msg_type);
671 }
672
673 }
674
675 static u32 netvsc_get_next_send_section(struct netvsc_device *net_device)
676 {
677 unsigned long index;
678 u32 max_words = net_device->map_words;
679 unsigned long *map_addr = (unsigned long *)net_device->send_section_map;
680 u32 section_cnt = net_device->send_section_cnt;
681 int ret_val = NETVSC_INVALID_INDEX;
682 int i;
683 int prev_val;
684
685 for (i = 0; i < max_words; i++) {
686 if (!~(map_addr[i]))
687 continue;
688 index = ffz(map_addr[i]);
689 prev_val = sync_test_and_set_bit(index, &map_addr[i]);
690 if (prev_val)
691 continue;
692 if ((index + (i * BITS_PER_LONG)) >= section_cnt)
693 break;
694 ret_val = (index + (i * BITS_PER_LONG));
695 break;
696 }
697 return ret_val;
698 }
699
700 static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device,
701 unsigned int section_index,
702 u32 pend_size,
703 struct hv_netvsc_packet *packet,
704 struct rndis_message *rndis_msg,
705 struct hv_page_buffer **pb,
706 struct sk_buff *skb)
707 {
708 char *start = net_device->send_buf;
709 char *dest = start + (section_index * net_device->send_section_size)
710 + pend_size;
711 int i;
712 bool is_data_pkt = (skb != NULL) ? true : false;
713 bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
714 u32 msg_size = 0;
715 u32 padding = 0;
716 u32 remain = packet->total_data_buflen % net_device->pkt_align;
717 u32 page_count = packet->cp_partial ? packet->rmsg_pgcnt :
718 packet->page_buf_cnt;
719
720 /* Add padding */
721 if (is_data_pkt && xmit_more && remain &&
722 !packet->cp_partial) {
723 padding = net_device->pkt_align - remain;
724 rndis_msg->msg_len += padding;
725 packet->total_data_buflen += padding;
726 }
727
728 for (i = 0; i < page_count; i++) {
729 char *src = phys_to_virt((*pb)[i].pfn << PAGE_SHIFT);
730 u32 offset = (*pb)[i].offset;
731 u32 len = (*pb)[i].len;
732
733 memcpy(dest, (src + offset), len);
734 msg_size += len;
735 dest += len;
736 }
737
738 if (padding) {
739 memset(dest, 0, padding);
740 msg_size += padding;
741 }
742
743 return msg_size;
744 }
745
746 static inline int netvsc_send_pkt(
747 struct hv_device *device,
748 struct hv_netvsc_packet *packet,
749 struct netvsc_device *net_device,
750 struct hv_page_buffer **pb,
751 struct sk_buff *skb)
752 {
753 struct nvsp_message nvmsg;
754 u16 q_idx = packet->q_idx;
755 struct vmbus_channel *out_channel = net_device->chn_table[q_idx];
756 struct net_device *ndev = hv_get_drvdata(device);
757 u64 req_id;
758 int ret;
759 struct hv_page_buffer *pgbuf;
760 u32 ring_avail = hv_ringbuf_avail_percent(&out_channel->outbound);
761 bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
762
763 nvmsg.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
764 if (skb != NULL) {
765 /* 0 is RMC_DATA; */
766 nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 0;
767 } else {
768 /* 1 is RMC_CONTROL; */
769 nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 1;
770 }
771
772 nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
773 packet->send_buf_index;
774 if (packet->send_buf_index == NETVSC_INVALID_INDEX)
775 nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
776 else
777 nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size =
778 packet->total_data_buflen;
779
780 req_id = (ulong)skb;
781
782 if (out_channel->rescind)
783 return -ENODEV;
784
785 /*
786 * It is possible that once we successfully place this packet
787 * on the ringbuffer, we may stop the queue. In that case, we want
788 * to notify the host independent of the xmit_more flag. We don't
789 * need to be precise here; in the worst case we may signal the host
790 * unnecessarily.
791 */
792 if (ring_avail < (RING_AVAIL_PERCENT_LOWATER + 1))
793 xmit_more = false;
794
795 if (packet->page_buf_cnt) {
796 pgbuf = packet->cp_partial ? (*pb) +
797 packet->rmsg_pgcnt : (*pb);
798 ret = vmbus_sendpacket_pagebuffer_ctl(out_channel,
799 pgbuf,
800 packet->page_buf_cnt,
801 &nvmsg,
802 sizeof(struct nvsp_message),
803 req_id,
804 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED,
805 !xmit_more);
806 } else {
807 ret = vmbus_sendpacket_ctl(out_channel, &nvmsg,
808 sizeof(struct nvsp_message),
809 req_id,
810 VM_PKT_DATA_INBAND,
811 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED,
812 !xmit_more);
813 }
814
815 if (ret == 0) {
816 atomic_inc(&net_device->num_outstanding_sends);
817 atomic_inc(&net_device->queue_sends[q_idx]);
818
819 if (ring_avail < RING_AVAIL_PERCENT_LOWATER) {
820 netif_tx_stop_queue(netdev_get_tx_queue(ndev, q_idx));
821
822 if (atomic_read(&net_device->
823 queue_sends[q_idx]) < 1)
824 netif_tx_wake_queue(netdev_get_tx_queue(
825 ndev, q_idx));
826 }
827 } else if (ret == -EAGAIN) {
828 netif_tx_stop_queue(netdev_get_tx_queue(
829 ndev, q_idx));
830 if (atomic_read(&net_device->queue_sends[q_idx]) < 1) {
831 netif_tx_wake_queue(netdev_get_tx_queue(
832 ndev, q_idx));
833 ret = -ENOSPC;
834 }
835 } else {
836 netdev_err(ndev, "Unable to send packet %p ret %d\n",
837 packet, ret);
838 }
839
840 return ret;
841 }
842
843 /* Move packet out of multi send data (msd), and clear msd */
844 static inline void move_pkt_msd(struct hv_netvsc_packet **msd_send,
845 struct sk_buff **msd_skb,
846 struct multi_send_data *msdp)
847 {
848 *msd_skb = msdp->skb;
849 *msd_send = msdp->pkt;
850 msdp->skb = NULL;
851 msdp->pkt = NULL;
852 msdp->count = 0;
853 }
854
855 int netvsc_send(struct hv_device *device,
856 struct hv_netvsc_packet *packet,
857 struct rndis_message *rndis_msg,
858 struct hv_page_buffer **pb,
859 struct sk_buff *skb)
860 {
861 struct netvsc_device *net_device;
862 int ret = 0, m_ret = 0;
863 struct vmbus_channel *out_channel;
864 u16 q_idx = packet->q_idx;
865 u32 pktlen = packet->total_data_buflen, msd_len = 0;
866 unsigned int section_index = NETVSC_INVALID_INDEX;
867 struct multi_send_data *msdp;
868 struct hv_netvsc_packet *msd_send = NULL, *cur_send = NULL;
869 struct sk_buff *msd_skb = NULL;
870 bool try_batch;
871 bool xmit_more = (skb != NULL) ? skb->xmit_more : false;
872
873 net_device = get_outbound_net_device(device);
874 if (!net_device)
875 return -ENODEV;
876
877 out_channel = net_device->chn_table[q_idx];
878
879 packet->send_buf_index = NETVSC_INVALID_INDEX;
880 packet->cp_partial = false;
881
882 /* Send control message directly without accessing msd (Multi-Send
883 * Data) field which may be changed during data packet processing.
884 */
885 if (!skb) {
886 cur_send = packet;
887 goto send_now;
888 }
889
890 msdp = &net_device->msd[q_idx];
891
892 /* batch packets in send buffer if possible */
893 if (msdp->pkt)
894 msd_len = msdp->pkt->total_data_buflen;
895
896 try_batch = (skb != NULL) && msd_len > 0 && msdp->count <
897 net_device->max_pkt;
898
899 if (try_batch && msd_len + pktlen + net_device->pkt_align <
900 net_device->send_section_size) {
901 section_index = msdp->pkt->send_buf_index;
902
903 } else if (try_batch && msd_len + packet->rmsg_size <
904 net_device->send_section_size) {
905 section_index = msdp->pkt->send_buf_index;
906 packet->cp_partial = true;
907
908 } else if ((skb != NULL) && pktlen + net_device->pkt_align <
909 net_device->send_section_size) {
910 section_index = netvsc_get_next_send_section(net_device);
911 if (section_index != NETVSC_INVALID_INDEX) {
912 move_pkt_msd(&msd_send, &msd_skb, msdp);
913 msd_len = 0;
914 }
915 }
916
917 if (section_index != NETVSC_INVALID_INDEX) {
918 netvsc_copy_to_send_buf(net_device,
919 section_index, msd_len,
920 packet, rndis_msg, pb, skb);
921
922 packet->send_buf_index = section_index;
923
924 if (packet->cp_partial) {
925 packet->page_buf_cnt -= packet->rmsg_pgcnt;
926 packet->total_data_buflen = msd_len + packet->rmsg_size;
927 } else {
928 packet->page_buf_cnt = 0;
929 packet->total_data_buflen += msd_len;
930 }
931
932 if (msdp->skb)
933 dev_kfree_skb_any(msdp->skb);
934
935 if (xmit_more && !packet->cp_partial) {
936 msdp->skb = skb;
937 msdp->pkt = packet;
938 msdp->count++;
939 } else {
940 cur_send = packet;
941 msdp->skb = NULL;
942 msdp->pkt = NULL;
943 msdp->count = 0;
944 }
945 } else {
946 move_pkt_msd(&msd_send, &msd_skb, msdp);
947 cur_send = packet;
948 }
949
950 if (msd_send) {
951 m_ret = netvsc_send_pkt(device, msd_send, net_device,
952 NULL, msd_skb);
953
954 if (m_ret != 0) {
955 netvsc_free_send_slot(net_device,
956 msd_send->send_buf_index);
957 dev_kfree_skb_any(msd_skb);
958 }
959 }
960
961 send_now:
962 if (cur_send)
963 ret = netvsc_send_pkt(device, cur_send, net_device, pb, skb);
964
965 if (ret != 0 && section_index != NETVSC_INVALID_INDEX)
966 netvsc_free_send_slot(net_device, section_index);
967
968 return ret;
969 }
970
971 static void netvsc_send_recv_completion(struct hv_device *device,
972 struct vmbus_channel *channel,
973 struct netvsc_device *net_device,
974 u64 transaction_id, u32 status)
975 {
976 struct nvsp_message recvcompMessage;
977 int retries = 0;
978 int ret;
979 struct net_device *ndev = hv_get_drvdata(device);
980
981 recvcompMessage.hdr.msg_type =
982 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
983
984 recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
985
986 retry_send_cmplt:
987 /* Send the completion */
988 ret = vmbus_sendpacket(channel, &recvcompMessage,
989 sizeof(struct nvsp_message), transaction_id,
990 VM_PKT_COMP, 0);
991 if (ret == 0) {
992 /* success */
993 /* no-op */
994 } else if (ret == -EAGAIN) {
995 /* no more room...wait a bit and attempt to retry 3 times */
996 retries++;
997 netdev_err(ndev, "unable to send receive completion pkt"
998 " (tid %llx)...retrying %d\n", transaction_id, retries);
999
1000 if (retries < 4) {
1001 udelay(100);
1002 goto retry_send_cmplt;
1003 } else {
1004 netdev_err(ndev, "unable to send receive "
1005 "completion pkt (tid %llx)...give up retrying\n",
1006 transaction_id);
1007 }
1008 } else {
1009 netdev_err(ndev, "unable to send receive "
1010 "completion pkt - %llx\n", transaction_id);
1011 }
1012 }
1013
1014 static void netvsc_receive(struct netvsc_device *net_device,
1015 struct vmbus_channel *channel,
1016 struct hv_device *device,
1017 struct vmpacket_descriptor *packet)
1018 {
1019 struct vmtransfer_page_packet_header *vmxferpage_packet;
1020 struct nvsp_message *nvsp_packet;
1021 struct hv_netvsc_packet nv_pkt;
1022 struct hv_netvsc_packet *netvsc_packet = &nv_pkt;
1023 u32 status = NVSP_STAT_SUCCESS;
1024 int i;
1025 int count = 0;
1026 struct net_device *ndev = hv_get_drvdata(device);
1027 void *data;
1028
1029 /*
1030 * All inbound packets other than send completion should be xfer page
1031 * packet
1032 */
1033 if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
1034 netdev_err(ndev, "Unknown packet type received - %d\n",
1035 packet->type);
1036 return;
1037 }
1038
1039 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
1040 (packet->offset8 << 3));
1041
1042 /* Make sure this is a valid nvsp packet */
1043 if (nvsp_packet->hdr.msg_type !=
1044 NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
1045 netdev_err(ndev, "Unknown nvsp packet type received-"
1046 " %d\n", nvsp_packet->hdr.msg_type);
1047 return;
1048 }
1049
1050 vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
1051
1052 if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
1053 netdev_err(ndev, "Invalid xfer page set id - "
1054 "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
1055 vmxferpage_packet->xfer_pageset_id);
1056 return;
1057 }
1058
1059 count = vmxferpage_packet->range_cnt;
1060
1061 /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
1062 for (i = 0; i < count; i++) {
1063 /* Initialize the netvsc packet */
1064 data = (void *)((unsigned long)net_device->
1065 recv_buf + vmxferpage_packet->ranges[i].byte_offset);
1066 netvsc_packet->total_data_buflen =
1067 vmxferpage_packet->ranges[i].byte_count;
1068
1069 /* Pass it to the upper layer */
1070 status = rndis_filter_receive(device, netvsc_packet, &data,
1071 channel);
1072
1073 }
1074
1075 netvsc_send_recv_completion(device, channel, net_device,
1076 vmxferpage_packet->d.trans_id, status);
1077 }
1078
1079
1080 static void netvsc_send_table(struct hv_device *hdev,
1081 struct nvsp_message *nvmsg)
1082 {
1083 struct netvsc_device *nvscdev;
1084 struct net_device *ndev = hv_get_drvdata(hdev);
1085 int i;
1086 u32 count, *tab;
1087
1088 nvscdev = get_outbound_net_device(hdev);
1089 if (!nvscdev)
1090 return;
1091
1092 count = nvmsg->msg.v5_msg.send_table.count;
1093 if (count != VRSS_SEND_TAB_SIZE) {
1094 netdev_err(ndev, "Received wrong send-table size:%u\n", count);
1095 return;
1096 }
1097
1098 tab = (u32 *)((unsigned long)&nvmsg->msg.v5_msg.send_table +
1099 nvmsg->msg.v5_msg.send_table.offset);
1100
1101 for (i = 0; i < count; i++)
1102 nvscdev->send_table[i] = tab[i];
1103 }
1104
1105 static void netvsc_send_vf(struct net_device_context *net_device_ctx,
1106 struct nvsp_message *nvmsg)
1107 {
1108 net_device_ctx->vf_alloc = nvmsg->msg.v4_msg.vf_assoc.allocated;
1109 net_device_ctx->vf_serial = nvmsg->msg.v4_msg.vf_assoc.serial;
1110 }
1111
1112 static inline void netvsc_receive_inband(struct hv_device *hdev,
1113 struct net_device_context *net_device_ctx,
1114 struct nvsp_message *nvmsg)
1115 {
1116 switch (nvmsg->hdr.msg_type) {
1117 case NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE:
1118 netvsc_send_table(hdev, nvmsg);
1119 break;
1120
1121 case NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION:
1122 netvsc_send_vf(net_device_ctx, nvmsg);
1123 break;
1124 }
1125 }
1126
1127 static void netvsc_process_raw_pkt(struct hv_device *device,
1128 struct vmbus_channel *channel,
1129 struct netvsc_device *net_device,
1130 struct net_device *ndev,
1131 u64 request_id,
1132 struct vmpacket_descriptor *desc)
1133 {
1134 struct nvsp_message *nvmsg;
1135 struct net_device_context *net_device_ctx = netdev_priv(ndev);
1136
1137 nvmsg = (struct nvsp_message *)((unsigned long)
1138 desc + (desc->offset8 << 3));
1139
1140 switch (desc->type) {
1141 case VM_PKT_COMP:
1142 netvsc_send_completion(net_device, channel, device, desc);
1143 break;
1144
1145 case VM_PKT_DATA_USING_XFER_PAGES:
1146 netvsc_receive(net_device, channel, device, desc);
1147 break;
1148
1149 case VM_PKT_DATA_INBAND:
1150 netvsc_receive_inband(device, net_device_ctx, nvmsg);
1151 break;
1152
1153 default:
1154 netdev_err(ndev, "unhandled packet type %d, tid %llx\n",
1155 desc->type, request_id);
1156 break;
1157 }
1158 }
1159
1160
1161 void netvsc_channel_cb(void *context)
1162 {
1163 int ret;
1164 struct vmbus_channel *channel = (struct vmbus_channel *)context;
1165 struct hv_device *device;
1166 struct netvsc_device *net_device;
1167 u32 bytes_recvd;
1168 u64 request_id;
1169 struct vmpacket_descriptor *desc;
1170 unsigned char *buffer;
1171 int bufferlen = NETVSC_PACKET_SIZE;
1172 struct net_device *ndev;
1173 bool need_to_commit = false;
1174
1175 if (channel->primary_channel != NULL)
1176 device = channel->primary_channel->device_obj;
1177 else
1178 device = channel->device_obj;
1179
1180 net_device = get_inbound_net_device(device);
1181 if (!net_device)
1182 return;
1183 ndev = hv_get_drvdata(device);
1184 buffer = get_per_channel_state(channel);
1185
1186 do {
1187 desc = get_next_pkt_raw(channel);
1188 if (desc != NULL) {
1189 netvsc_process_raw_pkt(device,
1190 channel,
1191 net_device,
1192 ndev,
1193 desc->trans_id,
1194 desc);
1195
1196 put_pkt_raw(channel, desc);
1197 need_to_commit = true;
1198 continue;
1199 }
1200 if (need_to_commit) {
1201 need_to_commit = false;
1202 commit_rd_index(channel);
1203 }
1204
1205 ret = vmbus_recvpacket_raw(channel, buffer, bufferlen,
1206 &bytes_recvd, &request_id);
1207 if (ret == 0) {
1208 if (bytes_recvd > 0) {
1209 desc = (struct vmpacket_descriptor *)buffer;
1210 netvsc_process_raw_pkt(device,
1211 channel,
1212 net_device,
1213 ndev,
1214 request_id,
1215 desc);
1216
1217
1218 } else {
1219 /*
1220 * We are done for this pass.
1221 */
1222 break;
1223 }
1224
1225 } else if (ret == -ENOBUFS) {
1226 if (bufferlen > NETVSC_PACKET_SIZE)
1227 kfree(buffer);
1228 /* Handle large packet */
1229 buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
1230 if (buffer == NULL) {
1231 /* Try again next time around */
1232 netdev_err(ndev,
1233 "unable to allocate buffer of size "
1234 "(%d)!!\n", bytes_recvd);
1235 break;
1236 }
1237
1238 bufferlen = bytes_recvd;
1239 }
1240 } while (1);
1241
1242 if (bufferlen > NETVSC_PACKET_SIZE)
1243 kfree(buffer);
1244 return;
1245 }
1246
1247 /*
1248 * netvsc_device_add - Callback when the device belonging to this
1249 * driver is added
1250 */
1251 int netvsc_device_add(struct hv_device *device, void *additional_info)
1252 {
1253 int i, ret = 0;
1254 int ring_size =
1255 ((struct netvsc_device_info *)additional_info)->ring_size;
1256 struct netvsc_device *net_device;
1257 struct net_device *ndev = hv_get_drvdata(device);
1258 struct net_device_context *net_device_ctx = netdev_priv(ndev);
1259
1260 net_device = alloc_net_device();
1261 if (!net_device)
1262 return -ENOMEM;
1263
1264 net_device->ring_size = ring_size;
1265
1266 /* Initialize the NetVSC channel extension */
1267 init_completion(&net_device->channel_init_wait);
1268
1269 set_per_channel_state(device->channel, net_device->cb_buffer);
1270
1271 /* Open the channel */
1272 ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
1273 ring_size * PAGE_SIZE, NULL, 0,
1274 netvsc_channel_cb, device->channel);
1275
1276 if (ret != 0) {
1277 netdev_err(ndev, "unable to open channel: %d\n", ret);
1278 goto cleanup;
1279 }
1280
1281 /* Channel is opened */
1282 pr_info("hv_netvsc channel opened successfully\n");
1283
1284 /* If we're reopening the device we may have multiple queues, fill the
1285 * chn_table with the default channel to use it before subchannels are
1286 * opened.
1287 */
1288 for (i = 0; i < VRSS_CHANNEL_MAX; i++)
1289 net_device->chn_table[i] = device->channel;
1290
1291 /* Writing nvdev pointer unlocks netvsc_send(), make sure chn_table is
1292 * populated.
1293 */
1294 wmb();
1295
1296 net_device_ctx->nvdev = net_device;
1297
1298 /* Connect with the NetVsp */
1299 ret = netvsc_connect_vsp(device);
1300 if (ret != 0) {
1301 netdev_err(ndev,
1302 "unable to connect to NetVSP - %d\n", ret);
1303 goto close;
1304 }
1305
1306 return ret;
1307
1308 close:
1309 /* Now, we can close the channel safely */
1310 vmbus_close(device->channel);
1311
1312 cleanup:
1313 free_netvsc_device(net_device);
1314
1315 return ret;
1316 }
Linux kernel - Deliverables
This page took 0.099614 seconds and 5 git commands to generate.