blob: db4b887b889d268c3e427764e732ce88dc6a008e [file] [log] [blame]
K. Y. Srinivasan013254762014-02-16 11:34:30 -08001/*
2 * An implementation of file copy service.
3 *
4 * Copyright (C) 2014, Microsoft, Inc.
5 *
6 * Author : K. Y. Srinivasan <ksrinivasan@novell.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published
10 * by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
15 * NON INFRINGEMENT. See the GNU General Public License for more
16 * details.
17 *
18 */
19
20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
K. Y. Srinivasan013254762014-02-16 11:34:30 -080022#include <linux/nls.h>
23#include <linux/workqueue.h>
K. Y. Srinivasan013254762014-02-16 11:34:30 -080024#include <linux/hyperv.h>
25#include <linux/sched.h>
K. Y. Srinivasan013254762014-02-16 11:34:30 -080026
27#include "hyperv_vmbus.h"
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -070028#include "hv_utils_transport.h"
K. Y. Srinivasan013254762014-02-16 11:34:30 -080029
30#define WIN8_SRV_MAJOR 1
31#define WIN8_SRV_MINOR 1
32#define WIN8_SRV_VERSION (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
33
34/*
35 * Global state maintained for transaction that is being processed.
36 * For a class of integration services, including the "file copy service",
37 * the specified protocol is a "request/response" protocol which means that
38 * there can only be single outstanding transaction from the host at any
39 * given point in time. We use this to simplify memory management in this
40 * driver - we cache and process only one message at a time.
41 *
42 * While the request/response protocol is guaranteed by the host, we further
43 * ensure this by serializing packet processing in this driver - we do not
44 * read additional packets from the VMBUs until the current packet is fully
45 * handled.
K. Y. Srinivasan013254762014-02-16 11:34:30 -080046 */
47
48static struct {
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -070049 int state; /* hvutil_device_state */
K. Y. Srinivasan013254762014-02-16 11:34:30 -080050 int recv_len; /* number of bytes received. */
51 struct hv_fcopy_hdr *fcopy_msg; /* current message */
K. Y. Srinivasan013254762014-02-16 11:34:30 -080052 struct vmbus_channel *recv_channel; /* chn we got the request */
53 u64 recv_req_id; /* request ID. */
54 void *fcopy_context; /* for the channel callback */
K. Y. Srinivasan013254762014-02-16 11:34:30 -080055} fcopy_transaction;
56
K. Y. Srinivasan013254762014-02-16 11:34:30 -080057static void fcopy_respond_to_host(int error);
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -070058static void fcopy_send_data(struct work_struct *dummy);
Vitaly Kuznetsov1d072332015-04-11 18:07:45 -070059static void fcopy_timeout_func(struct work_struct *dummy);
60static DECLARE_DELAYED_WORK(fcopy_timeout_work, fcopy_timeout_func);
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -070061static DECLARE_WORK(fcopy_send_work, fcopy_send_data);
62static const char fcopy_devname[] = "vmbus/hv_fcopy";
K. Y. Srinivasan013254762014-02-16 11:34:30 -080063static u8 *recv_buffer;
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -070064static struct hvutil_transport *hvt;
Vitaly Kuznetsova4d1ee52015-04-11 18:07:58 -070065/*
66 * This state maintains the version number registered by the daemon.
67 */
68static int dm_reg_value;
K. Y. Srinivasan013254762014-02-16 11:34:30 -080069
Vitaly Kuznetsov1d072332015-04-11 18:07:45 -070070static void fcopy_timeout_func(struct work_struct *dummy)
K. Y. Srinivasan013254762014-02-16 11:34:30 -080071{
72 /*
73 * If the timer fires, the user-mode component has not responded;
74 * process the pending transaction.
75 */
76 fcopy_respond_to_host(HV_E_FAIL);
Dexuan Cuid9b16522015-01-14 01:55:10 -080077
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -070078 /* Transaction is finished, reset the state. */
79 if (fcopy_transaction.state > HVUTIL_READY)
80 fcopy_transaction.state = HVUTIL_READY;
81
Vitaly Kuznetsov242f3122015-04-11 18:07:42 -070082 hv_poll_channel(fcopy_transaction.fcopy_context,
83 hv_fcopy_onchannelcallback);
K. Y. Srinivasan013254762014-02-16 11:34:30 -080084}
85
86static int fcopy_handle_handshake(u32 version)
87{
Vitaly Kuznetsova4d1ee52015-04-11 18:07:58 -070088 u32 our_ver = FCOPY_CURRENT_VERSION;
89
K. Y. Srinivasan013254762014-02-16 11:34:30 -080090 switch (version) {
Vitaly Kuznetsova4d1ee52015-04-11 18:07:58 -070091 case FCOPY_VERSION_0:
92 /* Daemon doesn't expect us to reply */
93 dm_reg_value = version;
94 break;
95 case FCOPY_VERSION_1:
96 /* Daemon expects us to reply with our own version */
97 if (hvutil_transport_send(hvt, &our_ver, sizeof(our_ver)))
98 return -EFAULT;
99 dm_reg_value = version;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800100 break;
101 default:
102 /*
103 * For now we will fail the registration.
104 * If and when we have multiple versions to
105 * deal with, we will be backward compatible.
106 * We will add this code when needed.
107 */
108 return -EINVAL;
109 }
Vitaly Kuznetsov7c959122015-04-11 18:07:59 -0700110 pr_debug("FCP: userspace daemon ver. %d registered\n", version);
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700111 fcopy_transaction.state = HVUTIL_READY;
Vitaly Kuznetsov242f3122015-04-11 18:07:42 -0700112 hv_poll_channel(fcopy_transaction.fcopy_context,
113 hv_fcopy_onchannelcallback);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800114 return 0;
115}
116
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700117static void fcopy_send_data(struct work_struct *dummy)
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800118{
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700119 struct hv_start_fcopy *smsg_out = NULL;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800120 int operation = fcopy_transaction.fcopy_msg->operation;
121 struct hv_start_fcopy *smsg_in;
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700122 void *out_src;
123 int rc, out_len;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800124
125 /*
126 * The strings sent from the host are encoded in
127 * in utf16; convert it to utf8 strings.
128 * The host assures us that the utf16 strings will not exceed
129 * the max lengths specified. We will however, reserve room
130 * for the string terminating character - in the utf16s_utf8s()
131 * function we limit the size of the buffer where the converted
132 * string is placed to W_MAX_PATH -1 to guarantee
133 * that the strings can be properly terminated!
134 */
135
136 switch (operation) {
137 case START_FILE_COPY:
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700138 out_len = sizeof(struct hv_start_fcopy);
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700139 smsg_out = kzalloc(sizeof(*smsg_out), GFP_KERNEL);
140 if (!smsg_out)
141 return;
142
143 smsg_out->hdr.operation = operation;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800144 smsg_in = (struct hv_start_fcopy *)fcopy_transaction.fcopy_msg;
145
146 utf16s_to_utf8s((wchar_t *)smsg_in->file_name, W_MAX_PATH,
147 UTF16_LITTLE_ENDIAN,
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700148 (__u8 *)&smsg_out->file_name, W_MAX_PATH - 1);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800149
150 utf16s_to_utf8s((wchar_t *)smsg_in->path_name, W_MAX_PATH,
151 UTF16_LITTLE_ENDIAN,
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700152 (__u8 *)&smsg_out->path_name, W_MAX_PATH - 1);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800153
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700154 smsg_out->copy_flags = smsg_in->copy_flags;
155 smsg_out->file_size = smsg_in->file_size;
156 out_src = smsg_out;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800157 break;
158
159 default:
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700160 out_src = fcopy_transaction.fcopy_msg;
161 out_len = fcopy_transaction.recv_len;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800162 break;
163 }
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700164
165 fcopy_transaction.state = HVUTIL_USERSPACE_REQ;
166 rc = hvutil_transport_send(hvt, out_src, out_len);
167 if (rc) {
168 pr_debug("FCP: failed to communicate to the daemon: %d\n", rc);
169 if (cancel_delayed_work_sync(&fcopy_timeout_work)) {
170 fcopy_respond_to_host(HV_E_FAIL);
171 fcopy_transaction.state = HVUTIL_READY;
172 }
173 }
Vitaly Kuznetsov25ef06f2015-08-01 16:08:12 -0700174 kfree(smsg_out);
175
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800176 return;
177}
178
179/*
180 * Send a response back to the host.
181 */
182
183static void
184fcopy_respond_to_host(int error)
185{
186 struct icmsg_hdr *icmsghdr;
187 u32 buf_len;
188 struct vmbus_channel *channel;
189 u64 req_id;
190
191 /*
192 * Copy the global state for completing the transaction. Note that
193 * only one transaction can be active at a time. This is guaranteed
194 * by the file copy protocol implemented by the host. Furthermore,
195 * the "transaction active" state we maintain ensures that there can
196 * only be one active transaction at a time.
197 */
198
199 buf_len = fcopy_transaction.recv_len;
200 channel = fcopy_transaction.recv_channel;
201 req_id = fcopy_transaction.recv_req_id;
202
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800203 icmsghdr = (struct icmsg_hdr *)
204 &recv_buffer[sizeof(struct vmbuspipe_hdr)];
205
206 if (channel->onchannel_callback == NULL)
207 /*
208 * We have raced with util driver being unloaded;
209 * silently return.
210 */
211 return;
212
213 icmsghdr->status = error;
214 icmsghdr->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
215 vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
216 VM_PKT_DATA_INBAND, 0);
217}
218
219void hv_fcopy_onchannelcallback(void *context)
220{
221 struct vmbus_channel *channel = context;
222 u32 recvlen;
223 u64 requestid;
224 struct hv_fcopy_hdr *fcopy_msg;
225 struct icmsg_hdr *icmsghdr;
226 struct icmsg_negotiate *negop = NULL;
227 int util_fw_version;
228 int fcopy_srv_version;
229
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700230 if (fcopy_transaction.state > HVUTIL_READY) {
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800231 /*
232 * We will defer processing this callback once
233 * the current transaction is complete.
234 */
235 fcopy_transaction.fcopy_context = context;
236 return;
237 }
Vitaly Kuznetsov242f3122015-04-11 18:07:42 -0700238 fcopy_transaction.fcopy_context = NULL;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800239
240 vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
241 &requestid);
242 if (recvlen <= 0)
243 return;
244
245 icmsghdr = (struct icmsg_hdr *)&recv_buffer[
246 sizeof(struct vmbuspipe_hdr)];
247 if (icmsghdr->icmsgtype == ICMSGTYPE_NEGOTIATE) {
248 util_fw_version = UTIL_FW_VERSION;
249 fcopy_srv_version = WIN8_SRV_VERSION;
250 vmbus_prep_negotiate_resp(icmsghdr, negop, recv_buffer,
251 util_fw_version, fcopy_srv_version);
252 } else {
253 fcopy_msg = (struct hv_fcopy_hdr *)&recv_buffer[
254 sizeof(struct vmbuspipe_hdr) +
255 sizeof(struct icmsg_hdr)];
256
257 /*
258 * Stash away this global state for completing the
259 * transaction; note transactions are serialized.
260 */
261
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800262 fcopy_transaction.recv_len = recvlen;
263 fcopy_transaction.recv_channel = channel;
264 fcopy_transaction.recv_req_id = requestid;
265 fcopy_transaction.fcopy_msg = fcopy_msg;
266
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700267 if (fcopy_transaction.state < HVUTIL_READY) {
268 /* Userspace is not registered yet */
269 fcopy_respond_to_host(HV_E_FAIL);
270 return;
271 }
272 fcopy_transaction.state = HVUTIL_HOSTMSG_RECEIVED;
273
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800274 /*
275 * Send the information to the user-level daemon.
276 */
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700277 schedule_work(&fcopy_send_work);
Vitaly Kuznetsov1d072332015-04-11 18:07:45 -0700278 schedule_delayed_work(&fcopy_timeout_work, 5*HZ);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800279 return;
280 }
281 icmsghdr->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
282 vmbus_sendpacket(channel, recv_buffer, recvlen, requestid,
283 VM_PKT_DATA_INBAND, 0);
284}
285
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700286/* Callback when data is received from userspace */
287static int fcopy_on_msg(void *msg, int len)
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800288{
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700289 int *val = (int *)msg;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800290
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700291 if (len != sizeof(int))
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800292 return -EINVAL;
293
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700294 if (fcopy_transaction.state == HVUTIL_DEVICE_INIT)
295 return fcopy_handle_handshake(*val);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800296
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700297 if (fcopy_transaction.state != HVUTIL_USERSPACE_REQ)
298 return -EINVAL;
299
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800300 /*
301 * Complete the transaction by forwarding the result
302 * to the host. But first, cancel the timeout.
303 */
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700304 if (cancel_delayed_work_sync(&fcopy_timeout_work)) {
305 fcopy_transaction.state = HVUTIL_USERSPACE_RECV;
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700306 fcopy_respond_to_host(*val);
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700307 fcopy_transaction.state = HVUTIL_READY;
Vitaly Kuznetsov242f3122015-04-11 18:07:42 -0700308 hv_poll_channel(fcopy_transaction.fcopy_context,
309 hv_fcopy_onchannelcallback);
310 }
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800311
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800312 return 0;
313}
314
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700315static void fcopy_on_reset(void)
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800316{
317 /*
318 * The daemon has exited; reset the state.
319 */
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700320 fcopy_transaction.state = HVUTIL_DEVICE_INIT;
Dexuan Cuid9b16522015-01-14 01:55:10 -0800321
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700322 if (cancel_delayed_work_sync(&fcopy_timeout_work))
Dexuan Cuid9b16522015-01-14 01:55:10 -0800323 fcopy_respond_to_host(HV_E_FAIL);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800324}
325
326int hv_fcopy_init(struct hv_util_service *srv)
327{
328 recv_buffer = srv->recv_buffer;
329
330 /*
331 * When this driver loads, the user level daemon that
332 * processes the host requests may not yet be running.
333 * Defer processing channel callbacks until the daemon
334 * has registered.
335 */
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700336 fcopy_transaction.state = HVUTIL_DEVICE_INIT;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800337
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700338 hvt = hvutil_transport_init(fcopy_devname, 0, 0,
339 fcopy_on_msg, fcopy_on_reset);
340 if (!hvt)
341 return -EFAULT;
342
343 return 0;
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800344}
345
346void hv_fcopy_deinit(void)
347{
Vitaly Kuznetsov4c93ccc2015-04-11 18:07:49 -0700348 fcopy_transaction.state = HVUTIL_DEVICE_DYING;
Vitaly Kuznetsov1d072332015-04-11 18:07:45 -0700349 cancel_delayed_work_sync(&fcopy_timeout_work);
Vitaly Kuznetsovc7e490f2015-04-11 18:07:53 -0700350 hvutil_transport_destroy(hvt);
K. Y. Srinivasan013254762014-02-16 11:34:30 -0800351}