blob: 433f72a1c0062be9b13dff78b6885d37a80a8738 [file] [log] [blame]
Hank Janssen3e7ee492009-07-13 16:02:34 -07001/*
Hank Janssen3e7ee492009-07-13 16:02:34 -07002 * 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 *
17 * Authors:
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
Hank Janssen3e7ee492009-07-13 16:02:34 -070020 */
Hank Janssen0a466182011-03-29 13:58:47 -070021#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
Greg Kroah-Hartman5654e932009-07-14 15:08:20 -070023#include <linux/kernel.h>
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -080024#include <linux/sched.h>
25#include <linux/wait.h>
Greg Kroah-Hartmana0086dc2009-08-17 17:22:08 -070026#include <linux/mm.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Hank Janssenc88c4e42010-05-04 15:55:05 -070028#include <linux/module.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070029#include <linux/hyperv.h>
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -080030#include <linux/uio.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070031
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070032#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070033
K. Y. Srinivasane3fe0bb2011-02-11 10:00:12 -080034#define NUM_PAGES_SPANNED(addr, len) \
35((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT))
36
Hank Janssen3e189512010-03-04 22:11:00 +000037/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -070038 * vmbus_setevent- Trigger an event notification on the specified
Hank Janssen3e189512010-03-04 22:11:00 +000039 * channel.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -070040 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -070041static void vmbus_setevent(struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -070042{
Haiyang Zhang39d70a42010-09-30 10:52:13 -070043 struct hv_monitor_page *monitorpage;
Hank Janssen3e7ee492009-07-13 16:02:34 -070044
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -080045 if (channel->offermsg.monitor_allocated) {
Bill Pemberton454f18a2009-07-27 16:47:24 -040046 /* Each u32 represents 32 channels */
Olaf Hering22356582011-03-21 14:41:37 +010047 sync_set_bit(channel->offermsg.child_relid & 31,
Haiyang Zhangda9fcb72011-01-26 12:12:14 -080048 (unsigned long *) vmbus_connection.send_int_page +
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -080049 (channel->offermsg.child_relid >> 5));
Hank Janssen3e7ee492009-07-13 16:02:34 -070050
Greg Kroah-Hartman8681db42013-09-13 11:32:55 -070051 /* Get the child to parent monitor page */
52 monitorpage = vmbus_connection.monitor_pages[1];
Hank Janssen3e7ee492009-07-13 16:02:34 -070053
Olaf Hering22356582011-03-21 14:41:37 +010054 sync_set_bit(channel->monitor_bit,
Haiyang Zhangf6feebe2010-11-08 14:04:39 -080055 (unsigned long *)&monitorpage->trigger_group
56 [channel->monitor_grp].pending);
Bill Pemberton7c369f42009-07-29 17:00:11 -040057
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -070058 } else {
K. Y. Srinivasan21c3bef2012-12-01 06:46:43 -080059 vmbus_set_event(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -070060 }
Hank Janssen3e7ee492009-07-13 16:02:34 -070061}
62
Hank Janssen3e189512010-03-04 22:11:00 +000063/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -070064 * vmbus_open - Open the specified channel.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -070065 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -070066int vmbus_open(struct vmbus_channel *newchannel, u32 send_ringbuffer_size,
Haiyang Zhang39d70a42010-09-30 10:52:13 -070067 u32 recv_ringbuffer_size, void *userdata, u32 userdatalen,
68 void (*onchannelcallback)(void *context), void *context)
Hank Janssen3e7ee492009-07-13 16:02:34 -070069{
K. Y. Srinivasan0987ff62011-08-25 09:48:55 -070070 struct vmbus_channel_open_channel *open_msg;
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -070071 struct vmbus_channel_msginfo *open_info = NULL;
Hank Janssen3e7ee492009-07-13 16:02:34 -070072 void *in, *out;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -070073 unsigned long flags;
K. Y. Srinivasan9568a192011-05-10 07:55:39 -070074 int ret, t, err = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -070075
K. Y. Srinivasane68d2972013-05-23 12:02:32 -070076 spin_lock_irqsave(&newchannel->sc_lock, flags);
77 if (newchannel->state == CHANNEL_OPEN_STATE) {
78 newchannel->state = CHANNEL_OPENING_STATE;
79 } else {
80 spin_unlock_irqrestore(&newchannel->sc_lock, flags);
81 return -EINVAL;
82 }
83 spin_unlock_irqrestore(&newchannel->sc_lock, flags);
84
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -080085 newchannel->onchannel_callback = onchannelcallback;
86 newchannel->channel_callback_context = context;
Hank Janssen3e7ee492009-07-13 16:02:34 -070087
Bill Pemberton454f18a2009-07-27 16:47:24 -040088 /* Allocate the ring buffer */
K. Y. Srinivasandf3493e2011-02-11 09:59:00 -080089 out = (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
90 get_order(send_ringbuffer_size + recv_ringbuffer_size));
91
Bill Pemberton7e052d92010-05-05 15:27:30 -040092 if (!out)
93 return -ENOMEM;
94
Hank Janssen3e7ee492009-07-13 16:02:34 -070095
Haiyang Zhang39d70a42010-09-30 10:52:13 -070096 in = (void *)((unsigned long)out + send_ringbuffer_size);
Hank Janssen3e7ee492009-07-13 16:02:34 -070097
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -080098 newchannel->ringbuffer_pages = out;
99 newchannel->ringbuffer_pagecount = (send_ringbuffer_size +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700100 recv_ringbuffer_size) >> PAGE_SHIFT;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700101
K. Y. Srinivasan72a95cb2011-05-10 07:55:21 -0700102 ret = hv_ringbuffer_init(
103 &newchannel->outbound, out, send_ringbuffer_size);
104
Haiyang Zhangfd4dc882010-05-13 15:56:30 +0000105 if (ret != 0) {
Bill Pemberton3324fb42010-05-05 15:27:49 -0400106 err = ret;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700107 goto error0;
Bill Pemberton3324fb42010-05-05 15:27:49 -0400108 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700109
K. Y. Srinivasan72a95cb2011-05-10 07:55:21 -0700110 ret = hv_ringbuffer_init(
111 &newchannel->inbound, in, recv_ringbuffer_size);
Haiyang Zhangfd4dc882010-05-13 15:56:30 +0000112 if (ret != 0) {
Bill Pemberton3324fb42010-05-05 15:27:49 -0400113 err = ret;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700114 goto error0;
Bill Pemberton3324fb42010-05-05 15:27:49 -0400115 }
116
Hank Janssen3e7ee492009-07-13 16:02:34 -0700117
Bill Pemberton454f18a2009-07-27 16:47:24 -0400118 /* Establish the gpadl for the ring buffer */
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800119 newchannel->ringbuffer_gpadlhandle = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700120
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700121 ret = vmbus_establish_gpadl(newchannel,
Haiyang Zhang82f8bd42010-11-08 14:04:45 -0800122 newchannel->outbound.ring_buffer,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700123 send_ringbuffer_size +
124 recv_ringbuffer_size,
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800125 &newchannel->ringbuffer_gpadlhandle);
Bill Pembertonb94ef342010-05-05 15:27:37 -0400126
Haiyang Zhangfd4dc882010-05-13 15:56:30 +0000127 if (ret != 0) {
Bill Pembertonb94ef342010-05-05 15:27:37 -0400128 err = ret;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700129 goto error0;
Bill Pembertonb94ef342010-05-05 15:27:37 -0400130 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700131
Bill Pemberton454f18a2009-07-27 16:47:24 -0400132 /* Create and init the channel open message */
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700133 open_info = kmalloc(sizeof(*open_info) +
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700134 sizeof(struct vmbus_channel_open_channel),
135 GFP_KERNEL);
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700136 if (!open_info) {
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400137 err = -ENOMEM;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700138 goto error0;
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400139 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700140
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700141 init_completion(&open_info->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700142
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700143 open_msg = (struct vmbus_channel_open_channel *)open_info->msg;
K. Y. Srinivasan0987ff62011-08-25 09:48:55 -0700144 open_msg->header.msgtype = CHANNELMSG_OPENCHANNEL;
145 open_msg->openid = newchannel->offermsg.child_relid;
146 open_msg->child_relid = newchannel->offermsg.child_relid;
147 open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle;
148 open_msg->downstream_ringbuffer_pageoffset = send_ringbuffer_size >>
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700149 PAGE_SHIFT;
K. Y. Srinivasanabbf3b22012-12-01 06:46:48 -0800150 open_msg->target_vp = newchannel->target_vp;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700151
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700152 if (userdatalen > MAX_USER_DEFINED_BYTES) {
Bill Pembertonc827f942010-05-05 15:27:38 -0400153 err = -EINVAL;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700154 goto error0;
Bill Pembertonc827f942010-05-05 15:27:38 -0400155 }
156
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700157 if (userdatalen)
K. Y. Srinivasan0987ff62011-08-25 09:48:55 -0700158 memcpy(open_msg->userdata, userdata, userdatalen);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700159
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800160 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700161 list_add_tail(&open_info->msglistentry,
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800162 &vmbus_connection.chn_msg_list);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800163 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700164
K. Y. Srinivasan0987ff62011-08-25 09:48:55 -0700165 ret = vmbus_post_msg(open_msg,
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700166 sizeof(struct vmbus_channel_open_channel));
Hank Janssen98e08702011-03-29 13:58:44 -0700167
K. Y. Srinivasan45d727c2014-08-27 16:25:35 -0700168 if (ret != 0) {
169 err = ret;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700170 goto error1;
K. Y. Srinivasan45d727c2014-08-27 16:25:35 -0700171 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700172
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700173 t = wait_for_completion_timeout(&open_info->waitevent, 5*HZ);
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700174 if (t == 0) {
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800175 err = -ETIMEDOUT;
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700176 goto error1;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800177 }
178
Hank Janssen3e7ee492009-07-13 16:02:34 -0700179
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700180 if (open_info->response.open_result.status)
181 err = open_info->response.open_result.status;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700182
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800183 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700184 list_del(&open_info->msglistentry);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800185 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700186
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700187 if (err == 0)
188 newchannel->state = CHANNEL_OPENED_STATE;
189
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700190 kfree(open_info);
Hank Janssen98e08702011-03-29 13:58:44 -0700191 return err;
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400192
K. Y. Srinivasan13925502012-10-12 13:22:42 -0700193error1:
194 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
195 list_del(&open_info->msglistentry);
196 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
197
198error0:
K. Y. Srinivasandf3493e2011-02-11 09:59:00 -0800199 free_pages((unsigned long)out,
200 get_order(send_ringbuffer_size + recv_ringbuffer_size));
K. Y. Srinivasan176fb9e2011-08-25 09:48:57 -0700201 kfree(open_info);
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400202 return err;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700203}
Greg Kroah-Hartman36ceadf2010-10-21 09:58:21 -0700204EXPORT_SYMBOL_GPL(vmbus_open);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700205
Hank Janssen3e189512010-03-04 22:11:00 +0000206/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700207 * create_gpadl_header - Creates a gpadl for the specified buffer
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700208 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700209static int create_gpadl_header(void *kbuffer, u32 size,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700210 struct vmbus_channel_msginfo **msginfo,
211 u32 *messagecount)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700212{
213 int i;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700214 int pagecount;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700215 struct vmbus_channel_gpadl_header *gpadl_header;
216 struct vmbus_channel_gpadl_body *gpadl_body;
217 struct vmbus_channel_msginfo *msgheader;
218 struct vmbus_channel_msginfo *msgbody = NULL;
219 u32 msgsize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700220
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700221 int pfnsum, pfncount, pfnleft, pfncurr, pfnsize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700222
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700223 pagecount = size >> PAGE_SHIFT;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700224
Bill Pemberton454f18a2009-07-27 16:47:24 -0400225 /* do we need a gpadl body msg */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700226 pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700227 sizeof(struct vmbus_channel_gpadl_header) -
228 sizeof(struct gpa_range);
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700229 pfncount = pfnsize / sizeof(u64);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700230
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700231 if (pagecount > pfncount) {
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700232 /* we need a gpadl body */
Bill Pemberton454f18a2009-07-27 16:47:24 -0400233 /* fill in the header */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700234 msgsize = sizeof(struct vmbus_channel_msginfo) +
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700235 sizeof(struct vmbus_channel_gpadl_header) +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700236 sizeof(struct gpa_range) + pfncount * sizeof(u64);
237 msgheader = kzalloc(msgsize, GFP_KERNEL);
238 if (!msgheader)
Bill Pembertond1c250b2010-05-05 15:27:35 -0400239 goto nomem;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700240
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800241 INIT_LIST_HEAD(&msgheader->submsglist);
242 msgheader->msgsize = msgsize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700243
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700244 gpadl_header = (struct vmbus_channel_gpadl_header *)
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800245 msgheader->msg;
246 gpadl_header->rangecount = 1;
247 gpadl_header->range_buflen = sizeof(struct gpa_range) +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700248 pagecount * sizeof(u64);
Haiyang Zhang415f2282011-01-26 12:12:13 -0800249 gpadl_header->range[0].byte_offset = 0;
250 gpadl_header->range[0].byte_count = size;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700251 for (i = 0; i < pfncount; i++)
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800252 gpadl_header->range[0].pfn_array[i] = slow_virt_to_phys(
253 kbuffer + PAGE_SIZE * i) >> PAGE_SHIFT;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700254 *msginfo = msgheader;
255 *messagecount = 1;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700256
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700257 pfnsum = pfncount;
258 pfnleft = pagecount - pfncount;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700259
Bill Pemberton454f18a2009-07-27 16:47:24 -0400260 /* how many pfns can we fit */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700261 pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700262 sizeof(struct vmbus_channel_gpadl_body);
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700263 pfncount = pfnsize / sizeof(u64);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700264
Bill Pemberton454f18a2009-07-27 16:47:24 -0400265 /* fill in the body */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700266 while (pfnleft) {
267 if (pfnleft > pfncount)
268 pfncurr = pfncount;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700269 else
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700270 pfncurr = pfnleft;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700271
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700272 msgsize = sizeof(struct vmbus_channel_msginfo) +
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700273 sizeof(struct vmbus_channel_gpadl_body) +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700274 pfncurr * sizeof(u64);
275 msgbody = kzalloc(msgsize, GFP_KERNEL);
K. Y. Srinivasanf38cf9c2011-06-06 15:50:06 -0700276
277 if (!msgbody) {
278 struct vmbus_channel_msginfo *pos = NULL;
279 struct vmbus_channel_msginfo *tmp = NULL;
280 /*
281 * Free up all the allocated messages.
282 */
283 list_for_each_entry_safe(pos, tmp,
284 &msgheader->submsglist,
285 msglistentry) {
286
287 list_del(&pos->msglistentry);
288 kfree(pos);
289 }
290
Bill Pembertond1c250b2010-05-05 15:27:35 -0400291 goto nomem;
K. Y. Srinivasanf38cf9c2011-06-06 15:50:06 -0700292 }
293
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800294 msgbody->msgsize = msgsize;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700295 (*messagecount)++;
296 gpadl_body =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800297 (struct vmbus_channel_gpadl_body *)msgbody->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700298
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700299 /*
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700300 * Gpadl is u32 and we are using a pointer which could
301 * be 64-bit
K. Y. Srinivasanf27df642011-06-06 15:49:56 -0700302 * This is governed by the guest/host protocol and
303 * so the hypervisor gurantees that this is ok.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700304 */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700305 for (i = 0; i < pfncurr; i++)
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800306 gpadl_body->pfn[i] = slow_virt_to_phys(
307 kbuffer + PAGE_SIZE * (pfnsum + i)) >>
308 PAGE_SHIFT;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700309
Bill Pemberton454f18a2009-07-27 16:47:24 -0400310 /* add to msg header */
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800311 list_add_tail(&msgbody->msglistentry,
312 &msgheader->submsglist);
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700313 pfnsum += pfncurr;
314 pfnleft -= pfncurr;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700315 }
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700316 } else {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400317 /* everything fits in a header */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700318 msgsize = sizeof(struct vmbus_channel_msginfo) +
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700319 sizeof(struct vmbus_channel_gpadl_header) +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700320 sizeof(struct gpa_range) + pagecount * sizeof(u64);
321 msgheader = kzalloc(msgsize, GFP_KERNEL);
322 if (msgheader == NULL)
Kulikov Vasiliye3eb7cd2010-07-16 20:13:51 +0400323 goto nomem;
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800324 msgheader->msgsize = msgsize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700325
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700326 gpadl_header = (struct vmbus_channel_gpadl_header *)
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800327 msgheader->msg;
328 gpadl_header->rangecount = 1;
329 gpadl_header->range_buflen = sizeof(struct gpa_range) +
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700330 pagecount * sizeof(u64);
Haiyang Zhang415f2282011-01-26 12:12:13 -0800331 gpadl_header->range[0].byte_offset = 0;
332 gpadl_header->range[0].byte_count = size;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700333 for (i = 0; i < pagecount; i++)
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800334 gpadl_header->range[0].pfn_array[i] = slow_virt_to_phys(
335 kbuffer + PAGE_SIZE * i) >> PAGE_SHIFT;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700336
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700337 *msginfo = msgheader;
338 *messagecount = 1;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700339 }
340
341 return 0;
Bill Pembertond1c250b2010-05-05 15:27:35 -0400342nomem:
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700343 kfree(msgheader);
344 kfree(msgbody);
Bill Pembertond1c250b2010-05-05 15:27:35 -0400345 return -ENOMEM;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700346}
347
Hank Janssen3e189512010-03-04 22:11:00 +0000348/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700349 * vmbus_establish_gpadl - Estabish a GPADL for the specified buffer
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700350 *
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700351 * @channel: a channel
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800352 * @kbuffer: from kmalloc or vmalloc
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700353 * @size: page-size multiple
354 * @gpadl_handle: some funky thing
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700355 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700356int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700357 u32 size, u32 *gpadl_handle)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700358{
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700359 struct vmbus_channel_gpadl_header *gpadlmsg;
360 struct vmbus_channel_gpadl_body *gpadl_body;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700361 struct vmbus_channel_msginfo *msginfo = NULL;
362 struct vmbus_channel_msginfo *submsginfo;
363 u32 msgcount;
Bill Pemberton53af5452009-09-11 21:46:44 -0400364 struct list_head *curr;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700365 u32 next_gpadl_handle;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700366 unsigned long flags;
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400367 int ret = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700368
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800369 next_gpadl_handle = atomic_read(&vmbus_connection.next_gpadl_handle);
370 atomic_inc(&vmbus_connection.next_gpadl_handle);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700371
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700372 ret = create_gpadl_header(kbuffer, size, &msginfo, &msgcount);
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400373 if (ret)
374 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700375
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700376 init_completion(&msginfo->waitevent);
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400377
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800378 gpadlmsg = (struct vmbus_channel_gpadl_header *)msginfo->msg;
379 gpadlmsg->header.msgtype = CHANNELMSG_GPADL_HEADER;
380 gpadlmsg->child_relid = channel->offermsg.child_relid;
381 gpadlmsg->gpadl = next_gpadl_handle;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700382
Hank Janssen3e7ee492009-07-13 16:02:34 -0700383
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800384 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800385 list_add_tail(&msginfo->msglistentry,
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800386 &vmbus_connection.chn_msg_list);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700387
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800388 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700389
Haiyang Zhangc6977672011-01-26 12:12:08 -0800390 ret = vmbus_post_msg(gpadlmsg, msginfo->msgsize -
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700391 sizeof(*msginfo));
Hank Janssen98e08702011-03-29 13:58:44 -0700392 if (ret != 0)
K. Y. Srinivasan00d760b2011-06-06 15:50:12 -0700393 goto cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700394
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700395 if (msgcount > 1) {
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800396 list_for_each(curr, &msginfo->submsglist) {
Bill Pemberton53af5452009-09-11 21:46:44 -0400397
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700398 submsginfo = (struct vmbus_channel_msginfo *)curr;
399 gpadl_body =
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800400 (struct vmbus_channel_gpadl_body *)submsginfo->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700401
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800402 gpadl_body->header.msgtype =
403 CHANNELMSG_GPADL_BODY;
404 gpadl_body->gpadl = next_gpadl_handle;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700405
Haiyang Zhangc6977672011-01-26 12:12:08 -0800406 ret = vmbus_post_msg(gpadl_body,
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800407 submsginfo->msgsize -
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700408 sizeof(*submsginfo));
Haiyang Zhangfd4dc882010-05-13 15:56:30 +0000409 if (ret != 0)
K. Y. Srinivasan00d760b2011-06-06 15:50:12 -0700410 goto cleanup;
Bill Pemberton99259152010-05-05 15:27:36 -0400411
Hank Janssen3e7ee492009-07-13 16:02:34 -0700412 }
413 }
K. Y. Srinivasan72c6b712014-08-27 16:25:34 -0700414 wait_for_completion(&msginfo->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700415
Bill Pemberton454f18a2009-07-27 16:47:24 -0400416 /* At this point, we received the gpadl created msg */
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800417 *gpadl_handle = gpadlmsg->gpadl;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700418
K. Y. Srinivasan00d760b2011-06-06 15:50:12 -0700419cleanup:
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800420 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800421 list_del(&msginfo->msglistentry);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800422 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700423
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700424 kfree(msginfo);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700425 return ret;
426}
Greg Kroah-Hartman98873722010-10-21 08:47:43 -0700427EXPORT_SYMBOL_GPL(vmbus_establish_gpadl);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700428
Hank Janssen3e189512010-03-04 22:11:00 +0000429/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700430 * vmbus_teardown_gpadl -Teardown the specified GPADL handle
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700431 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700432int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700433{
Greg Kroah-Hartman82250212009-08-26 15:16:04 -0700434 struct vmbus_channel_gpadl_teardown *msg;
Greg Kroah-Hartmanaded7162009-08-18 15:21:19 -0700435 struct vmbus_channel_msginfo *info;
Greg Kroah-Hartmandd0813b2009-07-15 14:56:45 -0700436 unsigned long flags;
K. Y. Srinivasan66be6532014-08-27 16:25:32 -0700437 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700438
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700439 info = kmalloc(sizeof(*info) +
440 sizeof(struct vmbus_channel_gpadl_teardown), GFP_KERNEL);
Bill Pembertonc3bf2e22010-05-05 15:27:34 -0400441 if (!info)
442 return -ENOMEM;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700443
K. Y. Srinivasan9568a192011-05-10 07:55:39 -0700444 init_completion(&info->waitevent);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700445
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800446 msg = (struct vmbus_channel_gpadl_teardown *)info->msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700447
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800448 msg->header.msgtype = CHANNELMSG_GPADL_TEARDOWN;
449 msg->child_relid = channel->offermsg.child_relid;
450 msg->gpadl = gpadl_handle;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700451
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800452 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800453 list_add_tail(&info->msglistentry,
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800454 &vmbus_connection.chn_msg_list);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800455 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Haiyang Zhangc6977672011-01-26 12:12:08 -0800456 ret = vmbus_post_msg(msg,
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700457 sizeof(struct vmbus_channel_gpadl_teardown));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700458
K. Y. Srinivasan66be6532014-08-27 16:25:32 -0700459 if (ret)
460 goto post_msg_err;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700461
K. Y. Srinivasan66be6532014-08-27 16:25:32 -0700462 wait_for_completion(&info->waitevent);
463
464post_msg_err:
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800465 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800466 list_del(&info->msglistentry);
Haiyang Zhang15b2f642011-01-26 12:12:07 -0800467 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700468
Greg Kroah-Hartman8c69f522009-07-15 12:48:29 -0700469 kfree(info);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700470 return ret;
471}
Greg Kroah-Hartman18726d72010-10-21 08:39:59 -0700472EXPORT_SYMBOL_GPL(vmbus_teardown_gpadl);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700473
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700474static void reset_channel_cb(void *arg)
475{
476 struct vmbus_channel *channel = arg;
477
478 channel->onchannel_callback = NULL;
479}
480
K. Y. Srinivasan98d731b2014-08-27 16:25:33 -0700481static int vmbus_close_internal(struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700482{
Greg Kroah-Hartman82250212009-08-26 15:16:04 -0700483 struct vmbus_channel_close_channel *msg;
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700484 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700485
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700486 channel->state = CHANNEL_OPEN_STATE;
487 channel->sc_creation_callback = NULL;
Bill Pemberton454f18a2009-07-27 16:47:24 -0400488 /* Stop callback and cancel the timer asap */
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700489 if (channel->target_cpu != get_cpu()) {
490 put_cpu();
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700491 smp_call_function_single(channel->target_cpu, reset_channel_cb,
492 channel, true);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700493 } else {
K. Y. Srinivasand3ba7202014-04-08 18:45:53 -0700494 reset_channel_cb(channel);
K. Y. Srinivasan2115b562014-08-28 18:29:53 -0700495 put_cpu();
496 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700497
Bill Pemberton454f18a2009-07-27 16:47:24 -0400498 /* Send a closing message */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700499
K. Y. Srinivasane9a27a92011-06-06 15:49:59 -0700500 msg = &channel->close_msg.msg;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700501
Haiyang Zhangc50f7fb2010-11-08 14:04:38 -0800502 msg->header.msgtype = CHANNELMSG_CLOSECHANNEL;
503 msg->child_relid = channel->offermsg.child_relid;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700504
Haiyang Zhangc6977672011-01-26 12:12:08 -0800505 ret = vmbus_post_msg(msg, sizeof(struct vmbus_channel_close_channel));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700506
K. Y. Srinivasan98d731b2014-08-27 16:25:33 -0700507 if (ret) {
508 pr_err("Close failed: close post msg return is %d\n", ret);
509 /*
510 * If we failed to post the close msg,
511 * it is perhaps better to leak memory.
512 */
513 return ret;
514 }
515
Bill Pemberton454f18a2009-07-27 16:47:24 -0400516 /* Tear down the gpadl for the channel's ring buffer */
K. Y. Srinivasan98d731b2014-08-27 16:25:33 -0700517 if (channel->ringbuffer_gpadlhandle) {
518 ret = vmbus_teardown_gpadl(channel,
519 channel->ringbuffer_gpadlhandle);
520 if (ret) {
521 pr_err("Close failed: teardown gpadl return %d\n", ret);
522 /*
523 * If we failed to teardown gpadl,
524 * it is perhaps better to leak memory.
525 */
526 return ret;
527 }
528 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700529
Bill Pemberton454f18a2009-07-27 16:47:24 -0400530 /* Cleanup the ring buffers for this channel */
K. Y. Srinivasan2dba6882011-05-10 07:55:22 -0700531 hv_ringbuffer_cleanup(&channel->outbound);
532 hv_ringbuffer_cleanup(&channel->inbound);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700533
K. Y. Srinivasandf3493e2011-02-11 09:59:00 -0800534 free_pages((unsigned long)channel->ringbuffer_pages,
535 get_order(channel->ringbuffer_pagecount * PAGE_SIZE));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700536
K. Y. Srinivasan98d731b2014-08-27 16:25:33 -0700537 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700538}
K. Y. Srinivasane68d2972013-05-23 12:02:32 -0700539
540/*
541 * vmbus_close - Close the specified channel
542 */
543void vmbus_close(struct vmbus_channel *channel)
544{
545 struct list_head *cur, *tmp;
546 struct vmbus_channel *cur_channel;
547
548 if (channel->primary_channel != NULL) {
549 /*
550 * We will only close sub-channels when
551 * the primary is closed.
552 */
553 return;
554 }
555 /*
556 * Close all the sub-channels first and then close the
557 * primary channel.
558 */
559 list_for_each_safe(cur, tmp, &channel->sc_list) {
560 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
561 if (cur_channel->state != CHANNEL_OPENED_STATE)
562 continue;
563 vmbus_close_internal(cur_channel);
564 }
565 /*
566 * Now close the primary.
567 */
568 vmbus_close_internal(channel);
569}
Greg Kroah-Hartman70bfa302010-10-21 09:52:22 -0700570EXPORT_SYMBOL_GPL(vmbus_close);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700571
Hank Janssenc88c4e42010-05-04 15:55:05 -0700572/**
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700573 * vmbus_sendpacket() - Send the specified buffer on the given channel
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700574 * @channel: Pointer to vmbus_channel structure.
575 * @buffer: Pointer to the buffer you want to receive the data into.
576 * @bufferlen: Maximum size of what the the buffer will hold
577 * @requestid: Identifier of the request
578 * @type: Type of packet that is being send e.g. negotiate, time
Hank Janssenc88c4e42010-05-04 15:55:05 -0700579 * packet etc.
580 *
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700581 * Sends data in @buffer directly to hyper-v via the vmbus
Hank Janssenc88c4e42010-05-04 15:55:05 -0700582 * This will send the data unparsed to hyper-v.
583 *
584 * Mainly used by Hyper-V drivers.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700585 */
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800586int vmbus_sendpacket(struct vmbus_channel *channel, void *buffer,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700587 u32 bufferlen, u64 requestid,
588 enum vmbus_packet_type type, u32 flags)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700589{
Greg Kroah-Hartman8dc0a062009-08-27 16:02:36 -0700590 struct vmpacket_descriptor desc;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700591 u32 packetlen = sizeof(struct vmpacket_descriptor) + bufferlen;
Uwe Kleine-König73509682011-01-20 09:32:01 +0100592 u32 packetlen_aligned = ALIGN(packetlen, sizeof(u64));
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800593 struct kvec bufferlist[3];
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700594 u64 aligned_data = 0;
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700595 int ret;
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800596 bool signal = false;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700597
Hank Janssen3e7ee492009-07-13 16:02:34 -0700598
Bill Pemberton454f18a2009-07-27 16:47:24 -0400599 /* Setup the descriptor */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800600 desc.type = type; /* VmbusPacketTypeDataInBand; */
601 desc.flags = flags; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700602 /* in 8-bytes granularity */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800603 desc.offset8 = sizeof(struct vmpacket_descriptor) >> 3;
604 desc.len8 = (u16)(packetlen_aligned >> 3);
605 desc.trans_id = requestid;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700606
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800607 bufferlist[0].iov_base = &desc;
608 bufferlist[0].iov_len = sizeof(struct vmpacket_descriptor);
609 bufferlist[1].iov_base = buffer;
610 bufferlist[1].iov_len = bufferlen;
611 bufferlist[2].iov_base = &aligned_data;
612 bufferlist[2].iov_len = (packetlen_aligned - packetlen);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700613
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800614 ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3, &signal);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700615
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800616 if (ret == 0 && signal)
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700617 vmbus_setevent(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700618
Hank Janssen3e7ee492009-07-13 16:02:34 -0700619 return ret;
620}
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700621EXPORT_SYMBOL(vmbus_sendpacket);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700622
Hank Janssen3e189512010-03-04 22:11:00 +0000623/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700624 * vmbus_sendpacket_pagebuffer - Send a range of single-page buffer
Hank Janssen3e189512010-03-04 22:11:00 +0000625 * packets using a GPADL Direct packet type.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700626 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700627int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700628 struct hv_page_buffer pagebuffers[],
629 u32 pagecount, void *buffer, u32 bufferlen,
630 u64 requestid)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700631{
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700632 int ret;
633 int i;
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000634 struct vmbus_channel_packet_page_buffer desc;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700635 u32 descsize;
636 u32 packetlen;
637 u32 packetlen_aligned;
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800638 struct kvec bufferlist[3];
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700639 u64 aligned_data = 0;
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800640 bool signal = false;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700641
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700642 if (pagecount > MAX_PAGE_BUFFER_COUNT)
Bill Pemberton002b53e2010-05-05 15:27:39 -0400643 return -EINVAL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700644
Hank Janssen3e7ee492009-07-13 16:02:34 -0700645
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700646 /*
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000647 * Adjust the size down since vmbus_channel_packet_page_buffer is the
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700648 * largest size we support
649 */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700650 descsize = sizeof(struct vmbus_channel_packet_page_buffer) -
651 ((MAX_PAGE_BUFFER_COUNT - pagecount) *
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700652 sizeof(struct hv_page_buffer));
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700653 packetlen = descsize + bufferlen;
Uwe Kleine-König73509682011-01-20 09:32:01 +0100654 packetlen_aligned = ALIGN(packetlen, sizeof(u64));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700655
Bill Pemberton454f18a2009-07-27 16:47:24 -0400656 /* Setup the descriptor */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800657 desc.type = VM_PKT_DATA_USING_GPA_DIRECT;
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000658 desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700659 desc.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
660 desc.length8 = (u16)(packetlen_aligned >> 3);
661 desc.transactionid = requestid;
662 desc.rangecount = pagecount;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700663
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700664 for (i = 0; i < pagecount; i++) {
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800665 desc.range[i].len = pagebuffers[i].len;
666 desc.range[i].offset = pagebuffers[i].offset;
667 desc.range[i].pfn = pagebuffers[i].pfn;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700668 }
669
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800670 bufferlist[0].iov_base = &desc;
671 bufferlist[0].iov_len = descsize;
672 bufferlist[1].iov_base = buffer;
673 bufferlist[1].iov_len = bufferlen;
674 bufferlist[2].iov_base = &aligned_data;
675 bufferlist[2].iov_len = (packetlen_aligned - packetlen);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700676
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800677 ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3, &signal);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700678
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800679 if (ret == 0 && signal)
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700680 vmbus_setevent(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700681
Hank Janssen3e7ee492009-07-13 16:02:34 -0700682 return ret;
683}
Greg Kroah-Hartman713efeb2010-10-21 09:29:54 -0700684EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700685
Hank Janssen3e189512010-03-04 22:11:00 +0000686/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700687 * vmbus_sendpacket_multipagebuffer - Send a multi-page buffer packet
Hank Janssen3e189512010-03-04 22:11:00 +0000688 * using a GPADL Direct packet type.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700689 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700690int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700691 struct hv_multipage_buffer *multi_pagebuffer,
692 void *buffer, u32 bufferlen, u64 requestid)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700693{
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700694 int ret;
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000695 struct vmbus_channel_packet_multipage_buffer desc;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700696 u32 descsize;
697 u32 packetlen;
698 u32 packetlen_aligned;
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800699 struct kvec bufferlist[3];
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700700 u64 aligned_data = 0;
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800701 bool signal = false;
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800702 u32 pfncount = NUM_PAGES_SPANNED(multi_pagebuffer->offset,
703 multi_pagebuffer->len);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700704
Tobias Klauser24b8a402014-04-25 17:03:50 +0200705 if (pfncount > MAX_MULTIPAGE_BUFFER_COUNT)
Bill Pemberton002b53e2010-05-05 15:27:39 -0400706 return -EINVAL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700707
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700708 /*
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000709 * Adjust the size down since vmbus_channel_packet_multipage_buffer is
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700710 * the largest size we support
711 */
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700712 descsize = sizeof(struct vmbus_channel_packet_multipage_buffer) -
713 ((MAX_MULTIPAGE_BUFFER_COUNT - pfncount) *
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700714 sizeof(u64));
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700715 packetlen = descsize + bufferlen;
Uwe Kleine-König73509682011-01-20 09:32:01 +0100716 packetlen_aligned = ALIGN(packetlen, sizeof(u64));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700717
Hank Janssen3e7ee492009-07-13 16:02:34 -0700718
Bill Pemberton454f18a2009-07-27 16:47:24 -0400719 /* Setup the descriptor */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800720 desc.type = VM_PKT_DATA_USING_GPA_DIRECT;
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000721 desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700722 desc.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
723 desc.length8 = (u16)(packetlen_aligned >> 3);
724 desc.transactionid = requestid;
Haiyang Zhang430a8e92010-09-20 21:07:51 +0000725 desc.rangecount = 1;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700726
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800727 desc.range.len = multi_pagebuffer->len;
728 desc.range.offset = multi_pagebuffer->offset;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700729
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800730 memcpy(desc.range.pfn_array, multi_pagebuffer->pfn_array,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700731 pfncount * sizeof(u64));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700732
K. Y. Srinivasan011a7c32014-02-01 19:02:20 -0800733 bufferlist[0].iov_base = &desc;
734 bufferlist[0].iov_len = descsize;
735 bufferlist[1].iov_base = buffer;
736 bufferlist[1].iov_len = bufferlen;
737 bufferlist[2].iov_base = &aligned_data;
738 bufferlist[2].iov_len = (packetlen_aligned - packetlen);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700739
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800740 ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3, &signal);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700741
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800742 if (ret == 0 && signal)
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700743 vmbus_setevent(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700744
Hank Janssen3e7ee492009-07-13 16:02:34 -0700745 return ret;
746}
Greg Kroah-Hartman4cb106f2010-10-21 09:23:59 -0700747EXPORT_SYMBOL_GPL(vmbus_sendpacket_multipagebuffer);
Hank Janssenc88c4e42010-05-04 15:55:05 -0700748
749/**
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700750 * vmbus_recvpacket() - Retrieve the user packet on the specified channel
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700751 * @channel: Pointer to vmbus_channel structure.
752 * @buffer: Pointer to the buffer you want to receive the data into.
753 * @bufferlen: Maximum size of what the the buffer will hold
754 * @buffer_actual_len: The actual size of the data after it was received
755 * @requestid: Identifier of the request
Hank Janssenc88c4e42010-05-04 15:55:05 -0700756 *
757 * Receives directly from the hyper-v vmbus and puts the data it received
758 * into Buffer. This will receive the data unparsed from hyper-v.
759 *
760 * Mainly used by Hyper-V drivers.
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700761 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700762int vmbus_recvpacket(struct vmbus_channel *channel, void *buffer,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700763 u32 bufferlen, u32 *buffer_actual_len, u64 *requestid)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700764{
Greg Kroah-Hartman8dc0a062009-08-27 16:02:36 -0700765 struct vmpacket_descriptor desc;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700766 u32 packetlen;
767 u32 userlen;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700768 int ret;
K. Y. Srinivasanc2b8e522012-12-01 06:46:57 -0800769 bool signal = false;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700770
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700771 *buffer_actual_len = 0;
772 *requestid = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700773
Hank Janssen3e7ee492009-07-13 16:02:34 -0700774
K. Y. Srinivasana89186c2011-05-10 07:55:24 -0700775 ret = hv_ringbuffer_peek(&channel->inbound, &desc,
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700776 sizeof(struct vmpacket_descriptor));
K. Y. Srinivasandad76bf2011-08-27 11:31:33 -0700777 if (ret != 0)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700778 return 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700779
Haiyang Zhang415f2282011-01-26 12:12:13 -0800780 packetlen = desc.len8 << 3;
781 userlen = packetlen - (desc.offset8 << 3);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700782
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700783 *buffer_actual_len = userlen;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700784
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700785 if (userlen > bufferlen) {
Hank Janssen3e7ee492009-07-13 16:02:34 -0700786
Hank Janssen0a466182011-03-29 13:58:47 -0700787 pr_err("Buffer too small - got %d needs %d\n",
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700788 bufferlen, userlen);
K. Y. Srinivasan926ae5262011-06-06 15:50:11 -0700789 return -ETOOSMALL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700790 }
791
Haiyang Zhang415f2282011-01-26 12:12:13 -0800792 *requestid = desc.trans_id;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700793
Bill Pemberton454f18a2009-07-27 16:47:24 -0400794 /* Copy over the packet to the user buffer */
K. Y. Srinivasan38397c82011-05-10 07:55:25 -0700795 ret = hv_ringbuffer_read(&channel->inbound, buffer, userlen,
K. Y. Srinivasanc2b8e522012-12-01 06:46:57 -0800796 (desc.offset8 << 3), &signal);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700797
K. Y. Srinivasanc2b8e522012-12-01 06:46:57 -0800798 if (signal)
799 vmbus_setevent(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700800
Hank Janssen3e7ee492009-07-13 16:02:34 -0700801 return 0;
802}
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700803EXPORT_SYMBOL(vmbus_recvpacket);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700804
Hank Janssen3e189512010-03-04 22:11:00 +0000805/*
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700806 * vmbus_recvpacket_raw - Retrieve the raw packet on the specified channel
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700807 */
Haiyang Zhangfff41b22010-10-07 11:40:08 -0700808int vmbus_recvpacket_raw(struct vmbus_channel *channel, void *buffer,
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700809 u32 bufferlen, u32 *buffer_actual_len,
810 u64 *requestid)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700811{
Greg Kroah-Hartman8dc0a062009-08-27 16:02:36 -0700812 struct vmpacket_descriptor desc;
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700813 u32 packetlen;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700814 int ret;
K. Y. Srinivasanc2b8e522012-12-01 06:46:57 -0800815 bool signal = false;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700816
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700817 *buffer_actual_len = 0;
818 *requestid = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700819
Hank Janssen3e7ee492009-07-13 16:02:34 -0700820
K. Y. Srinivasana89186c2011-05-10 07:55:24 -0700821 ret = hv_ringbuffer_peek(&channel->inbound, &desc,
Greg Kroah-Hartmanf4266e32009-09-01 17:24:57 -0700822 sizeof(struct vmpacket_descriptor));
K. Y. Srinivasandad76bf2011-08-27 11:31:33 -0700823 if (ret != 0)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700824 return 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700825
Hank Janssen3e7ee492009-07-13 16:02:34 -0700826
Haiyang Zhang415f2282011-01-26 12:12:13 -0800827 packetlen = desc.len8 << 3;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700828
Haiyang Zhang39d70a42010-09-30 10:52:13 -0700829 *buffer_actual_len = packetlen;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700830
Jason Wang7a446d62014-06-30 14:14:48 +0800831 if (packetlen > bufferlen)
K. Y. Srinivasan3d5cad92011-08-25 09:48:59 -0700832 return -ENOBUFS;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700833
Haiyang Zhang415f2282011-01-26 12:12:13 -0800834 *requestid = desc.trans_id;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700835
Bill Pemberton454f18a2009-07-27 16:47:24 -0400836 /* Copy over the entire packet to the user buffer */
K. Y. Srinivasanc2b8e522012-12-01 06:46:57 -0800837 ret = hv_ringbuffer_read(&channel->inbound, buffer, packetlen, 0,
838 &signal);
839
840 if (signal)
841 vmbus_setevent(channel);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700842
Dan Carpenter33b06932013-09-17 00:58:36 +0300843 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700844}
Greg Kroah-Hartmanadaee6b2010-10-21 09:09:23 -0700845EXPORT_SYMBOL_GPL(vmbus_recvpacket_raw);