288 lines
6.7 KiB
C
288 lines
6.7 KiB
C
/*
|
|
* 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);
|
|
}
|