drivers/hv/connection.c

   1 /*
   2  *
   3  * Copyright (c) 2009, Microsoft Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  16  * Place - Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  * Authors:
  19  *   Haiyang Zhang <haiyangz@microsoft.com>
  20  *   Hank Janssen  <hjanssen@microsoft.com>
  21  *
  22  */
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #include <linux/kernel.h>
  26 #include <linux/sched.h>
  27 #include <linux/wait.h>
  28 #include <linux/delay.h>
  29 #include <linux/mm.h>
  30 #include <linux/slab.h>
  31 #include <linux/vmalloc.h>
  32 #include <linux/hyperv.h>
  33 #include <asm/hyperv.h>
  34 #include "hyperv_vmbus.h"
  35
  36
  37 struct vmbus_connection vmbus_connection = {
  38         .conn_state             = DISCONNECTED,
  39         .next_gpadl_handle      = ATOMIC_INIT(0xE1E10),
  40 };
  41
  42 /*
  43  * VMBUS version is 32 bit entity broken up into
  44  * two 16 bit quantities: major_number. minor_number.
  45  *
  46  * 0 . 13 (Windows Server 2008)
  47  * 1 . 1  (Windows 7)
  48  * 2 . 4  (Windows 8)
  49  */
  50
  51 #define VERSION_WS2008  ((0 << 16) | (13))
  52 #define VERSION_WIN7    ((1 << 16) | (1))
  53 #define VERSION_WIN8    ((2 << 16) | (4))
  54
  55 #define VERSION_INVAL -1
  56
  57 static __u32 vmbus_get_next_version(__u32 current_version)
  58 {
  59         switch (current_version) {
  60         case (VERSION_WIN7):
  61                 return VERSION_WS2008;
  62
  63         case (VERSION_WIN8):
  64                 return VERSION_WIN7;
  65
  66         case (VERSION_WS2008):
  67         default:
  68                 return VERSION_INVAL;
  69         }
  70 }
  71
  72 static int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo,
  73                                         __u32 version)
  74 {
  75         int ret = 0;
  76         struct vmbus_channel_initiate_contact *msg;
  77         unsigned long flags;
  78         int t;
  79
  80         init_completion(&msginfo->waitevent);
  81
  82         msg = (struct vmbus_channel_initiate_contact *)msginfo->msg;
  83
  84         msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT;
  85         msg->vmbus_version_requested = version;
  86         msg->interrupt_page = virt_to_phys(vmbus_connection.int_page);
  87         msg->monitor_page1 = virt_to_phys(vmbus_connection.monitor_pages);
  88         msg->monitor_page2 = virt_to_phys(
  89                         (void *)((unsigned long)vmbus_connection.monitor_pages +
  90                                  PAGE_SIZE));
  91
  92         /*
  93          * Add to list before we send the request since we may
  94          * receive the response before returning from this routine
  95          */
  96         spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
  97         list_add_tail(&msginfo->msglistentry,
  98                       &vmbus_connection.chn_msg_list);
  99
 100         spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
 101
 102         ret = vmbus_post_msg(msg,
 103                                sizeof(struct vmbus_channel_initiate_contact));
 104         if (ret != 0) {
 105                 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
 106                 list_del(&msginfo->msglistentry);
 107                 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
 108                                         flags);
 109                 return ret;
 110         }
 111
 112         /* Wait for the connection response */
 113         t =  wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
 114         if (t == 0) {
 115                 spin_lock_irqsave(&vmbus_connection.channelmsg_lock,
 116                                 flags);
 117                 list_del(&msginfo->msglistentry);
 118                 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
 119                                         flags);
 120                 return -ETIMEDOUT;
 121         }
 122
 123         spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
 124         list_del(&msginfo->msglistentry);
 125         spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
 126
 127         /* Check if successful */
 128         if (msginfo->response.version_response.version_supported) {
 129                 vmbus_connection.conn_state = CONNECTED;
 130         } else {
 131                 pr_err("Unable to connect, "
 132                         "Version %d not supported by Hyper-V\n",
 133                         version);
 134                 return -ECONNREFUSED;
 135         }
 136
 137         return ret;
 138 }
 139
 140 /*
 141  * vmbus_connect - Sends a connect request on the partition service connection
 142  */
 143 int vmbus_connect(void)
 144 {
 145         int ret = 0;
 146         struct vmbus_channel_msginfo *msginfo = NULL;
 147         __u32 version;
 148
 149         /* Initialize the vmbus connection */
 150         vmbus_connection.conn_state = CONNECTING;
 151         vmbus_connection.work_queue = create_workqueue("hv_vmbus_con");
 152         if (!vmbus_connection.work_queue) {
 153                 ret = -ENOMEM;
 154                 goto cleanup;
 155         }
 156
 157         INIT_LIST_HEAD(&vmbus_connection.chn_msg_list);
 158         spin_lock_init(&vmbus_connection.channelmsg_lock);
 159
 160         INIT_LIST_HEAD(&vmbus_connection.chn_list);
 161         spin_lock_init(&vmbus_connection.channel_lock);
 162
 163         /*
 164          * Setup the vmbus event connection for channel interrupt
 165          * abstraction stuff
 166          */
 167         vmbus_connection.int_page =
 168         (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, 0);
 169         if (vmbus_connection.int_page == NULL) {
 170                 ret = -ENOMEM;
 171                 goto cleanup;
 172         }
 173
 174         vmbus_connection.recv_int_page = vmbus_connection.int_page;
 175         vmbus_connection.send_int_page =
 176                 (void *)((unsigned long)vmbus_connection.int_page +
 177                         (PAGE_SIZE >> 1));
 178
 179         /*
 180          * Setup the monitor notification facility. The 1st page for
 181          * parent->child and the 2nd page for child->parent
 182          */
 183         vmbus_connection.monitor_pages =
 184         (void *)__get_free_pages((GFP_KERNEL|__GFP_ZERO), 1);
 185         if (vmbus_connection.monitor_pages == NULL) {
 186                 ret = -ENOMEM;
 187                 goto cleanup;
 188         }
 189
 190         msginfo = kzalloc(sizeof(*msginfo) +
 191                           sizeof(struct vmbus_channel_initiate_contact),
 192                           GFP_KERNEL);
 193         if (msginfo == NULL) {
 194                 ret = -ENOMEM;
 195                 goto cleanup;
 196         }
 197
 198         /*
 199          * Negotiate a compatible VMBUS version number with the
 200          * host. We start with the highest number we can support
 201          * and work our way down until we negotiate a compatible
 202          * version.
 203          */
 204
 205         version = VERSION_WS2008;
 206
 207         do {
 208                 ret = vmbus_negotiate_version(msginfo, version);
 209                 if (ret == 0)
 210                         break;
 211
 212                 version = vmbus_get_next_version(version);
 213         } while (version != VERSION_INVAL);
 214
 215         if (version == VERSION_INVAL)
 216                 goto cleanup;
 217
 218         kfree(msginfo);
 219         return 0;
 220
 221 cleanup:
 222         vmbus_connection.conn_state = DISCONNECTED;
 223
 224         if (vmbus_connection.work_queue)
 225                 destroy_workqueue(vmbus_connection.work_queue);
 226
 227         if (vmbus_connection.int_page) {
 228                 free_pages((unsigned long)vmbus_connection.int_page, 0);
 229                 vmbus_connection.int_page = NULL;
 230         }
 231
 232         if (vmbus_connection.monitor_pages) {
 233                 free_pages((unsigned long)vmbus_connection.monitor_pages, 1);
 234                 vmbus_connection.monitor_pages = NULL;
 235         }
 236
 237         kfree(msginfo);
 238
 239         return ret;
 240 }
 241
 242
 243 /*
 244  * relid2channel - Get the channel object given its
 245  * child relative id (ie channel id)
 246  */
 247 struct vmbus_channel *relid2channel(u32 relid)
 248 {
 249         struct vmbus_channel *channel;
 250         struct vmbus_channel *found_channel  = NULL;
 251         unsigned long flags;
 252
 253         spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
 254         list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
 255                 if (channel->offermsg.child_relid == relid) {
 256                         found_channel = channel;
 257                         break;
 258                 }
 259         }
 260         spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
 261
 262         return found_channel;
 263 }
 264
 265 /*
 266  * process_chn_event - Process a channel event notification
 267  */
 268 static void process_chn_event(u32 relid)
 269 {
 270         struct vmbus_channel *channel;
 271         unsigned long flags;
 272         void *arg;
 273         bool read_state;
 274         u32 bytes_to_read;
 275
 276         /*
 277          * Find the channel based on this relid and invokes the
 278          * channel callback to process the event
 279          */
 280         channel = relid2channel(relid);
 281
 282         if (!channel) {
 283                 pr_err("channel not found for relid - %u\n", relid);
 284                 return;
 285         }
 286
 287         /*
 288          * A channel once created is persistent even when there
 289          * is no driver handling the device. An unloading driver
 290          * sets the onchannel_callback to NULL under the
 291          * protection of the channel inbound_lock. Thus, checking
 292          * and invoking the driver specific callback takes care of
 293          * orderly unloading of the driver.
 294          */
 295
 296         spin_lock_irqsave(&channel->inbound_lock, flags);
 297         if (channel->onchannel_callback != NULL) {
 298                 arg = channel->channel_callback_context;
 299                 read_state = channel->batched_reading;
 300                 /*
 301                  * This callback reads the messages sent by the host.
 302                  * We can optimize host to guest signaling by ensuring:
 303                  * 1. While reading the channel, we disable interrupts from
 304                  *    host.
 305                  * 2. Ensure that we process all posted messages from the host
 306                  *    before returning from this callback.
 307                  * 3. Once we return, enable signaling from the host. Once this
 308                  *    state is set we check to see if additional packets are
 309                  *    available to read. In this case we repeat the process.
 310                  */
 311
 312                 do {
 313                         hv_begin_read(&channel->inbound);
 314                         channel->onchannel_callback(arg);
 315                         bytes_to_read = hv_end_read(&channel->inbound);
 316                 } while (read_state && (bytes_to_read != 0));
 317         } else {
 318                 pr_err("no channel callback for relid - %u\n", relid);
 319         }
 320
 321         spin_unlock_irqrestore(&channel->inbound_lock, flags);
 322 }
 323
 324 /*
 325  * vmbus_on_event - Handler for events
 326  */
 327 void vmbus_on_event(unsigned long data)
 328 {
 329         u32 dword;
 330         u32 maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
 331         int bit;
 332         u32 relid;
 333         u32 *recv_int_page = vmbus_connection.recv_int_page;
 334
 335         /* Check events */
 336         if (!recv_int_page)
 337                 return;
 338         for (dword = 0; dword < maxdword; dword++) {
 339                 if (!recv_int_page[dword])
 340                         continue;
 341                 for (bit = 0; bit < 32; bit++) {
 342                         if (sync_test_and_clear_bit(bit,
 343                                 (unsigned long *)&recv_int_page[dword])) {
 344                                 relid = (dword << 5) + bit;
 345
 346                                 if (relid == 0)
 347                                         /*
 348                                          * Special case - vmbus
 349                                          * channel protocol msg
 350                                          */
 351                                         continue;
 352
 353                                 process_chn_event(relid);
 354                         }
 355                 }
 356         }
 357 }
 358
 359 /*
 360  * vmbus_post_msg - Send a msg on the vmbus's message connection
 361  */
 362 int vmbus_post_msg(void *buffer, size_t buflen)
 363 {
 364         union hv_connection_id conn_id;
 365         int ret = 0;
 366         int retries = 0;
 367
 368         conn_id.asu32 = 0;
 369         conn_id.u.id = VMBUS_MESSAGE_CONNECTION_ID;
 370
 371         /*
 372          * hv_post_message() can have transient failures because of
 373          * insufficient resources. Retry the operation a couple of
 374          * times before giving up.
 375          */
 376         while (retries < 3) {
 377                 ret =  hv_post_message(conn_id, 1, buffer, buflen);
 378                 if (ret != HV_STATUS_INSUFFICIENT_BUFFERS)
 379                         return ret;
 380                 retries++;
 381                 msleep(100);
 382         }
 383         return ret;
 384 }
 385
 386 /*
 387  * vmbus_set_event - Send an event notification to the parent
 388  */
 389 int vmbus_set_event(u32 child_relid)
 390 {
 391         /* Each u32 represents 32 channels */
 392         sync_set_bit(child_relid & 31,
 393                 (unsigned long *)vmbus_connection.send_int_page +
 394                 (child_relid >> 5));
 395
 396         return hv_signal_event();
 397 }