xref: /openbmc/linux/drivers/hv/hv_fcopy.c (revision a2cce7a9)
1 /*
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 
22 #include <linux/nls.h>
23 #include <linux/workqueue.h>
24 #include <linux/hyperv.h>
25 #include <linux/sched.h>
26 
27 #include "hyperv_vmbus.h"
28 #include "hv_utils_transport.h"
29 
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.
46  */
47 
48 static struct {
49 	int state;   /* hvutil_device_state */
50 	int recv_len; /* number of bytes received. */
51 	struct hv_fcopy_hdr  *fcopy_msg; /* current message */
52 	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 */
55 } fcopy_transaction;
56 
57 static void fcopy_respond_to_host(int error);
58 static void fcopy_send_data(struct work_struct *dummy);
59 static void fcopy_timeout_func(struct work_struct *dummy);
60 static DECLARE_DELAYED_WORK(fcopy_timeout_work, fcopy_timeout_func);
61 static DECLARE_WORK(fcopy_send_work, fcopy_send_data);
62 static const char fcopy_devname[] = "vmbus/hv_fcopy";
63 static u8 *recv_buffer;
64 static struct hvutil_transport *hvt;
65 /*
66  * This state maintains the version number registered by the daemon.
67  */
68 static int dm_reg_value;
69 
70 static void fcopy_timeout_func(struct work_struct *dummy)
71 {
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);
77 
78 	/* Transaction is finished, reset the state. */
79 	if (fcopy_transaction.state > HVUTIL_READY)
80 		fcopy_transaction.state = HVUTIL_READY;
81 
82 	hv_poll_channel(fcopy_transaction.fcopy_context,
83 			hv_fcopy_onchannelcallback);
84 }
85 
86 static int fcopy_handle_handshake(u32 version)
87 {
88 	u32 our_ver = FCOPY_CURRENT_VERSION;
89 
90 	switch (version) {
91 	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;
100 		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 	}
110 	pr_debug("FCP: userspace daemon ver. %d registered\n", version);
111 	fcopy_transaction.state = HVUTIL_READY;
112 	hv_poll_channel(fcopy_transaction.fcopy_context,
113 			hv_fcopy_onchannelcallback);
114 	return 0;
115 }
116 
117 static void fcopy_send_data(struct work_struct *dummy)
118 {
119 	struct hv_start_fcopy *smsg_out = NULL;
120 	int operation = fcopy_transaction.fcopy_msg->operation;
121 	struct hv_start_fcopy *smsg_in;
122 	void *out_src;
123 	int rc, out_len;
124 
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:
138 		out_len = sizeof(struct hv_start_fcopy);
139 		smsg_out = kzalloc(sizeof(*smsg_out), GFP_KERNEL);
140 		if (!smsg_out)
141 			return;
142 
143 		smsg_out->hdr.operation = operation;
144 		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,
148 				(__u8 *)&smsg_out->file_name, W_MAX_PATH - 1);
149 
150 		utf16s_to_utf8s((wchar_t *)smsg_in->path_name, W_MAX_PATH,
151 				UTF16_LITTLE_ENDIAN,
152 				(__u8 *)&smsg_out->path_name, W_MAX_PATH - 1);
153 
154 		smsg_out->copy_flags = smsg_in->copy_flags;
155 		smsg_out->file_size = smsg_in->file_size;
156 		out_src = smsg_out;
157 		break;
158 
159 	default:
160 		out_src = fcopy_transaction.fcopy_msg;
161 		out_len = fcopy_transaction.recv_len;
162 		break;
163 	}
164 
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 	}
174 	kfree(smsg_out);
175 
176 	return;
177 }
178 
179 /*
180  * Send a response back to the host.
181  */
182 
183 static void
184 fcopy_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 
203 	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 
219 void 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 
230 	if (fcopy_transaction.state > HVUTIL_READY) {
231 		/*
232 		 * We will defer processing this callback once
233 		 * the current transaction is complete.
234 		 */
235 		fcopy_transaction.fcopy_context = context;
236 		return;
237 	}
238 	fcopy_transaction.fcopy_context = NULL;
239 
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 
262 		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 
267 		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 
274 		/*
275 		 * Send the information to the user-level daemon.
276 		 */
277 		schedule_work(&fcopy_send_work);
278 		schedule_delayed_work(&fcopy_timeout_work, 5*HZ);
279 		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 
286 /* Callback when data is received from userspace */
287 static int fcopy_on_msg(void *msg, int len)
288 {
289 	int *val = (int *)msg;
290 
291 	if (len != sizeof(int))
292 		return -EINVAL;
293 
294 	if (fcopy_transaction.state == HVUTIL_DEVICE_INIT)
295 		return fcopy_handle_handshake(*val);
296 
297 	if (fcopy_transaction.state != HVUTIL_USERSPACE_REQ)
298 		return -EINVAL;
299 
300 	/*
301 	 * Complete the transaction by forwarding the result
302 	 * to the host. But first, cancel the timeout.
303 	 */
304 	if (cancel_delayed_work_sync(&fcopy_timeout_work)) {
305 		fcopy_transaction.state = HVUTIL_USERSPACE_RECV;
306 		fcopy_respond_to_host(*val);
307 		fcopy_transaction.state = HVUTIL_READY;
308 		hv_poll_channel(fcopy_transaction.fcopy_context,
309 				hv_fcopy_onchannelcallback);
310 	}
311 
312 	return 0;
313 }
314 
315 static void fcopy_on_reset(void)
316 {
317 	/*
318 	 * The daemon has exited; reset the state.
319 	 */
320 	fcopy_transaction.state = HVUTIL_DEVICE_INIT;
321 
322 	if (cancel_delayed_work_sync(&fcopy_timeout_work))
323 		fcopy_respond_to_host(HV_E_FAIL);
324 }
325 
326 int 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 	 */
336 	fcopy_transaction.state = HVUTIL_DEVICE_INIT;
337 
338 	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;
344 }
345 
346 void hv_fcopy_deinit(void)
347 {
348 	fcopy_transaction.state = HVUTIL_DEVICE_DYING;
349 	cancel_delayed_work_sync(&fcopy_timeout_work);
350 	hvutil_transport_destroy(hvt);
351 }
352