hv_snapshot.c 9.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * An implementation of host initiated guest snapshot.
 *
 *
 * Copyright (C) 2013, Microsoft, Inc.
 * Author : K. Y. Srinivasan <kys@microsoft.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 */
#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>

27
#include "hyperv_vmbus.h"
28
#include "hv_utils_transport.h"
29

30 31
#define VSS_MAJOR  5
#define VSS_MINOR  0
32
#define VSS_VERSION    (VSS_MAJOR << 16 | VSS_MINOR)
33

34
#define VSS_USERSPACE_TIMEOUT (msecs_to_jiffies(10 * 1000))
35 36

/*
37 38 39 40 41 42
 * 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.
43
 *
44 45 46 47
 * 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.
48 49 50
 */

static struct {
51
	int state;   /* hvutil_device_state */
52 53 54 55
	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 */
56
	void *vss_context; /* for the channel callback */
57 58 59 60 61
} vss_transaction;


static void vss_respond_to_host(int error);

62 63 64 65 66
/*
 * This state maintains the version number registered by the daemon.
 */
static int dm_reg_value;

67
static const char vss_devname[] = "vmbus/hv_vss";
68
static __u8 *recv_buffer;
69
static struct hvutil_transport *hvt;
70 71

static void vss_send_op(struct work_struct *dummy);
72 73 74
static void vss_timeout_func(struct work_struct *dummy);

static DECLARE_DELAYED_WORK(vss_timeout_work, vss_timeout_func);
75 76 77 78 79 80
static DECLARE_WORK(vss_send_op_work, vss_send_op);

/*
 * Callback when data is received from user mode.
 */

81 82 83 84 85 86 87
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\n");
	vss_respond_to_host(HV_E_FAIL);
88

89 90 91 92
	/* Transaction is finished, reset the state. */
	if (vss_transaction.state > HVUTIL_READY)
		vss_transaction.state = HVUTIL_READY;

93 94
	hv_poll_channel(vss_transaction.vss_context,
			hv_vss_onchannelcallback);
95 96
}

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
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:
		/* Daemon expects us to reply with our own version*/
		if (hvutil_transport_send(hvt, &our_ver, sizeof(our_ver)))
			return -EFAULT;
		dm_reg_value = VSS_OP_REGISTER1;
		break;
	default:
		return -EINVAL;
	}
	vss_transaction.state = HVUTIL_READY;
	pr_info("VSS daemon registered\n");
	return 0;
}

120
static int vss_on_msg(void *msg, int len)
121
{
122
	struct hv_vss_msg *vss_msg = (struct hv_vss_msg *)msg;
123

124 125
	if (len != sizeof(*vss_msg))
		return -EINVAL;
126

127 128 129 130 131 132 133 134 135
	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.
		 */
		if (vss_transaction.state > HVUTIL_READY)
			return -EINVAL;
		return vss_handle_handshake(vss_msg);
136 137 138 139 140 141 142 143 144 145 146 147
	} else if (vss_transaction.state == HVUTIL_USERSPACE_REQ) {
		vss_transaction.state = HVUTIL_USERSPACE_RECV;
		if (cancel_delayed_work_sync(&vss_timeout_work)) {
			vss_respond_to_host(vss_msg->error);
			/* Transaction is finished, reset the state. */
			vss_transaction.state = HVUTIL_READY;
			hv_poll_channel(vss_transaction.vss_context,
					hv_vss_onchannelcallback);
		}
	} else {
		/* This is a spurious call! */
		pr_warn("VSS: Transaction not active\n");
148
		return -EINVAL;
149
	}
150
	return 0;
151 152 153 154 155 156
}


static void vss_send_op(struct work_struct *dummy)
{
	int op = vss_transaction.msg->vss_hdr.operation;
157
	int rc;
158 159
	struct hv_vss_msg *vss_msg;

160 161 162 163
	/* The transaction state is wrong. */
	if (vss_transaction.state != HVUTIL_HOSTMSG_RECEIVED)
		return;

164 165
	vss_msg = kzalloc(sizeof(*vss_msg), GFP_KERNEL);
	if (!vss_msg)
166 167 168 169
		return;

	vss_msg->vss_hdr.operation = op;

170
	vss_transaction.state = HVUTIL_USERSPACE_REQ;
171
	rc = hvutil_transport_send(hvt, vss_msg, sizeof(*vss_msg));
172 173
	if (rc) {
		pr_warn("VSS: failed to communicate to the daemon: %d\n", rc);
174
		if (cancel_delayed_work_sync(&vss_timeout_work)) {
175
			vss_respond_to_host(HV_E_FAIL);
176 177
			vss_transaction.state = HVUTIL_READY;
		}
178
	}
179

180
	kfree(vss_msg);
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240

	return;
}

/*
 * 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;

	/*
	 * 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;

	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;


	struct icmsg_hdr *icmsghdrp;
	struct icmsg_negotiate *negop = NULL;

241
	if (vss_transaction.state > HVUTIL_READY) {
242 243 244 245
		/*
		 * We will defer processing this callback once
		 * the current transaction is complete.
		 */
246
		vss_transaction.vss_context = context;
247 248
		return;
	}
249
	vss_transaction.vss_context = NULL;
250 251 252 253 254 255 256 257 258 259

	vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
			 &requestid);

	if (recvlen > 0) {
		icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
			sizeof(struct vmbuspipe_hdr)];

		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
			vmbus_prep_negotiate_resp(icmsghdrp, negop,
260 261
				 recv_buffer, UTIL_FW_VERSION,
				 VSS_VERSION);
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 289 290
		} 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;
			vss_transaction.recv_channel = channel;
			vss_transaction.recv_req_id = requestid;
			vss_transaction.msg = (struct hv_vss_msg *)vss_msg;

			switch (vss_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_FREEZE:
			case VSS_OP_THAW:
291 292 293 294 295 296
				if (vss_transaction.state < HVUTIL_READY) {
					/* Userspace is not registered yet */
					vss_respond_to_host(HV_E_FAIL);
					return;
				}
				vss_transaction.state = HVUTIL_HOSTMSG_RECEIVED;
297
				schedule_work(&vss_send_op_work);
298 299
				schedule_delayed_work(&vss_timeout_work,
						      VSS_USERSPACE_TIMEOUT);
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
				return;

			case VSS_OP_HOT_BACKUP:
				vss_msg->vss_cf.flags =
					 VSS_HBU_NO_AUTO_RECOVERY;
				vss_respond_to_host(0);
				return;

			case VSS_OP_GET_DM_INFO:
				vss_msg->dm_info.flags = 0;
				vss_respond_to_host(0);
				return;

			default:
				vss_respond_to_host(0);
				return;

			}

		}

		icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
			| ICMSGHDRFLAG_RESPONSE;

		vmbus_sendpacket(channel, recv_buffer,
				       recvlen, requestid,
				       VM_PKT_DATA_INBAND, 0);
	}

}

331 332 333 334 335 336 337
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;
}

338 339 340 341 342 343 344 345 346 347 348
int
hv_vss_init(struct hv_util_service *srv)
{
	recv_buffer = srv->recv_buffer;

	/*
	 * 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.
	 */
349 350
	vss_transaction.state = HVUTIL_DEVICE_INIT;

351 352 353 354 355
	hvt = hvutil_transport_init(vss_devname, CN_VSS_IDX, CN_VSS_VAL,
				    vss_on_msg, vss_on_reset);
	if (!hvt)
		return -EFAULT;

356 357 358 359 360
	return 0;
}

void hv_vss_deinit(void)
{
361
	vss_transaction.state = HVUTIL_DEVICE_DYING;
362
	cancel_delayed_work_sync(&vss_timeout_work);
363
	cancel_work_sync(&vss_send_op_work);
364
	hvutil_transport_destroy(hvt);
365
}