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