]>
Commit | Line | Data |
---|---|---|
1 | // SPDX-License-Identifier: GPL-2.0-only | |
2 | /* | |
3 | * An implementation of host initiated guest snapshot. | |
4 | * | |
5 | * Copyright (C) 2013, Microsoft, Inc. | |
6 | * Author : K. Y. Srinivasan <kys@microsoft.com> | |
7 | */ | |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
9 | ||
10 | #include <linux/net.h> | |
11 | #include <linux/nls.h> | |
12 | #include <linux/connector.h> | |
13 | #include <linux/workqueue.h> | |
14 | #include <linux/hyperv.h> | |
15 | #include <asm/hyperv-tlfs.h> | |
16 | ||
17 | #include "hyperv_vmbus.h" | |
18 | #include "hv_utils_transport.h" | |
19 | ||
20 | #define VSS_MAJOR 5 | |
21 | #define VSS_MINOR 0 | |
22 | #define VSS_VERSION (VSS_MAJOR << 16 | VSS_MINOR) | |
23 | ||
24 | #define VSS_VER_COUNT 1 | |
25 | static const int vss_versions[] = { | |
26 | VSS_VERSION | |
27 | }; | |
28 | ||
29 | #define FW_VER_COUNT 1 | |
30 | static const int fw_versions[] = { | |
31 | UTIL_FW_VERSION | |
32 | }; | |
33 | ||
34 | /* | |
35 | * Timeout values are based on expecations from host | |
36 | */ | |
37 | #define VSS_FREEZE_TIMEOUT (15 * 60) | |
38 | ||
39 | /* | |
40 | * Global state maintained for transaction that is being processed. For a class | |
41 | * of integration services, including the "VSS service", the specified protocol | |
42 | * is a "request/response" protocol which means that there can only be single | |
43 | * outstanding transaction from the host at any given point in time. We use | |
44 | * this to simplify memory management in this driver - we cache and process | |
45 | * only one message at a time. | |
46 | * | |
47 | * While the request/response protocol is guaranteed by the host, we further | |
48 | * ensure this by serializing packet processing in this driver - we do not | |
49 | * read additional packets from the VMBUs until the current packet is fully | |
50 | * handled. | |
51 | */ | |
52 | ||
53 | static struct { | |
54 | int state; /* hvutil_device_state */ | |
55 | int recv_len; /* number of bytes received. */ | |
56 | struct vmbus_channel *recv_channel; /* chn we got the request */ | |
57 | u64 recv_req_id; /* request ID. */ | |
58 | struct hv_vss_msg *msg; /* current message */ | |
59 | } vss_transaction; | |
60 | ||
61 | ||
62 | static void vss_respond_to_host(int error); | |
63 | ||
64 | /* | |
65 | * This state maintains the version number registered by the daemon. | |
66 | */ | |
67 | static int dm_reg_value; | |
68 | ||
69 | static const char vss_devname[] = "vmbus/hv_vss"; | |
70 | static __u8 *recv_buffer; | |
71 | static struct hvutil_transport *hvt; | |
72 | ||
73 | static void vss_timeout_func(struct work_struct *dummy); | |
74 | static void vss_handle_request(struct work_struct *dummy); | |
75 | ||
76 | static DECLARE_DELAYED_WORK(vss_timeout_work, vss_timeout_func); | |
77 | static DECLARE_WORK(vss_handle_request_work, vss_handle_request); | |
78 | ||
79 | static void vss_poll_wrapper(void *channel) | |
80 | { | |
81 | /* Transaction is finished, reset the state here to avoid races. */ | |
82 | vss_transaction.state = HVUTIL_READY; | |
83 | tasklet_schedule(&((struct vmbus_channel *)channel)->callback_event); | |
84 | } | |
85 | ||
86 | /* | |
87 | * Callback when data is received from user mode. | |
88 | */ | |
89 | ||
90 | static void vss_timeout_func(struct work_struct *dummy) | |
91 | { | |
92 | /* | |
93 | * Timeout waiting for userspace component to reply happened. | |
94 | */ | |
95 | pr_warn("VSS: timeout waiting for daemon to reply\n"); | |
96 | vss_respond_to_host(HV_E_FAIL); | |
97 | ||
98 | hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper); | |
99 | } | |
100 | ||
101 | static void vss_register_done(void) | |
102 | { | |
103 | hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper); | |
104 | pr_debug("VSS: userspace daemon registered\n"); | |
105 | } | |
106 | ||
107 | static int vss_handle_handshake(struct hv_vss_msg *vss_msg) | |
108 | { | |
109 | u32 our_ver = VSS_OP_REGISTER1; | |
110 | ||
111 | switch (vss_msg->vss_hdr.operation) { | |
112 | case VSS_OP_REGISTER: | |
113 | /* Daemon doesn't expect us to reply */ | |
114 | dm_reg_value = VSS_OP_REGISTER; | |
115 | break; | |
116 | case VSS_OP_REGISTER1: | |
117 | /* Daemon expects us to reply with our own version */ | |
118 | if (hvutil_transport_send(hvt, &our_ver, sizeof(our_ver), | |
119 | vss_register_done)) | |
120 | return -EFAULT; | |
121 | dm_reg_value = VSS_OP_REGISTER1; | |
122 | break; | |
123 | default: | |
124 | return -EINVAL; | |
125 | } | |
126 | pr_info("VSS: userspace daemon ver. %d connected\n", dm_reg_value); | |
127 | return 0; | |
128 | } | |
129 | ||
130 | static int vss_on_msg(void *msg, int len) | |
131 | { | |
132 | struct hv_vss_msg *vss_msg = (struct hv_vss_msg *)msg; | |
133 | ||
134 | if (len != sizeof(*vss_msg)) { | |
135 | pr_debug("VSS: Message size does not match length\n"); | |
136 | return -EINVAL; | |
137 | } | |
138 | ||
139 | if (vss_msg->vss_hdr.operation == VSS_OP_REGISTER || | |
140 | vss_msg->vss_hdr.operation == VSS_OP_REGISTER1) { | |
141 | /* | |
142 | * Don't process registration messages if we're in the middle | |
143 | * of a transaction processing. | |
144 | */ | |
145 | if (vss_transaction.state > HVUTIL_READY) { | |
146 | pr_debug("VSS: Got unexpected registration request\n"); | |
147 | return -EINVAL; | |
148 | } | |
149 | ||
150 | return vss_handle_handshake(vss_msg); | |
151 | } else if (vss_transaction.state == HVUTIL_USERSPACE_REQ) { | |
152 | vss_transaction.state = HVUTIL_USERSPACE_RECV; | |
153 | ||
154 | if (vss_msg->vss_hdr.operation == VSS_OP_HOT_BACKUP) | |
155 | vss_transaction.msg->vss_cf.flags = | |
156 | VSS_HBU_NO_AUTO_RECOVERY; | |
157 | ||
158 | if (cancel_delayed_work_sync(&vss_timeout_work)) { | |
159 | vss_respond_to_host(vss_msg->error); | |
160 | /* Transaction is finished, reset the state. */ | |
161 | hv_poll_channel(vss_transaction.recv_channel, | |
162 | vss_poll_wrapper); | |
163 | } | |
164 | } else { | |
165 | /* This is a spurious call! */ | |
166 | pr_debug("VSS: Transaction not active\n"); | |
167 | return -EINVAL; | |
168 | } | |
169 | return 0; | |
170 | } | |
171 | ||
172 | static void vss_send_op(void) | |
173 | { | |
174 | int op = vss_transaction.msg->vss_hdr.operation; | |
175 | int rc; | |
176 | struct hv_vss_msg *vss_msg; | |
177 | ||
178 | /* The transaction state is wrong. */ | |
179 | if (vss_transaction.state != HVUTIL_HOSTMSG_RECEIVED) { | |
180 | pr_debug("VSS: Unexpected attempt to send to daemon\n"); | |
181 | return; | |
182 | } | |
183 | ||
184 | vss_msg = kzalloc(sizeof(*vss_msg), GFP_KERNEL); | |
185 | if (!vss_msg) | |
186 | return; | |
187 | ||
188 | vss_msg->vss_hdr.operation = op; | |
189 | ||
190 | vss_transaction.state = HVUTIL_USERSPACE_REQ; | |
191 | ||
192 | schedule_delayed_work(&vss_timeout_work, op == VSS_OP_FREEZE ? | |
193 | VSS_FREEZE_TIMEOUT * HZ : HV_UTIL_TIMEOUT * HZ); | |
194 | ||
195 | rc = hvutil_transport_send(hvt, vss_msg, sizeof(*vss_msg), NULL); | |
196 | if (rc) { | |
197 | pr_warn("VSS: failed to communicate to the daemon: %d\n", rc); | |
198 | if (cancel_delayed_work_sync(&vss_timeout_work)) { | |
199 | vss_respond_to_host(HV_E_FAIL); | |
200 | vss_transaction.state = HVUTIL_READY; | |
201 | } | |
202 | } | |
203 | ||
204 | kfree(vss_msg); | |
205 | } | |
206 | ||
207 | static void vss_handle_request(struct work_struct *dummy) | |
208 | { | |
209 | switch (vss_transaction.msg->vss_hdr.operation) { | |
210 | /* | |
211 | * Initiate a "freeze/thaw" operation in the guest. | |
212 | * We respond to the host once the operation is complete. | |
213 | * | |
214 | * We send the message to the user space daemon and the operation is | |
215 | * performed in the daemon. | |
216 | */ | |
217 | case VSS_OP_THAW: | |
218 | case VSS_OP_FREEZE: | |
219 | case VSS_OP_HOT_BACKUP: | |
220 | if (vss_transaction.state < HVUTIL_READY) { | |
221 | /* Userspace is not registered yet */ | |
222 | pr_debug("VSS: Not ready for request.\n"); | |
223 | vss_respond_to_host(HV_E_FAIL); | |
224 | return; | |
225 | } | |
226 | ||
227 | pr_debug("VSS: Received request for op code: %d\n", | |
228 | vss_transaction.msg->vss_hdr.operation); | |
229 | vss_transaction.state = HVUTIL_HOSTMSG_RECEIVED; | |
230 | vss_send_op(); | |
231 | return; | |
232 | case VSS_OP_GET_DM_INFO: | |
233 | vss_transaction.msg->dm_info.flags = 0; | |
234 | break; | |
235 | default: | |
236 | break; | |
237 | } | |
238 | ||
239 | vss_respond_to_host(0); | |
240 | hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper); | |
241 | } | |
242 | ||
243 | /* | |
244 | * Send a response back to the host. | |
245 | */ | |
246 | ||
247 | static void | |
248 | vss_respond_to_host(int error) | |
249 | { | |
250 | struct icmsg_hdr *icmsghdrp; | |
251 | u32 buf_len; | |
252 | struct vmbus_channel *channel; | |
253 | u64 req_id; | |
254 | ||
255 | /* | |
256 | * Copy the global state for completing the transaction. Note that | |
257 | * only one transaction can be active at a time. | |
258 | */ | |
259 | ||
260 | buf_len = vss_transaction.recv_len; | |
261 | channel = vss_transaction.recv_channel; | |
262 | req_id = vss_transaction.recv_req_id; | |
263 | ||
264 | icmsghdrp = (struct icmsg_hdr *) | |
265 | &recv_buffer[sizeof(struct vmbuspipe_hdr)]; | |
266 | ||
267 | if (channel->onchannel_callback == NULL) | |
268 | /* | |
269 | * We have raced with util driver being unloaded; | |
270 | * silently return. | |
271 | */ | |
272 | return; | |
273 | ||
274 | icmsghdrp->status = error; | |
275 | ||
276 | icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE; | |
277 | ||
278 | vmbus_sendpacket(channel, recv_buffer, buf_len, req_id, | |
279 | VM_PKT_DATA_INBAND, 0); | |
280 | ||
281 | } | |
282 | ||
283 | /* | |
284 | * This callback is invoked when we get a VSS message from the host. | |
285 | * The host ensures that only one VSS transaction can be active at a time. | |
286 | */ | |
287 | ||
288 | void hv_vss_onchannelcallback(void *context) | |
289 | { | |
290 | struct vmbus_channel *channel = context; | |
291 | u32 recvlen; | |
292 | u64 requestid; | |
293 | struct hv_vss_msg *vss_msg; | |
294 | int vss_srv_version; | |
295 | ||
296 | struct icmsg_hdr *icmsghdrp; | |
297 | ||
298 | if (vss_transaction.state > HVUTIL_READY) | |
299 | return; | |
300 | ||
301 | if (vmbus_recvpacket(channel, recv_buffer, HV_HYP_PAGE_SIZE * 2, &recvlen, &requestid)) { | |
302 | pr_err_ratelimited("VSS request received. Could not read into recv buf\n"); | |
303 | return; | |
304 | } | |
305 | ||
306 | if (!recvlen) | |
307 | return; | |
308 | ||
309 | /* Ensure recvlen is big enough to read header data */ | |
310 | if (recvlen < ICMSG_HDR) { | |
311 | pr_err_ratelimited("VSS request received. Packet length too small: %d\n", | |
312 | recvlen); | |
313 | return; | |
314 | } | |
315 | ||
316 | icmsghdrp = (struct icmsg_hdr *)&recv_buffer[sizeof(struct vmbuspipe_hdr)]; | |
317 | ||
318 | if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { | |
319 | if (vmbus_prep_negotiate_resp(icmsghdrp, | |
320 | recv_buffer, recvlen, | |
321 | fw_versions, FW_VER_COUNT, | |
322 | vss_versions, VSS_VER_COUNT, | |
323 | NULL, &vss_srv_version)) { | |
324 | ||
325 | pr_info("VSS IC version %d.%d\n", | |
326 | vss_srv_version >> 16, | |
327 | vss_srv_version & 0xFFFF); | |
328 | } | |
329 | } else if (icmsghdrp->icmsgtype == ICMSGTYPE_VSS) { | |
330 | /* Ensure recvlen is big enough to contain hv_vss_msg */ | |
331 | if (recvlen < ICMSG_HDR + sizeof(struct hv_vss_msg)) { | |
332 | pr_err_ratelimited("Invalid VSS msg. Packet length too small: %u\n", | |
333 | recvlen); | |
334 | return; | |
335 | } | |
336 | vss_msg = (struct hv_vss_msg *)&recv_buffer[ICMSG_HDR]; | |
337 | ||
338 | /* | |
339 | * Stash away this global state for completing the | |
340 | * transaction; note transactions are serialized. | |
341 | */ | |
342 | ||
343 | vss_transaction.recv_len = recvlen; | |
344 | vss_transaction.recv_req_id = requestid; | |
345 | vss_transaction.msg = (struct hv_vss_msg *)vss_msg; | |
346 | ||
347 | schedule_work(&vss_handle_request_work); | |
348 | return; | |
349 | } else { | |
350 | pr_err_ratelimited("VSS request received. Invalid msg type: %d\n", | |
351 | icmsghdrp->icmsgtype); | |
352 | return; | |
353 | } | |
354 | ||
355 | icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | | |
356 | ICMSGHDRFLAG_RESPONSE; | |
357 | vmbus_sendpacket(channel, recv_buffer, recvlen, requestid, | |
358 | VM_PKT_DATA_INBAND, 0); | |
359 | } | |
360 | ||
361 | static void vss_on_reset(void) | |
362 | { | |
363 | if (cancel_delayed_work_sync(&vss_timeout_work)) | |
364 | vss_respond_to_host(HV_E_FAIL); | |
365 | vss_transaction.state = HVUTIL_DEVICE_INIT; | |
366 | } | |
367 | ||
368 | int | |
369 | hv_vss_init(struct hv_util_service *srv) | |
370 | { | |
371 | if (vmbus_proto_version < VERSION_WIN8_1) { | |
372 | pr_warn("Integration service 'Backup (volume snapshot)'" | |
373 | " not supported on this host version.\n"); | |
374 | return -ENOTSUPP; | |
375 | } | |
376 | recv_buffer = srv->recv_buffer; | |
377 | vss_transaction.recv_channel = srv->channel; | |
378 | vss_transaction.recv_channel->max_pkt_size = HV_HYP_PAGE_SIZE * 2; | |
379 | ||
380 | /* | |
381 | * When this driver loads, the user level daemon that | |
382 | * processes the host requests may not yet be running. | |
383 | * Defer processing channel callbacks until the daemon | |
384 | * has registered. | |
385 | */ | |
386 | vss_transaction.state = HVUTIL_DEVICE_INIT; | |
387 | ||
388 | hvt = hvutil_transport_init(vss_devname, CN_VSS_IDX, CN_VSS_VAL, | |
389 | vss_on_msg, vss_on_reset); | |
390 | if (!hvt) { | |
391 | pr_warn("VSS: Failed to initialize transport\n"); | |
392 | return -EFAULT; | |
393 | } | |
394 | ||
395 | return 0; | |
396 | } | |
397 | ||
398 | static void hv_vss_cancel_work(void) | |
399 | { | |
400 | cancel_delayed_work_sync(&vss_timeout_work); | |
401 | cancel_work_sync(&vss_handle_request_work); | |
402 | } | |
403 | ||
404 | int hv_vss_pre_suspend(void) | |
405 | { | |
406 | struct vmbus_channel *channel = vss_transaction.recv_channel; | |
407 | struct hv_vss_msg *vss_msg; | |
408 | ||
409 | /* | |
410 | * Fake a THAW message for the user space daemon in case the daemon | |
411 | * has frozen the file systems. It doesn't matter if there is already | |
412 | * a message pending to be delivered to the user space since we force | |
413 | * vss_transaction.state to be HVUTIL_READY, so the user space daemon's | |
414 | * write() will fail with EINVAL (see vss_on_msg()), and the daemon | |
415 | * will reset the device by closing and re-opening it. | |
416 | */ | |
417 | vss_msg = kzalloc(sizeof(*vss_msg), GFP_KERNEL); | |
418 | if (!vss_msg) | |
419 | return -ENOMEM; | |
420 | ||
421 | tasklet_disable(&channel->callback_event); | |
422 | ||
423 | vss_msg->vss_hdr.operation = VSS_OP_THAW; | |
424 | ||
425 | /* Cancel any possible pending work. */ | |
426 | hv_vss_cancel_work(); | |
427 | ||
428 | /* We don't care about the return value. */ | |
429 | hvutil_transport_send(hvt, vss_msg, sizeof(*vss_msg), NULL); | |
430 | ||
431 | kfree(vss_msg); | |
432 | ||
433 | vss_transaction.state = HVUTIL_READY; | |
434 | ||
435 | /* tasklet_enable() will be called in hv_vss_pre_resume(). */ | |
436 | return 0; | |
437 | } | |
438 | ||
439 | int hv_vss_pre_resume(void) | |
440 | { | |
441 | struct vmbus_channel *channel = vss_transaction.recv_channel; | |
442 | ||
443 | tasklet_enable(&channel->callback_event); | |
444 | ||
445 | return 0; | |
446 | } | |
447 | ||
448 | void hv_vss_deinit(void) | |
449 | { | |
450 | vss_transaction.state = HVUTIL_DEVICE_DYING; | |
451 | ||
452 | hv_vss_cancel_work(); | |
453 | ||
454 | hvutil_transport_destroy(hvt); | |
455 | } |