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