K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 1 | /* |
| 2 | * An implementation of file copy service. |
| 3 | * |
| 4 | * Copyright (C) 2014, Microsoft, Inc. |
| 5 | * |
| 6 | * Author : K. Y. Srinivasan <ksrinivasan@novell.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 | |
| 20 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 21 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 22 | #include <linux/nls.h> |
| 23 | #include <linux/workqueue.h> |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 24 | #include <linux/hyperv.h> |
| 25 | #include <linux/sched.h> |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 26 | |
| 27 | #include "hyperv_vmbus.h" |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 28 | #include "hv_utils_transport.h" |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 29 | |
| 30 | #define WIN8_SRV_MAJOR 1 |
| 31 | #define WIN8_SRV_MINOR 1 |
| 32 | #define WIN8_SRV_VERSION (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR) |
| 33 | |
| 34 | /* |
| 35 | * Global state maintained for transaction that is being processed. |
| 36 | * For a class of integration services, including the "file copy service", |
| 37 | * the specified protocol is a "request/response" protocol which means that |
| 38 | * there can only be single outstanding transaction from the host at any |
| 39 | * given point in time. We use this to simplify memory management in this |
| 40 | * driver - we cache and process only one message at a time. |
| 41 | * |
| 42 | * While the request/response protocol is guaranteed by the host, we further |
| 43 | * ensure this by serializing packet processing in this driver - we do not |
| 44 | * read additional packets from the VMBUs until the current packet is fully |
| 45 | * handled. |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 46 | */ |
| 47 | |
| 48 | static struct { |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 49 | int state; /* hvutil_device_state */ |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 50 | int recv_len; /* number of bytes received. */ |
| 51 | struct hv_fcopy_hdr *fcopy_msg; /* current message */ |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 52 | struct vmbus_channel *recv_channel; /* chn we got the request */ |
| 53 | u64 recv_req_id; /* request ID. */ |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 54 | } fcopy_transaction; |
| 55 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 56 | static void fcopy_respond_to_host(int error); |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 57 | static void fcopy_send_data(struct work_struct *dummy); |
Vitaly Kuznetsov | 1d07233 | 2015-04-11 18:07:45 -0700 | [diff] [blame] | 58 | static void fcopy_timeout_func(struct work_struct *dummy); |
| 59 | static DECLARE_DELAYED_WORK(fcopy_timeout_work, fcopy_timeout_func); |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 60 | static DECLARE_WORK(fcopy_send_work, fcopy_send_data); |
| 61 | static const char fcopy_devname[] = "vmbus/hv_fcopy"; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 62 | static u8 *recv_buffer; |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 63 | static struct hvutil_transport *hvt; |
Vitaly Kuznetsov | a4d1ee5 | 2015-04-11 18:07:58 -0700 | [diff] [blame] | 64 | /* |
| 65 | * This state maintains the version number registered by the daemon. |
| 66 | */ |
| 67 | static int dm_reg_value; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 68 | |
Olaf Hering | 3cace4a | 2015-12-14 16:01:33 -0800 | [diff] [blame] | 69 | static void fcopy_poll_wrapper(void *channel) |
| 70 | { |
| 71 | /* Transaction is finished, reset the state here to avoid races. */ |
| 72 | fcopy_transaction.state = HVUTIL_READY; |
| 73 | hv_fcopy_onchannelcallback(channel); |
| 74 | } |
| 75 | |
Vitaly Kuznetsov | 1d07233 | 2015-04-11 18:07:45 -0700 | [diff] [blame] | 76 | static void fcopy_timeout_func(struct work_struct *dummy) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 77 | { |
| 78 | /* |
| 79 | * If the timer fires, the user-mode component has not responded; |
| 80 | * process the pending transaction. |
| 81 | */ |
| 82 | fcopy_respond_to_host(HV_E_FAIL); |
Olaf Hering | 3cace4a | 2015-12-14 16:01:33 -0800 | [diff] [blame] | 83 | hv_poll_channel(fcopy_transaction.recv_channel, fcopy_poll_wrapper); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 84 | } |
| 85 | |
Vitaly Kuznetsov | e0fa3e5 | 2016-06-09 17:08:57 -0700 | [diff] [blame] | 86 | static void fcopy_register_done(void) |
| 87 | { |
| 88 | pr_debug("FCP: userspace daemon registered\n"); |
| 89 | hv_poll_channel(fcopy_transaction.recv_channel, fcopy_poll_wrapper); |
| 90 | } |
| 91 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 92 | static int fcopy_handle_handshake(u32 version) |
| 93 | { |
Vitaly Kuznetsov | a4d1ee5 | 2015-04-11 18:07:58 -0700 | [diff] [blame] | 94 | u32 our_ver = FCOPY_CURRENT_VERSION; |
| 95 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 96 | switch (version) { |
Vitaly Kuznetsov | a4d1ee5 | 2015-04-11 18:07:58 -0700 | [diff] [blame] | 97 | case FCOPY_VERSION_0: |
| 98 | /* Daemon doesn't expect us to reply */ |
| 99 | dm_reg_value = version; |
| 100 | break; |
| 101 | case FCOPY_VERSION_1: |
| 102 | /* Daemon expects us to reply with our own version */ |
Vitaly Kuznetsov | e0fa3e5 | 2016-06-09 17:08:57 -0700 | [diff] [blame] | 103 | if (hvutil_transport_send(hvt, &our_ver, sizeof(our_ver), |
| 104 | fcopy_register_done)) |
Vitaly Kuznetsov | a4d1ee5 | 2015-04-11 18:07:58 -0700 | [diff] [blame] | 105 | return -EFAULT; |
| 106 | dm_reg_value = version; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 107 | break; |
| 108 | default: |
| 109 | /* |
| 110 | * For now we will fail the registration. |
| 111 | * If and when we have multiple versions to |
| 112 | * deal with, we will be backward compatible. |
| 113 | * We will add this code when needed. |
| 114 | */ |
| 115 | return -EINVAL; |
| 116 | } |
Vitaly Kuznetsov | e0fa3e5 | 2016-06-09 17:08:57 -0700 | [diff] [blame] | 117 | pr_debug("FCP: userspace daemon ver. %d connected\n", version); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 118 | return 0; |
| 119 | } |
| 120 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 121 | static void fcopy_send_data(struct work_struct *dummy) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 122 | { |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 123 | struct hv_start_fcopy *smsg_out = NULL; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 124 | int operation = fcopy_transaction.fcopy_msg->operation; |
| 125 | struct hv_start_fcopy *smsg_in; |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 126 | void *out_src; |
| 127 | int rc, out_len; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 128 | |
| 129 | /* |
| 130 | * The strings sent from the host are encoded in |
| 131 | * in utf16; convert it to utf8 strings. |
| 132 | * The host assures us that the utf16 strings will not exceed |
| 133 | * the max lengths specified. We will however, reserve room |
| 134 | * for the string terminating character - in the utf16s_utf8s() |
| 135 | * function we limit the size of the buffer where the converted |
| 136 | * string is placed to W_MAX_PATH -1 to guarantee |
| 137 | * that the strings can be properly terminated! |
| 138 | */ |
| 139 | |
| 140 | switch (operation) { |
| 141 | case START_FILE_COPY: |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 142 | out_len = sizeof(struct hv_start_fcopy); |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 143 | smsg_out = kzalloc(sizeof(*smsg_out), GFP_KERNEL); |
| 144 | if (!smsg_out) |
| 145 | return; |
| 146 | |
| 147 | smsg_out->hdr.operation = operation; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 148 | smsg_in = (struct hv_start_fcopy *)fcopy_transaction.fcopy_msg; |
| 149 | |
| 150 | utf16s_to_utf8s((wchar_t *)smsg_in->file_name, W_MAX_PATH, |
| 151 | UTF16_LITTLE_ENDIAN, |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 152 | (__u8 *)&smsg_out->file_name, W_MAX_PATH - 1); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 153 | |
| 154 | utf16s_to_utf8s((wchar_t *)smsg_in->path_name, W_MAX_PATH, |
| 155 | UTF16_LITTLE_ENDIAN, |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 156 | (__u8 *)&smsg_out->path_name, W_MAX_PATH - 1); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 157 | |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 158 | smsg_out->copy_flags = smsg_in->copy_flags; |
| 159 | smsg_out->file_size = smsg_in->file_size; |
| 160 | out_src = smsg_out; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 161 | break; |
| 162 | |
Olaf Hering | c541aaa | 2017-09-21 23:41:48 -0700 | [diff] [blame] | 163 | case WRITE_TO_FILE: |
| 164 | out_src = fcopy_transaction.fcopy_msg; |
| 165 | out_len = sizeof(struct hv_do_fcopy); |
| 166 | break; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 167 | default: |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 168 | out_src = fcopy_transaction.fcopy_msg; |
| 169 | out_len = fcopy_transaction.recv_len; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 170 | break; |
| 171 | } |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 172 | |
| 173 | fcopy_transaction.state = HVUTIL_USERSPACE_REQ; |
Vitaly Kuznetsov | e0fa3e5 | 2016-06-09 17:08:57 -0700 | [diff] [blame] | 174 | rc = hvutil_transport_send(hvt, out_src, out_len, NULL); |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 175 | if (rc) { |
| 176 | pr_debug("FCP: failed to communicate to the daemon: %d\n", rc); |
| 177 | if (cancel_delayed_work_sync(&fcopy_timeout_work)) { |
| 178 | fcopy_respond_to_host(HV_E_FAIL); |
| 179 | fcopy_transaction.state = HVUTIL_READY; |
| 180 | } |
| 181 | } |
Vitaly Kuznetsov | 25ef06f | 2015-08-01 16:08:12 -0700 | [diff] [blame] | 182 | kfree(smsg_out); |
| 183 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 184 | return; |
| 185 | } |
| 186 | |
| 187 | /* |
| 188 | * Send a response back to the host. |
| 189 | */ |
| 190 | |
| 191 | static void |
| 192 | fcopy_respond_to_host(int error) |
| 193 | { |
| 194 | struct icmsg_hdr *icmsghdr; |
| 195 | u32 buf_len; |
| 196 | struct vmbus_channel *channel; |
| 197 | u64 req_id; |
| 198 | |
| 199 | /* |
| 200 | * Copy the global state for completing the transaction. Note that |
| 201 | * only one transaction can be active at a time. This is guaranteed |
| 202 | * by the file copy protocol implemented by the host. Furthermore, |
| 203 | * the "transaction active" state we maintain ensures that there can |
| 204 | * only be one active transaction at a time. |
| 205 | */ |
| 206 | |
| 207 | buf_len = fcopy_transaction.recv_len; |
| 208 | channel = fcopy_transaction.recv_channel; |
| 209 | req_id = fcopy_transaction.recv_req_id; |
| 210 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 211 | icmsghdr = (struct icmsg_hdr *) |
| 212 | &recv_buffer[sizeof(struct vmbuspipe_hdr)]; |
| 213 | |
| 214 | if (channel->onchannel_callback == NULL) |
| 215 | /* |
| 216 | * We have raced with util driver being unloaded; |
| 217 | * silently return. |
| 218 | */ |
| 219 | return; |
| 220 | |
| 221 | icmsghdr->status = error; |
| 222 | icmsghdr->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE; |
| 223 | vmbus_sendpacket(channel, recv_buffer, buf_len, req_id, |
| 224 | VM_PKT_DATA_INBAND, 0); |
| 225 | } |
| 226 | |
| 227 | void hv_fcopy_onchannelcallback(void *context) |
| 228 | { |
| 229 | struct vmbus_channel *channel = context; |
| 230 | u32 recvlen; |
| 231 | u64 requestid; |
| 232 | struct hv_fcopy_hdr *fcopy_msg; |
| 233 | struct icmsg_hdr *icmsghdr; |
| 234 | struct icmsg_negotiate *negop = NULL; |
| 235 | int util_fw_version; |
| 236 | int fcopy_srv_version; |
| 237 | |
Olaf Hering | 3cace4a | 2015-12-14 16:01:33 -0800 | [diff] [blame] | 238 | if (fcopy_transaction.state > HVUTIL_READY) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 239 | return; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 240 | |
| 241 | vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 2, &recvlen, |
| 242 | &requestid); |
| 243 | if (recvlen <= 0) |
| 244 | return; |
| 245 | |
| 246 | icmsghdr = (struct icmsg_hdr *)&recv_buffer[ |
| 247 | sizeof(struct vmbuspipe_hdr)]; |
| 248 | if (icmsghdr->icmsgtype == ICMSGTYPE_NEGOTIATE) { |
| 249 | util_fw_version = UTIL_FW_VERSION; |
| 250 | fcopy_srv_version = WIN8_SRV_VERSION; |
| 251 | vmbus_prep_negotiate_resp(icmsghdr, negop, recv_buffer, |
| 252 | util_fw_version, fcopy_srv_version); |
| 253 | } else { |
| 254 | fcopy_msg = (struct hv_fcopy_hdr *)&recv_buffer[ |
| 255 | sizeof(struct vmbuspipe_hdr) + |
| 256 | sizeof(struct icmsg_hdr)]; |
| 257 | |
| 258 | /* |
| 259 | * Stash away this global state for completing the |
| 260 | * transaction; note transactions are serialized. |
| 261 | */ |
| 262 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 263 | fcopy_transaction.recv_len = recvlen; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 264 | fcopy_transaction.recv_req_id = requestid; |
| 265 | fcopy_transaction.fcopy_msg = fcopy_msg; |
| 266 | |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 267 | if (fcopy_transaction.state < HVUTIL_READY) { |
| 268 | /* Userspace is not registered yet */ |
| 269 | fcopy_respond_to_host(HV_E_FAIL); |
| 270 | return; |
| 271 | } |
| 272 | fcopy_transaction.state = HVUTIL_HOSTMSG_RECEIVED; |
| 273 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 274 | /* |
| 275 | * Send the information to the user-level daemon. |
| 276 | */ |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 277 | schedule_work(&fcopy_send_work); |
K. Y. Srinivasan | c0b200c | 2015-12-14 16:01:32 -0800 | [diff] [blame] | 278 | schedule_delayed_work(&fcopy_timeout_work, |
| 279 | HV_UTIL_TIMEOUT * HZ); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 280 | return; |
| 281 | } |
| 282 | icmsghdr->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE; |
| 283 | vmbus_sendpacket(channel, recv_buffer, recvlen, requestid, |
| 284 | VM_PKT_DATA_INBAND, 0); |
| 285 | } |
| 286 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 287 | /* Callback when data is received from userspace */ |
| 288 | static int fcopy_on_msg(void *msg, int len) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 289 | { |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 290 | int *val = (int *)msg; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 291 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 292 | if (len != sizeof(int)) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 293 | return -EINVAL; |
| 294 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 295 | if (fcopy_transaction.state == HVUTIL_DEVICE_INIT) |
| 296 | return fcopy_handle_handshake(*val); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 297 | |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 298 | if (fcopy_transaction.state != HVUTIL_USERSPACE_REQ) |
| 299 | return -EINVAL; |
| 300 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 301 | /* |
| 302 | * Complete the transaction by forwarding the result |
| 303 | * to the host. But first, cancel the timeout. |
| 304 | */ |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 305 | if (cancel_delayed_work_sync(&fcopy_timeout_work)) { |
| 306 | fcopy_transaction.state = HVUTIL_USERSPACE_RECV; |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 307 | fcopy_respond_to_host(*val); |
Olaf Hering | 3cace4a | 2015-12-14 16:01:33 -0800 | [diff] [blame] | 308 | hv_poll_channel(fcopy_transaction.recv_channel, |
| 309 | fcopy_poll_wrapper); |
Vitaly Kuznetsov | 242f312 | 2015-04-11 18:07:42 -0700 | [diff] [blame] | 310 | } |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 311 | |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 312 | return 0; |
| 313 | } |
| 314 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 315 | static void fcopy_on_reset(void) |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 316 | { |
| 317 | /* |
| 318 | * The daemon has exited; reset the state. |
| 319 | */ |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 320 | fcopy_transaction.state = HVUTIL_DEVICE_INIT; |
Dexuan Cui | d9b1652 | 2015-01-14 01:55:10 -0800 | [diff] [blame] | 321 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 322 | if (cancel_delayed_work_sync(&fcopy_timeout_work)) |
Dexuan Cui | d9b1652 | 2015-01-14 01:55:10 -0800 | [diff] [blame] | 323 | fcopy_respond_to_host(HV_E_FAIL); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | int hv_fcopy_init(struct hv_util_service *srv) |
| 327 | { |
| 328 | recv_buffer = srv->recv_buffer; |
K. Y. Srinivasan | b9830d1 | 2016-02-26 15:13:19 -0800 | [diff] [blame] | 329 | fcopy_transaction.recv_channel = srv->channel; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 330 | |
| 331 | /* |
| 332 | * When this driver loads, the user level daemon that |
| 333 | * processes the host requests may not yet be running. |
| 334 | * Defer processing channel callbacks until the daemon |
| 335 | * has registered. |
| 336 | */ |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 337 | fcopy_transaction.state = HVUTIL_DEVICE_INIT; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 338 | |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 339 | hvt = hvutil_transport_init(fcopy_devname, 0, 0, |
| 340 | fcopy_on_msg, fcopy_on_reset); |
| 341 | if (!hvt) |
| 342 | return -EFAULT; |
| 343 | |
| 344 | return 0; |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 345 | } |
| 346 | |
| 347 | void hv_fcopy_deinit(void) |
| 348 | { |
Vitaly Kuznetsov | 4c93ccc | 2015-04-11 18:07:49 -0700 | [diff] [blame] | 349 | fcopy_transaction.state = HVUTIL_DEVICE_DYING; |
Vitaly Kuznetsov | 1d07233 | 2015-04-11 18:07:45 -0700 | [diff] [blame] | 350 | cancel_delayed_work_sync(&fcopy_timeout_work); |
Vitaly Kuznetsov | c7e490f | 2015-04-11 18:07:53 -0700 | [diff] [blame] | 351 | hvutil_transport_destroy(hvt); |
K. Y. Srinivasan | 01325476 | 2014-02-16 11:34:30 -0800 | [diff] [blame] | 352 | } |