drivers/staging/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/mm.h>
  29 #include <linux/slab.h>
  30 #include <linux/vmalloc.h>
  31 #include "hv_api.h"
  32 #include "logging.h"
  33 #include "vmbus_private.h"
  34
  35
  36 struct vmbus_connection vmbus_connection = {
  37         .conn_state             = DISCONNECTED,
  38         .next_gpadl_handle      = ATOMIC_INIT(0xE1E10),
  39 };
  40
  41 /*
  42  * vmbus_connect - Sends a connect request on the partition service connection
  43  */
  44 int vmbus_connect(void)
  45 {
  46         int ret = 0;
  47         struct vmbus_channel_msginfo *msginfo = NULL;
  48         struct vmbus_channel_initiate_contact *msg;
  49         unsigned long flags;
  50
  51         /* Make sure we are not connecting or connected */
  52         if (vmbus_connection.conn_state != DISCONNECTED)
  53                 return -1;
  54
  55         /* Initialize the vmbus connection */
  56         vmbus_connection.conn_state = CONNECTING;
  57         vmbus_connection.work_queue = create_workqueue("hv_vmbus_con");
  58         if (!vmbus_connection.work_queue) {
  59                 ret = -1;
  60                 goto Cleanup;
  61         }
  62
  63         INIT_LIST_HEAD(&vmbus_connection.chn_msg_list);
  64         spin_lock_init(&vmbus_connection.channelmsg_lock);
  65
  66         INIT_LIST_HEAD(&vmbus_connection.chn_list);
  67         spin_lock_init(&vmbus_connection.channel_lock);
  68
  69         /*
  70          * Setup the vmbus event connection for channel interrupt
  71          * abstraction stuff
  72          */
  73         vmbus_connection.int_page =
  74         (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, 0);
  75         if (vmbus_connection.int_page == NULL) {
  76                 ret = -1;
  77                 goto Cleanup;
  78         }
  79
  80         vmbus_connection.recv_int_page = vmbus_connection.int_page;
  81         vmbus_connection.send_int_page =
  82                 (void *)((unsigned long)vmbus_connection.int_page +
  83                         (PAGE_SIZE >> 1));
  84
  85         /*
  86          * Setup the monitor notification facility. The 1st page for
  87          * parent->child and the 2nd page for child->parent
  88          */
  89         vmbus_connection.monitor_pages =
  90         (void *)__get_free_pages((GFP_KERNEL|__GFP_ZERO), 1);
  91         if (vmbus_connection.monitor_pages == NULL) {
  92                 ret = -1;
  93                 goto Cleanup;
  94         }
  95
  96         msginfo = kzalloc(sizeof(*msginfo) +
  97                           sizeof(struct vmbus_channel_initiate_contact),
  98                           GFP_KERNEL);
  99         if (msginfo == NULL) {
 100                 ret = -ENOMEM;
 101                 goto Cleanup;
 102         }
 103
 104         init_waitqueue_head(&msginfo->waitevent);
 105
 106         msg = (struct vmbus_channel_initiate_contact *)msginfo->msg;
 107
 108         msg->header.msgtype = CHANNELMSG_INITIATE_CONTACT;
 109         msg->vmbus_version_requested = VMBUS_REVISION_NUMBER;
 110         msg->interrupt_page = virt_to_phys(vmbus_connection.int_page);
 111         msg->monitor_page1 = virt_to_phys(vmbus_connection.monitor_pages);
 112         msg->monitor_page2 = virt_to_phys(
 113                         (void *)((unsigned long)vmbus_connection.monitor_pages +
 114                                  PAGE_SIZE));
 115
 116         /*
 117          * Add to list before we send the request since we may
 118          * receive the response before returning from this routine
 119          */
 120         spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
 121         list_add_tail(&msginfo->msglistentry,
 122                       &vmbus_connection.chn_msg_list);
 123
 124         spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
 125
 126         ret = vmbus_post_msg(msg,
 127                                sizeof(struct vmbus_channel_initiate_contact));
 128         if (ret != 0) {
 129                 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
 130                 list_del(&msginfo->msglistentry);
 131                 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
 132                                         flags);
 133                 goto Cleanup;
 134         }
 135
 136         /* Wait for the connection response */
 137         msginfo->wait_condition = 0;
 138         wait_event_timeout(msginfo->waitevent, msginfo->wait_condition,
 139                         msecs_to_jiffies(1000));
 140         if (msginfo->wait_condition == 0) {
 141                 spin_lock_irqsave(&vmbus_connection.channelmsg_lock,
 142                                 flags);
 143                 list_del(&msginfo->msglistentry);
 144                 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock,
 145                                         flags);
 146                 ret = -ETIMEDOUT;
 147                 goto Cleanup;
 148         }
 149
 150         spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
 151         list_del(&msginfo->msglistentry);
 152         spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
 153
 154         /* Check if successful */
 155         if (msginfo->response.version_response.version_supported) {
 156                 vmbus_connection.conn_state = CONNECTED;
 157         } else {
 158                 pr_err("Unable to connect, "
 159                         "Version %d not supported by Hyper-V\n",
 160                         VMBUS_REVISION_NUMBER);
 161                 ret = -1;
 162                 goto Cleanup;
 163         }
 164
 165         kfree(msginfo);
 166         return 0;
 167
 168 Cleanup:
 169         vmbus_connection.conn_state = DISCONNECTED;
 170
 171         if (vmbus_connection.work_queue)
 172                 destroy_workqueue(vmbus_connection.work_queue);
 173
 174         if (vmbus_connection.int_page) {
 175                 free_pages((unsigned long)vmbus_connection.int_page, 0);
 176                 vmbus_connection.int_page = NULL;
 177         }
 178
 179         if (vmbus_connection.monitor_pages) {
 180                 free_pages((unsigned long)vmbus_connection.monitor_pages, 1);
 181                 vmbus_connection.monitor_pages = NULL;
 182         }
 183
 184         kfree(msginfo);
 185
 186         return ret;
 187 }
 188
 189 /*
 190  * vmbus_disconnect -
 191  * Sends a disconnect request on the partition service connection
 192  */
 193 int vmbus_disconnect(void)
 194 {
 195         int ret = 0;
 196         struct vmbus_channel_message_header *msg;
 197
 198         /* Make sure we are connected */
 199         if (vmbus_connection.conn_state != CONNECTED)
 200                 return -1;
 201
 202         msg = kzalloc(sizeof(struct vmbus_channel_message_header), GFP_KERNEL);
 203         if (!msg)
 204                 return -ENOMEM;
 205
 206         msg->msgtype = CHANNELMSG_UNLOAD;
 207
 208         ret = vmbus_post_msg(msg,
 209                                sizeof(struct vmbus_channel_message_header));
 210         if (ret != 0)
 211                 goto Cleanup;
 212
 213         free_pages((unsigned long)vmbus_connection.int_page, 0);
 214         free_pages((unsigned long)vmbus_connection.monitor_pages, 1);
 215
 216         /* TODO: iterate thru the msg list and free up */
 217         destroy_workqueue(vmbus_connection.work_queue);
 218
 219         vmbus_connection.conn_state = DISCONNECTED;
 220
 221         pr_info("hv_vmbus disconnected\n");
 222
 223 Cleanup:
 224         kfree(msg);
 225         return ret;
 226 }
 227
 228 /*
 229  * relid2channel - Get the channel object given its
 230  * child relative id (ie channel id)
 231  */
 232 struct vmbus_channel *relid2channel(u32 relid)
 233 {
 234         struct vmbus_channel *channel;
 235         struct vmbus_channel *found_channel  = NULL;
 236         unsigned long flags;
 237
 238         spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
 239         list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
 240                 if (channel->offermsg.child_relid == relid) {
 241                         found_channel = channel;
 242                         break;
 243                 }
 244         }
 245         spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
 246
 247         return found_channel;
 248 }
 249
 250 /*
 251  * process_chn_event - Process a channel event notification
 252  */
 253 static void process_chn_event(u32 relid)
 254 {
 255         struct vmbus_channel *channel;
 256
 257         /* ASSERT(relId > 0); */
 258
 259         /*
 260          * Find the channel based on this relid and invokes the
 261          * channel callback to process the event
 262          */
 263         channel = relid2channel(relid);
 264
 265         if (channel) {
 266                 vmbus_onchannel_event(channel);
 267                 /*
 268                  * WorkQueueQueueWorkItem(channel->dataWorkQueue,
 269                  *                        vmbus_onchannel_event,
 270                  *                        (void*)channel);
 271                  */
 272         } else {
 273                 pr_err("channel not found for relid - %u\n", relid);
 274         }
 275 }
 276
 277 /*
 278  * vmbus_on_event - Handler for events
 279  */
 280 void vmbus_on_event(unsigned long data)
 281 {
 282         u32 dword;
 283         u32 maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
 284         int bit;
 285         u32 relid;
 286         u32 *recv_int_page = vmbus_connection.recv_int_page;
 287
 288         /* Check events */
 289         if (!recv_int_page)
 290                 return;
 291         for (dword = 0; dword < maxdword; dword++) {
 292                 if (!recv_int_page[dword])
 293                         continue;
 294                 for (bit = 0; bit < 32; bit++) {
 295                         if (sync_test_and_clear_bit(bit, (unsigned long *)&recv_int_page[dword])) {
 296                                 relid = (dword << 5) + bit;
 297
 298                                 if (relid == 0) {
 299                                         /* special case - vmbus channel protocol msg */
 300                                         continue;
 301                                 }
 302                                 process_chn_event(relid);
 303                         }
 304                 }
 305         }
 306 }
 307
 308 /*
 309  * vmbus_post_msg - Send a msg on the vmbus's message connection
 310  */
 311 int vmbus_post_msg(void *buffer, size_t buflen)
 312 {
 313         union hv_connection_id conn_id;
 314
 315         conn_id.asu32 = 0;
 316         conn_id.u.id = VMBUS_MESSAGE_CONNECTION_ID;
 317         return hv_post_message(conn_id, 1, buffer, buflen);
 318 }
 319
 320 /*
 321  * vmbus_set_event - Send an event notification to the parent
 322  */
 323 int vmbus_set_event(u32 child_relid)
 324 {
 325         /* Each u32 represents 32 channels */
 326         sync_set_bit(child_relid & 31,
 327                 (unsigned long *)vmbus_connection.send_int_page +
 328                 (child_relid >> 5));
 329
 330         return hv_signal_event();
 331 }