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_register.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,
 126                                          data->data.value,
 127                                         !strlen(data->data.key));
 128         }
 129 }
 130
 131 static void
 132 kvp_send_key(struct work_struct *dummy)
 133 {
 134         struct cn_msg *msg;
 135         struct hv_kvp_msg *message;
 136         int index = kvp_transaction.index;
 137
 138         msg = kzalloc(sizeof(*msg) + sizeof(struct hv_kvp_msg) , GFP_ATOMIC);
 139
 140         if (msg) {
 141                 msg->id.idx =  CN_KVP_IDX;
 142                 msg->id.val = CN_KVP_VAL;
 143
 144                 message = (struct hv_kvp_msg *)msg->data;
 145                 message->kvp_hdr.operation = KVP_OP_ENUMERATE;
 146                 message->body.kvp_enum_data.index = index;
 147                 msg->len = sizeof(struct hv_kvp_msg);
 148                 cn_netlink_send(msg, 0, GFP_ATOMIC);
 149                 kfree(msg);
 150         }
 151         return;
 152 }
 153
 154 /*
 155  * Send a response back to the host.
 156  */
 157
 158 static void
 159 kvp_respond_to_host(char *key, char *value, int error)
 160 {
 161         struct hv_kvp_msg  *kvp_msg;
 162         struct hv_kvp_msg_enumerate  *kvp_data;
 163         char    *key_name;
 164         struct icmsg_hdr *icmsghdrp;
 165         int     keylen, valuelen;
 166         u32     buf_len;
 167         struct vmbus_channel *channel;
 168         u64     req_id;
 169
 170         /*
 171          * If a transaction is not active; log and return.
 172          */
 173
 174         if (!kvp_transaction.active) {
 175                 /*
 176                  * This is a spurious call!
 177                  */
 178                 pr_warn("KVP: Transaction not active\n");
 179                 return;
 180         }
 181         /*
 182          * Copy the global state for completing the transaction. Note that
 183          * only one transaction can be active at a time.
 184          */
 185
 186         buf_len = kvp_transaction.recv_len;
 187         channel = kvp_transaction.recv_channel;
 188         req_id = kvp_transaction.recv_req_id;
 189
 190         kvp_transaction.active = false;
 191
 192         if (channel->onchannel_callback == NULL)
 193                 /*
 194                  * We have raced with util driver being unloaded;
 195                  * silently return.
 196                  */
 197                 return;
 198
 199         icmsghdrp = (struct icmsg_hdr *)
 200                         &recv_buffer[sizeof(struct vmbuspipe_hdr)];
 201         kvp_msg = (struct hv_kvp_msg *)
 202                         &recv_buffer[sizeof(struct vmbuspipe_hdr) +
 203                         sizeof(struct icmsg_hdr)];
 204         kvp_data = &kvp_msg->body.kvp_enum_data;
 205         key_name = key;
 206
 207         /*
 208          * If the error parameter is set, terminate the host's enumeration.
 209          */
 210         if (error) {
 211                 /*
 212                  * We don't support this index or the we have timedout;
 213                  * terminate the host-side iteration by returning an error.
 214                  */
 215                 icmsghdrp->status = HV_E_FAIL;
 216                 goto response_done;
 217         }
 218
 219         /*
 220          * The windows host expects the key/value pair to be encoded
 221          * in utf16.
 222          */
 223         keylen = utf8s_to_utf16s(key_name, strlen(key_name), UTF16_HOST_ENDIAN,
 224                                 (wchar_t *) kvp_data->data.key,
 225                                 HV_KVP_EXCHANGE_MAX_KEY_SIZE / 2);
 226         kvp_data->data.key_size = 2*(keylen + 1); /* utf16 encoding */
 227         valuelen = utf8s_to_utf16s(value, strlen(value), UTF16_HOST_ENDIAN,
 228                                 (wchar_t *) kvp_data->data.value,
 229                                 HV_KVP_EXCHANGE_MAX_VALUE_SIZE / 2);
 230         kvp_data->data.value_size = 2*(valuelen + 1); /* utf16 encoding */
 231
 232         kvp_data->data.value_type = REG_SZ; /* all our values are strings */
 233         icmsghdrp->status = HV_S_OK;
 234
 235 response_done:
 236         icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;
 237
 238         vmbus_sendpacket(channel, recv_buffer, buf_len, req_id,
 239                                 VM_PKT_DATA_INBAND, 0);
 240
 241 }
 242
 243 /*
 244  * This callback is invoked when we get a KVP message from the host.
 245  * The host ensures that only one KVP transaction can be active at a time.
 246  * KVP implementation in Linux needs to forward the key to a user-mde
 247  * component to retrive the corresponding value. Consequently, we cannot
 248  * respond to the host in the conext of this callback. Since the host
 249  * guarantees that at most only one transaction can be active at a time,
 250  * we stash away the transaction state in a set of global variables.
 251  */
 252
 253 void hv_kvp_onchannelcallback(void *context)
 254 {
 255         struct vmbus_channel *channel = context;
 256         u32 recvlen;
 257         u64 requestid;
 258
 259         struct hv_kvp_msg *kvp_msg;
 260         struct hv_kvp_msg_enumerate *kvp_data;
 261
 262         struct icmsg_hdr *icmsghdrp;
 263         struct icmsg_negotiate *negop = NULL;
 264
 265
 266         vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE, &recvlen, &requestid);
 267
 268         if (recvlen > 0) {
 269                 icmsghdrp = (struct icmsg_hdr *)&recv_buffer[
 270                         sizeof(struct vmbuspipe_hdr)];
 271
 272                 if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
 273                         vmbus_prep_negotiate_resp(icmsghdrp, negop, recv_buffer);
 274                 } else {
 275                         kvp_msg = (struct hv_kvp_msg *)&recv_buffer[
 276                                 sizeof(struct vmbuspipe_hdr) +
 277                                 sizeof(struct icmsg_hdr)];
 278
 279                         kvp_data = &kvp_msg->body.kvp_enum_data;
 280
 281                         /*
 282                          * We only support the "get" operation on
 283                          * "KVP_POOL_AUTO" pool.
 284                          */
 285
 286                         if ((kvp_msg->kvp_hdr.pool != KVP_POOL_AUTO) ||
 287                                 (kvp_msg->kvp_hdr.operation !=
 288                                 KVP_OP_ENUMERATE)) {
 289                                 icmsghdrp->status = HV_E_FAIL;
 290                                 goto callback_done;
 291                         }
 292
 293                         /*
 294                          * Stash away this global state for completing the
 295                          * transaction; note transactions are serialized.
 296                          */
 297                         kvp_transaction.recv_len = recvlen;
 298                         kvp_transaction.recv_channel = channel;
 299                         kvp_transaction.recv_req_id = requestid;
 300                         kvp_transaction.active = true;
 301                         kvp_transaction.index = kvp_data->index;
 302
 303                         /*
 304                          * Get the information from the
 305                          * user-mode component.
 306                          * component. This transaction will be
 307                          * completed when we get the value from
 308                          * the user-mode component.
 309                          * Set a timeout to deal with
 310                          * user-mode not responding.
 311                          */
 312                         schedule_work(&kvp_sendkey_work);
 313                         schedule_delayed_work(&kvp_work, 5*HZ);
 314
 315                         return;
 316
 317                 }
 318
 319 callback_done:
 320
 321                 icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION
 322                         | ICMSGHDRFLAG_RESPONSE;
 323
 324                 vmbus_sendpacket(channel, recv_buffer,
 325                                        recvlen, requestid,
 326                                        VM_PKT_DATA_INBAND, 0);
 327         }
 328
 329 }
 330
 331 int
 332 hv_kvp_init(struct hv_util_service *srv)
 333 {
 334         int err;
 335
 336         err = cn_add_callback(&kvp_id, kvp_name, kvp_cn_callback);
 337         if (err)
 338                 return err;
 339         recv_buffer = srv->recv_buffer;
 340
 341         return 0;
 342 }
 343
 344 void hv_kvp_deinit(void)
 345 {
 346         cn_del_callback(&kvp_id);
 347         cancel_delayed_work_sync(&kvp_work);
 348         cancel_work_sync(&kvp_sendkey_work);
 349 }