drivers/hv/hv_kvp.c

   1 /*
   2  * An implementation of key value pair (KVP) functionality for Linux.
   3  *
   4  *
   5  * Copyright (C) 2010, Novell, Inc.
   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  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  */
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #include <linux/net.h>
  26 #include <linux/nls.h>
  27 #include <linux/connector.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/hyperv.h>
  30
  31
  32
  33 /*
  34  * Global state maintained for transaction that is being processed.
  35  * Note that only one transaction can be active at any point in time.
  36  *
  37  * This state is set when we receive a request from the host; we
  38  * cleanup this state when the transaction is completed - when we respond
  39  * to the host with the key value.
  40  */
  41
  42 static struct {
  43         bool active; /* transaction status - active or not */
  44         int recv_len; /* number of bytes received. */
  45         int index; /* current index */
  46         struct vmbus_channel *recv_channel; /* chn we got the request */
  47         u64 recv_req_id; /* request ID. */
  48 } kvp_transaction;
  49
  50 static void kvp_send_key(struct work_struct *dummy);
  51
  52 #define TIMEOUT_FIRED 1
  53
  54 static void kvp_respond_to_host(char *key, char *value, int error);
  55 static void kvp_work_func(struct work_struct *dummy);
  56 static void kvp_register(void);
  57
  58 static DECLARE_DELAYED_WORK(kvp_work, kvp_work_func);
  59 static DECLARE_WORK(kvp_sendkey_work, kvp_send_key);
  60
  61 static struct cb_id kvp_id = { CN_KVP_IDX, CN_KVP_VAL };
  62 static const char kvp_name[] = "kvp_kernel_module";
  63 static u8 *recv_buffer;
  64 /*
  65  * Register the kernel component with the user-level daemon.
  66  * As part of this registration, pass the LIC version number.
  67  */
  68
  69 static void
  70 kvp_register(void)
  71 {
  72
  73         struct cn_msg *msg;
  74         struct hv_kvp_msg *kvp_msg;
  75         char *version;
  76
  77         msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg), GFP_ATOMIC);
  78
  79         if (msg) {
  80                 kvp_msg = (struct hv_kvp_msg *)msg->data;
  81                 version = kvp_msg->body.kvp_version;
  82                 msg->id.idx =  CN_KVP_IDX;
  83                 msg->id.val = CN_KVP_VAL;
  84
  85                 kvp_msg->kvp_hdr.operation = KVP_OP_REGISTER;
  86                 strcpy(version, HV_DRV_VERSION);
  87                 msg->len = sizeof(struct hv_kvp_msg);
  88                 cn_netlink_send(msg, 0, GFP_ATOMIC);
  89                 kfree(msg);
  90         }
  91 }
  92 static void
  93 kvp_work_func(struct work_struct *dummy)
  94 {
  95         /*
  96          * If the timer fires, the user-mode component has not responded;
  97          * process the pending transaction.
  98          */
  99         kvp_respond_to_host("Unknown key", "Guest timed out", TIMEOUT_FIRED);
 100 }
 101
 102 /*
 103  * Callback when data is received from user mode.
 104  */
 105
 106 static void
 107 kvp_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
 108 {
 109         struct hv_kvp_msg *message;
 110         struct hv_kvp_msg_enumerate *data;
 111
 112         message = (struct hv_kvp_msg *)msg->data;
 113         if (message->kvp_hdr.operation == KVP_OP_REGISTER) {
 114                 pr_info("KVP: user-mode registering done.\n");
 115                 kvp_register();
 116         }
 117
 118         if (message->kvp_hdr.operation == KVP_OP_ENUMERATE) {
 119                 data = &message->body.kvp_enum_data;
 120                 /*
 121                  * Complete the transaction by forwarding the key value
 122                  * to the host. But first, cancel the timeout.
 123                  */
 124                 if (cancel_delayed_work_sync(&kvp_work))
 125                         kvp_respond_to_host(data->data.key, data->data.value,
 126                                         !strlen(data->data.key));
 127         }
 128 }
 129
 130 static void
 131 kvp_send_key(struct work_struct *dummy)
 132 {
 133         struct cn_msg *msg;
 134         struct hv_kvp_msg *message;
 135         int index = kvp_transaction.index;
 136
 137         msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg) , GFP_ATOMIC);
 138
 139         if (msg) {
 140                 msg->id.idx =  CN_KVP_IDX;
 141                 msg->id.val = CN_KVP_VAL;
 142
 143                 message = (struct hv_kvp_msg *)msg->data;
 144                 message->kvp_hdr.operation = KVP_OP_ENUMERATE;
 145                 message->body.kvp_enum_data.index = index;
 146                 msg->len = sizeof(struct hv_kvp_msg);
 147                 cn_netlink_send(msg, 0, GFP_ATOMIC);
 148                 kfree(msg);
 149         }
 150         return;
 151 }
 152
 153 /*
 154  * Send a response back to the host.
 155  */
 156
 157 static void
 158 kvp_respond_to_host(char *key, char *value, int error)
 159 {
 160         struct hv_kvp_msg  *kvp_msg;
 161         struct hv_kvp_msg_enumerate  *kvp_data;
 162         char    *key_name;
 163         struct icmsg_hdr *icmsghdrp;
 164         int     keylen, valuelen;
 165         u32     buf_len;
 166         struct vmbus_channel *channel;
 167         u64     req_id;
 168
 169         /*
 170          * If a transaction is not active; log and return.
 171          */
 172
 173         if (!kvp_transaction.active) {
 174                 /*
 175                  * This is a spurious call!
 176                  */
 177                 pr_warn("KVP: Transaction not active\n");
 178                 return;
 179         }
 180         /*
 181          * Copy the global state for completing the transaction. Note that
 182          * only one transaction can be active at a time.
 183          */
 184
 185         buf_len = kvp_transaction.recv_len;
 186         channel = kvp_transaction.recv_channel;
 187         req_id = kvp_transaction.recv_req_id;
 188
 189         kvp_transaction.active = false;
 190
 191         if (channel->onchannel_callback == NULL)
 192                 /*
 193                  * We have raced with util driver being unloaded;
 194                  * silently return.
 195                  */
 196                 return;
 197
 198         icmsghdrp = (struct icmsg_hdr *)
 199                         &recv_buffer[sizeof(struct vmbuspipe_hdr)];
 200         kvp_msg = (struct hv_kvp_msg *)
 201                         &recv_buffer[sizeof(struct vmbuspipe_hdr) +
 202                         sizeof(struct icmsg_hdr)];
 203         kvp_data = &kvp_msg->body.kvp_enum_data;
 204         key_name = key;
 205
 206         /*
 207          * If the error parameter is set, terminate the host's enumeration.
 208          */
 209         if (error) {
 210                 /*
 211                  * We don't support this index or the we have timedout;
 212                  * terminate the host-side iteration by returning an error.
 213                  */
 214                 icmsghdrp->status = HV_E_FAIL;
 215                 goto response_done;
 216         }
 217
 218         /*
 219          * The windows host expects the key/value pair to be encoded
 220          * in utf16.
 221          */
 222         keylen = utf8s_to_utf16s(key_name, strlen(key_name), UTF16_HOST_ENDIAN,
 223                                 (wchar_t *) kvp_data->data.key,
 224                                 HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2);
 225         kvp_data->data.key_size = 2*(keylen + 1); /* utf16 encoding */
 226         valuelen = utf8s_to_utf16s(value, strlen(value), UTF16_HOST_ENDIAN,
 227                                 (wchar_t *) kvp_data->data.value,
 228                                 HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2);
 229         kvp_data->data.value_size = 2*(valuelen + 1); /* utf16 encoding */
 230
 231         kvp_data->data.value_type = REG_SZ; /* all our values are strings */
 232         icmsghdrp->status = HV_S_OK;
 233
 234 response_done:
 235         icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
 236
 237         vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
 238                                 VM_PKT_DATA_INBAND, 0);
 239
 240 }
 241
 242 /*
 243  * This callback is invoked when we get a KVP message from the host.
 244  * The host ensures that only one KVP transaction can be active at a time.
 245  * KVP implementation in Linux needs to forward the key to a user-mde
 246  * component to retrive the corresponding value. Consequently, we cannot
 247  * respond to the host in the conext of this callback. Since the host
 248  * guarantees that at most only one transaction can be active at a time,
 249  * we stash away the transaction state in a set of global variables.
 250  */
 251
 252 void hv_kvp_onchannelcallback(void *context)
 253 {
 254         struct vmbus_channel *channel = context;
 255         u32 recvlen;
 256         u64 requestid;
 257
 258         struct hv_kvp_msg *kvp_msg;
 259         struct hv_kvp_msg_enumerate *kvp_data;
 260
 261         struct icmsg_hdr *icmsghdrp;
 262         struct icmsg_negotiate *negop = NULL;
 263
 264
 265         vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE, &recvlen, &requestid);
 266
 267         if (recvlen > 0) {
 268                 icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
 269                         sizeof(struct vmbuspipe_hdr)];
 270
 271                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 272                         vmbus_prep_negotiate_resp(icmsghdrp, negop, recv_buffer);
 273                 } else {
 274                         kvp_msg = (struct hv_kvp_msg *)&recv_buffer[
 275                                 sizeof(struct vmbuspipe_hdr) +
 276                                 sizeof(struct icmsg_hdr)];
 277
 278                         kvp_data = &kvp_msg->body.kvp_enum_data;
 279
 280                         /*
 281                          * We only support the "get" operation on
 282                          * "KVP_POOL_AUTO" pool.
 283                          */
 284
 285                         if ((kvp_msg->kvp_hdr.pool != KVP_POOL_AUTO) ||
 286                                 (kvp_msg->kvp_hdr.operation !=
 287                                 KVP_OP_ENUMERATE)) {
 288                                 icmsghdrp->status = HV_E_FAIL;
 289                                 goto callback_done;
 290                         }
 291
 292                         /*
 293                          * Stash away this global state for completing the
 294                          * transaction; note transactions are serialized.
 295                          */
 296                         kvp_transaction.recv_len = recvlen;
 297                         kvp_transaction.recv_channel = channel;
 298                         kvp_transaction.recv_req_id = requestid;
 299                         kvp_transaction.active = true;
 300                         kvp_transaction.index = kvp_data->index;
 301
 302                         /*
 303                          * Get the information from the
 304                          * user-mode component.
 305                          * component. This transaction will be
 306                          * completed when we get the value from
 307                          * the user-mode component.
 308                          * Set a timeout to deal with
 309                          * user-mode not responding.
 310                          */
 311                         schedule_work(&kvp_sendkey_work);
 312                         schedule_delayed_work(&kvp_work, 5*HZ);
 313
 314                         return;
 315
 316                 }
 317
 318 callback_done:
 319
 320                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 321                         | ICMSGHDRFLAG_RESPONSE;
 322
 323                 vmbus_sendpacket(channel, recv_buffer,
 324                                        recvlen, requestid,
 325                                        VM_PKT_DATA_INBAND, 0);
 326         }
 327
 328 }
 329
 330 int
 331 hv_kvp_init(struct hv_util_service *srv)
 332 {
 333         int err;
 334
 335         err = cn_add_callback(&kvp_id, kvp_name, kvp_cn_callback);
 336         if (err)
 337                 return err;
 338         recv_buffer = srv->recv_buffer;
 339
 340         return 0;
 341 }
 342
 343 void hv_kvp_deinit(void)
 344 {
 345         cn_del_callback(&kvp_id);
 346         cancel_delayed_work_sync(&kvp_work);
 347         cancel_work_sync(&kvp_sendkey_work);
 348 }