Merge branch 'stable' of git://git.kernel.org/pub/scm/linux/kernel/git/cmetcalf/linux...
[linux-2.6-microblaze.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 #include "hyperv_vmbus.h"
28 #include "hv_utils_transport.h"
29
30 #define VSS_MAJOR  5
31 #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  * Global state maintained for transaction that is being processed. For a class
38  * of integration services, including the "VSS service", the specified protocol
39  * is a "request/response" protocol which means that there can only be single
40  * outstanding transaction from the host at any given point in time. We use
41  * this to simplify memory management in this driver - we cache and process
42  * only one message at a time.
43  *
44  * While the request/response protocol is guaranteed by the host, we further
45  * ensure this by serializing packet processing in this driver - we do not
46  * read additional packets from the VMBUs until the current packet is fully
47  * handled.
48  */
49
50 static struct {
51         int state;   /* hvutil_device_state */
52         int recv_len; /* number of bytes received. */
53         struct vmbus_channel *recv_channel; /* chn we got the request */
54         u64 recv_req_id; /* request ID. */
55         struct hv_vss_msg  *msg; /* current message */
56 } vss_transaction;
57
58
59 static void vss_respond_to_host(int error);
60
61 /*
62  * This state maintains the version number registered by the daemon.
63  */
64 static int dm_reg_value;
65
66 static const char vss_devname[] = "vmbus/hv_vss";
67 static __u8 *recv_buffer;
68 static struct hvutil_transport *hvt;
69
70 static void vss_timeout_func(struct work_struct *dummy);
71 static void vss_handle_request(struct work_struct *dummy);
72
73 static DECLARE_DELAYED_WORK(vss_timeout_work, vss_timeout_func);
74 static DECLARE_WORK(vss_handle_request_work, vss_handle_request);
75
76 static void vss_poll_wrapper(void *channel)
77 {
78         /* Transaction is finished, reset the state here to avoid races. */
79         vss_transaction.state = HVUTIL_READY;
80         hv_vss_onchannelcallback(channel);
81 }
82
83 /*
84  * Callback when data is received from user mode.
85  */
86
87 static void vss_timeout_func(struct work_struct *dummy)
88 {
89         /*
90          * Timeout waiting for userspace component to reply happened.
91          */
92         pr_warn("VSS: timeout waiting for daemon to reply\n");
93         vss_respond_to_host(HV_E_FAIL);
94
95         hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper);
96 }
97
98 static void vss_register_done(void)
99 {
100         hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper);
101         pr_debug("VSS: userspace daemon registered\n");
102 }
103
104 static int vss_handle_handshake(struct hv_vss_msg *vss_msg)
105 {
106         u32 our_ver = VSS_OP_REGISTER1;
107
108         switch (vss_msg->vss_hdr.operation) {
109         case VSS_OP_REGISTER:
110                 /* Daemon doesn't expect us to reply */
111                 dm_reg_value = VSS_OP_REGISTER;
112                 break;
113         case VSS_OP_REGISTER1:
114                 /* Daemon expects us to reply with our own version */
115                 if (hvutil_transport_send(hvt, &our_ver, sizeof(our_ver),
116                                           vss_register_done))
117                         return -EFAULT;
118                 dm_reg_value = VSS_OP_REGISTER1;
119                 break;
120         default:
121                 return -EINVAL;
122         }
123         pr_debug("VSS: userspace daemon ver. %d connected\n", dm_reg_value);
124         return 0;
125 }
126
127 static int vss_on_msg(void *msg, int len)
128 {
129         struct hv_vss_msg *vss_msg = (struct hv_vss_msg *)msg;
130
131         if (len != sizeof(*vss_msg))
132                 return -EINVAL;
133
134         if (vss_msg->vss_hdr.operation == VSS_OP_REGISTER ||
135             vss_msg->vss_hdr.operation == VSS_OP_REGISTER1) {
136                 /*
137                  * Don't process registration messages if we're in the middle
138                  * of a transaction processing.
139                  */
140                 if (vss_transaction.state > HVUTIL_READY)
141                         return -EINVAL;
142                 return vss_handle_handshake(vss_msg);
143         } else if (vss_transaction.state == HVUTIL_USERSPACE_REQ) {
144                 vss_transaction.state = HVUTIL_USERSPACE_RECV;
145
146                 if (vss_msg->vss_hdr.operation == VSS_OP_HOT_BACKUP)
147                         vss_transaction.msg->vss_cf.flags =
148                                 VSS_HBU_NO_AUTO_RECOVERY;
149
150                 if (cancel_delayed_work_sync(&vss_timeout_work)) {
151                         vss_respond_to_host(vss_msg->error);
152                         /* Transaction is finished, reset the state. */
153                         hv_poll_channel(vss_transaction.recv_channel,
154                                         vss_poll_wrapper);
155                 }
156         } else {
157                 /* This is a spurious call! */
158                 pr_warn("VSS: Transaction not active\n");
159                 return -EINVAL;
160         }
161         return 0;
162 }
163
164 static void vss_send_op(void)
165 {
166         int op = vss_transaction.msg->vss_hdr.operation;
167         int rc;
168         struct hv_vss_msg *vss_msg;
169
170         /* The transaction state is wrong. */
171         if (vss_transaction.state != HVUTIL_HOSTMSG_RECEIVED)
172                 return;
173
174         vss_msg = kzalloc(sizeof(*vss_msg), GFP_KERNEL);
175         if (!vss_msg)
176                 return;
177
178         vss_msg->vss_hdr.operation = op;
179
180         vss_transaction.state = HVUTIL_USERSPACE_REQ;
181
182         schedule_delayed_work(&vss_timeout_work, VSS_USERSPACE_TIMEOUT);
183
184         rc = hvutil_transport_send(hvt, vss_msg, sizeof(*vss_msg), NULL);
185         if (rc) {
186                 pr_warn("VSS: failed to communicate to the daemon: %d\n", rc);
187                 if (cancel_delayed_work_sync(&vss_timeout_work)) {
188                         vss_respond_to_host(HV_E_FAIL);
189                         vss_transaction.state = HVUTIL_READY;
190                 }
191         }
192
193         kfree(vss_msg);
194
195         return;
196 }
197
198 static void vss_handle_request(struct work_struct *dummy)
199 {
200         switch (vss_transaction.msg->vss_hdr.operation) {
201         /*
202          * Initiate a "freeze/thaw" operation in the guest.
203          * We respond to the host once the operation is complete.
204          *
205          * We send the message to the user space daemon and the operation is
206          * performed in the daemon.
207          */
208         case VSS_OP_THAW:
209         case VSS_OP_FREEZE:
210         case VSS_OP_HOT_BACKUP:
211                 if (vss_transaction.state < HVUTIL_READY) {
212                         /* Userspace is not registered yet */
213                         vss_respond_to_host(HV_E_FAIL);
214                         return;
215                 }
216                 vss_transaction.state = HVUTIL_HOSTMSG_RECEIVED;
217                 vss_send_op();
218                 return;
219         case VSS_OP_GET_DM_INFO:
220                 vss_transaction.msg->dm_info.flags = 0;
221                 break;
222         default:
223                 break;
224         }
225
226         vss_respond_to_host(0);
227         hv_poll_channel(vss_transaction.recv_channel, vss_poll_wrapper);
228 }
229
230 /*
231  * Send a response back to the host.
232  */
233
234 static void
235 vss_respond_to_host(int error)
236 {
237         struct icmsg_hdr *icmsghdrp;
238         u32     buf_len;
239         struct vmbus_channel *channel;
240         u64     req_id;
241
242         /*
243          * Copy the global state for completing the transaction. Note that
244          * only one transaction can be active at a time.
245          */
246
247         buf_len = vss_transaction.recv_len;
248         channel = vss_transaction.recv_channel;
249         req_id = vss_transaction.recv_req_id;
250
251         icmsghdrp = (struct icmsg_hdr *)
252                         &recv_buffer[sizeof(struct vmbuspipe_hdr)];
253
254         if (channel->onchannel_callback == NULL)
255                 /*
256                  * We have raced with util driver being unloaded;
257                  * silently return.
258                  */
259                 return;
260
261         icmsghdrp->status = error;
262
263         icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
264
265         vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
266                                 VM_PKT_DATA_INBAND, 0);
267
268 }
269
270 /*
271  * This callback is invoked when we get a VSS message from the host.
272  * The host ensures that only one VSS transaction can be active at a time.
273  */
274
275 void hv_vss_onchannelcallback(void *context)
276 {
277         struct vmbus_channel *channel = context;
278         u32 recvlen;
279         u64 requestid;
280         struct hv_vss_msg *vss_msg;
281
282
283         struct icmsg_hdr *icmsghdrp;
284         struct icmsg_negotiate *negop = NULL;
285
286         if (vss_transaction.state > HVUTIL_READY)
287                 return;
288
289         vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen,
290                          &requestid);
291
292         if (recvlen > 0) {
293                 icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
294                         sizeof(struct vmbuspipe_hdr)];
295
296                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
297                         vmbus_prep_negotiate_resp(icmsghdrp, negop,
298                                  recv_buffer, UTIL_FW_VERSION,
299                                  VSS_VERSION);
300                 } else {
301                         vss_msg = (struct hv_vss_msg *)&recv_buffer[
302                                 sizeof(struct vmbuspipe_hdr) +
303                                 sizeof(struct icmsg_hdr)];
304
305                         /*
306                          * Stash away this global state for completing the
307                          * transaction; note transactions are serialized.
308                          */
309
310                         vss_transaction.recv_len = recvlen;
311                         vss_transaction.recv_req_id = requestid;
312                         vss_transaction.msg = (struct hv_vss_msg *)vss_msg;
313
314                         schedule_work(&vss_handle_request_work);
315                         return;
316                 }
317
318                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
319                         | ICMSGHDRFLAG_RESPONSE;
320
321                 vmbus_sendpacket(channel, recv_buffer,
322                                        recvlen, requestid,
323                                        VM_PKT_DATA_INBAND, 0);
324         }
325
326 }
327
328 static void vss_on_reset(void)
329 {
330         if (cancel_delayed_work_sync(&vss_timeout_work))
331                 vss_respond_to_host(HV_E_FAIL);
332         vss_transaction.state = HVUTIL_DEVICE_INIT;
333 }
334
335 int
336 hv_vss_init(struct hv_util_service *srv)
337 {
338         if (vmbus_proto_version < VERSION_WIN8_1) {
339                 pr_warn("Integration service 'Backup (volume snapshot)'"
340                         " not supported on this host version.\n");
341                 return -ENOTSUPP;
342         }
343         recv_buffer = srv->recv_buffer;
344         vss_transaction.recv_channel = srv->channel;
345
346         /*
347          * When this driver loads, the user level daemon that
348          * processes the host requests may not yet be running.
349          * Defer processing channel callbacks until the daemon
350          * has registered.
351          */
352         vss_transaction.state = HVUTIL_DEVICE_INIT;
353
354         hvt = hvutil_transport_init(vss_devname, CN_VSS_IDX, CN_VSS_VAL,
355                                     vss_on_msg, vss_on_reset);
356         if (!hvt)
357                 return -EFAULT;
358
359         return 0;
360 }
361
362 void hv_vss_deinit(void)
363 {
364         vss_transaction.state = HVUTIL_DEVICE_DYING;
365         cancel_delayed_work_sync(&vss_timeout_work);
366         cancel_work_sync(&vss_handle_request_work);
367         hvutil_transport_destroy(hvt);
368 }