Drivers: hv: Add a new driver to support host initiated backup
[linux-3.10.git] / drivers / hv / hv_snapshot.c
1 /*
2  * An implementation of host initiated guest snapshot.
3  *
4  *
5  * Copyright (C) 2013, Microsoft, Inc.
6  * Author : K. Y. Srinivasan <kys@microsoft.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published
10  * by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
15  * NON INFRINGEMENT.  See the GNU General Public License for more
16  * details.
17  *
18  */
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #include <linux/net.h>
22 #include <linux/nls.h>
23 #include <linux/connector.h>
24 #include <linux/workqueue.h>
25 #include <linux/hyperv.h>
26
27
28
29 /*
30  * Global state maintained for transaction that is being processed.
31  * Note that only one transaction can be active at any point in time.
32  *
33  * This state is set when we receive a request from the host; we
34  * cleanup this state when the transaction is completed - when we respond
35  * to the host with the key value.
36  */
37
38 static struct {
39         bool active; /* transaction status - active or not */
40         int recv_len; /* number of bytes received. */
41         struct vmbus_channel *recv_channel; /* chn we got the request */
42         u64 recv_req_id; /* request ID. */
43         struct hv_vss_msg  *msg; /* current message */
44 } vss_transaction;
45
46
47 static void vss_respond_to_host(int error);
48
49 static struct cb_id vss_id = { CN_VSS_IDX, CN_VSS_VAL };
50 static const char vss_name[] = "vss_kernel_module";
51 static __u8 *recv_buffer;
52
53 static void vss_send_op(struct work_struct *dummy);
54 static DECLARE_WORK(vss_send_op_work, vss_send_op);
55
56 /*
57  * Callback when data is received from user mode.
58  */
59
60 static void
61 vss_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
62 {
63         struct hv_vss_msg *vss_msg;
64
65         vss_msg = (struct hv_vss_msg *)msg->data;
66
67         if (vss_msg->vss_hdr.operation == VSS_OP_REGISTER) {
68                 pr_info("VSS daemon registered\n");
69                 vss_transaction.active = false;
70                 if (vss_transaction.recv_channel != NULL)
71                         hv_vss_onchannelcallback(vss_transaction.recv_channel);
72                 return;
73
74         }
75         vss_respond_to_host(vss_msg->error);
76 }
77
78
79 static void vss_send_op(struct work_struct *dummy)
80 {
81         int op = vss_transaction.msg->vss_hdr.operation;
82         struct cn_msg *msg;
83         struct hv_vss_msg *vss_msg;
84
85         msg = kzalloc(sizeof(*msg) + sizeof(*vss_msg), GFP_ATOMIC);
86         if (!msg)
87                 return;
88
89         vss_msg = (struct hv_vss_msg *)msg->data;
90
91         msg->id.idx =  CN_VSS_IDX;
92         msg->id.val = CN_VSS_VAL;
93
94         vss_msg->vss_hdr.operation = op;
95         msg->len = sizeof(struct hv_vss_msg);
96
97         cn_netlink_send(msg, 0, GFP_ATOMIC);
98         kfree(msg);
99
100         return;
101 }
102
103 /*
104  * Send a response back to the host.
105  */
106
107 static void
108 vss_respond_to_host(int error)
109 {
110         struct icmsg_hdr *icmsghdrp;
111         u32     buf_len;
112         struct vmbus_channel *channel;
113         u64     req_id;
114
115         /*
116          * If a transaction is not active; log and return.
117          */
118
119         if (!vss_transaction.active) {
120                 /*
121                  * This is a spurious call!
122                  */
123                 pr_warn("VSS: Transaction not active\n");
124                 return;
125         }
126         /*
127          * Copy the global state for completing the transaction. Note that
128          * only one transaction can be active at a time.
129          */
130
131         buf_len = vss_transaction.recv_len;
132         channel = vss_transaction.recv_channel;
133         req_id = vss_transaction.recv_req_id;
134         vss_transaction.active = false;
135
136         icmsghdrp = (struct icmsg_hdr *)
137                         &recv_buffer[sizeof(struct vmbuspipe_hdr)];
138
139         if (channel->onchannel_callback == NULL)
140                 /*
141                  * We have raced with util driver being unloaded;
142                  * silently return.
143                  */
144                 return;
145
146         icmsghdrp->status = error;
147
148         icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
149
150         vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
151                                 VM_PKT_DATA_INBAND, 0);
152
153 }
154
155 /*
156  * This callback is invoked when we get a VSS message from the host.
157  * The host ensures that only one VSS transaction can be active at a time.
158  */
159
160 void hv_vss_onchannelcallback(void *context)
161 {
162         struct vmbus_channel *channel = context;
163         u32 recvlen;
164         u64 requestid;
165         struct hv_vss_msg *vss_msg;
166
167
168         struct icmsg_hdr *icmsghdrp;
169         struct icmsg_negotiate *negop = NULL;
170
171         if (vss_transaction.active) {
172                 /*
173                  * We will defer processing this callback once
174                  * the current transaction is complete.
175                  */
176                 vss_transaction.recv_channel = channel;
177                 return;
178         }
179
180         vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
181                          &requestid);
182
183         if (recvlen > 0) {
184                 icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
185                         sizeof(struct vmbuspipe_hdr)];
186
187                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
188                         vmbus_prep_negotiate_resp(icmsghdrp, negop,
189                                  recv_buffer, MAX_SRV_VER, MAX_SRV_VER);
190                         /*
191                          * We currently negotiate the highest number the
192                          * host has presented. If this version is not
193                          * atleast 5.0, reject.
194                          */
195                         negop = (struct icmsg_negotiate *)&recv_buffer[
196                                 sizeof(struct vmbuspipe_hdr) +
197                                 sizeof(struct icmsg_hdr)];
198
199                         if (negop->icversion_data[1].major < 5)
200                                 negop->icframe_vercnt = 0;
201                 } else {
202                         vss_msg = (struct hv_vss_msg *)&recv_buffer[
203                                 sizeof(struct vmbuspipe_hdr) +
204                                 sizeof(struct icmsg_hdr)];
205
206                         /*
207                          * Stash away this global state for completing the
208                          * transaction; note transactions are serialized.
209                          */
210
211                         vss_transaction.recv_len = recvlen;
212                         vss_transaction.recv_channel = channel;
213                         vss_transaction.recv_req_id = requestid;
214                         vss_transaction.active = true;
215                         vss_transaction.msg = (struct hv_vss_msg *)vss_msg;
216
217                         switch (vss_msg->vss_hdr.operation) {
218                                 /*
219                                  * Initiate a "freeze/thaw"
220                                  * operation in the guest.
221                                  * We respond to the host once
222                                  * the operation is complete.
223                                  *
224                                  * We send the message to the
225                                  * user space daemon and the
226                                  * operation is performed in
227                                  * the daemon.
228                                  */
229                         case VSS_OP_FREEZE:
230                         case VSS_OP_THAW:
231                                 schedule_work(&vss_send_op_work);
232                                 return;
233
234                         case VSS_OP_HOT_BACKUP:
235                                 vss_msg->vss_cf.flags =
236                                          VSS_HBU_NO_AUTO_RECOVERY;
237                                 vss_respond_to_host(0);
238                                 return;
239
240                         case VSS_OP_GET_DM_INFO:
241                                 vss_msg->dm_info.flags = 0;
242                                 vss_respond_to_host(0);
243                                 return;
244
245                         default:
246                                 vss_respond_to_host(0);
247                                 return;
248
249                         }
250
251                 }
252
253                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
254                         | ICMSGHDRFLAG_RESPONSE;
255
256                 vmbus_sendpacket(channel, recv_buffer,
257                                        recvlen, requestid,
258                                        VM_PKT_DATA_INBAND, 0);
259         }
260
261 }
262
263 int
264 hv_vss_init(struct hv_util_service *srv)
265 {
266         int err;
267
268         err = cn_add_callback(&vss_id, vss_name, vss_cn_callback);
269         if (err)
270                 return err;
271         recv_buffer = srv->recv_buffer;
272
273         /*
274          * When this driver loads, the user level daemon that
275          * processes the host requests may not yet be running.
276          * Defer processing channel callbacks until the daemon
277          * has registered.
278          */
279         vss_transaction.active = true;
280         return 0;
281 }
282
283 void hv_vss_deinit(void)
284 {
285         cn_del_callback(&vss_id);
286         cancel_work_sync(&vss_send_op_work);
287 }