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
  24
  25 #include "include/logging.h"
  26
  27 #include "VmbusPrivate.h"
  28
  29 /* Globals */
  30
  31
  32 struct VMBUS_CONNECTION gVmbusConnection = {
  33         .ConnectState           = Disconnected,
  34         .NextGpadlHandle        = 0xE1E10,
  35 };
  36
  37
  38 /*++
  39
  40 Name:
  41         VmbusConnect()
  42
  43 Description:
  44         Sends a connect request on the partition service connection
  45
  46 --*/
  47 static int
  48 VmbusConnect(void)
  49 {
  50         int ret=0;
  51         VMBUS_CHANNEL_MSGINFO *msgInfo=NULL;
  52         VMBUS_CHANNEL_INITIATE_CONTACT *msg;
  53         unsigned long flags;
  54
  55         DPRINT_ENTER(VMBUS);
  56
  57         /* Make sure we are not connecting or connected */
  58         if (gVmbusConnection.ConnectState != Disconnected)
  59                 return -1;
  60
  61         /* Initialize the vmbus connection */
  62         gVmbusConnection.ConnectState = Connecting;
  63         gVmbusConnection.WorkQueue = WorkQueueCreate("vmbusQ");
  64
  65         INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelMsgList);
  66         spin_lock_init(&gVmbusConnection.channelmsg_lock);
  67
  68         INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelList);
  69         spin_lock_init(&gVmbusConnection.channel_lock);
  70
  71         /*
  72          * Setup the vmbus event connection for channel interrupt
  73          * abstraction stuff
  74          */
  75         gVmbusConnection.InterruptPage = PageAlloc(1);
  76         if (gVmbusConnection.InterruptPage == NULL)
  77         {
  78                 ret = -1;
  79                 goto Cleanup;
  80         }
  81
  82         gVmbusConnection.RecvInterruptPage = gVmbusConnection.InterruptPage;
  83         gVmbusConnection.SendInterruptPage = (void*)((unsigned long)gVmbusConnection.InterruptPage + (PAGE_SIZE >> 1));
  84
  85         /* Setup the monitor
  86          * notification facility. The 1st page for parent->child and
  87          * the 2nd page for child->parent
  88          */
  89         gVmbusConnection.MonitorPages = PageAlloc(2);
  90         if (gVmbusConnection.MonitorPages == NULL)
  91         {
  92                 ret = -1;
  93                 goto Cleanup;
  94         }
  95
  96         msgInfo = kzalloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_INITIATE_CONTACT), GFP_KERNEL);
  97         if (msgInfo == NULL)
  98         {
  99                 ret = -1;
 100                 goto Cleanup;
 101         }
 102
 103         msgInfo->WaitEvent = WaitEventCreate();
 104         msg = (VMBUS_CHANNEL_INITIATE_CONTACT*)msgInfo->Msg;
 105
 106         msg->Header.MessageType = ChannelMessageInitiateContact;
 107         msg->VMBusVersionRequested = VMBUS_REVISION_NUMBER;
 108         msg->InterruptPage = GetPhysicalAddress(gVmbusConnection.InterruptPage);
 109         msg->MonitorPage1 = GetPhysicalAddress(gVmbusConnection.MonitorPages);
 110         msg->MonitorPage2 = GetPhysicalAddress((void *)((unsigned long)gVmbusConnection.MonitorPages + PAGE_SIZE));
 111
 112         /*
 113          * Add to list before we send the request since we may
 114          * receive the response before returning from this routine
 115          */
 116         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 117         INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &msgInfo->MsgListEntry);
 118         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 119
 120         DPRINT_DBG(VMBUS, "Vmbus connection -  interrupt pfn %llx, monitor1 pfn %llx,, monitor2 pfn %llx",
 121                 msg->InterruptPage, msg->MonitorPage1, msg->MonitorPage2);
 122
 123         DPRINT_DBG(VMBUS, "Sending channel initiate msg...");
 124
 125         ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_INITIATE_CONTACT));
 126         if (ret != 0)
 127         {
 128                 REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
 129                 goto Cleanup;
 130         }
 131
 132         /* Wait for the connection response */
 133         WaitEventWait(msgInfo->WaitEvent);
 134
 135         REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
 136
 137         /* Check if successful */
 138         if (msgInfo->Response.VersionResponse.VersionSupported)
 139         {
 140                 DPRINT_INFO(VMBUS, "Vmbus connected!!");
 141                 gVmbusConnection.ConnectState = Connected;
 142
 143         }
 144         else
 145         {
 146                 DPRINT_ERR(VMBUS, "Vmbus connection failed!!...current version (%d) not supported", VMBUS_REVISION_NUMBER);
 147                 ret = -1;
 148
 149                 goto Cleanup;
 150         }
 151
 152
 153         WaitEventClose(msgInfo->WaitEvent);
 154         kfree(msgInfo);
 155         DPRINT_EXIT(VMBUS);
 156
 157         return 0;
 158
 159 Cleanup:
 160
 161         gVmbusConnection.ConnectState = Disconnected;
 162
 163         WorkQueueClose(gVmbusConnection.WorkQueue);
 164
 165         if (gVmbusConnection.InterruptPage)
 166         {
 167                 PageFree(gVmbusConnection.InterruptPage, 1);
 168                 gVmbusConnection.InterruptPage = NULL;
 169         }
 170
 171         if (gVmbusConnection.MonitorPages)
 172         {
 173                 PageFree(gVmbusConnection.MonitorPages, 2);
 174                 gVmbusConnection.MonitorPages = NULL;
 175         }
 176
 177         if (msgInfo)
 178         {
 179                 if (msgInfo->WaitEvent)
 180                         WaitEventClose(msgInfo->WaitEvent);
 181
 182                 kfree(msgInfo);
 183         }
 184
 185         DPRINT_EXIT(VMBUS);
 186
 187         return ret;
 188 }
 189
 190
 191 /*++
 192
 193 Name:
 194         VmbusDisconnect()
 195
 196 Description:
 197         Sends a disconnect request on the partition service connection
 198
 199 --*/
 200 static int
 201 VmbusDisconnect(
 202         void
 203         )
 204 {
 205         int ret=0;
 206         VMBUS_CHANNEL_UNLOAD *msg;
 207
 208         DPRINT_ENTER(VMBUS);
 209
 210         /* Make sure we are connected */
 211         if (gVmbusConnection.ConnectState != Connected)
 212                 return -1;
 213
 214         msg = kzalloc(sizeof(VMBUS_CHANNEL_UNLOAD), GFP_KERNEL);
 215
 216         msg->MessageType = ChannelMessageUnload;
 217
 218         ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_UNLOAD));
 219
 220         if (ret != 0)
 221         {
 222                 goto Cleanup;
 223         }
 224
 225         PageFree(gVmbusConnection.InterruptPage, 1);
 226
 227         /* TODO: iterate thru the msg list and free up */
 228
 229         WorkQueueClose(gVmbusConnection.WorkQueue);
 230
 231         gVmbusConnection.ConnectState = Disconnected;
 232
 233         DPRINT_INFO(VMBUS, "Vmbus disconnected!!");
 234
 235 Cleanup:
 236         if (msg)
 237         {
 238                 kfree(msg);
 239         }
 240
 241         DPRINT_EXIT(VMBUS);
 242
 243         return ret;
 244 }
 245
 246
 247 /*++
 248
 249 Name:
 250         GetChannelFromRelId()
 251
 252 Description:
 253         Get the channel object given its child relative id (ie channel id)
 254
 255 --*/
 256 static VMBUS_CHANNEL*
 257 GetChannelFromRelId(
 258         u32 relId
 259         )
 260 {
 261         VMBUS_CHANNEL* channel;
 262         VMBUS_CHANNEL* foundChannel=NULL;
 263         LIST_ENTRY* anchor;
 264         LIST_ENTRY* curr;
 265         unsigned long flags;
 266
 267         spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);
 268         ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelList)
 269         {
 270                 channel = CONTAINING_RECORD(curr, VMBUS_CHANNEL, ListEntry);
 271
 272                 if (channel->OfferMsg.ChildRelId == relId)
 273                 {
 274                         foundChannel = channel;
 275                         break;
 276                 }
 277         }
 278         spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);
 279
 280         return foundChannel;
 281 }
 282
 283
 284
 285 /*++
 286
 287 Name:
 288         VmbusProcessChannelEvent()
 289
 290 Description:
 291         Process a channel event notification
 292
 293 --*/
 294 static void
 295 VmbusProcessChannelEvent(
 296         void * context
 297         )
 298 {
 299         VMBUS_CHANNEL* channel;
 300         u32 relId = (u32)(unsigned long)context;
 301
 302         ASSERT(relId > 0);
 303
 304         /*
 305          * Find the channel based on this relid and invokes the
 306          * channel callback to process the event
 307          */
 308         channel = GetChannelFromRelId(relId);
 309
 310         if (channel)
 311         {
 312                 VmbusChannelOnChannelEvent(channel);
 313                 /* WorkQueueQueueWorkItem(channel->dataWorkQueue, VmbusChannelOnChannelEvent, (void*)channel); */
 314         }
 315         else
 316         {
 317         DPRINT_ERR(VMBUS, "channel not found for relid - %d.", relId);
 318         }
 319 }
 320
 321
 322 /*++
 323
 324 Name:
 325         VmbusOnEvents()
 326
 327 Description:
 328         Handler for events
 329
 330 --*/
 331 static void
 332 VmbusOnEvents(
 333   void
 334         )
 335 {
 336         int dword;
 337         /* int maxdword = PAGE_SIZE >> 3; // receive size is 1/2 page and divide that by 4 bytes */
 338         int maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
 339         int bit;
 340         int relid;
 341         u32* recvInterruptPage = gVmbusConnection.RecvInterruptPage;
 342         /* VMBUS_CHANNEL_MESSAGE* receiveMsg; */
 343
 344         DPRINT_ENTER(VMBUS);
 345
 346         /* Check events */
 347         if (recvInterruptPage)
 348         {
 349                 for (dword = 0; dword < maxdword; dword++)
 350                 {
 351                         if (recvInterruptPage[dword])
 352                         {
 353                                 for (bit = 0; bit < 32; bit++)
 354                                 {
 355                                         if (BitTestAndClear(&recvInterruptPage[dword], bit))
 356                                         {
 357                                                 relid = (dword << 5) + bit;
 358
 359                                                 DPRINT_DBG(VMBUS, "event detected for relid - %d", relid);
 360
 361                                                 if (relid == 0) /* special case - vmbus channel protocol msg */
 362                                                 {
 363                                                         DPRINT_DBG(VMBUS, "invalid relid - %d", relid);
 364
 365                                                         continue;                                               }
 366                                                 else
 367                                                 {
 368                                                         /* QueueWorkItem(VmbusProcessEvent, (void*)relid); */
 369                                                         /* ret = WorkQueueQueueWorkItem(gVmbusConnection.workQueue, VmbusProcessChannelEvent, (void*)relid); */
 370                                                         VmbusProcessChannelEvent((void*)(unsigned long)relid);
 371                                                 }
 372                                         }
 373                                 }
 374                         }
 375                  }
 376         }
 377         DPRINT_EXIT(VMBUS);
 378
 379         return;
 380 }
 381
 382 /*++
 383
 384 Name:
 385         VmbusPostMessage()
 386
 387 Description:
 388         Send a msg on the vmbus's message connection
 389
 390 --*/
 391 static int
 392 VmbusPostMessage(
 393         void *                  buffer,
 394         size_t                  bufferLen
 395         )
 396 {
 397         int ret=0;
 398         HV_CONNECTION_ID connId;
 399
 400
 401         connId.Asu32 =0;
 402         connId.u.Id = VMBUS_MESSAGE_CONNECTION_ID;
 403         ret = HvPostMessage(
 404                         connId,
 405                         1,
 406                         buffer,
 407                         bufferLen);
 408
 409         return  ret;
 410 }
 411
 412 /*++
 413
 414 Name:
 415         VmbusSetEvent()
 416
 417 Description:
 418         Send an event notification to the parent
 419
 420 --*/
 421 static int
 422 VmbusSetEvent(u32 childRelId)
 423 {
 424         int ret=0;
 425
 426         DPRINT_ENTER(VMBUS);
 427
 428         /* Each u32 represents 32 channels */
 429         BitSet((u32*)gVmbusConnection.SendInterruptPage + (childRelId >> 5), childRelId & 31);
 430         ret = HvSignalEvent();
 431
 432         DPRINT_EXIT(VMBUS);
 433
 434         return ret;
 435 }
 436
 437 /* EOF */