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