update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/hv/channel.c
..
..
@@ -1,18 +1,6 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * 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, write to the Free Software Foundation, Inc., 59 Temple
15
- * Place - Suite 330, Boston, MA 02111-1307 USA.
16
4
  *
17
5
  * Authors:
18
6
  *   Haiyang Zhang <haiyangz@microsoft.com>
..
..
@@ -30,23 +18,101 @@
30
18
 #include <linux/uio.h>
31
19
 #include <linux/interrupt.h>
32
20
 #include <asm/page.h>
21
+#include <asm/mshyperv.h>
33
22
 
34
23
 #include "hyperv_vmbus.h"
35
24
 
36
-#define NUM_PAGES_SPANNED(addr, len) \
37
-((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT))
38
-
39
-static unsigned long virt_to_hvpfn(void *addr)
25
+/*
26
+ * hv_gpadl_size - Return the real size of a gpadl, the size that Hyper-V uses
27
+ *
28
+ * For BUFFER gpadl, Hyper-V uses the exact same size as the guest does.
29
+ *
30
+ * For RING gpadl, in each ring, the guest uses one PAGE_SIZE as the header
31
+ * (because of the alignment requirement), however, the hypervisor only
32
+ * uses the first HV_HYP_PAGE_SIZE as the header, therefore leaving a
33
+ * (PAGE_SIZE - HV_HYP_PAGE_SIZE) gap. And since there are two rings in a
34
+ * ringbuffer, the total size for a RING gpadl that Hyper-V uses is the
35
+ * total size that the guest uses minus twice of the gap size.
36
+ */
37
+static inline u32 hv_gpadl_size(enum hv_gpadl_type type, u32 size)
40
38
 {
41
-	phys_addr_t paddr;
39
+	switch (type) {
40
+	case HV_GPADL_BUFFER:
41
+		return size;
42
+	case HV_GPADL_RING:
43
+		/* The size of a ringbuffer must be page-aligned */
44
+		BUG_ON(size % PAGE_SIZE);
45
+		/*
46
+		 * Two things to notice here:
47
+		 * 1) We're processing two ring buffers as a unit
48
+		 * 2) We're skipping any space larger than HV_HYP_PAGE_SIZE in
49
+		 * the first guest-size page of each of the two ring buffers.
50
+		 * So we effectively subtract out two guest-size pages, and add
51
+		 * back two Hyper-V size pages.
52
+		 */
53
+		return size - 2 * (PAGE_SIZE - HV_HYP_PAGE_SIZE);
54
+	}
55
+	BUG();
56
+	return 0;
57
+}
42
58
 
43
-	if (is_vmalloc_addr(addr))
44
-		paddr = page_to_phys(vmalloc_to_page(addr)) +
45
-					 offset_in_page(addr);
46
-	else
47
-		paddr = __pa(addr);
59
+/*
60
+ * hv_ring_gpadl_send_hvpgoffset - Calculate the send offset (in unit of
61
+ *                                 HV_HYP_PAGE) in a ring gpadl based on the
62
+ *                                 offset in the guest
63
+ *
64
+ * @offset: the offset (in bytes) where the send ringbuffer starts in the
65
+ *               virtual address space of the guest
66
+ */
67
+static inline u32 hv_ring_gpadl_send_hvpgoffset(u32 offset)
68
+{
48
69
 
49
-	return  paddr >> PAGE_SHIFT;
70
+	/*
71
+	 * For RING gpadl, in each ring, the guest uses one PAGE_SIZE as the
72
+	 * header (because of the alignment requirement), however, the
73
+	 * hypervisor only uses the first HV_HYP_PAGE_SIZE as the header,
74
+	 * therefore leaving a (PAGE_SIZE - HV_HYP_PAGE_SIZE) gap.
75
+	 *
76
+	 * And to calculate the effective send offset in gpadl, we need to
77
+	 * substract this gap.
78
+	 */
79
+	return (offset - (PAGE_SIZE - HV_HYP_PAGE_SIZE)) >> HV_HYP_PAGE_SHIFT;
80
+}
81
+
82
+/*
83
+ * hv_gpadl_hvpfn - Return the Hyper-V page PFN of the @i th Hyper-V page in
84
+ *                  the gpadl
85
+ *
86
+ * @type: the type of the gpadl
87
+ * @kbuffer: the pointer to the gpadl in the guest
88
+ * @size: the total size (in bytes) of the gpadl
89
+ * @send_offset: the offset (in bytes) where the send ringbuffer starts in the
90
+ *               virtual address space of the guest
91
+ * @i: the index
92
+ */
93
+static inline u64 hv_gpadl_hvpfn(enum hv_gpadl_type type, void *kbuffer,
94
+				 u32 size, u32 send_offset, int i)
95
+{
96
+	int send_idx = hv_ring_gpadl_send_hvpgoffset(send_offset);
97
+	unsigned long delta = 0UL;
98
+
99
+	switch (type) {
100
+	case HV_GPADL_BUFFER:
101
+		break;
102
+	case HV_GPADL_RING:
103
+		if (i == 0)
104
+			delta = 0;
105
+		else if (i <= send_idx)
106
+			delta = PAGE_SIZE - HV_HYP_PAGE_SIZE;
107
+		else
108
+			delta = 2 * (PAGE_SIZE - HV_HYP_PAGE_SIZE);
109
+		break;
110
+	default:
111
+		BUG();
112
+		break;
113
+	}
114
+
115
+	return virt_to_hvpfn(kbuffer + delta + (HV_HYP_PAGE_SIZE * i));
50
116
 }
51
117
 
52
118
 /*
..
..
@@ -79,175 +145,53 @@
79
145
 }
80
146
 EXPORT_SYMBOL_GPL(vmbus_setevent);
81
147
 
82
-/*
83
- * vmbus_open - Open the specified channel.
84
- */
85
-int vmbus_open(struct vmbus_channel *newchannel, u32 send_ringbuffer_size,
86
-		     u32 recv_ringbuffer_size, void *userdata, u32 userdatalen,
87
-		     void (*onchannelcallback)(void *context), void *context)
148
+/* vmbus_free_ring - drop mapping of ring buffer */
149
+void vmbus_free_ring(struct vmbus_channel *channel)
88
150
 {
89
-	struct vmbus_channel_open_channel *open_msg;
90
-	struct vmbus_channel_msginfo *open_info = NULL;
91
-	unsigned long flags;
92
-	int ret, err = 0;
93
-	struct page *page;
94
-	unsigned int order;
151
+	hv_ringbuffer_cleanup(&channel->outbound);
152
+	hv_ringbuffer_cleanup(&channel->inbound);
95
153
 
96
-	if (send_ringbuffer_size % PAGE_SIZE ||
97
-	    recv_ringbuffer_size % PAGE_SIZE)
98
-		return -EINVAL;
99
-
100
-	order = get_order(send_ringbuffer_size + recv_ringbuffer_size);
101
-
102
-	spin_lock_irqsave(&newchannel->lock, flags);
103
-	if (newchannel->state == CHANNEL_OPEN_STATE) {
104
-		newchannel->state = CHANNEL_OPENING_STATE;
105
-	} else {
106
-		spin_unlock_irqrestore(&newchannel->lock, flags);
107
-		return -EINVAL;
154
+	if (channel->ringbuffer_page) {
155
+		__free_pages(channel->ringbuffer_page,
156
+			     get_order(channel->ringbuffer_pagecount
157
+				       << PAGE_SHIFT));
158
+		channel->ringbuffer_page = NULL;
108
159
 	}
109
-	spin_unlock_irqrestore(&newchannel->lock, flags);
160
+}
161
+EXPORT_SYMBOL_GPL(vmbus_free_ring);
110
162
 
111
-	newchannel->onchannel_callback = onchannelcallback;
112
-	newchannel->channel_callback_context = context;
163
+/* vmbus_alloc_ring - allocate and map pages for ring buffer */
164
+int vmbus_alloc_ring(struct vmbus_channel *newchannel,
165
+		     u32 send_size, u32 recv_size)
166
+{
167
+	struct page *page;
168
+	int order;
169
+
170
+	if (send_size % PAGE_SIZE || recv_size % PAGE_SIZE)
171
+		return -EINVAL;
113
172
 
114
173
 	/* Allocate the ring buffer */
174
+	order = get_order(send_size + recv_size);
115
175
 	page = alloc_pages_node(cpu_to_node(newchannel->target_cpu),
116
176
 				GFP_KERNEL|__GFP_ZERO, order);
117
177
 
118
178
 	if (!page)
119
179
 		page = alloc_pages(GFP_KERNEL|__GFP_ZERO, order);
120
180
 
121
-	if (!page) {
122
-		err = -ENOMEM;
123
-		goto error_set_chnstate;
124
-	}
181
+	if (!page)
182
+		return -ENOMEM;
125
183
 
126
184
 	newchannel->ringbuffer_page = page;
127
-	newchannel->ringbuffer_pagecount = (send_ringbuffer_size +
128
-					   recv_ringbuffer_size) >> PAGE_SHIFT;
185
+	newchannel->ringbuffer_pagecount = (send_size + recv_size) >> PAGE_SHIFT;
186
+	newchannel->ringbuffer_send_offset = send_size >> PAGE_SHIFT;
129
187
 
130
-	ret = hv_ringbuffer_init(&newchannel->outbound, page,
131
-				 send_ringbuffer_size >> PAGE_SHIFT);
132
-
133
-	if (ret != 0) {
134
-		err = ret;
135
-		goto error_free_pages;
136
-	}
137
-
138
-	ret = hv_ringbuffer_init(&newchannel->inbound,
139
-				 &page[send_ringbuffer_size >> PAGE_SHIFT],
140
-				 recv_ringbuffer_size >> PAGE_SHIFT);
141
-	if (ret != 0) {
142
-		err = ret;
143
-		goto error_free_pages;
144
-	}
145
-
146
-
147
-	/* Establish the gpadl for the ring buffer */
148
-	newchannel->ringbuffer_gpadlhandle = 0;
149
-
150
-	ret = vmbus_establish_gpadl(newchannel,
151
-				    page_address(page),
152
-				    send_ringbuffer_size +
153
-				    recv_ringbuffer_size,
154
-				    &newchannel->ringbuffer_gpadlhandle);
155
-
156
-	if (ret != 0) {
157
-		err = ret;
158
-		goto error_free_pages;
159
-	}
160
-
161
-	/* Create and init the channel open message */
162
-	open_info = kmalloc(sizeof(*open_info) +
163
-			   sizeof(struct vmbus_channel_open_channel),
164
-			   GFP_KERNEL);
165
-	if (!open_info) {
166
-		err = -ENOMEM;
167
-		goto error_free_gpadl;
168
-	}
169
-
170
-	init_completion(&open_info->waitevent);
171
-	open_info->waiting_channel = newchannel;
172
-
173
-	open_msg = (struct vmbus_channel_open_channel *)open_info->msg;
174
-	open_msg->header.msgtype = CHANNELMSG_OPENCHANNEL;
175
-	open_msg->openid = newchannel->offermsg.child_relid;
176
-	open_msg->child_relid = newchannel->offermsg.child_relid;
177
-	open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle;
178
-	open_msg->downstream_ringbuffer_pageoffset = send_ringbuffer_size >>
179
-						  PAGE_SHIFT;
180
-	open_msg->target_vp = newchannel->target_vp;
181
-
182
-	if (userdatalen > MAX_USER_DEFINED_BYTES) {
183
-		err = -EINVAL;
184
-		goto error_free_gpadl;
185
-	}
186
-
187
-	if (userdatalen)
188
-		memcpy(open_msg->userdata, userdata, userdatalen);
189
-
190
-	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
191
-	list_add_tail(&open_info->msglistentry,
192
-		      &vmbus_connection.chn_msg_list);
193
-	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
194
-
195
-	if (newchannel->rescind) {
196
-		err = -ENODEV;
197
-		goto error_free_gpadl;
198
-	}
199
-
200
-	ret = vmbus_post_msg(open_msg,
201
-			     sizeof(struct vmbus_channel_open_channel), true);
202
-
203
-	trace_vmbus_open(open_msg, ret);
204
-
205
-	if (ret != 0) {
206
-		err = ret;
207
-		goto error_clean_msglist;
208
-	}
209
-
210
-	wait_for_completion(&open_info->waitevent);
211
-
212
-	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
213
-	list_del(&open_info->msglistentry);
214
-	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
215
-
216
-	if (newchannel->rescind) {
217
-		err = -ENODEV;
218
-		goto error_free_gpadl;
219
-	}
220
-
221
-	if (open_info->response.open_result.status) {
222
-		err = -EAGAIN;
223
-		goto error_free_gpadl;
224
-	}
225
-
226
-	newchannel->state = CHANNEL_OPENED_STATE;
227
-	kfree(open_info);
228
188
 	return 0;
229
-
230
-error_clean_msglist:
231
-	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
232
-	list_del(&open_info->msglistentry);
233
-	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
234
-
235
-error_free_gpadl:
236
-	vmbus_teardown_gpadl(newchannel, newchannel->ringbuffer_gpadlhandle);
237
-	kfree(open_info);
238
-error_free_pages:
239
-	hv_ringbuffer_cleanup(&newchannel->outbound);
240
-	hv_ringbuffer_cleanup(&newchannel->inbound);
241
-	__free_pages(page, order);
242
-error_set_chnstate:
243
-	newchannel->state = CHANNEL_OPEN_STATE;
244
-	return err;
245
189
 }
246
-EXPORT_SYMBOL_GPL(vmbus_open);
190
+EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
247
191
 
248
192
 /* Used for Hyper-V Socket: a guest client's connect() to the host */
249
-int vmbus_send_tl_connect_request(const uuid_le *shv_guest_servie_id,
250
-				  const uuid_le *shv_host_servie_id)
193
+int vmbus_send_tl_connect_request(const guid_t *shv_guest_servie_id,
194
+				  const guid_t *shv_host_servie_id)
251
195
 {
252
196
 	struct vmbus_channel_tl_connect_request conn_msg;
253
197
 	int ret;
..
..
@@ -266,9 +210,38 @@
266
210
 EXPORT_SYMBOL_GPL(vmbus_send_tl_connect_request);
267
211
 
268
212
 /*
213
+ * Set/change the vCPU (@target_vp) the channel (@child_relid) will interrupt.
214
+ *
215
+ * CHANNELMSG_MODIFYCHANNEL messages are aynchronous.  Also, Hyper-V does not
216
+ * ACK such messages.  IOW we can't know when the host will stop interrupting
217
+ * the "old" vCPU and start interrupting the "new" vCPU for the given channel.
218
+ *
219
+ * The CHANNELMSG_MODIFYCHANNEL message type is supported since VMBus version
220
+ * VERSION_WIN10_V4_1.
221
+ */
222
+int vmbus_send_modifychannel(u32 child_relid, u32 target_vp)
223
+{
224
+	struct vmbus_channel_modifychannel conn_msg;
225
+	int ret;
226
+
227
+	memset(&conn_msg, 0, sizeof(conn_msg));
228
+	conn_msg.header.msgtype = CHANNELMSG_MODIFYCHANNEL;
229
+	conn_msg.child_relid = child_relid;
230
+	conn_msg.target_vp = target_vp;
231
+
232
+	ret = vmbus_post_msg(&conn_msg, sizeof(conn_msg), true);
233
+
234
+	trace_vmbus_send_modifychannel(&conn_msg, ret);
235
+
236
+	return ret;
237
+}
238
+EXPORT_SYMBOL_GPL(vmbus_send_modifychannel);
239
+
240
+/*
269
241
  * create_gpadl_header - Creates a gpadl for the specified buffer
270
242
  */
271
-static int create_gpadl_header(void *kbuffer, u32 size,
243
+static int create_gpadl_header(enum hv_gpadl_type type, void *kbuffer,
244
+			       u32 size, u32 send_offset,
272
245
 			       struct vmbus_channel_msginfo **msginfo)
273
246
 {
274
247
 	int i;
..
..
@@ -281,7 +254,7 @@
281
254
 
282
255
 	int pfnsum, pfncount, pfnleft, pfncurr, pfnsize;
283
256
 
284
-	pagecount = size >> PAGE_SHIFT;
257
+	pagecount = hv_gpadl_size(type, size) >> HV_HYP_PAGE_SHIFT;
285
258
 
286
259
 	/* do we need a gpadl body msg */
287
260
 	pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
..
..
@@ -308,10 +281,10 @@
308
281
 		gpadl_header->range_buflen = sizeof(struct gpa_range) +
309
282
 					 pagecount * sizeof(u64);
310
283
 		gpadl_header->range[0].byte_offset = 0;
311
-		gpadl_header->range[0].byte_count = size;
284
+		gpadl_header->range[0].byte_count = hv_gpadl_size(type, size);
312
285
 		for (i = 0; i < pfncount; i++)
313
-			gpadl_header->range[0].pfn_array[i] = virt_to_hvpfn(
314
-				kbuffer + PAGE_SIZE * i);
286
+			gpadl_header->range[0].pfn_array[i] = hv_gpadl_hvpfn(
287
+				type, kbuffer, size, send_offset, i);
315
288
 		*msginfo = msgheader;
316
289
 
317
290
 		pfnsum = pfncount;
..
..
@@ -362,8 +335,8 @@
362
335
 			 * so the hypervisor guarantees that this is ok.
363
336
 			 */
364
337
 			for (i = 0; i < pfncurr; i++)
365
-				gpadl_body->pfn[i] = virt_to_hvpfn(
366
-					kbuffer + PAGE_SIZE * (pfnsum + i));
338
+				gpadl_body->pfn[i] = hv_gpadl_hvpfn(type,
339
+					kbuffer, size, send_offset, pfnsum + i);
367
340
 
368
341
 			/* add to msg header */
369
342
 			list_add_tail(&msgbody->msglistentry,
..
..
@@ -389,10 +362,10 @@
389
362
 		gpadl_header->range_buflen = sizeof(struct gpa_range) +
390
363
 					 pagecount * sizeof(u64);
391
364
 		gpadl_header->range[0].byte_offset = 0;
392
-		gpadl_header->range[0].byte_count = size;
365
+		gpadl_header->range[0].byte_count = hv_gpadl_size(type, size);
393
366
 		for (i = 0; i < pagecount; i++)
394
-			gpadl_header->range[0].pfn_array[i] = virt_to_hvpfn(
395
-				kbuffer + PAGE_SIZE * i);
367
+			gpadl_header->range[0].pfn_array[i] = hv_gpadl_hvpfn(
368
+				type, kbuffer, size, send_offset, i);
396
369
 
397
370
 		*msginfo = msgheader;
398
371
 	}
..
..
@@ -405,15 +378,20 @@
405
378
 }
406
379
 
407
380
 /*
408
- * vmbus_establish_gpadl - Establish a GPADL for the specified buffer
381
+ * __vmbus_establish_gpadl - Establish a GPADL for a buffer or ringbuffer
409
382
  *
410
383
  * @channel: a channel
384
+ * @type: the type of the corresponding GPADL, only meaningful for the guest.
411
385
  * @kbuffer: from kmalloc or vmalloc
412
386
  * @size: page-size multiple
387
+ * @send_offset: the offset (in bytes) where the send ring buffer starts,
388
+ * 		 should be 0 for BUFFER type gpadl
413
389
  * @gpadl_handle: some funky thing
414
390
  */
415
-int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer,
416
-			       u32 size, u32 *gpadl_handle)
391
+static int __vmbus_establish_gpadl(struct vmbus_channel *channel,
392
+				   enum hv_gpadl_type type, void *kbuffer,
393
+				   u32 size, u32 send_offset,
394
+				   u32 *gpadl_handle)
417
395
 {
418
396
 	struct vmbus_channel_gpadl_header *gpadlmsg;
419
397
 	struct vmbus_channel_gpadl_body *gpadl_body;
..
..
@@ -427,7 +405,7 @@
427
405
 	next_gpadl_handle =
428
406
 		(atomic_inc_return(&vmbus_connection.next_gpadl_handle) - 1);
429
407
 
430
-	ret = create_gpadl_header(kbuffer, size, &msginfo);
408
+	ret = create_gpadl_header(type, kbuffer, size, send_offset, &msginfo);
431
409
 	if (ret)
432
410
 		return ret;
433
411
 
..
..
@@ -508,7 +486,183 @@
508
486
 	kfree(msginfo);
509
487
 	return ret;
510
488
 }
489
+
490
+/*
491
+ * vmbus_establish_gpadl - Establish a GPADL for the specified buffer
492
+ *
493
+ * @channel: a channel
494
+ * @kbuffer: from kmalloc or vmalloc
495
+ * @size: page-size multiple
496
+ * @gpadl_handle: some funky thing
497
+ */
498
+int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer,
499
+			  u32 size, u32 *gpadl_handle)
500
+{
501
+	return __vmbus_establish_gpadl(channel, HV_GPADL_BUFFER, kbuffer, size,
502
+				       0U, gpadl_handle);
503
+}
511
504
 EXPORT_SYMBOL_GPL(vmbus_establish_gpadl);
505
+
506
+static int __vmbus_open(struct vmbus_channel *newchannel,
507
+		       void *userdata, u32 userdatalen,
508
+		       void (*onchannelcallback)(void *context), void *context)
509
+{
510
+	struct vmbus_channel_open_channel *open_msg;
511
+	struct vmbus_channel_msginfo *open_info = NULL;
512
+	struct page *page = newchannel->ringbuffer_page;
513
+	u32 send_pages, recv_pages;
514
+	unsigned long flags;
515
+	int err;
516
+
517
+	if (userdatalen > MAX_USER_DEFINED_BYTES)
518
+		return -EINVAL;
519
+
520
+	send_pages = newchannel->ringbuffer_send_offset;
521
+	recv_pages = newchannel->ringbuffer_pagecount - send_pages;
522
+
523
+	if (newchannel->state != CHANNEL_OPEN_STATE)
524
+		return -EINVAL;
525
+
526
+	newchannel->state = CHANNEL_OPENING_STATE;
527
+	newchannel->onchannel_callback = onchannelcallback;
528
+	newchannel->channel_callback_context = context;
529
+
530
+	err = hv_ringbuffer_init(&newchannel->outbound, page, send_pages);
531
+	if (err)
532
+		goto error_clean_ring;
533
+
534
+	err = hv_ringbuffer_init(&newchannel->inbound,
535
+				 &page[send_pages], recv_pages);
536
+	if (err)
537
+		goto error_clean_ring;
538
+
539
+	/* Establish the gpadl for the ring buffer */
540
+	newchannel->ringbuffer_gpadlhandle = 0;
541
+
542
+	err = __vmbus_establish_gpadl(newchannel, HV_GPADL_RING,
543
+				      page_address(newchannel->ringbuffer_page),
544
+				      (send_pages + recv_pages) << PAGE_SHIFT,
545
+				      newchannel->ringbuffer_send_offset << PAGE_SHIFT,
546
+				      &newchannel->ringbuffer_gpadlhandle);
547
+	if (err)
548
+		goto error_clean_ring;
549
+
550
+	/* Create and init the channel open message */
551
+	open_info = kmalloc(sizeof(*open_info) +
552
+			   sizeof(struct vmbus_channel_open_channel),
553
+			   GFP_KERNEL);
554
+	if (!open_info) {
555
+		err = -ENOMEM;
556
+		goto error_free_gpadl;
557
+	}
558
+
559
+	init_completion(&open_info->waitevent);
560
+	open_info->waiting_channel = newchannel;
561
+
562
+	open_msg = (struct vmbus_channel_open_channel *)open_info->msg;
563
+	open_msg->header.msgtype = CHANNELMSG_OPENCHANNEL;
564
+	open_msg->openid = newchannel->offermsg.child_relid;
565
+	open_msg->child_relid = newchannel->offermsg.child_relid;
566
+	open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle;
567
+	/*
568
+	 * The unit of ->downstream_ringbuffer_pageoffset is HV_HYP_PAGE and
569
+	 * the unit of ->ringbuffer_send_offset (i.e. send_pages) is PAGE, so
570
+	 * here we calculate it into HV_HYP_PAGE.
571
+	 */
572
+	open_msg->downstream_ringbuffer_pageoffset =
573
+		hv_ring_gpadl_send_hvpgoffset(send_pages << PAGE_SHIFT);
574
+	open_msg->target_vp = hv_cpu_number_to_vp_number(newchannel->target_cpu);
575
+
576
+	if (userdatalen)
577
+		memcpy(open_msg->userdata, userdata, userdatalen);
578
+
579
+	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
580
+	list_add_tail(&open_info->msglistentry,
581
+		      &vmbus_connection.chn_msg_list);
582
+	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
583
+
584
+	if (newchannel->rescind) {
585
+		err = -ENODEV;
586
+		goto error_clean_msglist;
587
+	}
588
+
589
+	err = vmbus_post_msg(open_msg,
590
+			     sizeof(struct vmbus_channel_open_channel), true);
591
+
592
+	trace_vmbus_open(open_msg, err);
593
+
594
+	if (err != 0)
595
+		goto error_clean_msglist;
596
+
597
+	wait_for_completion(&open_info->waitevent);
598
+
599
+	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
600
+	list_del(&open_info->msglistentry);
601
+	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
602
+
603
+	if (newchannel->rescind) {
604
+		err = -ENODEV;
605
+		goto error_free_info;
606
+	}
607
+
608
+	if (open_info->response.open_result.status) {
609
+		err = -EAGAIN;
610
+		goto error_free_info;
611
+	}
612
+
613
+	newchannel->state = CHANNEL_OPENED_STATE;
614
+	kfree(open_info);
615
+	return 0;
616
+
617
+error_clean_msglist:
618
+	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
619
+	list_del(&open_info->msglistentry);
620
+	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
621
+error_free_info:
622
+	kfree(open_info);
623
+error_free_gpadl:
624
+	vmbus_teardown_gpadl(newchannel, newchannel->ringbuffer_gpadlhandle);
625
+	newchannel->ringbuffer_gpadlhandle = 0;
626
+error_clean_ring:
627
+	hv_ringbuffer_cleanup(&newchannel->outbound);
628
+	hv_ringbuffer_cleanup(&newchannel->inbound);
629
+	newchannel->state = CHANNEL_OPEN_STATE;
630
+	return err;
631
+}
632
+
633
+/*
634
+ * vmbus_connect_ring - Open the channel but reuse ring buffer
635
+ */
636
+int vmbus_connect_ring(struct vmbus_channel *newchannel,
637
+		       void (*onchannelcallback)(void *context), void *context)
638
+{
639
+	return  __vmbus_open(newchannel, NULL, 0, onchannelcallback, context);
640
+}
641
+EXPORT_SYMBOL_GPL(vmbus_connect_ring);
642
+
643
+/*
644
+ * vmbus_open - Open the specified channel.
645
+ */
646
+int vmbus_open(struct vmbus_channel *newchannel,
647
+	       u32 send_ringbuffer_size, u32 recv_ringbuffer_size,
648
+	       void *userdata, u32 userdatalen,
649
+	       void (*onchannelcallback)(void *context), void *context)
650
+{
651
+	int err;
652
+
653
+	err = vmbus_alloc_ring(newchannel, send_ringbuffer_size,
654
+			       recv_ringbuffer_size);
655
+	if (err)
656
+		return err;
657
+
658
+	err = __vmbus_open(newchannel, userdata, userdatalen,
659
+			   onchannelcallback, context);
660
+	if (err)
661
+		vmbus_free_ring(newchannel);
662
+
663
+	return err;
664
+}
665
+EXPORT_SYMBOL_GPL(vmbus_open);
512
666
 
513
667
 /*
514
668
  * vmbus_teardown_gpadl -Teardown the specified GPADL handle
..
..
@@ -570,35 +724,31 @@
570
724
 }
571
725
 EXPORT_SYMBOL_GPL(vmbus_teardown_gpadl);
572
726
 
573
-static void reset_channel_cb(void *arg)
574
-{
575
-	struct vmbus_channel *channel = arg;
576
-
577
-	channel->onchannel_callback = NULL;
578
-}
579
-
580
727
 void vmbus_reset_channel_cb(struct vmbus_channel *channel)
581
728
 {
729
+	unsigned long flags;
730
+
582
731
 	/*
583
732
 	 * vmbus_on_event(), running in the per-channel tasklet, can race
584
733
 	 * with vmbus_close_internal() in the case of SMP guest, e.g., when
585
734
 	 * the former is accessing channel->inbound.ring_buffer, the latter
586
735
 	 * could be freeing the ring_buffer pages, so here we must stop it
587
736
 	 * first.
737
+	 *
738
+	 * vmbus_chan_sched() might call the netvsc driver callback function
739
+	 * that ends up scheduling NAPI work that accesses the ring buffer.
740
+	 * At this point, we have to ensure that any such work is completed
741
+	 * and that the channel ring buffer is no longer being accessed, cf.
742
+	 * the calls to napi_disable() in netvsc_device_remove().
588
743
 	 */
589
744
 	tasklet_disable(&channel->callback_event);
590
745
 
591
-	channel->sc_creation_callback = NULL;
746
+	/* See the inline comments in vmbus_chan_sched(). */
747
+	spin_lock_irqsave(&channel->sched_lock, flags);
748
+	channel->onchannel_callback = NULL;
749
+	spin_unlock_irqrestore(&channel->sched_lock, flags);
592
750
 
593
-	/* Stop the callback asap */
594
-	if (channel->target_cpu != get_cpu()) {
595
-		put_cpu();
596
-		smp_call_function_single(channel->target_cpu, reset_channel_cb,
597
-					 channel, true);
598
-	} else {
599
-		reset_channel_cb(channel);
600
-		put_cpu();
601
-	}
751
+	channel->sc_creation_callback = NULL;
602
752
 
603
753
 	/* Re-enable tasklet for use on re-open */
604
754
 	tasklet_enable(&channel->callback_event);
..
..
@@ -618,10 +768,8 @@
618
768
 	 * in Hyper-V Manager), the driver's remove() invokes vmbus_close():
619
769
 	 * here we should skip most of the below cleanup work.
620
770
 	 */
621
-	if (channel->state != CHANNEL_OPENED_STATE) {
622
-		ret = -EINVAL;
623
-		goto out;
624
-	}
771
+	if (channel->state != CHANNEL_OPENED_STATE)
772
+		return -EINVAL;
625
773
 
626
774
 	channel->state = CHANNEL_OPEN_STATE;
627
775
 
..
..
@@ -643,11 +791,10 @@
643
791
 		 * If we failed to post the close msg,
644
792
 		 * it is perhaps better to leak memory.
645
793
 		 */
646
-		goto out;
647
794
 	}
648
795
 
649
796
 	/* Tear down the gpadl for the channel's ring buffer */
650
-	if (channel->ringbuffer_gpadlhandle) {
797
+	else if (channel->ringbuffer_gpadlhandle) {
651
798
 		ret = vmbus_teardown_gpadl(channel,
652
799
 					   channel->ringbuffer_gpadlhandle);
653
800
 		if (ret) {
..
..
@@ -656,74 +803,70 @@
656
803
 			 * If we failed to teardown gpadl,
657
804
 			 * it is perhaps better to leak memory.
658
805
 			 */
659
-			goto out;
660
806
 		}
807
+
808
+		channel->ringbuffer_gpadlhandle = 0;
661
809
 	}
662
810
 
663
-	/* Cleanup the ring buffers for this channel */
664
-	hv_ringbuffer_cleanup(&channel->outbound);
665
-	hv_ringbuffer_cleanup(&channel->inbound);
666
-
667
-	__free_pages(channel->ringbuffer_page,
668
-		     get_order(channel->ringbuffer_pagecount << PAGE_SHIFT));
669
-
670
-out:
671
811
 	return ret;
672
812
 }
813
+
814
+/* disconnect ring - close all channels */
815
+int vmbus_disconnect_ring(struct vmbus_channel *channel)
816
+{
817
+	struct vmbus_channel *cur_channel, *tmp;
818
+	int ret;
819
+
820
+	if (channel->primary_channel != NULL)
821
+		return -EINVAL;
822
+
823
+	list_for_each_entry_safe(cur_channel, tmp, &channel->sc_list, sc_list) {
824
+		if (cur_channel->rescind)
825
+			wait_for_completion(&cur_channel->rescind_event);
826
+
827
+		mutex_lock(&vmbus_connection.channel_mutex);
828
+		if (vmbus_close_internal(cur_channel) == 0) {
829
+			vmbus_free_ring(cur_channel);
830
+
831
+			if (cur_channel->rescind)
832
+				hv_process_channel_removal(cur_channel);
833
+		}
834
+		mutex_unlock(&vmbus_connection.channel_mutex);
835
+	}
836
+
837
+	/*
838
+	 * Now close the primary.
839
+	 */
840
+	mutex_lock(&vmbus_connection.channel_mutex);
841
+	ret = vmbus_close_internal(channel);
842
+	mutex_unlock(&vmbus_connection.channel_mutex);
843
+
844
+	return ret;
845
+}
846
+EXPORT_SYMBOL_GPL(vmbus_disconnect_ring);
673
847
 
674
848
 /*
675
849
  * vmbus_close - Close the specified channel
676
850
  */
677
851
 void vmbus_close(struct vmbus_channel *channel)
678
852
 {
679
-	struct list_head *cur, *tmp;
680
-	struct vmbus_channel *cur_channel;
681
-
682
-	if (channel->primary_channel != NULL) {
683
-		/*
684
-		 * We will only close sub-channels when
685
-		 * the primary is closed.
686
-		 */
687
-		return;
688
-	}
689
-	/*
690
-	 * Close all the sub-channels first and then close the
691
-	 * primary channel.
692
-	 */
693
-	list_for_each_safe(cur, tmp, &channel->sc_list) {
694
-		cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
695
-		if (cur_channel->rescind) {
696
-			wait_for_completion(&cur_channel->rescind_event);
697
-			mutex_lock(&vmbus_connection.channel_mutex);
698
-			vmbus_close_internal(cur_channel);
699
-			hv_process_channel_removal(
700
-					   cur_channel->offermsg.child_relid);
701
-		} else {
702
-			mutex_lock(&vmbus_connection.channel_mutex);
703
-			vmbus_close_internal(cur_channel);
704
-		}
705
-		mutex_unlock(&vmbus_connection.channel_mutex);
706
-	}
707
-	/*
708
-	 * Now close the primary.
709
-	 */
710
-	mutex_lock(&vmbus_connection.channel_mutex);
711
-	vmbus_close_internal(channel);
712
-	mutex_unlock(&vmbus_connection.channel_mutex);
853
+	if (vmbus_disconnect_ring(channel) == 0)
854
+		vmbus_free_ring(channel);
713
855
 }
714
856
 EXPORT_SYMBOL_GPL(vmbus_close);
715
857
 
716
858
 /**
717
859
  * vmbus_sendpacket() - Send the specified buffer on the given channel
718
- * @channel: Pointer to vmbus_channel structure.
719
- * @buffer: Pointer to the buffer you want to receive the data into.
720
- * @bufferlen: Maximum size of what the the buffer will hold
860
+ * @channel: Pointer to vmbus_channel structure
861
+ * @buffer: Pointer to the buffer you want to send the data from.
862
+ * @bufferlen: Maximum size of what the buffer holds.
721
863
  * @requestid: Identifier of the request
722
- * @type: Type of packet that is being send e.g. negotiate, time
723
- * packet etc.
864
+ * @type: Type of packet that is being sent e.g. negotiate, time
865
+ *	  packet etc.
866
+ * @flags: 0 or VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
724
867
  *
725
- * Sends data in @buffer directly to hyper-v via the vmbus
726
- * This will send the data unparsed to hyper-v.
868
+ * Sends data in @buffer directly to Hyper-V via the vmbus.
869
+ * This will send the data unparsed to Hyper-V.
727
870
  *
728
871
  * Mainly used by Hyper-V drivers.
729
872
  */
..
..
@@ -856,12 +999,13 @@
856
999
 EXPORT_SYMBOL_GPL(vmbus_sendpacket_mpb_desc);
857
1000
 
858
1001
 /**
859
- * vmbus_recvpacket() - Retrieve the user packet on the specified channel
860
- * @channel: Pointer to vmbus_channel structure.
1002
+ * __vmbus_recvpacket() - Retrieve the user packet on the specified channel
1003
+ * @channel: Pointer to vmbus_channel structure
861
1004
  * @buffer: Pointer to the buffer you want to receive the data into.
862
- * @bufferlen: Maximum size of what the the buffer will hold
863
- * @buffer_actual_len: The actual size of the data after it was received
1005
+ * @bufferlen: Maximum size of what the buffer can hold.
1006
+ * @buffer_actual_len: The actual size of the data after it was received.
864
1007
  * @requestid: Identifier of the request
1008
+ * @raw: true means keep the vmpacket_descriptor header in the received data.
865
1009
  *
866
1010
  * Receives directly from the hyper-v vmbus and puts the data it received
867
1011
  * into Buffer. This will receive the data unparsed from hyper-v.