drivers/staging/hv/Channel.c

   1 /*
   2  * Copyright (c) 2009, Microsoft Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA 02111-1307 USA.
  16  *
  17  * Authors:
  18  *   Haiyang Zhang <haiyangz@microsoft.com>
  19  *   Hank Janssen  <hjanssen@microsoft.com>
  20  */
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25 #include "osd.h"
  26 #include "logging.h"
  27 #include "VmbusPrivate.h"
  28
  29 /* Internal routines */
  30 static int VmbusChannelCreateGpadlHeader(
  31         void *Kbuffer,  /* must be phys and virt contiguous */
  32         u32 Size,       /* page-size multiple */
  33         struct vmbus_channel_msginfo **msgInfo,
  34         u32 *MessageCount);
  35 static void DumpVmbusChannel(struct vmbus_channel *channel);
  36 static void VmbusChannelSetEvent(struct vmbus_channel *channel);
  37
  38
  39 #if 0
  40 static void DumpMonitorPage(struct hv_monitor_page *MonitorPage)
  41 {
  42         int i = 0;
  43         int j = 0;
  44
  45         DPRINT_DBG(VMBUS, "monitorPage - %p, trigger state - %d",
  46                    MonitorPage, MonitorPage->TriggerState);
  47
  48         for (i = 0; i < 4; i++)
  49                 DPRINT_DBG(VMBUS, "trigger group (%d) - %llx", i,
  50                            MonitorPage->TriggerGroup[i].AsUINT64);
  51
  52         for (i = 0; i < 4; i++) {
  53                 for (j = 0; j < 32; j++) {
  54                         DPRINT_DBG(VMBUS, "latency (%d)(%d) - %llx", i, j,
  55                                    MonitorPage->Latency[i][j]);
  56                 }
  57         }
  58         for (i = 0; i < 4; i++) {
  59                 for (j = 0; j < 32; j++) {
  60                         DPRINT_DBG(VMBUS, "param-conn id (%d)(%d) - %d", i, j,
  61                                MonitorPage->Parameter[i][j].ConnectionId.Asu32);
  62                         DPRINT_DBG(VMBUS, "param-flag (%d)(%d) - %d", i, j,
  63                                 MonitorPage->Parameter[i][j].FlagNumber);
  64                 }
  65         }
  66 }
  67 #endif
  68
  69 /*
  70  * VmbusChannelSetEvent - Trigger an event notification on the specified
  71  * channel.
  72  */
  73 static void VmbusChannelSetEvent(struct vmbus_channel *Channel)
  74 {
  75         struct hv_monitor_page *monitorPage;
  76
  77         DPRINT_ENTER(VMBUS);
  78
  79         if (Channel->OfferMsg.MonitorAllocated) {
  80                 /* Each u32 represents 32 channels */
  81                 set_bit(Channel->OfferMsg.ChildRelId & 31,
  82                         (unsigned long *) gVmbusConnection.SendInterruptPage +
  83                         (Channel->OfferMsg.ChildRelId >> 5));
  84
  85                 monitorPage = gVmbusConnection.MonitorPages;
  86                 monitorPage++; /* Get the child to parent monitor page */
  87
  88                 set_bit(Channel->MonitorBit,
  89                         (unsigned long *)&monitorPage->TriggerGroup
  90                                         [Channel->MonitorGroup].Pending);
  91
  92         } else {
  93                 VmbusSetEvent(Channel->OfferMsg.ChildRelId);
  94         }
  95
  96         DPRINT_EXIT(VMBUS);
  97 }
  98
  99 #if 0
 100 static void VmbusChannelClearEvent(struct vmbus_channel *channel)
 101 {
 102         struct hv_monitor_page *monitorPage;
 103
 104         DPRINT_ENTER(VMBUS);
 105
 106         if (Channel->OfferMsg.MonitorAllocated) {
 107                 /* Each u32 represents 32 channels */
 108                 clear_bit(Channel->OfferMsg.ChildRelId & 31,
 109                           (unsigned long *)gVmbusConnection.SendInterruptPage +
 110                           (Channel->OfferMsg.ChildRelId >> 5));
 111
 112                 monitorPage =
 113                         (struct hv_monitor_page *)gVmbusConnection.MonitorPages;
 114                 monitorPage++; /* Get the child to parent monitor page */
 115
 116                 clear_bit(Channel->MonitorBit,
 117                           (unsigned long *)&monitorPage->TriggerGroup
 118                                         [Channel->MonitorGroup].Pending);
 119         }
 120
 121         DPRINT_EXIT(VMBUS);
 122 }
 123
 124 #endif
 125 /*
 126  * VmbusChannelGetDebugInfo -Retrieve various channel debug info
 127  */
 128 void VmbusChannelGetDebugInfo(struct vmbus_channel *Channel,
 129                               struct vmbus_channel_debug_info *DebugInfo)
 130 {
 131         struct hv_monitor_page *monitorPage;
 132         u8 monitorGroup = (u8)Channel->OfferMsg.MonitorId / 32;
 133         u8 monitorOffset = (u8)Channel->OfferMsg.MonitorId % 32;
 134         /* u32 monitorBit       = 1 << monitorOffset; */
 135
 136         DebugInfo->RelId = Channel->OfferMsg.ChildRelId;
 137         DebugInfo->State = Channel->State;
 138         memcpy(&DebugInfo->InterfaceType,
 139                &Channel->OfferMsg.Offer.InterfaceType, sizeof(struct hv_guid));
 140         memcpy(&DebugInfo->InterfaceInstance,
 141                &Channel->OfferMsg.Offer.InterfaceInstance,
 142                sizeof(struct hv_guid));
 143
 144         monitorPage = (struct hv_monitor_page *)gVmbusConnection.MonitorPages;
 145
 146         DebugInfo->MonitorId = Channel->OfferMsg.MonitorId;
 147
 148         DebugInfo->ServerMonitorPending =
 149                         monitorPage->TriggerGroup[monitorGroup].Pending;
 150         DebugInfo->ServerMonitorLatency =
 151                         monitorPage->Latency[monitorGroup][monitorOffset];
 152         DebugInfo->ServerMonitorConnectionId =
 153                         monitorPage->Parameter[monitorGroup]
 154                                               [monitorOffset].ConnectionId.u.Id;
 155
 156         monitorPage++;
 157
 158         DebugInfo->ClientMonitorPending =
 159                         monitorPage->TriggerGroup[monitorGroup].Pending;
 160         DebugInfo->ClientMonitorLatency =
 161                         monitorPage->Latency[monitorGroup][monitorOffset];
 162         DebugInfo->ClientMonitorConnectionId =
 163                         monitorPage->Parameter[monitorGroup]
 164                                               [monitorOffset].ConnectionId.u.Id;
 165
 166         RingBufferGetDebugInfo(&Channel->Inbound, &DebugInfo->Inbound);
 167         RingBufferGetDebugInfo(&Channel->Outbound, &DebugInfo->Outbound);
 168 }
 169
 170 /*
 171  * VmbusChannelOpen - Open the specified channel.
 172  */
 173 int VmbusChannelOpen(struct vmbus_channel *NewChannel, u32 SendRingBufferSize,
 174                      u32 RecvRingBufferSize, void *UserData, u32 UserDataLen,
 175                      void (*OnChannelCallback)(void *context), void *Context)
 176 {
 177         struct vmbus_channel_open_channel *openMsg;
 178         struct vmbus_channel_msginfo *openInfo;
 179         void *in, *out;
 180         unsigned long flags;
 181         int ret, err = 0;
 182
 183         DPRINT_ENTER(VMBUS);
 184
 185         /* Aligned to page size */
 186         ASSERT(!(SendRingBufferSize & (PAGE_SIZE - 1)));
 187         ASSERT(!(RecvRingBufferSize & (PAGE_SIZE - 1)));
 188
 189         NewChannel->OnChannelCallback = OnChannelCallback;
 190         NewChannel->ChannelCallbackContext = Context;
 191
 192         /* Allocate the ring buffer */
 193         out = osd_PageAlloc((SendRingBufferSize + RecvRingBufferSize)
 194                              >> PAGE_SHIFT);
 195         if (!out)
 196                 return -ENOMEM;
 197
 198         ASSERT(((unsigned long)out & (PAGE_SIZE-1)) == 0);
 199
 200         in = (void *)((unsigned long)out + SendRingBufferSize);
 201
 202         NewChannel->RingBufferPages = out;
 203         NewChannel->RingBufferPageCount = (SendRingBufferSize +
 204                                            RecvRingBufferSize) >> PAGE_SHIFT;
 205
 206         RingBufferInit(&NewChannel->Outbound, out, SendRingBufferSize);
 207
 208         RingBufferInit(&NewChannel->Inbound, in, RecvRingBufferSize);
 209
 210         /* Establish the gpadl for the ring buffer */
 211         DPRINT_DBG(VMBUS, "Establishing ring buffer's gpadl for channel %p...",
 212                    NewChannel);
 213
 214         NewChannel->RingBufferGpadlHandle = 0;
 215
 216         ret = VmbusChannelEstablishGpadl(NewChannel,
 217                                          NewChannel->Outbound.RingBuffer,
 218                                          SendRingBufferSize +
 219                                          RecvRingBufferSize,
 220                                          &NewChannel->RingBufferGpadlHandle);
 221 /* FIXME: the value of ret is not checked */
 222
 223         DPRINT_DBG(VMBUS, "channel %p <relid %d gpadl 0x%x send ring %p "
 224                    "size %d recv ring %p size %d, downstreamoffset %d>",
 225                    NewChannel, NewChannel->OfferMsg.ChildRelId,
 226                    NewChannel->RingBufferGpadlHandle,
 227                    NewChannel->Outbound.RingBuffer,
 228                    NewChannel->Outbound.RingSize,
 229                    NewChannel->Inbound.RingBuffer,
 230                    NewChannel->Inbound.RingSize,
 231                    SendRingBufferSize);
 232
 233         /* Create and init the channel open message */
 234         openInfo = kmalloc(sizeof(*openInfo) +
 235                            sizeof(struct vmbus_channel_open_channel),
 236                            GFP_KERNEL);
 237         if (!openInfo) {
 238                 err = -ENOMEM;
 239                 goto errorout;
 240         }
 241
 242         openInfo->WaitEvent = osd_WaitEventCreate();
 243         if (!openInfo->WaitEvent) {
 244                 err = -ENOMEM;
 245                 goto errorout;
 246         }
 247
 248         openMsg = (struct vmbus_channel_open_channel *)openInfo->Msg;
 249         openMsg->Header.MessageType = ChannelMessageOpenChannel;
 250         openMsg->OpenId = NewChannel->OfferMsg.ChildRelId; /* FIXME */
 251         openMsg->ChildRelId = NewChannel->OfferMsg.ChildRelId;
 252         openMsg->RingBufferGpadlHandle = NewChannel->RingBufferGpadlHandle;
 253         ASSERT(openMsg->RingBufferGpadlHandle);
 254         openMsg->DownstreamRingBufferPageOffset = SendRingBufferSize >>
 255                                                   PAGE_SHIFT;
 256         openMsg->ServerContextAreaGpadlHandle = 0; /* TODO */
 257
 258         ASSERT(UserDataLen <= MAX_USER_DEFINED_BYTES);
 259         if (UserDataLen)
 260                 memcpy(openMsg->UserData, UserData, UserDataLen);
 261
 262         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 263         list_add_tail(&openInfo->MsgListEntry,
 264                       &gVmbusConnection.ChannelMsgList);
 265         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 266
 267         DPRINT_DBG(VMBUS, "Sending channel open msg...");
 268
 269         ret = VmbusPostMessage(openMsg,
 270                                sizeof(struct vmbus_channel_open_channel));
 271         if (ret != 0) {
 272                 DPRINT_ERR(VMBUS, "unable to open channel - %d", ret);
 273                 goto Cleanup;
 274         }
 275
 276         /* FIXME: Need to time-out here */
 277         osd_WaitEventWait(openInfo->WaitEvent);
 278
 279         if (openInfo->Response.OpenResult.Status == 0)
 280                 DPRINT_INFO(VMBUS, "channel <%p> open success!!", NewChannel);
 281         else
 282                 DPRINT_INFO(VMBUS, "channel <%p> open failed - %d!!",
 283                             NewChannel, openInfo->Response.OpenResult.Status);
 284
 285 Cleanup:
 286         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 287         list_del(&openInfo->MsgListEntry);
 288         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 289
 290         kfree(openInfo->WaitEvent);
 291         kfree(openInfo);
 292
 293         DPRINT_EXIT(VMBUS);
 294
 295         return 0;
 296
 297 errorout:
 298         osd_PageFree(out, (SendRingBufferSize + RecvRingBufferSize)
 299                      >> PAGE_SHIFT);
 300         kfree(openInfo);
 301         return err;
 302 }
 303
 304 /*
 305  * DumpGpadlBody - Dump the gpadl body message to the console for
 306  * debugging purposes.
 307  */
 308 static void DumpGpadlBody(struct vmbus_channel_gpadl_body *Gpadl, u32 Len)
 309 {
 310         int i;
 311         int pfnCount;
 312
 313         pfnCount = (Len - sizeof(struct vmbus_channel_gpadl_body)) /
 314                    sizeof(u64);
 315         DPRINT_DBG(VMBUS, "gpadl body - len %d pfn count %d", Len, pfnCount);
 316
 317         for (i = 0; i < pfnCount; i++)
 318                 DPRINT_DBG(VMBUS, "gpadl body  - %d) pfn %llu",
 319                            i, Gpadl->Pfn[i]);
 320 }
 321
 322 /*
 323  * DumpGpadlHeader - Dump the gpadl header message to the console for
 324  * debugging purposes.
 325  */
 326 static void DumpGpadlHeader(struct vmbus_channel_gpadl_header *Gpadl)
 327 {
 328         int i, j;
 329         int pageCount;
 330
 331         DPRINT_DBG(VMBUS,
 332                    "gpadl header - relid %d, range count %d, range buflen %d",
 333                    Gpadl->ChildRelId, Gpadl->RangeCount, Gpadl->RangeBufLen);
 334         for (i = 0; i < Gpadl->RangeCount; i++) {
 335                 pageCount = Gpadl->Range[i].ByteCount >> PAGE_SHIFT;
 336                 pageCount = (pageCount > 26) ? 26 : pageCount;
 337
 338                 DPRINT_DBG(VMBUS, "gpadl range %d - len %d offset %d "
 339                            "page count %d", i, Gpadl->Range[i].ByteCount,
 340                            Gpadl->Range[i].ByteOffset, pageCount);
 341
 342                 for (j = 0; j < pageCount; j++)
 343                         DPRINT_DBG(VMBUS, "%d) pfn %llu", j,
 344                                    Gpadl->Range[i].PfnArray[j]);
 345         }
 346 }
 347
 348 /*
 349  * VmbusChannelCreateGpadlHeader - Creates a gpadl for the specified buffer
 350  */
 351 static int VmbusChannelCreateGpadlHeader(void *Kbuffer, u32 Size,
 352                                          struct vmbus_channel_msginfo **MsgInfo,
 353                                          u32 *MessageCount)
 354 {
 355         int i;
 356         int pageCount;
 357         unsigned long long pfn;
 358         struct vmbus_channel_gpadl_header *gpaHeader;
 359         struct vmbus_channel_gpadl_body *gpadlBody;
 360         struct vmbus_channel_msginfo *msgHeader;
 361         struct vmbus_channel_msginfo *msgBody;
 362         u32 msgSize;
 363
 364         int pfnSum, pfnCount, pfnLeft, pfnCurr, pfnSize;
 365
 366         /* ASSERT((kbuffer & (PAGE_SIZE-1)) == 0); */
 367         ASSERT((Size & (PAGE_SIZE-1)) == 0);
 368
 369         pageCount = Size >> PAGE_SHIFT;
 370         pfn = virt_to_phys(Kbuffer) >> PAGE_SHIFT;
 371
 372         /* do we need a gpadl body msg */
 373         pfnSize = MAX_SIZE_CHANNEL_MESSAGE -
 374                   sizeof(struct vmbus_channel_gpadl_header) -
 375                   sizeof(struct gpa_range);
 376         pfnCount = pfnSize / sizeof(u64);
 377
 378         if (pageCount > pfnCount) {
 379                 /* we need a gpadl body */
 380                 /* fill in the header */
 381                 msgSize = sizeof(struct vmbus_channel_msginfo) +
 382                           sizeof(struct vmbus_channel_gpadl_header) +
 383                           sizeof(struct gpa_range) + pfnCount * sizeof(u64);
 384                 msgHeader =  kzalloc(msgSize, GFP_KERNEL);
 385                 if (!msgHeader)
 386                         goto nomem;
 387
 388                 INIT_LIST_HEAD(&msgHeader->SubMsgList);
 389                 msgHeader->MessageSize = msgSize;
 390
 391                 gpaHeader = (struct vmbus_channel_gpadl_header *)msgHeader->Msg;
 392                 gpaHeader->RangeCount = 1;
 393                 gpaHeader->RangeBufLen = sizeof(struct gpa_range) +
 394                                          pageCount * sizeof(u64);
 395                 gpaHeader->Range[0].ByteOffset = 0;
 396                 gpaHeader->Range[0].ByteCount = Size;
 397                 for (i = 0; i < pfnCount; i++)
 398                         gpaHeader->Range[0].PfnArray[i] = pfn+i;
 399                 *MsgInfo = msgHeader;
 400                 *MessageCount = 1;
 401
 402                 pfnSum = pfnCount;
 403                 pfnLeft = pageCount - pfnCount;
 404
 405                 /* how many pfns can we fit */
 406                 pfnSize = MAX_SIZE_CHANNEL_MESSAGE -
 407                           sizeof(struct vmbus_channel_gpadl_body);
 408                 pfnCount = pfnSize / sizeof(u64);
 409
 410                 /* fill in the body */
 411                 while (pfnLeft) {
 412                         if (pfnLeft > pfnCount)
 413                                 pfnCurr = pfnCount;
 414                         else
 415                                 pfnCurr = pfnLeft;
 416
 417                         msgSize = sizeof(struct vmbus_channel_msginfo) +
 418                                   sizeof(struct vmbus_channel_gpadl_body) +
 419                                   pfnCurr * sizeof(u64);
 420                         msgBody = kzalloc(msgSize, GFP_KERNEL);
 421                         /* FIXME: we probably need to more if this fails */
 422                         if (!msgBody)
 423                                 goto nomem;
 424                         msgBody->MessageSize = msgSize;
 425                         (*MessageCount)++;
 426                         gpadlBody =
 427                                 (struct vmbus_channel_gpadl_body *)msgBody->Msg;
 428
 429                         /*
 430                          * FIXME:
 431                          * Gpadl is u32 and we are using a pointer which could
 432                          * be 64-bit
 433                          */
 434                         /* gpadlBody->Gpadl = kbuffer; */
 435                         for (i = 0; i < pfnCurr; i++)
 436                                 gpadlBody->Pfn[i] = pfn + pfnSum + i;
 437
 438                         /* add to msg header */
 439                         list_add_tail(&msgBody->MsgListEntry,
 440                                       &msgHeader->SubMsgList);
 441                         pfnSum += pfnCurr;
 442                         pfnLeft -= pfnCurr;
 443                 }
 444         } else {
 445                 /* everything fits in a header */
 446                 msgSize = sizeof(struct vmbus_channel_msginfo) +
 447                           sizeof(struct vmbus_channel_gpadl_header) +
 448                           sizeof(struct gpa_range) + pageCount * sizeof(u64);
 449                 msgHeader = kzalloc(msgSize, GFP_KERNEL);
 450                 msgHeader->MessageSize = msgSize;
 451
 452                 gpaHeader = (struct vmbus_channel_gpadl_header *)msgHeader->Msg;
 453                 gpaHeader->RangeCount = 1;
 454                 gpaHeader->RangeBufLen = sizeof(struct gpa_range) +
 455                                          pageCount * sizeof(u64);
 456                 gpaHeader->Range[0].ByteOffset = 0;
 457                 gpaHeader->Range[0].ByteCount = Size;
 458                 for (i = 0; i < pageCount; i++)
 459                         gpaHeader->Range[0].PfnArray[i] = pfn+i;
 460
 461                 *MsgInfo = msgHeader;
 462                 *MessageCount = 1;
 463         }
 464
 465         return 0;
 466 nomem:
 467         kfree(msgHeader);
 468         kfree(msgBody);
 469         return -ENOMEM;
 470 }
 471
 472 /*
 473  * VmbusChannelEstablishGpadl - Estabish a GPADL for the specified buffer
 474  *
 475  * @Channel: a channel
 476  * @Kbuffer: from kmalloc
 477  * @Size: page-size multiple
 478  * @GpadlHandle: some funky thing
 479  */
 480 int VmbusChannelEstablishGpadl(struct vmbus_channel *Channel, void *Kbuffer,
 481                                u32 Size, u32 *GpadlHandle)
 482 {
 483         struct vmbus_channel_gpadl_header *gpadlMsg;
 484         struct vmbus_channel_gpadl_body *gpadlBody;
 485         /* struct vmbus_channel_gpadl_created *gpadlCreated; */
 486         struct vmbus_channel_msginfo *msgInfo = NULL;
 487         struct vmbus_channel_msginfo *subMsgInfo;
 488         u32 msgCount;
 489         struct list_head *curr;
 490         u32 nextGpadlHandle;
 491         unsigned long flags;
 492         int ret = 0;
 493
 494         DPRINT_ENTER(VMBUS);
 495
 496         nextGpadlHandle = atomic_read(&gVmbusConnection.NextGpadlHandle);
 497         atomic_inc(&gVmbusConnection.NextGpadlHandle);
 498
 499         ret = VmbusChannelCreateGpadlHeader(Kbuffer, Size, &msgInfo, &msgCount);
 500         if (ret)
 501                 return ret;
 502
 503         msgInfo->WaitEvent = osd_WaitEventCreate();
 504         if (!msgInfo->WaitEvent) {
 505                 ret = -ENOMEM;
 506                 goto Cleanup;
 507         }
 508
 509         gpadlMsg = (struct vmbus_channel_gpadl_header *)msgInfo->Msg;
 510         gpadlMsg->Header.MessageType = ChannelMessageGpadlHeader;
 511         gpadlMsg->ChildRelId = Channel->OfferMsg.ChildRelId;
 512         gpadlMsg->Gpadl = nextGpadlHandle;
 513
 514         DumpGpadlHeader(gpadlMsg);
 515
 516         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 517         list_add_tail(&msgInfo->MsgListEntry,
 518                       &gVmbusConnection.ChannelMsgList);
 519
 520         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 521         DPRINT_DBG(VMBUS, "buffer %p, size %d msg cnt %d",
 522                    Kbuffer, Size, msgCount);
 523
 524         DPRINT_DBG(VMBUS, "Sending GPADL Header - len %zd",
 525                    msgInfo->MessageSize - sizeof(*msgInfo));
 526
 527         ret = VmbusPostMessage(gpadlMsg, msgInfo->MessageSize -
 528                                sizeof(*msgInfo));
 529         if (ret != 0) {
 530                 DPRINT_ERR(VMBUS, "Unable to open channel - %d", ret);
 531                 goto Cleanup;
 532         }
 533
 534         if (msgCount > 1) {
 535                 list_for_each(curr, &msgInfo->SubMsgList) {
 536
 537                         /* FIXME: should this use list_entry() instead ? */
 538                         subMsgInfo = (struct vmbus_channel_msginfo *)curr;
 539                         gpadlBody =
 540                              (struct vmbus_channel_gpadl_body *)subMsgInfo->Msg;
 541
 542                         gpadlBody->Header.MessageType = ChannelMessageGpadlBody;
 543                         gpadlBody->Gpadl = nextGpadlHandle;
 544
 545                         DPRINT_DBG(VMBUS, "Sending GPADL Body - len %zd",
 546                                    subMsgInfo->MessageSize -
 547                                    sizeof(*subMsgInfo));
 548
 549                         DumpGpadlBody(gpadlBody, subMsgInfo->MessageSize -
 550                                       sizeof(*subMsgInfo));
 551                         ret = VmbusPostMessage(gpadlBody,
 552                                                subMsgInfo->MessageSize -
 553                                                sizeof(*subMsgInfo));
 554                         ASSERT(ret == 0);
 555                 }
 556         }
 557         osd_WaitEventWait(msgInfo->WaitEvent);
 558
 559         /* At this point, we received the gpadl created msg */
 560         DPRINT_DBG(VMBUS, "Received GPADL created "
 561                    "(relid %d, status %d handle %x)",
 562                    Channel->OfferMsg.ChildRelId,
 563                    msgInfo->Response.GpadlCreated.CreationStatus,
 564                    gpadlMsg->Gpadl);
 565
 566         *GpadlHandle = gpadlMsg->Gpadl;
 567
 568 Cleanup:
 569         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 570         list_del(&msgInfo->MsgListEntry);
 571         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 572
 573         kfree(msgInfo->WaitEvent);
 574         kfree(msgInfo);
 575
 576         DPRINT_EXIT(VMBUS);
 577
 578         return ret;
 579 }
 580
 581 /*
 582  * VmbusChannelTeardownGpadl -Teardown the specified GPADL handle
 583  */
 584 int VmbusChannelTeardownGpadl(struct vmbus_channel *Channel, u32 GpadlHandle)
 585 {
 586         struct vmbus_channel_gpadl_teardown *msg;
 587         struct vmbus_channel_msginfo *info;
 588         unsigned long flags;
 589         int ret;
 590
 591         DPRINT_ENTER(VMBUS);
 592
 593         ASSERT(GpadlHandle != 0);
 594
 595         info = kmalloc(sizeof(*info) +
 596                        sizeof(struct vmbus_channel_gpadl_teardown), GFP_KERNEL);
 597         if (!info)
 598                 return -ENOMEM;
 599
 600         info->WaitEvent = osd_WaitEventCreate();
 601         if (!info->WaitEvent) {
 602                 kfree(info);
 603                 return -ENOMEM;
 604         }
 605
 606         msg = (struct vmbus_channel_gpadl_teardown *)info->Msg;
 607
 608         msg->Header.MessageType = ChannelMessageGpadlTeardown;
 609         msg->ChildRelId = Channel->OfferMsg.ChildRelId;
 610         msg->Gpadl = GpadlHandle;
 611
 612         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 613         list_add_tail(&info->MsgListEntry,
 614                       &gVmbusConnection.ChannelMsgList);
 615         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 616
 617         ret = VmbusPostMessage(msg,
 618                                sizeof(struct vmbus_channel_gpadl_teardown));
 619         if (ret != 0) {
 620                 /* TODO: */
 621                 /* something... */
 622         }
 623
 624         osd_WaitEventWait(info->WaitEvent);
 625
 626         /* Received a torndown response */
 627         spin_lock_irqsave(&gVmbusConnection.channelmsg_lock, flags);
 628         list_del(&info->MsgListEntry);
 629         spin_unlock_irqrestore(&gVmbusConnection.channelmsg_lock, flags);
 630
 631         kfree(info->WaitEvent);
 632         kfree(info);
 633
 634         DPRINT_EXIT(VMBUS);
 635
 636         return ret;
 637 }
 638
 639 /*
 640  * VmbusChannelClose - Close the specified channel
 641  */
 642 void VmbusChannelClose(struct vmbus_channel *Channel)
 643 {
 644         struct vmbus_channel_close_channel *msg;
 645         struct vmbus_channel_msginfo *info;
 646         unsigned long flags;
 647         int ret;
 648
 649         DPRINT_ENTER(VMBUS);
 650
 651         /* Stop callback and cancel the timer asap */
 652         Channel->OnChannelCallback = NULL;
 653         del_timer_sync(&Channel->poll_timer);
 654
 655         /* Send a closing message */
 656         info = kmalloc(sizeof(*info) +
 657                        sizeof(struct vmbus_channel_close_channel), GFP_KERNEL);
 658         /* FIXME: can't do anything other than return here because the
 659          *        function is void */
 660         if (!info)
 661                 return;
 662
 663         /* info->waitEvent = osd_WaitEventCreate(); */
 664
 665         msg = (struct vmbus_channel_close_channel *)info->Msg;
 666         msg->Header.MessageType = ChannelMessageCloseChannel;
 667         msg->ChildRelId = Channel->OfferMsg.ChildRelId;
 668
 669         ret = VmbusPostMessage(msg, sizeof(struct vmbus_channel_close_channel));
 670         if (ret != 0) {
 671                 /* TODO: */
 672                 /* something... */
 673         }
 674
 675         /* Tear down the gpadl for the channel's ring buffer */
 676         if (Channel->RingBufferGpadlHandle)
 677                 VmbusChannelTeardownGpadl(Channel,
 678                                           Channel->RingBufferGpadlHandle);
 679
 680         /* TODO: Send a msg to release the childRelId */
 681
 682         /* Cleanup the ring buffers for this channel */
 683         RingBufferCleanup(&Channel->Outbound);
 684         RingBufferCleanup(&Channel->Inbound);
 685
 686         osd_PageFree(Channel->RingBufferPages, Channel->RingBufferPageCount);
 687
 688         kfree(info);
 689
 690         /*
 691          * If we are closing the channel during an error path in
 692          * opening the channel, don't free the channel since the
 693          * caller will free the channel
 694          */
 695
 696         if (Channel->State == CHANNEL_OPEN_STATE) {
 697                 spin_lock_irqsave(&gVmbusConnection.channel_lock, flags);
 698                 list_del(&Channel->ListEntry);
 699                 spin_unlock_irqrestore(&gVmbusConnection.channel_lock, flags);
 700
 701                 FreeVmbusChannel(Channel);
 702         }
 703
 704         DPRINT_EXIT(VMBUS);
 705 }
 706
 707 /**
 708  * VmbusChannelSendPacket() - Send the specified buffer on the given channel
 709  * @Channel: Pointer to vmbus_channel structure.
 710  * @Buffer: Pointer to the buffer you want to receive the data into.
 711  * @BufferLen: Maximum size of what the the buffer will hold
 712  * @RequestId: Identifier of the request
 713  * @vmbus_packet_type: Type of packet that is being send e.g. negotiate, time
 714  * packet etc.
 715  *
 716  * Sends data in @Buffer directly to hyper-v via the vmbus
 717  * This will send the data unparsed to hyper-v.
 718  *
 719  * Mainly used by Hyper-V drivers.
 720  */
 721 int VmbusChannelSendPacket(struct vmbus_channel *Channel, const void *Buffer,
 722                            u32 BufferLen, u64 RequestId,
 723                            enum vmbus_packet_type Type, u32 Flags)
 724 {
 725         struct vmpacket_descriptor desc;
 726         u32 packetLen = sizeof(struct vmpacket_descriptor) + BufferLen;
 727         u32 packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
 728         struct scatterlist bufferList[3];
 729         u64 alignedData = 0;
 730         int ret;
 731
 732         DPRINT_ENTER(VMBUS);
 733         DPRINT_DBG(VMBUS, "channel %p buffer %p len %d",
 734                    Channel, Buffer, BufferLen);
 735
 736         DumpVmbusChannel(Channel);
 737
 738         ASSERT((packetLenAligned - packetLen) < sizeof(u64));
 739
 740         /* Setup the descriptor */
 741         desc.Type = Type; /* VmbusPacketTypeDataInBand; */
 742         desc.Flags = Flags; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
 743         /* in 8-bytes granularity */
 744         desc.DataOffset8 = sizeof(struct vmpacket_descriptor) >> 3;
 745         desc.Length8 = (u16)(packetLenAligned >> 3);
 746         desc.TransactionId = RequestId;
 747
 748         sg_init_table(bufferList, 3);
 749         sg_set_buf(&bufferList[0], &desc, sizeof(struct vmpacket_descriptor));
 750         sg_set_buf(&bufferList[1], Buffer, BufferLen);
 751         sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
 752
 753         ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
 754
 755         /* TODO: We should determine if this is optional */
 756         if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
 757                 VmbusChannelSetEvent(Channel);
 758
 759         DPRINT_EXIT(VMBUS);
 760
 761         return ret;
 762 }
 763 EXPORT_SYMBOL(VmbusChannelSendPacket);
 764
 765 /*
 766  * VmbusChannelSendPacketPageBuffer - Send a range of single-page buffer
 767  * packets using a GPADL Direct packet type.
 768  */
 769 int VmbusChannelSendPacketPageBuffer(struct vmbus_channel *Channel,
 770                                      struct hv_page_buffer PageBuffers[],
 771                                      u32 PageCount, void *Buffer, u32 BufferLen,
 772                                      u64 RequestId)
 773 {
 774         int ret;
 775         int i;
 776         struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER desc;
 777         u32 descSize;
 778         u32 packetLen;
 779         u32 packetLenAligned;
 780         struct scatterlist bufferList[3];
 781         u64 alignedData = 0;
 782
 783         DPRINT_ENTER(VMBUS);
 784
 785         ASSERT(PageCount <= MAX_PAGE_BUFFER_COUNT);
 786
 787         DumpVmbusChannel(Channel);
 788
 789         /*
 790          * Adjust the size down since VMBUS_CHANNEL_PACKET_PAGE_BUFFER is the
 791          * largest size we support
 792          */
 793         descSize = sizeof(struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER) -
 794                           ((MAX_PAGE_BUFFER_COUNT - PageCount) *
 795                           sizeof(struct hv_page_buffer));
 796         packetLen = descSize + BufferLen;
 797         packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
 798
 799         ASSERT((packetLenAligned - packetLen) < sizeof(u64));
 800
 801         /* Setup the descriptor */
 802         desc.Type = VmbusPacketTypeDataUsingGpaDirect;
 803         desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
 804         desc.DataOffset8 = descSize >> 3; /* in 8-bytes grandularity */
 805         desc.Length8 = (u16)(packetLenAligned >> 3);
 806         desc.TransactionId = RequestId;
 807         desc.RangeCount = PageCount;
 808
 809         for (i = 0; i < PageCount; i++) {
 810                 desc.Range[i].Length = PageBuffers[i].Length;
 811                 desc.Range[i].Offset = PageBuffers[i].Offset;
 812                 desc.Range[i].Pfn        = PageBuffers[i].Pfn;
 813         }
 814
 815         sg_init_table(bufferList, 3);
 816         sg_set_buf(&bufferList[0], &desc, descSize);
 817         sg_set_buf(&bufferList[1], Buffer, BufferLen);
 818         sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
 819
 820         ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
 821
 822         /* TODO: We should determine if this is optional */
 823         if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
 824                 VmbusChannelSetEvent(Channel);
 825
 826         DPRINT_EXIT(VMBUS);
 827
 828         return ret;
 829 }
 830
 831 /*
 832  * VmbusChannelSendPacketMultiPageBuffer - Send a multi-page buffer packet
 833  * using a GPADL Direct packet type.
 834  */
 835 int VmbusChannelSendPacketMultiPageBuffer(struct vmbus_channel *Channel,
 836                                 struct hv_multipage_buffer *MultiPageBuffer,
 837                                 void *Buffer, u32 BufferLen, u64 RequestId)
 838 {
 839         int ret;
 840         struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER desc;
 841         u32 descSize;
 842         u32 packetLen;
 843         u32 packetLenAligned;
 844         struct scatterlist bufferList[3];
 845         u64 alignedData = 0;
 846         u32 PfnCount = NUM_PAGES_SPANNED(MultiPageBuffer->Offset,
 847                                          MultiPageBuffer->Length);
 848
 849         DPRINT_ENTER(VMBUS);
 850
 851         DumpVmbusChannel(Channel);
 852
 853         DPRINT_DBG(VMBUS, "data buffer - offset %u len %u pfn count %u",
 854                    MultiPageBuffer->Offset, MultiPageBuffer->Length, PfnCount);
 855
 856         ASSERT(PfnCount > 0);
 857         ASSERT(PfnCount <= MAX_MULTIPAGE_BUFFER_COUNT);
 858
 859         /*
 860          * Adjust the size down since VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER is
 861          * the largest size we support
 862          */
 863         descSize = sizeof(struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER) -
 864                           ((MAX_MULTIPAGE_BUFFER_COUNT - PfnCount) *
 865                           sizeof(u64));
 866         packetLen = descSize + BufferLen;
 867         packetLenAligned = ALIGN_UP(packetLen, sizeof(u64));
 868
 869         ASSERT((packetLenAligned - packetLen) < sizeof(u64));
 870
 871         /* Setup the descriptor */
 872         desc.Type = VmbusPacketTypeDataUsingGpaDirect;
 873         desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
 874         desc.DataOffset8 = descSize >> 3; /* in 8-bytes grandularity */
 875         desc.Length8 = (u16)(packetLenAligned >> 3);
 876         desc.TransactionId = RequestId;
 877         desc.RangeCount = 1;
 878
 879         desc.Range.Length = MultiPageBuffer->Length;
 880         desc.Range.Offset = MultiPageBuffer->Offset;
 881
 882         memcpy(desc.Range.PfnArray, MultiPageBuffer->PfnArray,
 883                PfnCount * sizeof(u64));
 884
 885         sg_init_table(bufferList, 3);
 886         sg_set_buf(&bufferList[0], &desc, descSize);
 887         sg_set_buf(&bufferList[1], Buffer, BufferLen);
 888         sg_set_buf(&bufferList[2], &alignedData, packetLenAligned - packetLen);
 889
 890         ret = RingBufferWrite(&Channel->Outbound, bufferList, 3);
 891
 892         /* TODO: We should determine if this is optional */
 893         if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
 894                 VmbusChannelSetEvent(Channel);
 895
 896         DPRINT_EXIT(VMBUS);
 897
 898         return ret;
 899 }
 900
 901
 902 /**
 903  * VmbusChannelRecvPacket() - Retrieve the user packet on the specified channel
 904  * @Channel: Pointer to vmbus_channel structure.
 905  * @Buffer: Pointer to the buffer you want to receive the data into.
 906  * @BufferLen: Maximum size of what the the buffer will hold
 907  * @BufferActualLen: The actual size of the data after it was received
 908  * @RequestId: Identifier of the request
 909  *
 910  * Receives directly from the hyper-v vmbus and puts the data it received
 911  * into Buffer. This will receive the data unparsed from hyper-v.
 912  *
 913  * Mainly used by Hyper-V drivers.
 914  */
 915 int VmbusChannelRecvPacket(struct vmbus_channel *Channel, void *Buffer,
 916                            u32 BufferLen, u32 *BufferActualLen, u64 *RequestId)
 917 {
 918         struct vmpacket_descriptor desc;
 919         u32 packetLen;
 920         u32 userLen;
 921         int ret;
 922         unsigned long flags;
 923
 924         DPRINT_ENTER(VMBUS);
 925
 926         *BufferActualLen = 0;
 927         *RequestId = 0;
 928
 929         spin_lock_irqsave(&Channel->inbound_lock, flags);
 930
 931         ret = RingBufferPeek(&Channel->Inbound, &desc,
 932                              sizeof(struct vmpacket_descriptor));
 933         if (ret != 0) {
 934                 spin_unlock_irqrestore(&Channel->inbound_lock, flags);
 935
 936                 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
 937                 DPRINT_EXIT(VMBUS);
 938                 return 0;
 939         }
 940
 941         /* VmbusChannelClearEvent(Channel); */
 942
 943         packetLen = desc.Length8 << 3;
 944         userLen = packetLen - (desc.DataOffset8 << 3);
 945         /* ASSERT(userLen > 0); */
 946
 947         DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d "
 948                    "flag %d tid %llx pktlen %d datalen %d> ",
 949                    Channel, Channel->OfferMsg.ChildRelId, desc.Type,
 950                    desc.Flags, desc.TransactionId, packetLen, userLen);
 951
 952         *BufferActualLen = userLen;
 953
 954         if (userLen > BufferLen) {
 955                 spin_unlock_irqrestore(&Channel->inbound_lock, flags);
 956
 957                 DPRINT_ERR(VMBUS, "buffer too small - got %d needs %d",
 958                            BufferLen, userLen);
 959                 DPRINT_EXIT(VMBUS);
 960
 961                 return -1;
 962         }
 963
 964         *RequestId = desc.TransactionId;
 965
 966         /* Copy over the packet to the user buffer */
 967         ret = RingBufferRead(&Channel->Inbound, Buffer, userLen,
 968                              (desc.DataOffset8 << 3));
 969
 970         spin_unlock_irqrestore(&Channel->inbound_lock, flags);
 971
 972         DPRINT_EXIT(VMBUS);
 973
 974         return 0;
 975 }
 976 EXPORT_SYMBOL(VmbusChannelRecvPacket);
 977
 978 /*
 979  * VmbusChannelRecvPacketRaw - Retrieve the raw packet on the specified channel
 980  */
 981 int VmbusChannelRecvPacketRaw(struct vmbus_channel *Channel, void *Buffer,
 982                               u32 BufferLen, u32 *BufferActualLen,
 983                               u64 *RequestId)
 984 {
 985         struct vmpacket_descriptor desc;
 986         u32 packetLen;
 987         u32 userLen;
 988         int ret;
 989         unsigned long flags;
 990
 991         DPRINT_ENTER(VMBUS);
 992
 993         *BufferActualLen = 0;
 994         *RequestId = 0;
 995
 996         spin_lock_irqsave(&Channel->inbound_lock, flags);
 997
 998         ret = RingBufferPeek(&Channel->Inbound, &desc,
 999                              sizeof(struct vmpacket_descriptor));
1000         if (ret != 0) {
1001                 spin_unlock_irqrestore(&Channel->inbound_lock, flags);
1002
1003                 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
1004                 DPRINT_EXIT(VMBUS);
1005                 return 0;
1006         }
1007
1008         /* VmbusChannelClearEvent(Channel); */
1009
1010         packetLen = desc.Length8 << 3;
1011         userLen = packetLen - (desc.DataOffset8 << 3);
1012
1013         DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d "
1014                    "flag %d tid %llx pktlen %d datalen %d> ",
1015                    Channel, Channel->OfferMsg.ChildRelId, desc.Type,
1016                    desc.Flags, desc.TransactionId, packetLen, userLen);
1017
1018         *BufferActualLen = packetLen;
1019
1020         if (packetLen > BufferLen) {
1021                 spin_unlock_irqrestore(&Channel->inbound_lock, flags);
1022
1023                 DPRINT_ERR(VMBUS, "buffer too small - needed %d bytes but "
1024                            "got space for only %d bytes", packetLen, BufferLen);
1025                 DPRINT_EXIT(VMBUS);
1026                 return -2;
1027         }
1028
1029         *RequestId = desc.TransactionId;
1030
1031         /* Copy over the entire packet to the user buffer */
1032         ret = RingBufferRead(&Channel->Inbound, Buffer, packetLen, 0);
1033
1034         spin_unlock_irqrestore(&Channel->inbound_lock, flags);
1035
1036         DPRINT_EXIT(VMBUS);
1037
1038         return 0;
1039 }
1040
1041 /*
1042  * VmbusChannelOnChannelEvent - Channel event callback
1043  */
1044 void VmbusChannelOnChannelEvent(struct vmbus_channel *Channel)
1045 {
1046         DumpVmbusChannel(Channel);
1047         ASSERT(Channel->OnChannelCallback);
1048
1049         Channel->OnChannelCallback(Channel->ChannelCallbackContext);
1050
1051         mod_timer(&Channel->poll_timer, jiffies + usecs_to_jiffies(100));
1052 }
1053
1054 /*
1055  * VmbusChannelOnTimer - Timer event callback
1056  */
1057 void VmbusChannelOnTimer(unsigned long data)
1058 {
1059         struct vmbus_channel *channel = (struct vmbus_channel *)data;
1060
1061         if (channel->OnChannelCallback)
1062                 channel->OnChannelCallback(channel->ChannelCallbackContext);
1063 }
1064
1065 /*
1066  * DumpVmbusChannel - Dump vmbus channel info to the console
1067  */
1068 static void DumpVmbusChannel(struct vmbus_channel *Channel)
1069 {
1070         DPRINT_DBG(VMBUS, "Channel (%d)", Channel->OfferMsg.ChildRelId);
1071         DumpRingInfo(&Channel->Outbound, "Outbound ");
1072         DumpRingInfo(&Channel->Inbound, "Inbound ");
1073 }