drivers/hv/hv_balloon.c

   1 /*
   2  * Copyright (c) 2012, Microsoft Corporation.
   3  *
   4  * Author:
   5  *   K. Y. Srinivasan <kys@microsoft.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published
   9  * by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  14  * NON INFRINGEMENT.  See the GNU General Public License for more
  15  * details.
  16  *
  17  */
  18
  19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20
  21 #include <linux/kernel.h>
  22 #include <linux/mman.h>
  23 #include <linux/delay.h>
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27 #include <linux/kthread.h>
  28 #include <linux/completion.h>
  29 #include <linux/memory_hotplug.h>
  30 #include <linux/memory.h>
  31 #include <linux/notifier.h>
  32 #include <linux/percpu_counter.h>
  33
  34 #include <linux/hyperv.h>
  35
  36 /*
  37  * We begin with definitions supporting the Dynamic Memory protocol
  38  * with the host.
  39  *
  40  * Begin protocol definitions.
  41  */
  42
  43
  44
  45 /*
  46  * Protocol versions. The low word is the minor version, the high word the major
  47  * version.
  48  *
  49  * History:
  50  * Initial version 1.0
  51  * Changed to 0.1 on 2009/03/25
  52  * Changes to 0.2 on 2009/05/14
  53  * Changes to 0.3 on 2009/12/03
  54  * Changed to 1.0 on 2011/04/05
  55  */
  56
  57 #define DYNMEM_MAKE_VERSION(Major, Minor) ((__u32)(((Major) << 16) | (Minor)))
  58 #define DYNMEM_MAJOR_VERSION(Version) ((__u32)(Version) >> 16)
  59 #define DYNMEM_MINOR_VERSION(Version) ((__u32)(Version) & 0xff)
  60
  61 enum {
  62         DYNMEM_PROTOCOL_VERSION_1 = DYNMEM_MAKE_VERSION(0, 3),
  63         DYNMEM_PROTOCOL_VERSION_2 = DYNMEM_MAKE_VERSION(1, 0),
  64
  65         DYNMEM_PROTOCOL_VERSION_WIN7 = DYNMEM_PROTOCOL_VERSION_1,
  66         DYNMEM_PROTOCOL_VERSION_WIN8 = DYNMEM_PROTOCOL_VERSION_2,
  67
  68         DYNMEM_PROTOCOL_VERSION_CURRENT = DYNMEM_PROTOCOL_VERSION_WIN8
  69 };
  70
  71
  72
  73 /*
  74  * Message Types
  75  */
  76
  77 enum dm_message_type {
  78         /*
  79          * Version 0.3
  80          */
  81         DM_ERROR                        = 0,
  82         DM_VERSION_REQUEST              = 1,
  83         DM_VERSION_RESPONSE             = 2,
  84         DM_CAPABILITIES_REPORT          = 3,
  85         DM_CAPABILITIES_RESPONSE        = 4,
  86         DM_STATUS_REPORT                = 5,
  87         DM_BALLOON_REQUEST              = 6,
  88         DM_BALLOON_RESPONSE             = 7,
  89         DM_UNBALLOON_REQUEST            = 8,
  90         DM_UNBALLOON_RESPONSE           = 9,
  91         DM_MEM_HOT_ADD_REQUEST          = 10,
  92         DM_MEM_HOT_ADD_RESPONSE         = 11,
  93         DM_VERSION_03_MAX               = 11,
  94         /*
  95          * Version 1.0.
  96          */
  97         DM_INFO_MESSAGE                 = 12,
  98         DM_VERSION_1_MAX                = 12
  99 };
 100
 101
 102 /*
 103  * Structures defining the dynamic memory management
 104  * protocol.
 105  */
 106
 107 union dm_version {
 108         struct {
 109                 __u16 minor_version;
 110                 __u16 major_version;
 111         };
 112         __u32 version;
 113 } __packed;
 114
 115
 116 union dm_caps {
 117         struct {
 118                 __u64 balloon:1;
 119                 __u64 hot_add:1;
 120                 __u64 reservedz:62;
 121         } cap_bits;
 122         __u64 caps;
 123 } __packed;
 124
 125 union dm_mem_page_range {
 126         struct  {
 127                 /*
 128                  * The PFN number of the first page in the range.
 129                  * 40 bits is the architectural limit of a PFN
 130                  * number for AMD64.
 131                  */
 132                 __u64 start_page:40;
 133                 /*
 134                  * The number of pages in the range.
 135                  */
 136                 __u64 page_cnt:24;
 137         } finfo;
 138         __u64  page_range;
 139 } __packed;
 140
 141
 142
 143 /*
 144  * The header for all dynamic memory messages:
 145  *
 146  * type: Type of the message.
 147  * size: Size of the message in bytes; including the header.
 148  * trans_id: The guest is responsible for manufacturing this ID.
 149  */
 150
 151 struct dm_header {
 152         __u16 type;
 153         __u16 size;
 154         __u32 trans_id;
 155 } __packed;
 156
 157 /*
 158  * A generic message format for dynamic memory.
 159  * Specific message formats are defined later in the file.
 160  */
 161
 162 struct dm_message {
 163         struct dm_header hdr;
 164         __u8 data[]; /* enclosed message */
 165 } __packed;
 166
 167
 168 /*
 169  * Specific message types supporting the dynamic memory protocol.
 170  */
 171
 172 /*
 173  * Version negotiation message. Sent from the guest to the host.
 174  * The guest is free to try different versions until the host
 175  * accepts the version.
 176  *
 177  * dm_version: The protocol version requested.
 178  * is_last_attempt: If TRUE, this is the last version guest will request.
 179  * reservedz: Reserved field, set to zero.
 180  */
 181
 182 struct dm_version_request {
 183         struct dm_header hdr;
 184         union dm_version version;
 185         __u32 is_last_attempt:1;
 186         __u32 reservedz:31;
 187 } __packed;
 188
 189 /*
 190  * Version response message; Host to Guest and indicates
 191  * if the host has accepted the version sent by the guest.
 192  *
 193  * is_accepted: If TRUE, host has accepted the version and the guest
 194  * should proceed to the next stage of the protocol. FALSE indicates that
 195  * guest should re-try with a different version.
 196  *
 197  * reservedz: Reserved field, set to zero.
 198  */
 199
 200 struct dm_version_response {
 201         struct dm_header hdr;
 202         __u64 is_accepted:1;
 203         __u64 reservedz:63;
 204 } __packed;
 205
 206 /*
 207  * Message reporting capabilities. This is sent from the guest to the
 208  * host.
 209  */
 210
 211 struct dm_capabilities {
 212         struct dm_header hdr;
 213         union dm_caps caps;
 214         __u64 min_page_cnt;
 215         __u64 max_page_number;
 216 } __packed;
 217
 218 /*
 219  * Response to the capabilities message. This is sent from the host to the
 220  * guest. This message notifies if the host has accepted the guest's
 221  * capabilities. If the host has not accepted, the guest must shutdown
 222  * the service.
 223  *
 224  * is_accepted: Indicates if the host has accepted guest's capabilities.
 225  * reservedz: Must be 0.
 226  */
 227
 228 struct dm_capabilities_resp_msg {
 229         struct dm_header hdr;
 230         __u64 is_accepted:1;
 231         __u64 reservedz:63;
 232 } __packed;
 233
 234 /*
 235  * This message is used to report memory pressure from the guest.
 236  * This message is not part of any transaction and there is no
 237  * response to this message.
 238  *
 239  * num_avail: Available memory in pages.
 240  * num_committed: Committed memory in pages.
 241  * page_file_size: The accumulated size of all page files
 242  *                 in the system in pages.
 243  * zero_free: The nunber of zero and free pages.
 244  * page_file_writes: The writes to the page file in pages.
 245  * io_diff: An indicator of file cache efficiency or page file activity,
 246  *          calculated as File Cache Page Fault Count - Page Read Count.
 247  *          This value is in pages.
 248  *
 249  * Some of these metrics are Windows specific and fortunately
 250  * the algorithm on the host side that computes the guest memory
 251  * pressure only uses num_committed value.
 252  */
 253
 254 struct dm_status {
 255         struct dm_header hdr;
 256         __u64 num_avail;
 257         __u64 num_committed;
 258         __u64 page_file_size;
 259         __u64 zero_free;
 260         __u32 page_file_writes;
 261         __u32 io_diff;
 262 } __packed;
 263
 264
 265 /*
 266  * Message to ask the guest to allocate memory - balloon up message.
 267  * This message is sent from the host to the guest. The guest may not be
 268  * able to allocate as much memory as requested.
 269  *
 270  * num_pages: number of pages to allocate.
 271  */
 272
 273 struct dm_balloon {
 274         struct dm_header hdr;
 275         __u32 num_pages;
 276         __u32 reservedz;
 277 } __packed;
 278
 279
 280 /*
 281  * Balloon response message; this message is sent from the guest
 282  * to the host in response to the balloon message.
 283  *
 284  * reservedz: Reserved; must be set to zero.
 285  * more_pages: If FALSE, this is the last message of the transaction.
 286  * if TRUE there will atleast one more message from the guest.
 287  *
 288  * range_count: The number of ranges in the range array.
 289  *
 290  * range_array: An array of page ranges returned to the host.
 291  *
 292  */
 293
 294 struct dm_balloon_response {
 295         struct dm_header hdr;
 296         __u32 reservedz;
 297         __u32 more_pages:1;
 298         __u32 range_count:31;
 299         union dm_mem_page_range range_array[];
 300 } __packed;
 301
 302 /*
 303  * Un-balloon message; this message is sent from the host
 304  * to the guest to give guest more memory.
 305  *
 306  * more_pages: If FALSE, this is the last message of the transaction.
 307  * if TRUE there will atleast one more message from the guest.
 308  *
 309  * reservedz: Reserved; must be set to zero.
 310  *
 311  * range_count: The number of ranges in the range array.
 312  *
 313  * range_array: An array of page ranges returned to the host.
 314  *
 315  */
 316
 317 struct dm_unballoon_request {
 318         struct dm_header hdr;
 319         __u32 more_pages:1;
 320         __u32 reservedz:31;
 321         __u32 range_count;
 322         union dm_mem_page_range range_array[];
 323 } __packed;
 324
 325 /*
 326  * Un-balloon response message; this message is sent from the guest
 327  * to the host in response to an unballoon request.
 328  *
 329  */
 330
 331 struct dm_unballoon_response {
 332         struct dm_header hdr;
 333 } __packed;
 334
 335
 336 /*
 337  * Hot add request message. Message sent from the host to the guest.
 338  *
 339  * mem_range: Memory range to hot add.
 340  *
 341  * On Linux we currently don't support this since we cannot hot add
 342  * arbitrary granularity of memory.
 343  */
 344
 345 struct dm_hot_add {
 346         struct dm_header hdr;
 347         union dm_mem_page_range range;
 348 } __packed;
 349
 350 /*
 351  * Hot add response message.
 352  * This message is sent by the guest to report the status of a hot add request.
 353  * If page_count is less than the requested page count, then the host should
 354  * assume all further hot add requests will fail, since this indicates that
 355  * the guest has hit an upper physical memory barrier.
 356  *
 357  * Hot adds may also fail due to low resources; in this case, the guest must
 358  * not complete this message until the hot add can succeed, and the host must
 359  * not send a new hot add request until the response is sent.
 360  * If VSC fails to hot add memory DYNMEM_NUMBER_OF_UNSUCCESSFUL_HOTADD_ATTEMPTS
 361  * times it fails the request.
 362  *
 363  *
 364  * page_count: number of pages that were successfully hot added.
 365  *
 366  * result: result of the operation 1: success, 0: failure.
 367  *
 368  */
 369
 370 struct dm_hot_add_response {
 371         struct dm_header hdr;
 372         __u32 page_count;
 373         __u32 result;
 374 } __packed;
 375
 376 /*
 377  * Types of information sent from host to the guest.
 378  */
 379
 380 enum dm_info_type {
 381         INFO_TYPE_MAX_PAGE_CNT = 0,
 382         MAX_INFO_TYPE
 383 };
 384
 385
 386 /*
 387  * Header for the information message.
 388  */
 389
 390 struct dm_info_header {
 391         enum dm_info_type type;
 392         __u32 data_size;
 393 } __packed;
 394
 395 /*
 396  * This message is sent from the host to the guest to pass
 397  * some relevant information (win8 addition).
 398  *
 399  * reserved: no used.
 400  * info_size: size of the information blob.
 401  * info: information blob.
 402  */
 403
 404 struct dm_info_msg {
 405         struct dm_header hdr;
 406         __u32 reserved;
 407         __u32 info_size;
 408         __u8  info[];
 409 };
 410
 411 /*
 412  * End protocol definitions.
 413  */
 414
 415 struct balloon_state {
 416         __u32 num_pages;
 417         struct work_struct wrk;
 418 };
 419
 420 static bool hot_add;
 421 static bool do_hot_add;
 422 /*
 423  * Delay reporting memory pressure by
 424  * the specified number of seconds.
 425  */
 426 static uint pressure_report_delay = 30;
 427
 428 module_param(hot_add, bool, (S_IRUGO | S_IWUSR));
 429 MODULE_PARM_DESC(hot_add, "If set attempt memory hot_add");
 430
 431 module_param(pressure_report_delay, uint, (S_IRUGO | S_IWUSR));
 432 MODULE_PARM_DESC(pressure_report_delay, "Delay in secs in reporting pressure");
 433 static atomic_t trans_id = ATOMIC_INIT(0);
 434
 435 static int dm_ring_size = (5 * PAGE_SIZE);
 436
 437 /*
 438  * Driver specific state.
 439  */
 440
 441 enum hv_dm_state {
 442         DM_INITIALIZING = 0,
 443         DM_INITIALIZED,
 444         DM_BALLOON_UP,
 445         DM_BALLOON_DOWN,
 446         DM_HOT_ADD,
 447         DM_INIT_ERROR
 448 };
 449
 450
 451 static __u8 recv_buffer[PAGE_SIZE];
 452 static __u8 *send_buffer;
 453 #define PAGES_IN_2M     512
 454
 455 struct hv_dynmem_device {
 456         struct hv_device *dev;
 457         enum hv_dm_state state;
 458         struct completion host_event;
 459         struct completion config_event;
 460
 461         /*
 462          * Number of pages we have currently ballooned out.
 463          */
 464         unsigned int num_pages_ballooned;
 465
 466         /*
 467          * State to manage the ballooning (up) operation.
 468          */
 469         struct balloon_state balloon_wrk;
 470
 471         /*
 472          * This thread handles hot-add
 473          * requests from the host as well as notifying
 474          * the host with regards to memory pressure in
 475          * the guest.
 476          */
 477         struct task_struct *thread;
 478
 479         /*
 480          * We start with the highest version we can support
 481          * and downgrade based on the host; we save here the
 482          * next version to try.
 483          */
 484         __u32 next_version;
 485 };
 486
 487 static struct hv_dynmem_device dm_device;
 488
 489 static void hot_add_req(struct hv_dynmem_device *dm, struct dm_hot_add *msg)
 490 {
 491
 492         struct dm_hot_add_response resp;
 493
 494         if (do_hot_add) {
 495
 496                 pr_info("Memory hot add not supported\n");
 497
 498                 /*
 499                  * Currently we do not support hot add.
 500                  * Just fail the request.
 501                  */
 502         }
 503
 504         memset(&resp, 0, sizeof(struct dm_hot_add_response));
 505         resp.hdr.type = DM_MEM_HOT_ADD_RESPONSE;
 506         resp.hdr.size = sizeof(struct dm_hot_add_response);
 507         resp.hdr.trans_id = atomic_inc_return(&trans_id);
 508
 509         resp.page_count = 0;
 510         resp.result = 0;
 511
 512         dm->state = DM_INITIALIZED;
 513         vmbus_sendpacket(dm->dev->channel, &resp,
 514                         sizeof(struct dm_hot_add_response),
 515                         (unsigned long)NULL,
 516                         VM_PKT_DATA_INBAND, 0);
 517
 518 }
 519
 520 static void process_info(struct hv_dynmem_device *dm, struct dm_info_msg *msg)
 521 {
 522         struct dm_info_header *info_hdr;
 523
 524         info_hdr = (struct dm_info_header *)msg->info;
 525
 526         switch (info_hdr->type) {
 527         case INFO_TYPE_MAX_PAGE_CNT:
 528                 pr_info("Received INFO_TYPE_MAX_PAGE_CNT\n");
 529                 pr_info("Data Size is %d\n", info_hdr->data_size);
 530                 break;
 531         default:
 532                 pr_info("Received Unknown type: %d\n", info_hdr->type);
 533         }
 534 }
 535
 536 unsigned long compute_balloon_floor(void)
 537 {
 538         unsigned long min_pages;
 539 #define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT))
 540         /* Simple continuous piecewiese linear function:
 541          *  max MiB -> min MiB  gradient
 542          *       0         0
 543          *      16        16
 544          *      32        24
 545          *     128        72    (1/2)
 546          *     512       168    (1/4)
 547          *    2048       360    (1/8)
 548          *    8192       552    (1/32)
 549          *   32768      1320
 550          *  131072      4392
 551          */
 552         if (totalram_pages < MB2PAGES(128))
 553                 min_pages = MB2PAGES(8) + (totalram_pages >> 1);
 554         else if (totalram_pages < MB2PAGES(512))
 555                 min_pages = MB2PAGES(40) + (totalram_pages >> 2);
 556         else if (totalram_pages < MB2PAGES(2048))
 557                 min_pages = MB2PAGES(104) + (totalram_pages >> 3);
 558         else
 559                 min_pages = MB2PAGES(296) + (totalram_pages >> 5);
 560 #undef MB2PAGES
 561         return min_pages;
 562 }
 563
 564 /*
 565  * Post our status as it relates memory pressure to the
 566  * host. Host expects the guests to post this status
 567  * periodically at 1 second intervals.
 568  *
 569  * The metrics specified in this protocol are very Windows
 570  * specific and so we cook up numbers here to convey our memory
 571  * pressure.
 572  */
 573
 574 static void post_status(struct hv_dynmem_device *dm)
 575 {
 576         struct dm_status status;
 577         struct sysinfo val;
 578
 579         if (pressure_report_delay > 0) {
 580                 --pressure_report_delay;
 581                 return;
 582         }
 583         si_meminfo(&val);
 584         memset(&status, 0, sizeof(struct dm_status));
 585         status.hdr.type = DM_STATUS_REPORT;
 586         status.hdr.size = sizeof(struct dm_status);
 587         status.hdr.trans_id = atomic_inc_return(&trans_id);
 588
 589         /*
 590          * The host expects the guest to report free memory.
 591          * Further, the host expects the pressure information to
 592          * include the ballooned out pages.
 593          * For a given amount of memory that we are managing, we
 594          * need to compute a floor below which we should not balloon.
 595          * Compute this and add it to the pressure report.
 596          */
 597         status.num_avail = val.freeram;
 598         status.num_committed = vm_memory_committed() +
 599                                 dm->num_pages_ballooned +
 600                                 compute_balloon_floor();
 601
 602         vmbus_sendpacket(dm->dev->channel, &status,
 603                                 sizeof(struct dm_status),
 604                                 (unsigned long)NULL,
 605                                 VM_PKT_DATA_INBAND, 0);
 606
 607 }
 608
 609 static void free_balloon_pages(struct hv_dynmem_device *dm,
 610                          union dm_mem_page_range *range_array)
 611 {
 612         int num_pages = range_array->finfo.page_cnt;
 613         __u64 start_frame = range_array->finfo.start_page;
 614         struct page *pg;
 615         int i;
 616
 617         for (i = 0; i < num_pages; i++) {
 618                 pg = pfn_to_page(i + start_frame);
 619                 __free_page(pg);
 620                 dm->num_pages_ballooned--;
 621         }
 622 }
 623
 624
 625
 626 static int  alloc_balloon_pages(struct hv_dynmem_device *dm, int num_pages,
 627                          struct dm_balloon_response *bl_resp, int alloc_unit,
 628                          bool *alloc_error)
 629 {
 630         int i = 0;
 631         struct page *pg;
 632
 633         if (num_pages < alloc_unit)
 634                 return 0;
 635
 636         for (i = 0; (i * alloc_unit) < num_pages; i++) {
 637                 if (bl_resp->hdr.size + sizeof(union dm_mem_page_range) >
 638                         PAGE_SIZE)
 639                         return i * alloc_unit;
 640
 641                 /*
 642                  * We execute this code in a thread context. Furthermore,
 643                  * we don't want the kernel to try too hard.
 644                  */
 645                 pg = alloc_pages(GFP_HIGHUSER | __GFP_NORETRY |
 646                                 __GFP_NOMEMALLOC | __GFP_NOWARN,
 647                                 get_order(alloc_unit << PAGE_SHIFT));
 648
 649                 if (!pg) {
 650                         *alloc_error = true;
 651                         return i * alloc_unit;
 652                 }
 653
 654
 655                 dm->num_pages_ballooned += alloc_unit;
 656
 657                 bl_resp->range_count++;
 658                 bl_resp->range_array[i].finfo.start_page =
 659                         page_to_pfn(pg);
 660                 bl_resp->range_array[i].finfo.page_cnt = alloc_unit;
 661                 bl_resp->hdr.size += sizeof(union dm_mem_page_range);
 662
 663         }
 664
 665         return num_pages;
 666 }
 667
 668
 669
 670 static void balloon_up(struct work_struct *dummy)
 671 {
 672         int num_pages = dm_device.balloon_wrk.num_pages;
 673         int num_ballooned = 0;
 674         struct dm_balloon_response *bl_resp;
 675         int alloc_unit;
 676         int ret;
 677         bool alloc_error = false;
 678         bool done = false;
 679         int i;
 680
 681
 682         /*
 683          * Currently, we only support 4k allocations.
 684          */
 685         alloc_unit = 1;
 686
 687         while (!done) {
 688                 bl_resp = (struct dm_balloon_response *)send_buffer;
 689                 memset(send_buffer, 0, PAGE_SIZE);
 690                 bl_resp->hdr.type = DM_BALLOON_RESPONSE;
 691                 bl_resp->hdr.trans_id = atomic_inc_return(&trans_id);
 692                 bl_resp->hdr.size = sizeof(struct dm_balloon_response);
 693                 bl_resp->more_pages = 1;
 694
 695
 696                 num_pages -= num_ballooned;
 697                 num_ballooned = alloc_balloon_pages(&dm_device, num_pages,
 698                                                 bl_resp, alloc_unit,
 699                                                  &alloc_error);
 700
 701                 if ((alloc_error) || (num_ballooned == num_pages)) {
 702                         bl_resp->more_pages = 0;
 703                         done = true;
 704                         dm_device.state = DM_INITIALIZED;
 705                 }
 706
 707                 /*
 708                  * We are pushing a lot of data through the channel;
 709                  * deal with transient failures caused because of the
 710                  * lack of space in the ring buffer.
 711                  */
 712
 713                 do {
 714                         ret = vmbus_sendpacket(dm_device.dev->channel,
 715                                                 bl_resp,
 716                                                 bl_resp->hdr.size,
 717                                                 (unsigned long)NULL,
 718                                                 VM_PKT_DATA_INBAND, 0);
 719
 720                         if (ret == -EAGAIN)
 721                                 msleep(20);
 722
 723                 } while (ret == -EAGAIN);
 724
 725                 if (ret) {
 726                         /*
 727                          * Free up the memory we allocatted.
 728                          */
 729                         pr_info("Balloon response failed\n");
 730
 731                         for (i = 0; i < bl_resp->range_count; i++)
 732                                 free_balloon_pages(&dm_device,
 733                                                  &bl_resp->range_array[i]);
 734
 735                         done = true;
 736                 }
 737         }
 738
 739 }
 740
 741 static void balloon_down(struct hv_dynmem_device *dm,
 742                         struct dm_unballoon_request *req)
 743 {
 744         union dm_mem_page_range *range_array = req->range_array;
 745         int range_count = req->range_count;
 746         struct dm_unballoon_response resp;
 747         int i;
 748
 749         for (i = 0; i < range_count; i++)
 750                 free_balloon_pages(dm, &range_array[i]);
 751
 752         if (req->more_pages == 1)
 753                 return;
 754
 755         memset(&resp, 0, sizeof(struct dm_unballoon_response));
 756         resp.hdr.type = DM_UNBALLOON_RESPONSE;
 757         resp.hdr.trans_id = atomic_inc_return(&trans_id);
 758         resp.hdr.size = sizeof(struct dm_unballoon_response);
 759
 760         vmbus_sendpacket(dm_device.dev->channel, &resp,
 761                                 sizeof(struct dm_unballoon_response),
 762                                 (unsigned long)NULL,
 763                                 VM_PKT_DATA_INBAND, 0);
 764
 765         dm->state = DM_INITIALIZED;
 766 }
 767
 768 static void balloon_onchannelcallback(void *context);
 769
 770 static int dm_thread_func(void *dm_dev)
 771 {
 772         struct hv_dynmem_device *dm = dm_dev;
 773         int t;
 774         unsigned long  scan_start;
 775
 776         while (!kthread_should_stop()) {
 777                 t = wait_for_completion_timeout(&dm_device.config_event, 1*HZ);
 778                 /*
 779                  * The host expects us to post information on the memory
 780                  * pressure every second.
 781                  */
 782
 783                 if (t == 0)
 784                         post_status(dm);
 785
 786                 scan_start = jiffies;
 787                 switch (dm->state) {
 788
 789                 case DM_HOT_ADD:
 790                         hot_add_req(dm, (struct dm_hot_add *)recv_buffer);
 791                         break;
 792                 default:
 793                         break;
 794                 }
 795
 796                 if (!time_in_range(jiffies, scan_start, scan_start + HZ))
 797                         post_status(dm);
 798
 799         }
 800
 801         return 0;
 802 }
 803
 804
 805 static void version_resp(struct hv_dynmem_device *dm,
 806                         struct dm_version_response *vresp)
 807 {
 808         struct dm_version_request version_req;
 809         int ret;
 810
 811         if (vresp->is_accepted) {
 812                 /*
 813                  * We are done; wakeup the
 814                  * context waiting for version
 815                  * negotiation.
 816                  */
 817                 complete(&dm->host_event);
 818                 return;
 819         }
 820         /*
 821          * If there are more versions to try, continue
 822          * with negotiations; if not
 823          * shutdown the service since we are not able
 824          * to negotiate a suitable version number
 825          * with the host.
 826          */
 827         if (dm->next_version == 0)
 828                 goto version_error;
 829
 830         dm->next_version = 0;
 831         memset(&version_req, 0, sizeof(struct dm_version_request));
 832         version_req.hdr.type = DM_VERSION_REQUEST;
 833         version_req.hdr.size = sizeof(struct dm_version_request);
 834         version_req.hdr.trans_id = atomic_inc_return(&trans_id);
 835         version_req.version.version = DYNMEM_PROTOCOL_VERSION_WIN7;
 836         version_req.is_last_attempt = 1;
 837
 838         ret = vmbus_sendpacket(dm->dev->channel, &version_req,
 839                                 sizeof(struct dm_version_request),
 840                                 (unsigned long)NULL,
 841                                 VM_PKT_DATA_INBAND, 0);
 842
 843         if (ret)
 844                 goto version_error;
 845
 846         return;
 847
 848 version_error:
 849         dm->state = DM_INIT_ERROR;
 850         complete(&dm->host_event);
 851 }
 852
 853 static void cap_resp(struct hv_dynmem_device *dm,
 854                         struct dm_capabilities_resp_msg *cap_resp)
 855 {
 856         if (!cap_resp->is_accepted) {
 857                 pr_info("Capabilities not accepted by host\n");
 858                 dm->state = DM_INIT_ERROR;
 859         }
 860         complete(&dm->host_event);
 861 }
 862
 863 static void balloon_onchannelcallback(void *context)
 864 {
 865         struct hv_device *dev = context;
 866         u32 recvlen;
 867         u64 requestid;
 868         struct dm_message *dm_msg;
 869         struct dm_header *dm_hdr;
 870         struct hv_dynmem_device *dm = hv_get_drvdata(dev);
 871         struct dm_balloon *bal_msg;
 872
 873         memset(recv_buffer, 0, sizeof(recv_buffer));
 874         vmbus_recvpacket(dev->channel, recv_buffer,
 875                          PAGE_SIZE, &recvlen, &requestid);
 876
 877         if (recvlen > 0) {
 878                 dm_msg = (struct dm_message *)recv_buffer;
 879                 dm_hdr = &dm_msg->hdr;
 880
 881                 switch (dm_hdr->type) {
 882                 case DM_VERSION_RESPONSE:
 883                         version_resp(dm,
 884                                  (struct dm_version_response *)dm_msg);
 885                         break;
 886
 887                 case DM_CAPABILITIES_RESPONSE:
 888                         cap_resp(dm,
 889                                  (struct dm_capabilities_resp_msg *)dm_msg);
 890                         break;
 891
 892                 case DM_BALLOON_REQUEST:
 893                         if (dm->state == DM_BALLOON_UP)
 894                                 pr_warn("Currently ballooning\n");
 895                         bal_msg = (struct dm_balloon *)recv_buffer;
 896                         dm->state = DM_BALLOON_UP;
 897                         dm_device.balloon_wrk.num_pages = bal_msg->num_pages;
 898                         schedule_work(&dm_device.balloon_wrk.wrk);
 899                         break;
 900
 901                 case DM_UNBALLOON_REQUEST:
 902                         dm->state = DM_BALLOON_DOWN;
 903                         balloon_down(dm,
 904                                  (struct dm_unballoon_request *)recv_buffer);
 905                         break;
 906
 907                 case DM_MEM_HOT_ADD_REQUEST:
 908                         dm->state = DM_HOT_ADD;
 909                         complete(&dm->config_event);
 910                         break;
 911
 912                 case DM_INFO_MESSAGE:
 913                         process_info(dm, (struct dm_info_msg *)dm_msg);
 914                         break;
 915
 916                 default:
 917                         pr_err("Unhandled message: type: %d\n", dm_hdr->type);
 918
 919                 }
 920         }
 921
 922 }
 923
 924 static int balloon_probe(struct hv_device *dev,
 925                         const struct hv_vmbus_device_id *dev_id)
 926 {
 927         int ret, t;
 928         struct dm_version_request version_req;
 929         struct dm_capabilities cap_msg;
 930
 931         do_hot_add = hot_add;
 932
 933         /*
 934          * First allocate a send buffer.
 935          */
 936
 937         send_buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
 938         if (!send_buffer)
 939                 return -ENOMEM;
 940
 941         ret = vmbus_open(dev->channel, dm_ring_size, dm_ring_size, NULL, 0,
 942                         balloon_onchannelcallback, dev);
 943
 944         if (ret)
 945                 goto probe_error0;
 946
 947         dm_device.dev = dev;
 948         dm_device.state = DM_INITIALIZING;
 949         dm_device.next_version = DYNMEM_PROTOCOL_VERSION_WIN7;
 950         init_completion(&dm_device.host_event);
 951         init_completion(&dm_device.config_event);
 952         INIT_WORK(&dm_device.balloon_wrk.wrk, balloon_up);
 953
 954         dm_device.thread =
 955                  kthread_run(dm_thread_func, &dm_device, "hv_balloon");
 956         if (IS_ERR(dm_device.thread)) {
 957                 ret = PTR_ERR(dm_device.thread);
 958                 goto probe_error1;
 959         }
 960
 961         hv_set_drvdata(dev, &dm_device);
 962         /*
 963          * Initiate the hand shake with the host and negotiate
 964          * a version that the host can support. We start with the
 965          * highest version number and go down if the host cannot
 966          * support it.
 967          */
 968         memset(&version_req, 0, sizeof(struct dm_version_request));
 969         version_req.hdr.type = DM_VERSION_REQUEST;
 970         version_req.hdr.size = sizeof(struct dm_version_request);
 971         version_req.hdr.trans_id = atomic_inc_return(&trans_id);
 972         version_req.version.version = DYNMEM_PROTOCOL_VERSION_WIN8;
 973         version_req.is_last_attempt = 0;
 974
 975         ret = vmbus_sendpacket(dev->channel, &version_req,
 976                                 sizeof(struct dm_version_request),
 977                                 (unsigned long)NULL,
 978                                 VM_PKT_DATA_INBAND, 0);
 979         if (ret)
 980                 goto probe_error2;
 981
 982         t = wait_for_completion_timeout(&dm_device.host_event, 5*HZ);
 983         if (t == 0) {
 984                 ret = -ETIMEDOUT;
 985                 goto probe_error2;
 986         }
 987
 988         /*
 989          * If we could not negotiate a compatible version with the host
 990          * fail the probe function.
 991          */
 992         if (dm_device.state == DM_INIT_ERROR) {
 993                 ret = -ETIMEDOUT;
 994                 goto probe_error2;
 995         }
 996         /*
 997          * Now submit our capabilities to the host.
 998          */
 999         memset(&cap_msg, 0, sizeof(struct dm_capabilities));
1000         cap_msg.hdr.type = DM_CAPABILITIES_REPORT;
1001         cap_msg.hdr.size = sizeof(struct dm_capabilities);
1002         cap_msg.hdr.trans_id = atomic_inc_return(&trans_id);
1003
1004         cap_msg.caps.cap_bits.balloon = 1;
1005         /*
1006          * While we currently don't support hot-add,
1007          * we still advertise this capability since the
1008          * host requires that guests partcipating in the
1009          * dynamic memory protocol support hot add.
1010          */
1011         cap_msg.caps.cap_bits.hot_add = 1;
1012
1013         /*
1014          * Currently the host does not use these
1015          * values and we set them to what is done in the
1016          * Windows driver.
1017          */
1018         cap_msg.min_page_cnt = 0;
1019         cap_msg.max_page_number = -1;
1020
1021         ret = vmbus_sendpacket(dev->channel, &cap_msg,
1022                                 sizeof(struct dm_capabilities),
1023                                 (unsigned long)NULL,
1024                                 VM_PKT_DATA_INBAND, 0);
1025         if (ret)
1026                 goto probe_error2;
1027
1028         t = wait_for_completion_timeout(&dm_device.host_event, 5*HZ);
1029         if (t == 0) {
1030                 ret = -ETIMEDOUT;
1031                 goto probe_error2;
1032         }
1033
1034         /*
1035          * If the host does not like our capabilities,
1036          * fail the probe function.
1037          */
1038         if (dm_device.state == DM_INIT_ERROR) {
1039                 ret = -ETIMEDOUT;
1040                 goto probe_error2;
1041         }
1042
1043         dm_device.state = DM_INITIALIZED;
1044
1045         return 0;
1046
1047 probe_error2:
1048         kthread_stop(dm_device.thread);
1049
1050 probe_error1:
1051         vmbus_close(dev->channel);
1052 probe_error0:
1053         kfree(send_buffer);
1054         return ret;
1055 }
1056
1057 static int balloon_remove(struct hv_device *dev)
1058 {
1059         struct hv_dynmem_device *dm = hv_get_drvdata(dev);
1060
1061         if (dm->num_pages_ballooned != 0)
1062                 pr_warn("Ballooned pages: %d\n", dm->num_pages_ballooned);
1063
1064         cancel_work_sync(&dm->balloon_wrk.wrk);
1065         vmbus_close(dev->channel);
1066         kthread_stop(dm->thread);
1067         kfree(send_buffer);
1068
1069         return 0;
1070 }
1071
1072 static const struct hv_vmbus_device_id id_table[] = {
1073         /* Dynamic Memory Class ID */
1074         /* 525074DC-8985-46e2-8057-A307DC18A502 */
1075         { HV_DM_GUID, },
1076         { },
1077 };
1078
1079 MODULE_DEVICE_TABLE(vmbus, id_table);
1080
1081 static  struct hv_driver balloon_drv = {
1082         .name = "hv_balloon",
1083         .id_table = id_table,
1084         .probe =  balloon_probe,
1085         .remove =  balloon_remove,
1086 };
1087
1088 static int __init init_balloon_drv(void)
1089 {
1090
1091         return vmbus_driver_register(&balloon_drv);
1092 }
1093
1094 static void exit_balloon_drv(void)
1095 {
1096
1097         vmbus_driver_unregister(&balloon_drv);
1098 }
1099
1100 module_init(init_balloon_drv);
1101 module_exit(exit_balloon_drv);
1102
1103 MODULE_DESCRIPTION("Hyper-V Balloon");
1104 MODULE_VERSION(HV_DRV_VERSION);
1105 MODULE_LICENSE("GPL");