Drivers: hv: Add a new driver to support host initiated backup (96dd86fa) · Commits · 戴 / test

drivers/hv/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -5,4 +5,4 @@ obj-$(CONFIG_HYPERV_BALLOON) += hv_balloon.o
		hv_vmbus-y := vmbus_drv.o \
		hv.o connection.o channel.o \
		channel_mgmt.o ring_buffer.o
		hv_utils-y := hv_util.o hv_kvp.o
		hv_utils-y := hv_util.o hv_kvp.o hv_snapshot.o

drivers/hv/hv_snapshot.c

0 → 100644

+287 −0

Original line number	Diff line number	Diff line
		/*
		* 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>



		/*
		* Global state maintained for transaction that is being processed.
		* Note that only one transaction can be active at any point in time.
		*
		* This state is set when we receive a request from the host; we
		* cleanup this state when the transaction is completed - when we respond
		* to the host with the key value.
		*/

		static struct {
		bool active; /* transaction status - active or not */
		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);

		static struct cb_id vss_id = { CN_VSS_IDX, CN_VSS_VAL };
		static const char vss_name[] = "vss_kernel_module";
		static __u8 *recv_buffer;

		static void vss_send_op(struct work_struct *dummy);
		static DECLARE_WORK(vss_send_op_work, vss_send_op);

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

		static void
		vss_cn_callback(struct cn_msg msg, struct netlink_skb_parms nsp)
		{
		struct hv_vss_msg *vss_msg;

		vss_msg = (struct hv_vss_msg *)msg->data;

		if (vss_msg->vss_hdr.operation == VSS_OP_REGISTER) {
		pr_info("VSS daemon registered\n");
		vss_transaction.active = false;
		if (vss_transaction.recv_channel != NULL)
		hv_vss_onchannelcallback(vss_transaction.recv_channel);
		return;

		}
		vss_respond_to_host(vss_msg->error);
		}


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

		msg = kzalloc(sizeof(msg) + sizeof(vss_msg), GFP_ATOMIC);
		if (!msg)
		return;

		vss_msg = (struct hv_vss_msg *)msg->data;

		msg->id.idx = CN_VSS_IDX;
		msg->id.val = CN_VSS_VAL;

		vss_msg->vss_hdr.operation = op;
		msg->len = sizeof(struct hv_vss_msg);

		cn_netlink_send(msg, 0, GFP_ATOMIC);
		kfree(msg);

		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;

		/*
		* If a transaction is not active; log and return.
		*/

		if (!vss_transaction.active) {
		/*
		* This is a spurious call!
		*/
		pr_warn("VSS: Transaction not active\n");
		return;
		}
		/*
		* 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;
		vss_transaction.active = false;

		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;

		if (vss_transaction.active) {
		/*
		* We will defer processing this callback once
		* the current transaction is complete.
		*/
		vss_transaction.recv_channel = channel;
		return;
		}

		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,
		recv_buffer, MAX_SRV_VER, MAX_SRV_VER);
		/*
		* We currently negotiate the highest number the
		* host has presented. If this version is not
		* atleast 5.0, reject.
		*/
		negop = (struct icmsg_negotiate *)&recv_buffer[
		sizeof(struct vmbuspipe_hdr) +
		sizeof(struct icmsg_hdr)];

		if (negop->icversion_data[1].major < 5)
		negop->icframe_vercnt = 0;
		} 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.active = true;
		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:
		schedule_work(&vss_send_op_work);
		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);
		}

		}

		int
		hv_vss_init(struct hv_util_service *srv)
		{
		int err;

		err = cn_add_callback(&vss_id, vss_name, vss_cn_callback);
		if (err)
		return err;
		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.
		*/
		vss_transaction.active = true;
		return 0;
		}

		void hv_vss_deinit(void)
		{
		cn_del_callback(&vss_id);
		cancel_work_sync(&vss_send_op_work);
		}

drivers/hv/hv_util.c

+10 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,12 @@ static struct hv_util_service util_kvp = {
		.util_deinit = hv_kvp_deinit,
		};

		static struct hv_util_service util_vss = {
		.util_cb = hv_vss_onchannelcallback,
		.util_init = hv_vss_init,
		.util_deinit = hv_vss_deinit,
		};

		static void perform_shutdown(struct work_struct *dummy)
		{
		orderly_poweroff(true);
		@@ -339,6 +345,10 @@ static const struct hv_vmbus_device_id id_table[] = {
		{ HV_KVP_GUID,
		.driver_data = (unsigned long)&util_kvp
		},
		/* VSS GUID */
		{ HV_VSS_GUID,
		.driver_data = (unsigned long)&util_vss
		},
		{ },
		};

include/linux/hyperv.h

+69 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,63 @@

		#include <linux/types.h>


		/*
		* Implementation of host controlled snapshot of the guest.
		*/

		#define VSS_OP_REGISTER 128

		enum hv_vss_op {
		VSS_OP_CREATE = 0,
		VSS_OP_DELETE,
		VSS_OP_HOT_BACKUP,
		VSS_OP_GET_DM_INFO,
		VSS_OP_BU_COMPLETE,
		/*
		* Following operations are only supported with IC version >= 5.0
		*/
		VSS_OP_FREEZE, /* Freeze the file systems in the VM */
		VSS_OP_THAW, /* Unfreeze the file systems */
		VSS_OP_AUTO_RECOVER,
		VSS_OP_COUNT /* Number of operations, must be last */
		};


		/*
		* Header for all VSS messages.
		*/
		struct hv_vss_hdr {
		__u8 operation;
		__u8 reserved[7];
		} __attribute__((packed));


		/*
		* Flag values for the hv_vss_check_feature. Linux supports only
		* one value.
		*/
		#define VSS_HBU_NO_AUTO_RECOVERY 0x00000005

		struct hv_vss_check_feature {
		__u32 flags;
		} __attribute__((packed));

		struct hv_vss_check_dm_info {
		__u32 flags;
		} __attribute__((packed));

		struct hv_vss_msg {
		union {
		struct hv_vss_hdr vss_hdr;
		int error;
		};
		union {
		struct hv_vss_check_feature vss_cf;
		struct hv_vss_check_dm_info dm_info;
		};
		} __attribute__((packed));

		/*
		* An implementation of HyperV key value pair (KVP) functionality for Linux.
		*
		@@ -1252,6 +1309,14 @@ void vmbus_driver_unregister(struct hv_driver *hv_driver);
		0xb9, 0x8b, 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a \
		}

		/*
		* VSS (Backup/Restore) GUID
		*/
		#define HV_VSS_GUID \
		.guid = { \
		0x29, 0x2e, 0xfa, 0x35, 0x23, 0xea, 0x36, 0x42, \
		0x96, 0xae, 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40 \
		}
		/*
		* Common header for Hyper-V ICs
		*/
		@@ -1356,6 +1421,10 @@ int hv_kvp_init(struct hv_util_service *);
		void hv_kvp_deinit(void);
		void hv_kvp_onchannelcallback(void *);

		int hv_vss_init(struct hv_util_service *);
		void hv_vss_deinit(void);
		void hv_vss_onchannelcallback(void *);

		/*
		* Negotiated version with the Host.
		*/

include/uapi/linux/connector.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -44,8 +44,11 @@
		#define CN_VAL_DRBD 0x1
		#define CN_KVP_IDX 0x9 /* HyperV KVP */
		#define CN_KVP_VAL 0x1 /* queries from the kernel */
		#define CN_VSS_IDX 0xA /* HyperV VSS */
		#define CN_VSS_VAL 0x1 /* queries from the kernel */

		#define CN_NETLINK_USERS 10 /* Highest index + 1 */

		#define CN_NETLINK_USERS 11 /* Highest index + 1 */

		/*
		* Maximum connector's message size.

Admin message