2 * VMware Balloon driver.
4 * Copyright (C) 2000-2010, VMware, Inc. All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; version 2 of the License and no later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13 * NON INFRINGEMENT. See the GNU General Public License for more
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 * Maintained by: Xavier Deguillard <xdeguillard@vmware.com>
21 * Philip Moltmann <moltmann@vmware.com>
25 * This is VMware physical memory management driver for Linux. The driver
26 * acts like a "balloon" that can be inflated to reclaim physical pages by
27 * reserving them in the guest and invalidating them in the monitor,
28 * freeing up the underlying machine pages so they can be allocated to
29 * other guests. The balloon can also be deflated to allow the guest to
30 * use more physical memory. Higher level policies can control the sizes
31 * of balloons in VMs in order to manage physical memory resources.
35 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
37 #include <linux/types.h>
38 #include <linux/kernel.h>
40 #include <linux/sched.h>
41 #include <linux/module.h>
42 #include <linux/workqueue.h>
43 #include <linux/debugfs.h>
44 #include <linux/seq_file.h>
45 #include <asm/hypervisor.h>
47 MODULE_AUTHOR("VMware, Inc.");
48 MODULE_DESCRIPTION("VMware Memory Control (Balloon) Driver");
49 MODULE_VERSION("1.3.0.0-k");
50 MODULE_ALIAS("dmi:*:svnVMware*:*");
51 MODULE_ALIAS("vmware_vmmemctl");
52 MODULE_LICENSE("GPL");
55 * Various constants controlling rate of inflaint/deflating balloon,
60 * Rate of allocating memory when there is no memory pressure
61 * (driver performs non-sleeping allocations).
63 #define VMW_BALLOON_NOSLEEP_ALLOC_MAX 16384U
66 * Rates of memory allocaton when guest experiences memory pressure
67 * (driver performs sleeping allocations).
69 #define VMW_BALLOON_RATE_ALLOC_MIN 512U
70 #define VMW_BALLOON_RATE_ALLOC_MAX 2048U
71 #define VMW_BALLOON_RATE_ALLOC_INC 16U
74 * Rates for releasing pages while deflating balloon.
76 #define VMW_BALLOON_RATE_FREE_MIN 512U
77 #define VMW_BALLOON_RATE_FREE_MAX 16384U
78 #define VMW_BALLOON_RATE_FREE_INC 16U
81 * When guest is under memory pressure, use a reduced page allocation
82 * rate for next several cycles.
84 #define VMW_BALLOON_SLOW_CYCLES 4
87 * Use __GFP_HIGHMEM to allow pages from HIGHMEM zone. We don't
88 * allow wait (__GFP_WAIT) for NOSLEEP page allocations. Use
89 * __GFP_NOWARN, to suppress page allocation failure warnings.
91 #define VMW_PAGE_ALLOC_NOSLEEP (__GFP_HIGHMEM|__GFP_NOWARN)
94 * Use GFP_HIGHUSER when executing in a separate kernel thread
95 * context and allocation can sleep. This is less stressful to
96 * the guest memory system, since it allows the thread to block
97 * while memory is reclaimed, and won't take pages from emergency
100 #define VMW_PAGE_ALLOC_CANSLEEP (GFP_HIGHUSER)
102 /* Maximum number of page allocations without yielding processor */
103 #define VMW_BALLOON_YIELD_THRESHOLD 1024
105 /* Maximum number of refused pages we accumulate during inflation cycle */
106 #define VMW_BALLOON_MAX_REFUSED 16
109 * Hypervisor communication port definitions.
111 #define VMW_BALLOON_HV_PORT 0x5670
112 #define VMW_BALLOON_HV_MAGIC 0x456c6d6f
113 #define VMW_BALLOON_GUEST_ID 1 /* Linux */
115 enum vmwballoon_capabilities
{
117 * Bit 0 is reserved and not associated to any capability.
119 VMW_BALLOON_BASIC_CMDS
= (1 << 1),
120 VMW_BALLOON_BATCHED_CMDS
= (1 << 2)
123 #define VMW_BALLOON_CAPABILITIES (VMW_BALLOON_BASIC_CMDS)
125 #define VMW_BALLOON_CMD_START 0
126 #define VMW_BALLOON_CMD_GET_TARGET 1
127 #define VMW_BALLOON_CMD_LOCK 2
128 #define VMW_BALLOON_CMD_UNLOCK 3
129 #define VMW_BALLOON_CMD_GUEST_ID 4
132 #define VMW_BALLOON_SUCCESS 0
133 #define VMW_BALLOON_FAILURE -1
134 #define VMW_BALLOON_ERROR_CMD_INVALID 1
135 #define VMW_BALLOON_ERROR_PPN_INVALID 2
136 #define VMW_BALLOON_ERROR_PPN_LOCKED 3
137 #define VMW_BALLOON_ERROR_PPN_UNLOCKED 4
138 #define VMW_BALLOON_ERROR_PPN_PINNED 5
139 #define VMW_BALLOON_ERROR_PPN_NOTNEEDED 6
140 #define VMW_BALLOON_ERROR_RESET 7
141 #define VMW_BALLOON_ERROR_BUSY 8
143 #define VMW_BALLOON_SUCCESS_WITH_CAPABILITIES (0x03000000)
145 #define VMWARE_BALLOON_CMD(cmd, data, result) \
147 unsigned long __status, __dummy1, __dummy2; \
148 __asm__ __volatile__ ("inl %%dx" : \
153 "0"(VMW_BALLOON_HV_MAGIC), \
154 "1"(VMW_BALLOON_CMD_##cmd), \
155 "2"(VMW_BALLOON_HV_PORT), \
158 if (VMW_BALLOON_CMD_##cmd == VMW_BALLOON_CMD_START) \
164 #ifdef CONFIG_DEBUG_FS
165 struct vmballoon_stats
{
168 /* allocation statistics */
170 unsigned int alloc_fail
;
171 unsigned int sleep_alloc
;
172 unsigned int sleep_alloc_fail
;
173 unsigned int refused_alloc
;
174 unsigned int refused_free
;
177 /* monitor operations */
179 unsigned int lock_fail
;
181 unsigned int unlock_fail
;
183 unsigned int target_fail
;
185 unsigned int start_fail
;
186 unsigned int guest_type
;
187 unsigned int guest_type_fail
;
190 #define STATS_INC(stat) (stat)++
192 #define STATS_INC(stat)
197 /* list of reserved physical pages */
198 struct list_head pages
;
200 /* transient list of non-balloonable pages */
201 struct list_head refused_pages
;
202 unsigned int n_refused_pages
;
204 /* balloon size in pages */
211 /* adjustment rates (pages per second) */
212 unsigned int rate_alloc
;
213 unsigned int rate_free
;
215 /* slowdown page allocations for next few cycles */
216 unsigned int slow_allocation_cycles
;
218 #ifdef CONFIG_DEBUG_FS
220 struct vmballoon_stats stats
;
222 /* debugfs file exporting statistics */
223 struct dentry
*dbg_entry
;
226 struct sysinfo sysinfo
;
228 struct delayed_work dwork
;
231 static struct vmballoon balloon
;
234 * Send "start" command to the host, communicating supported version
237 static bool vmballoon_send_start(struct vmballoon
*b
)
239 unsigned long status
, capabilities
;
241 STATS_INC(b
->stats
.start
);
243 status
= VMWARE_BALLOON_CMD(START
, VMW_BALLOON_CAPABILITIES
,
245 if (status
== VMW_BALLOON_SUCCESS
)
248 pr_debug("%s - failed, hv returns %ld\n", __func__
, status
);
249 STATS_INC(b
->stats
.start_fail
);
253 static bool vmballoon_check_status(struct vmballoon
*b
, unsigned long status
)
256 case VMW_BALLOON_SUCCESS
:
259 case VMW_BALLOON_ERROR_RESET
:
260 b
->reset_required
= true;
269 * Communicate guest type to the host so that it can adjust ballooning
270 * algorithm to the one most appropriate for the guest. This command
271 * is normally issued after sending "start" command and is part of
272 * standard reset sequence.
274 static bool vmballoon_send_guest_id(struct vmballoon
*b
)
276 unsigned long status
, dummy
;
278 status
= VMWARE_BALLOON_CMD(GUEST_ID
, VMW_BALLOON_GUEST_ID
, dummy
);
280 STATS_INC(b
->stats
.guest_type
);
282 if (vmballoon_check_status(b
, status
))
285 pr_debug("%s - failed, hv returns %ld\n", __func__
, status
);
286 STATS_INC(b
->stats
.guest_type_fail
);
291 * Retrieve desired balloon size from the host.
293 static bool vmballoon_send_get_target(struct vmballoon
*b
, u32
*new_target
)
295 unsigned long status
;
296 unsigned long target
;
301 * si_meminfo() is cheap. Moreover, we want to provide dynamic
302 * max balloon size later. So let us call si_meminfo() every
305 si_meminfo(&b
->sysinfo
);
306 limit
= b
->sysinfo
.totalram
;
308 /* Ensure limit fits in 32-bits */
309 limit32
= (u32
)limit
;
310 if (limit
!= limit32
)
314 STATS_INC(b
->stats
.target
);
316 status
= VMWARE_BALLOON_CMD(GET_TARGET
, limit
, target
);
317 if (vmballoon_check_status(b
, status
)) {
318 *new_target
= target
;
322 pr_debug("%s - failed, hv returns %ld\n", __func__
, status
);
323 STATS_INC(b
->stats
.target_fail
);
328 * Notify the host about allocated page so that host can use it without
329 * fear that guest will need it. Host may reject some pages, we need to
330 * check the return value and maybe submit a different page.
332 static int vmballoon_send_lock_page(struct vmballoon
*b
, unsigned long pfn
,
333 unsigned int *hv_status
)
335 unsigned long status
, dummy
;
342 STATS_INC(b
->stats
.lock
);
344 *hv_status
= status
= VMWARE_BALLOON_CMD(LOCK
, pfn
, dummy
);
345 if (vmballoon_check_status(b
, status
))
348 pr_debug("%s - ppn %lx, hv returns %ld\n", __func__
, pfn
, status
);
349 STATS_INC(b
->stats
.lock_fail
);
354 * Notify the host that guest intends to release given page back into
355 * the pool of available (to the guest) pages.
357 static bool vmballoon_send_unlock_page(struct vmballoon
*b
, unsigned long pfn
)
359 unsigned long status
, dummy
;
366 STATS_INC(b
->stats
.unlock
);
368 status
= VMWARE_BALLOON_CMD(UNLOCK
, pfn
, dummy
);
369 if (vmballoon_check_status(b
, status
))
372 pr_debug("%s - ppn %lx, hv returns %ld\n", __func__
, pfn
, status
);
373 STATS_INC(b
->stats
.unlock_fail
);
378 * Quickly release all pages allocated for the balloon. This function is
379 * called when host decides to "reset" balloon for one reason or another.
380 * Unlike normal "deflate" we do not (shall not) notify host of the pages
383 static void vmballoon_pop(struct vmballoon
*b
)
385 struct page
*page
, *next
;
386 unsigned int count
= 0;
388 list_for_each_entry_safe(page
, next
, &b
->pages
, lru
) {
389 list_del(&page
->lru
);
391 STATS_INC(b
->stats
.free
);
394 if (++count
>= b
->rate_free
) {
402 * Perform standard reset sequence by popping the balloon (in case it
403 * is not empty) and then restarting protocol. This operation normally
404 * happens when host responds with VMW_BALLOON_ERROR_RESET to a command.
406 static void vmballoon_reset(struct vmballoon
*b
)
408 /* free all pages, skipping monitor unlock */
411 if (vmballoon_send_start(b
)) {
412 b
->reset_required
= false;
413 if (!vmballoon_send_guest_id(b
))
414 pr_err("failed to send guest ID to the host\n");
419 * Notify the host of a ballooned page. If host rejects the page put it on the
420 * refuse list, those refused page are then released at the end of the
423 static int vmballoon_lock_page(struct vmballoon
*b
, struct page
*page
)
425 int locked
, hv_status
;
427 locked
= vmballoon_send_lock_page(b
, page_to_pfn(page
), &hv_status
);
429 STATS_INC(b
->stats
.refused_alloc
);
431 if (hv_status
== VMW_BALLOON_ERROR_RESET
||
432 hv_status
== VMW_BALLOON_ERROR_PPN_NOTNEEDED
) {
438 * Place page on the list of non-balloonable pages
439 * and retry allocation, unless we already accumulated
440 * too many of them, in which case take a breather.
442 if (b
->n_refused_pages
< VMW_BALLOON_MAX_REFUSED
) {
443 b
->n_refused_pages
++;
444 list_add(&page
->lru
, &b
->refused_pages
);
451 /* track allocated page */
452 list_add(&page
->lru
, &b
->pages
);
454 /* update balloon size */
461 * Release the page allocated for the balloon. Note that we first notify
462 * the host so it can make sure the page will be available for the guest
465 static int vmballoon_release_page(struct vmballoon
*b
, struct page
*page
)
467 if (!vmballoon_send_unlock_page(b
, page_to_pfn(page
)))
470 list_del(&page
->lru
);
472 /* deallocate page */
474 STATS_INC(b
->stats
.free
);
476 /* update balloon size */
483 * Release pages that were allocated while attempting to inflate the
484 * balloon but were refused by the host for one reason or another.
486 static void vmballoon_release_refused_pages(struct vmballoon
*b
)
488 struct page
*page
, *next
;
490 list_for_each_entry_safe(page
, next
, &b
->refused_pages
, lru
) {
491 list_del(&page
->lru
);
493 STATS_INC(b
->stats
.refused_free
);
496 b
->n_refused_pages
= 0;
500 * Inflate the balloon towards its target size. Note that we try to limit
501 * the rate of allocation to make sure we are not choking the rest of the
504 static void vmballoon_inflate(struct vmballoon
*b
)
509 unsigned int allocations
= 0;
511 gfp_t flags
= VMW_PAGE_ALLOC_NOSLEEP
;
513 pr_debug("%s - size: %d, target %d\n", __func__
, b
->size
, b
->target
);
516 * First try NOSLEEP page allocations to inflate balloon.
518 * If we do not throttle nosleep allocations, we can drain all
519 * free pages in the guest quickly (if the balloon target is high).
520 * As a side-effect, draining free pages helps to inform (force)
521 * the guest to start swapping if balloon target is not met yet,
522 * which is a desired behavior. However, balloon driver can consume
523 * all available CPU cycles if too many pages are allocated in a
524 * second. Therefore, we throttle nosleep allocations even when
525 * the guest is not under memory pressure. OTOH, if we have already
526 * predicted that the guest is under memory pressure, then we
527 * slowdown page allocations considerably.
530 goal
= b
->target
- b
->size
;
532 * Start with no sleep allocation rate which may be higher
533 * than sleeping allocation rate.
535 rate
= b
->slow_allocation_cycles
?
536 b
->rate_alloc
: VMW_BALLOON_NOSLEEP_ALLOC_MAX
;
538 pr_debug("%s - goal: %d, no-sleep rate: %d, sleep rate: %d\n",
539 __func__
, goal
, rate
, b
->rate_alloc
);
541 for (i
= 0; i
< goal
; i
++) {
544 if (flags
== VMW_PAGE_ALLOC_NOSLEEP
)
545 STATS_INC(b
->stats
.alloc
);
547 STATS_INC(b
->stats
.sleep_alloc
);
549 page
= alloc_page(flags
);
551 if (flags
== VMW_PAGE_ALLOC_CANSLEEP
) {
553 * CANSLEEP page allocation failed, so guest
554 * is under severe memory pressure. Quickly
555 * decrease allocation rate.
557 b
->rate_alloc
= max(b
->rate_alloc
/ 2,
558 VMW_BALLOON_RATE_ALLOC_MIN
);
559 STATS_INC(b
->stats
.sleep_alloc_fail
);
562 STATS_INC(b
->stats
.alloc_fail
);
565 * NOSLEEP page allocation failed, so the guest is
566 * under memory pressure. Let us slow down page
567 * allocations for next few cycles so that the guest
568 * gets out of memory pressure. Also, if we already
569 * allocated b->rate_alloc pages, let's pause,
570 * otherwise switch to sleeping allocations.
572 b
->slow_allocation_cycles
= VMW_BALLOON_SLOW_CYCLES
;
574 if (i
>= b
->rate_alloc
)
577 flags
= VMW_PAGE_ALLOC_CANSLEEP
;
578 /* Lower rate for sleeping allocations. */
579 rate
= b
->rate_alloc
;
583 error
= vmballoon_lock_page(b
, page
);
587 if (++allocations
> VMW_BALLOON_YIELD_THRESHOLD
) {
593 /* We allocated enough pages, let's take a break. */
599 * We reached our goal without failures so try increasing
602 if (error
== 0 && i
>= b
->rate_alloc
) {
603 unsigned int mult
= i
/ b
->rate_alloc
;
606 min(b
->rate_alloc
+ mult
* VMW_BALLOON_RATE_ALLOC_INC
,
607 VMW_BALLOON_RATE_ALLOC_MAX
);
610 vmballoon_release_refused_pages(b
);
614 * Decrease the size of the balloon allowing guest to use more memory.
616 static void vmballoon_deflate(struct vmballoon
*b
)
618 struct page
*page
, *next
;
623 pr_debug("%s - size: %d, target %d\n", __func__
, b
->size
, b
->target
);
625 /* limit deallocation rate */
626 goal
= min(b
->size
- b
->target
, b
->rate_free
);
628 pr_debug("%s - goal: %d, rate: %d\n", __func__
, goal
, b
->rate_free
);
630 /* free pages to reach target */
631 list_for_each_entry_safe(page
, next
, &b
->pages
, lru
) {
632 error
= vmballoon_release_page(b
, page
);
634 /* quickly decrease rate in case of error */
635 b
->rate_free
= max(b
->rate_free
/ 2,
636 VMW_BALLOON_RATE_FREE_MIN
);
644 /* slowly increase rate if there were no errors */
645 b
->rate_free
= min(b
->rate_free
+ VMW_BALLOON_RATE_FREE_INC
,
646 VMW_BALLOON_RATE_FREE_MAX
);
650 * Balloon work function: reset protocol, if needed, get the new size and
651 * adjust balloon as needed. Repeat in 1 sec.
653 static void vmballoon_work(struct work_struct
*work
)
655 struct delayed_work
*dwork
= to_delayed_work(work
);
656 struct vmballoon
*b
= container_of(dwork
, struct vmballoon
, dwork
);
659 STATS_INC(b
->stats
.timer
);
661 if (b
->reset_required
)
664 if (b
->slow_allocation_cycles
> 0)
665 b
->slow_allocation_cycles
--;
667 if (vmballoon_send_get_target(b
, &target
)) {
668 /* update target, adjust size */
671 if (b
->size
< target
)
672 vmballoon_inflate(b
);
673 else if (b
->size
> target
)
674 vmballoon_deflate(b
);
678 * We are using a freezable workqueue so that balloon operations are
679 * stopped while the system transitions to/from sleep/hibernation.
681 queue_delayed_work(system_freezable_wq
,
682 dwork
, round_jiffies_relative(HZ
));
688 #ifdef CONFIG_DEBUG_FS
690 static int vmballoon_debug_show(struct seq_file
*f
, void *offset
)
692 struct vmballoon
*b
= f
->private;
693 struct vmballoon_stats
*stats
= &b
->stats
;
695 /* format size info */
697 "target: %8d pages\n"
698 "current: %8d pages\n",
701 /* format rate info */
703 "rateNoSleepAlloc: %8d pages/sec\n"
704 "rateSleepAlloc: %8d pages/sec\n"
705 "rateFree: %8d pages/sec\n",
706 VMW_BALLOON_NOSLEEP_ALLOC_MAX
,
707 b
->rate_alloc
, b
->rate_free
);
712 "start: %8u (%4u failed)\n"
713 "guestType: %8u (%4u failed)\n"
714 "lock: %8u (%4u failed)\n"
715 "unlock: %8u (%4u failed)\n"
716 "target: %8u (%4u failed)\n"
717 "primNoSleepAlloc: %8u (%4u failed)\n"
718 "primCanSleepAlloc: %8u (%4u failed)\n"
723 stats
->start
, stats
->start_fail
,
724 stats
->guest_type
, stats
->guest_type_fail
,
725 stats
->lock
, stats
->lock_fail
,
726 stats
->unlock
, stats
->unlock_fail
,
727 stats
->target
, stats
->target_fail
,
728 stats
->alloc
, stats
->alloc_fail
,
729 stats
->sleep_alloc
, stats
->sleep_alloc_fail
,
731 stats
->refused_alloc
, stats
->refused_free
);
736 static int vmballoon_debug_open(struct inode
*inode
, struct file
*file
)
738 return single_open(file
, vmballoon_debug_show
, inode
->i_private
);
741 static const struct file_operations vmballoon_debug_fops
= {
742 .owner
= THIS_MODULE
,
743 .open
= vmballoon_debug_open
,
746 .release
= single_release
,
749 static int __init
vmballoon_debugfs_init(struct vmballoon
*b
)
753 b
->dbg_entry
= debugfs_create_file("vmmemctl", S_IRUGO
, NULL
, b
,
754 &vmballoon_debug_fops
);
755 if (IS_ERR(b
->dbg_entry
)) {
756 error
= PTR_ERR(b
->dbg_entry
);
757 pr_err("failed to create debugfs entry, error: %d\n", error
);
764 static void __exit
vmballoon_debugfs_exit(struct vmballoon
*b
)
766 debugfs_remove(b
->dbg_entry
);
771 static inline int vmballoon_debugfs_init(struct vmballoon
*b
)
776 static inline void vmballoon_debugfs_exit(struct vmballoon
*b
)
780 #endif /* CONFIG_DEBUG_FS */
782 static int __init
vmballoon_init(void)
787 * Check if we are running on VMware's hypervisor and bail out
790 if (x86_hyper
!= &x86_hyper_vmware
)
793 INIT_LIST_HEAD(&balloon
.pages
);
794 INIT_LIST_HEAD(&balloon
.refused_pages
);
796 /* initialize rates */
797 balloon
.rate_alloc
= VMW_BALLOON_RATE_ALLOC_MAX
;
798 balloon
.rate_free
= VMW_BALLOON_RATE_FREE_MAX
;
800 INIT_DELAYED_WORK(&balloon
.dwork
, vmballoon_work
);
805 if (!vmballoon_send_start(&balloon
)) {
806 pr_err("failed to send start command to the host\n");
810 if (!vmballoon_send_guest_id(&balloon
)) {
811 pr_err("failed to send guest ID to the host\n");
815 error
= vmballoon_debugfs_init(&balloon
);
819 queue_delayed_work(system_freezable_wq
, &balloon
.dwork
, 0);
823 module_init(vmballoon_init
);
825 static void __exit
vmballoon_exit(void)
827 cancel_delayed_work_sync(&balloon
.dwork
);
829 vmballoon_debugfs_exit(&balloon
);
832 * Deallocate all reserved memory, and reset connection with monitor.
833 * Reset connection before deallocating memory to avoid potential for
834 * additional spurious resets from guest touching deallocated pages.
836 vmballoon_send_start(&balloon
);
837 vmballoon_pop(&balloon
);
839 module_exit(vmballoon_exit
);