1/****************************************************************************** 2 * Xen balloon driver - enables returning/claiming memory to/from Xen. 3 * 4 * Copyright (c) 2003, B Dragovic 5 * Copyright (c) 2003-2004, M Williamson, K Fraser 6 * Copyright (c) 2005 Dan M. Smith, IBM Corporation 7 * Copyright (c) 2010 Daniel Kiper 8 * 9 * Memory hotplug support was written by Daniel Kiper. Work on 10 * it was sponsored by Google under Google Summer of Code 2010 11 * program. Jeremy Fitzhardinge from Citrix was the mentor for 12 * this project. 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License version 2 16 * as published by the Free Software Foundation; or, when distributed 17 * separately from the Linux kernel or incorporated into other 18 * software packages, subject to the following license: 19 * 20 * Permission is hereby granted, free of charge, to any person obtaining a copy 21 * of this source file (the "Software"), to deal in the Software without 22 * restriction, including without limitation the rights to use, copy, modify, 23 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 24 * and to permit persons to whom the Software is furnished to do so, subject to 25 * the following conditions: 26 * 27 * The above copyright notice and this permission notice shall be included in 28 * all copies or substantial portions of the Software. 29 * 30 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 31 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 32 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 33 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 34 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 35 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 36 * IN THE SOFTWARE. 37 */ 38 39#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt 40 41#include <linux/cpu.h> 42#include <linux/kernel.h> 43#include <linux/sched.h> 44#include <linux/cred.h> 45#include <linux/errno.h> 46#include <linux/freezer.h> 47#include <linux/kthread.h> 48#include <linux/mm.h> 49#include <linux/memblock.h> 50#include <linux/pagemap.h> 51#include <linux/highmem.h> 52#include <linux/mutex.h> 53#include <linux/list.h> 54#include <linux/gfp.h> 55#include <linux/notifier.h> 56#include <linux/memory.h> 57#include <linux/memory_hotplug.h> 58#include <linux/percpu-defs.h> 59#include <linux/slab.h> 60#include <linux/sysctl.h> 61#include <linux/moduleparam.h> 62#include <linux/jiffies.h> 63 64#include <asm/page.h> 65#include <asm/tlb.h> 66 67#include <asm/xen/hypervisor.h> 68#include <asm/xen/hypercall.h> 69 70#include <xen/xen.h> 71#include <xen/interface/xen.h> 72#include <xen/interface/memory.h> 73#include <xen/balloon.h> 74#include <xen/features.h> 75#include <xen/page.h> 76#include <xen/mem-reservation.h> 77 78#undef MODULE_PARAM_PREFIX 79#define MODULE_PARAM_PREFIX "xen." 80 81static uint __read_mostly balloon_boot_timeout = 180; 82module_param(balloon_boot_timeout, uint, 0444); 83 84#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG 85static int xen_hotplug_unpopulated; 86 87static struct ctl_table balloon_table[] = { 88 { 89 .procname = "hotplug_unpopulated", 90 .data = &xen_hotplug_unpopulated, 91 .maxlen = sizeof(int), 92 .mode = 0644, 93 .proc_handler = proc_dointvec_minmax, 94 .extra1 = SYSCTL_ZERO, 95 .extra2 = SYSCTL_ONE, 96 }, 97 { } 98}; 99 100#else 101#define xen_hotplug_unpopulated 0 102#endif 103 104/* 105 * Use one extent per PAGE_SIZE to avoid to break down the page into 106 * multiple frame. 107 */ 108#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1) 109 110/* 111 * balloon_thread() state: 112 * 113 * BP_DONE: done or nothing to do, 114 * BP_WAIT: wait to be rescheduled, 115 * BP_EAGAIN: error, go to sleep, 116 * BP_ECANCELED: error, balloon operation canceled. 117 */ 118 119static enum bp_state { 120 BP_DONE, 121 BP_WAIT, 122 BP_EAGAIN, 123 BP_ECANCELED 124} balloon_state = BP_DONE; 125 126/* Main waiting point for xen-balloon thread. */ 127static DECLARE_WAIT_QUEUE_HEAD(balloon_thread_wq); 128 129static DEFINE_MUTEX(balloon_mutex); 130 131struct balloon_stats balloon_stats; 132EXPORT_SYMBOL_GPL(balloon_stats); 133 134/* We increase/decrease in batches which fit in a page */ 135static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)]; 136 137 138/* List of ballooned pages, threaded through the mem_map array. */ 139static LIST_HEAD(ballooned_pages); 140static DECLARE_WAIT_QUEUE_HEAD(balloon_wq); 141 142/* When ballooning out (allocating memory to return to Xen) we don't really 143 want the kernel to try too hard since that can trigger the oom killer. */ 144#define GFP_BALLOON \ 145 (GFP_HIGHUSER | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC) 146 147/* balloon_append: add the given page to the balloon. */ 148static void balloon_append(struct page *page) 149{ 150 __SetPageOffline(page); 151 152 /* Lowmem is re-populated first, so highmem pages go at list tail. */ 153 if (PageHighMem(page)) { 154 list_add_tail(&page->lru, &ballooned_pages); 155 balloon_stats.balloon_high++; 156 } else { 157 list_add(&page->lru, &ballooned_pages); 158 balloon_stats.balloon_low++; 159 } 160 wake_up(&balloon_wq); 161} 162 163/* balloon_retrieve: rescue a page from the balloon, if it is not empty. */ 164static struct page *balloon_retrieve(bool require_lowmem) 165{ 166 struct page *page; 167 168 if (list_empty(&ballooned_pages)) 169 return NULL; 170 171 page = list_entry(ballooned_pages.next, struct page, lru); 172 if (require_lowmem && PageHighMem(page)) 173 return NULL; 174 list_del(&page->lru); 175 176 if (PageHighMem(page)) 177 balloon_stats.balloon_high--; 178 else 179 balloon_stats.balloon_low--; 180 181 __ClearPageOffline(page); 182 return page; 183} 184 185static struct page *balloon_next_page(struct page *page) 186{ 187 struct list_head *next = page->lru.next; 188 if (next == &ballooned_pages) 189 return NULL; 190 return list_entry(next, struct page, lru); 191} 192 193static void update_schedule(void) 194{ 195 if (balloon_state == BP_WAIT || balloon_state == BP_ECANCELED) 196 return; 197 198 if (balloon_state == BP_DONE) { 199 balloon_stats.schedule_delay = 1; 200 balloon_stats.retry_count = 1; 201 return; 202 } 203 204 ++balloon_stats.retry_count; 205 206 if (balloon_stats.max_retry_count != RETRY_UNLIMITED && 207 balloon_stats.retry_count > balloon_stats.max_retry_count) { 208 balloon_stats.schedule_delay = 1; 209 balloon_stats.retry_count = 1; 210 balloon_state = BP_ECANCELED; 211 return; 212 } 213 214 balloon_stats.schedule_delay <<= 1; 215 216 if (balloon_stats.schedule_delay > balloon_stats.max_schedule_delay) 217 balloon_stats.schedule_delay = balloon_stats.max_schedule_delay; 218 219 balloon_state = BP_EAGAIN; 220} 221 222#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG 223static void release_memory_resource(struct resource *resource) 224{ 225 if (!resource) 226 return; 227 228 /* 229 * No need to reset region to identity mapped since we now 230 * know that no I/O can be in this region 231 */ 232 release_resource(resource); 233 kfree(resource); 234} 235 236static struct resource *additional_memory_resource(phys_addr_t size) 237{ 238 struct resource *res; 239 int ret; 240 241 res = kzalloc(sizeof(*res), GFP_KERNEL); 242 if (!res) 243 return NULL; 244 245 res->name = "System RAM"; 246 res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 247 248 ret = allocate_resource(&iomem_resource, res, 249 size, 0, -1, 250 PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL); 251 if (ret < 0) { 252 pr_err("Cannot allocate new System RAM resource\n"); 253 kfree(res); 254 return NULL; 255 } 256 257 return res; 258} 259 260static enum bp_state reserve_additional_memory(void) 261{ 262 long credit; 263 struct resource *resource; 264 int nid, rc; 265 unsigned long balloon_hotplug; 266 267 credit = balloon_stats.target_pages + balloon_stats.target_unpopulated 268 - balloon_stats.total_pages; 269 270 /* 271 * Already hotplugged enough pages? Wait for them to be 272 * onlined. 273 */ 274 if (credit <= 0) 275 return BP_WAIT; 276 277 balloon_hotplug = round_up(credit, PAGES_PER_SECTION); 278 279 resource = additional_memory_resource(balloon_hotplug * PAGE_SIZE); 280 if (!resource) 281 goto err; 282 283 nid = memory_add_physaddr_to_nid(resource->start); 284 285#ifdef CONFIG_XEN_HAVE_PVMMU 286 /* 287 * We don't support PV MMU when Linux and Xen is using 288 * different page granularity. 289 */ 290 BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); 291 292 /* 293 * add_memory() will build page tables for the new memory so 294 * the p2m must contain invalid entries so the correct 295 * non-present PTEs will be written. 296 * 297 * If a failure occurs, the original (identity) p2m entries 298 * are not restored since this region is now known not to 299 * conflict with any devices. 300 */ 301 if (!xen_feature(XENFEAT_auto_translated_physmap)) { 302 unsigned long pfn, i; 303 304 pfn = PFN_DOWN(resource->start); 305 for (i = 0; i < balloon_hotplug; i++) { 306 if (!set_phys_to_machine(pfn + i, INVALID_P2M_ENTRY)) { 307 pr_warn("set_phys_to_machine() failed, no memory added\n"); 308 goto err; 309 } 310 } 311 } 312#endif 313 314 /* 315 * add_memory_resource() will call online_pages() which in its turn 316 * will call xen_online_page() callback causing deadlock if we don't 317 * release balloon_mutex here. Unlocking here is safe because the 318 * callers drop the mutex before trying again. 319 */ 320 mutex_unlock(&balloon_mutex); 321 /* add_memory_resource() requires the device_hotplug lock */ 322 lock_device_hotplug(); 323 rc = add_memory_resource(nid, resource, MHP_MERGE_RESOURCE); 324 unlock_device_hotplug(); 325 mutex_lock(&balloon_mutex); 326 327 if (rc) { 328 pr_warn("Cannot add additional memory (%i)\n", rc); 329 goto err; 330 } 331 332 balloon_stats.total_pages += balloon_hotplug; 333 334 return BP_WAIT; 335 err: 336 release_memory_resource(resource); 337 return BP_ECANCELED; 338} 339 340static void xen_online_page(struct page *page, unsigned int order) 341{ 342 unsigned long i, size = (1 << order); 343 unsigned long start_pfn = page_to_pfn(page); 344 struct page *p; 345 346 pr_debug("Online %lu pages starting at pfn 0x%lx\n", size, start_pfn); 347 mutex_lock(&balloon_mutex); 348 for (i = 0; i < size; i++) { 349 p = pfn_to_page(start_pfn + i); 350 balloon_append(p); 351 } 352 mutex_unlock(&balloon_mutex); 353} 354 355static int xen_memory_notifier(struct notifier_block *nb, unsigned long val, void *v) 356{ 357 if (val == MEM_ONLINE) 358 wake_up(&balloon_thread_wq); 359 360 return NOTIFY_OK; 361} 362 363static struct notifier_block xen_memory_nb = { 364 .notifier_call = xen_memory_notifier, 365 .priority = 0 366}; 367#else 368static enum bp_state reserve_additional_memory(void) 369{ 370 balloon_stats.target_pages = balloon_stats.current_pages + 371 balloon_stats.target_unpopulated; 372 return BP_ECANCELED; 373} 374#endif /* CONFIG_XEN_BALLOON_MEMORY_HOTPLUG */ 375 376static long current_credit(void) 377{ 378 return balloon_stats.target_pages - balloon_stats.current_pages; 379} 380 381static bool balloon_is_inflated(void) 382{ 383 return balloon_stats.balloon_low || balloon_stats.balloon_high; 384} 385 386static enum bp_state increase_reservation(unsigned long nr_pages) 387{ 388 int rc; 389 unsigned long i; 390 struct page *page; 391 392 if (nr_pages > ARRAY_SIZE(frame_list)) 393 nr_pages = ARRAY_SIZE(frame_list); 394 395 page = list_first_entry_or_null(&ballooned_pages, struct page, lru); 396 for (i = 0; i < nr_pages; i++) { 397 if (!page) { 398 nr_pages = i; 399 break; 400 } 401 402 frame_list[i] = page_to_xen_pfn(page); 403 page = balloon_next_page(page); 404 } 405 406 rc = xenmem_reservation_increase(nr_pages, frame_list); 407 if (rc <= 0) 408 return BP_EAGAIN; 409 410 for (i = 0; i < rc; i++) { 411 page = balloon_retrieve(false); 412 BUG_ON(page == NULL); 413 414 xenmem_reservation_va_mapping_update(1, &page, &frame_list[i]); 415 416 /* Relinquish the page back to the allocator. */ 417 free_reserved_page(page); 418 } 419 420 balloon_stats.current_pages += rc; 421 422 return BP_DONE; 423} 424 425static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) 426{ 427 enum bp_state state = BP_DONE; 428 unsigned long i; 429 struct page *page, *tmp; 430 int ret; 431 LIST_HEAD(pages); 432 433 if (nr_pages > ARRAY_SIZE(frame_list)) 434 nr_pages = ARRAY_SIZE(frame_list); 435 436 for (i = 0; i < nr_pages; i++) { 437 page = alloc_page(gfp); 438 if (page == NULL) { 439 nr_pages = i; 440 state = BP_EAGAIN; 441 break; 442 } 443 adjust_managed_page_count(page, -1); 444 xenmem_reservation_scrub_page(page); 445 list_add(&page->lru, &pages); 446 } 447 448 /* 449 * Ensure that ballooned highmem pages don't have kmaps. 450 * 451 * Do this before changing the p2m as kmap_flush_unused() 452 * reads PTEs to obtain pages (and hence needs the original 453 * p2m entry). 454 */ 455 kmap_flush_unused(); 456 457 /* 458 * Setup the frame, update direct mapping, invalidate P2M, 459 * and add to balloon. 460 */ 461 i = 0; 462 list_for_each_entry_safe(page, tmp, &pages, lru) { 463 frame_list[i++] = xen_page_to_gfn(page); 464 465 xenmem_reservation_va_mapping_reset(1, &page); 466 467 list_del(&page->lru); 468 469 balloon_append(page); 470 } 471 472 flush_tlb_all(); 473 474 ret = xenmem_reservation_decrease(nr_pages, frame_list); 475 BUG_ON(ret != nr_pages); 476 477 balloon_stats.current_pages -= nr_pages; 478 479 return state; 480} 481 482/* 483 * Stop waiting if either state is BP_DONE and ballooning action is 484 * needed, or if the credit has changed while state is not BP_DONE. 485 */ 486static bool balloon_thread_cond(long credit) 487{ 488 if (balloon_state == BP_DONE) 489 credit = 0; 490 491 return current_credit() != credit || kthread_should_stop(); 492} 493 494/* 495 * As this is a kthread it is guaranteed to run as a single instance only. 496 * We may of course race updates of the target counts (which are protected 497 * by the balloon lock), or with changes to the Xen hard limit, but we will 498 * recover from these in time. 499 */ 500static int balloon_thread(void *unused) 501{ 502 long credit; 503 unsigned long timeout; 504 505 set_freezable(); 506 for (;;) { 507 switch (balloon_state) { 508 case BP_DONE: 509 case BP_ECANCELED: 510 timeout = 3600 * HZ; 511 break; 512 case BP_EAGAIN: 513 timeout = balloon_stats.schedule_delay * HZ; 514 break; 515 case BP_WAIT: 516 timeout = HZ; 517 break; 518 } 519 520 credit = current_credit(); 521 522 wait_event_freezable_timeout(balloon_thread_wq, 523 balloon_thread_cond(credit), timeout); 524 525 if (kthread_should_stop()) 526 return 0; 527 528 mutex_lock(&balloon_mutex); 529 530 credit = current_credit(); 531 532 if (credit > 0) { 533 if (balloon_is_inflated()) 534 balloon_state = increase_reservation(credit); 535 else 536 balloon_state = reserve_additional_memory(); 537 } 538 539 if (credit < 0) { 540 long n_pages; 541 542 n_pages = min(-credit, si_mem_available()); 543 balloon_state = decrease_reservation(n_pages, 544 GFP_BALLOON); 545 if (balloon_state == BP_DONE && n_pages != -credit && 546 n_pages < totalreserve_pages) 547 balloon_state = BP_EAGAIN; 548 } 549 550 update_schedule(); 551 552 mutex_unlock(&balloon_mutex); 553 554 cond_resched(); 555 } 556} 557 558/* Resets the Xen limit, sets new target, and kicks off processing. */ 559void balloon_set_new_target(unsigned long target) 560{ 561 /* No need for lock. Not read-modify-write updates. */ 562 balloon_stats.target_pages = target; 563 wake_up(&balloon_thread_wq); 564} 565EXPORT_SYMBOL_GPL(balloon_set_new_target); 566 567static int add_ballooned_pages(unsigned int nr_pages) 568{ 569 enum bp_state st; 570 571 if (xen_hotplug_unpopulated) { 572 st = reserve_additional_memory(); 573 if (st != BP_ECANCELED) { 574 int rc; 575 576 mutex_unlock(&balloon_mutex); 577 rc = wait_event_interruptible(balloon_wq, 578 !list_empty(&ballooned_pages)); 579 mutex_lock(&balloon_mutex); 580 return rc ? -ENOMEM : 0; 581 } 582 } 583 584 if (si_mem_available() < nr_pages) 585 return -ENOMEM; 586 587 st = decrease_reservation(nr_pages, GFP_USER); 588 if (st != BP_DONE) 589 return -ENOMEM; 590 591 return 0; 592} 593 594/** 595 * xen_alloc_ballooned_pages - get pages that have been ballooned out 596 * @nr_pages: Number of pages to get 597 * @pages: pages returned 598 * @return 0 on success, error otherwise 599 */ 600int xen_alloc_ballooned_pages(unsigned int nr_pages, struct page **pages) 601{ 602 unsigned int pgno = 0; 603 struct page *page; 604 int ret; 605 606 mutex_lock(&balloon_mutex); 607 608 balloon_stats.target_unpopulated += nr_pages; 609 610 while (pgno < nr_pages) { 611 page = balloon_retrieve(true); 612 if (page) { 613 pages[pgno++] = page; 614#ifdef CONFIG_XEN_HAVE_PVMMU 615 /* 616 * We don't support PV MMU when Linux and Xen is using 617 * different page granularity. 618 */ 619 BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); 620 621 if (!xen_feature(XENFEAT_auto_translated_physmap)) { 622 ret = xen_alloc_p2m_entry(page_to_pfn(page)); 623 if (ret < 0) 624 goto out_undo; 625 } 626#endif 627 } else { 628 ret = add_ballooned_pages(nr_pages - pgno); 629 if (ret < 0) 630 goto out_undo; 631 } 632 } 633 mutex_unlock(&balloon_mutex); 634 return 0; 635 out_undo: 636 mutex_unlock(&balloon_mutex); 637 xen_free_ballooned_pages(pgno, pages); 638 /* 639 * NB: xen_free_ballooned_pages will only subtract pgno pages, but since 640 * target_unpopulated is incremented with nr_pages at the start we need 641 * to remove the remaining ones also, or accounting will be screwed. 642 */ 643 balloon_stats.target_unpopulated -= nr_pages - pgno; 644 return ret; 645} 646EXPORT_SYMBOL(xen_alloc_ballooned_pages); 647 648/** 649 * xen_free_ballooned_pages - return pages retrieved with get_ballooned_pages 650 * @nr_pages: Number of pages 651 * @pages: pages to return 652 */ 653void xen_free_ballooned_pages(unsigned int nr_pages, struct page **pages) 654{ 655 unsigned int i; 656 657 mutex_lock(&balloon_mutex); 658 659 for (i = 0; i < nr_pages; i++) { 660 if (pages[i]) 661 balloon_append(pages[i]); 662 } 663 664 balloon_stats.target_unpopulated -= nr_pages; 665 666 /* The balloon may be too large now. Shrink it if needed. */ 667 if (current_credit()) 668 wake_up(&balloon_thread_wq); 669 670 mutex_unlock(&balloon_mutex); 671} 672EXPORT_SYMBOL(xen_free_ballooned_pages); 673 674static void __init balloon_add_regions(void) 675{ 676#if defined(CONFIG_XEN_PV) 677 unsigned long start_pfn, pages; 678 unsigned long pfn, extra_pfn_end; 679 unsigned int i; 680 681 for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { 682 pages = xen_extra_mem[i].n_pfns; 683 if (!pages) 684 continue; 685 686 start_pfn = xen_extra_mem[i].start_pfn; 687 688 /* 689 * If the amount of usable memory has been limited (e.g., with 690 * the 'mem' command line parameter), don't add pages beyond 691 * this limit. 692 */ 693 extra_pfn_end = min(max_pfn, start_pfn + pages); 694 695 for (pfn = start_pfn; pfn < extra_pfn_end; pfn++) 696 balloon_append(pfn_to_page(pfn)); 697 698 balloon_stats.total_pages += extra_pfn_end - start_pfn; 699 } 700#endif 701} 702 703static int __init balloon_init(void) 704{ 705 struct task_struct *task; 706 707 if (!xen_domain()) 708 return -ENODEV; 709 710 pr_info("Initialising balloon driver\n"); 711 712#ifdef CONFIG_XEN_PV 713 balloon_stats.current_pages = xen_pv_domain() 714 ? min(xen_start_info->nr_pages - xen_released_pages, max_pfn) 715 : get_num_physpages(); 716#else 717 balloon_stats.current_pages = get_num_physpages(); 718#endif 719 balloon_stats.target_pages = balloon_stats.current_pages; 720 balloon_stats.balloon_low = 0; 721 balloon_stats.balloon_high = 0; 722 balloon_stats.total_pages = balloon_stats.current_pages; 723 724 balloon_stats.schedule_delay = 1; 725 balloon_stats.max_schedule_delay = 32; 726 balloon_stats.retry_count = 1; 727 balloon_stats.max_retry_count = 4; 728 729#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG 730 set_online_page_callback(&xen_online_page); 731 register_memory_notifier(&xen_memory_nb); 732 register_sysctl_init("xen/balloon", balloon_table); 733#endif 734 735 balloon_add_regions(); 736 737 task = kthread_run(balloon_thread, NULL, "xen-balloon"); 738 if (IS_ERR(task)) { 739 pr_err("xen-balloon thread could not be started, ballooning will not work!\n"); 740 return PTR_ERR(task); 741 } 742 743 /* Init the xen-balloon driver. */ 744 xen_balloon_init(); 745 746 return 0; 747} 748subsys_initcall(balloon_init); 749 750static int __init balloon_wait_finish(void) 751{ 752 long credit, last_credit = 0; 753 unsigned long last_changed = 0; 754 755 if (!xen_domain()) 756 return -ENODEV; 757 758 /* PV guests don't need to wait. */ 759 if (xen_pv_domain() || !current_credit()) 760 return 0; 761 762 pr_notice("Waiting for initial ballooning down having finished.\n"); 763 764 while ((credit = current_credit()) < 0) { 765 if (credit != last_credit) { 766 last_changed = jiffies; 767 last_credit = credit; 768 } 769 if (balloon_state == BP_ECANCELED) { 770 pr_warn_once("Initial ballooning failed, %ld pages need to be freed.\n", 771 -credit); 772 if (time_is_before_eq_jiffies(last_changed + HZ * balloon_boot_timeout)) 773 panic("Initial ballooning failed!\n"); 774 } 775 776 schedule_timeout_interruptible(HZ / 10); 777 } 778 779 pr_notice("Initial ballooning down finished.\n"); 780 781 return 0; 782} 783late_initcall_sync(balloon_wait_finish); 784