vmw_balloon: 64-bit limit support, compaction, shrinker
cover vmw_balloon: 64-bit limit support, compaction, shrinker
Various enhancements for VMware balloon, some of which are remainder from a previous patch-set.
Patch 1: Drop the version number
Patch 2: Adds support for 64-bit memory limit Patches 3-4: Support for compaction
Patch 5: Support for memory shrinker - disabled by default Patch 6: Split refused pages to improve performance
This is sort of a resend, since patches 2-6 have not been sent (the mail server rejected since Xavier, whose email address was deactivated, was mistakenly cc'd). Patch 1 was changed according to Greg's feedback.
Nadav Amit (5):
vmw_balloon: remove the version number
mm/balloon_compaction: list interfaces
vmw_balloon: compaction support
vmw_balloon: add memory shrinker
vmw_balloon: split refused pages
Xavier Deguillard (1):
vmw_balloon: support 64-bit memory limit
drivers/misc/Kconfig | 1 + drivers/misc/vmw_balloon.c | 510 ++++++++++++++++++++++++++--- include/linux/balloon_compaction.h | 4 + mm/balloon_compaction.c | 139 +++++--- 4 files changed, 565 insertions(+), 89 deletions(-)
Signature · 1 line
2.17.1
PATCH 1/6 vmw_balloon: remove the version number
Following the new kernel policy.
--- drivers/misc/vmw_balloon.c | 1 - 1 file changed, 1 deletion(-)
drivers/misc/vmw_balloon.c +0 -1
@@ -34,7 +34,6 @@MODULE_AUTHOR ("VMware, Inc." );MODULE_DESCRIPTION ("VMware Memory Control (Balloon) Driver" ); -MODULE_VERSION ("1.5.0.0-k" );MODULE_ALIAS ("dmi:*:svnVMware*:*" );MODULE_ALIAS ("vmware_vmmemctl" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.17.1
PATCH 3/6 mm/balloon_compaction: list interfaces
In reply to Nadav AmitIntroduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
--- include/linux/balloon_compaction.h | 4 + mm/balloon_compaction.c | 139 +++++++++++++++++++++-------- 2 files changed, 105 insertions(+), 38 deletions(-)
include/linux/balloon_compaction.h +4 -0
@@ -72,6 +72,10 @@ extern struct page *balloon_page_alloc(void);extern void balloon_page_enqueue (struct balloon_dev_info *b_dev_info,struct page *page);extern struct page *balloon_page_dequeue (struct balloon_dev_info *b_dev_info); +extern void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages); +extern int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages);static inline void balloon_devinfo_init (struct balloon_dev_info *balloon) {
mm/balloon_compaction.c +101 -38
169 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH 4/6 vmw_balloon: compaction support
In reply to Nadav AmitAdd support for compaction for VMware balloon. Since unlike the virtio balloon, we also support huge-pages, which are not going through compaction, we keep these pages in vmballoon and handle this list separately. We use the same lock to protect both lists, as this lock is not supposed to be contended.
Doing so also eliminates the need for the page_size lists. We update the accounting as needed to reflect inflation, deflation and migration to be reflected in vmstat.
Since VMware balloon now provides statistics for inflation, deflation and migration in vmstat, select MEMORY_BALLOON in Kconfig.
--- drivers/misc/Kconfig | 1 + drivers/misc/vmw_balloon.c | 301 ++++++++++++++++++++++++++++++++----- 2 files changed, 264 insertions(+), 38 deletions(-)
drivers/misc/Kconfig +1 -0
@@ -409,6 +409,7 @@ config SPEAR13XX_PCIE_GADGET config VMWARE_BALLOON tristate "VMware Balloon Driver" depends on VMWARE_VMCI && X86 && HYPERVISOR_GUEST + select MEMORY_BALLOON help This is VMware physical memory management driver which acts like a "balloon" that can be inflated to reclaim physical pages
drivers/misc/vmw_balloon.c +263 -38
392 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH 6/6 vmw_balloon: split refused pages
In reply to Nadav AmitThe hypervisor might refuse to inflate pages. While the balloon driver handles this scenario correctly, a refusal to inflate a 2MB pages might cause the same page to be allocated again later just for its inflation to be refused again. This wastes energy and time.
To avoid this situation, split the 2MB page to 4KB pages, and then try to inflate each one individually. Most of the 4KB pages out of the 2MB should be inflated successfully, and the balloon is likely to prevent the scenario of repeated refused inflation.
--- drivers/misc/vmw_balloon.c | 63 +++++++++++++++++++++++++++++++------- 1 file changed, 52 insertions(+), 11 deletions(-)
drivers/misc/vmw_balloon.c +52 -11
@@ -241,6 +241,7 @@ static DEFINE_STATIC_KEY_FALSE(balloon_stat_enabled);struct vmballoon_ctl {struct list_head pages;struct list_head refused_pages; +struct list_head prealloc_pages;unsigned int n_refused_pages;unsigned int n_pages;enum vmballoon_page_size_type page_size;
@@ -640,15 +641,25 @@ static int vmballoon_alloc_page_list(struct vmballoon *b,unsigned int i;for (i =0 ; i < req_n_pages; i++) { -if (ctl->page_size ==VMW_BALLOON_2M_PAGE ) - page =alloc_pages (__GFP_HIGHMEM|__GFP_NOWARN| +/* +* First check if we happen to have pages that were allocated +* before. This happens when 2MB page rejected during inflation +* by the hypervisor, and then split into 4KB pages. +*/ +if (!list_empty (&ctl->prealloc_pages)) { + page =list_first_entry (&ctl->prealloc_pages, + struct page, lru); +list_del (&page->lru); + }else { +if (ctl->page_size ==VMW_BALLOON_2M_PAGE ) + page =alloc_pages (__GFP_HIGHMEM|__GFP_NOWARN| __GFP_NOMEMALLOC,VMW_BALLOON_2M_ORDER ); -else - page =balloon_page_alloc (); +else + page =balloon_page_alloc (); -/* Update statistics */ -vmballoon_stats_page_inc (b,VMW_BALLOON_PAGE_STAT_ALLOC , - ctl->page_size); +vmballoon_stats_page_inc (b,VMW_BALLOON_PAGE_STAT_ALLOC , + ctl->page_size); + }if (page) {/* Success. Add the page to the list and continue. */
@@ -892,7 +903,8 @@ static void vmballoon_release_page_list(struct list_head *page_list,__free_pages (page,vmballoon_page_order (page_size)); } - *n_pages =0 ; +if (n_pages) + *n_pages =0 ; }
@@ -1024,6 +1036,32 @@ static void vmballoon_dequeue_page_list(struct vmballoon *b, *n_pages = i; } +/** +* vmballoon_split_refused_pages() - Split the 2MB refused pages to 4k. +* +* If inflation of 2MB pages was denied by the hypervisor, it is likely to be +* due to one or few 4KB pages. These 2MB pages may keep being allocated and +* then being refused. To prevent this case, this function splits the refused +* pages into 4KB pages and adds them into @prealloc_pages list. +* +* @ctl: pointer for the %struct vmballoon_ctl, which defines the operation. +*/ +static void vmballoon_split_refused_pages (struct vmballoon_ctl *ctl) +{ +struct page *page, *tmp; +unsigned int i, order; + + order =vmballoon_page_order (ctl->page_size); + +list_for_each_entry_safe (page, tmp, &ctl->refused_pages, lru) { +list_del (&page->lru); +split_page (page, order); +for (i =0 ; i < (1 << order); i++) +list_add (&page[i].lru, &ctl->prealloc_pages); + } + ctl->n_refused_pages =0 ; +} +/** * vmballoon_inflate() - Inflate the balloon towards its target size. *
@@ -1035,6 +1073,7 @@ static void vmballoon_inflate(struct vmballoon *b)struct vmballoon_ctl ctl = { .pages =LIST_HEAD_INIT (ctl.pages), .refused_pages =LIST_HEAD_INIT (ctl.refused_pages), + .prealloc_pages =LIST_HEAD_INIT (ctl.prealloc_pages), .page_size = b->max_page_size, .op =VMW_BALLOON_INFLATE };
@@ -1082,10 +1121,10 @@ static void vmballoon_inflate(struct vmballoon *b)break ;/* -* Ignore errors from locking as we now switch to 4k -* pages and we might get different errors. +* Split the refused pages to 4k. This will also empty +* the refused pages list. */ -vmballoon_release_refused_pages (b, &ctl); +vmballoon_split_refused_pages (&ctl); ctl.page_size--; }
@@ -1099,6 +1138,8 @@ static void vmballoon_inflate(struct vmballoon *b)*/ if (ctl.n_refused_pages !=0 )vmballoon_release_refused_pages (b, &ctl); + +vmballoon_release_page_list (&ctl.prealloc_pages,NULL , ctl.page_size); }/**
Signature · 1 line
2.17.1
PATCH 5/6 vmw_balloon: add memory shrinker
In reply to Nadav AmitAdd a shrinker to the VMware balloon to prevent out-of-memory events. We reuse the deflate logic for this matter. Deadlocks should not happen, as no memory allocation is performed while the locks of the communication (batch/page) and page-list are taken. In the unlikely event in which the configuration semaphore is taken for write we bail out and fail gracefully (causing processes to be killed).
Once the shrinker is called, inflation is postponed for few seconds. The timeout is updated without any lock, but this should not cause any races, as it is written and read atomically.
This feature is disabled by default, since it might cause performance degradation.
--- drivers/misc/vmw_balloon.c | 135 ++++++++++++++++++++++++++++++++++++- 1 file changed, 133 insertions(+), 2 deletions(-)
drivers/misc/vmw_balloon.c +133 -2
@@ -40,6 +40,17 @@ MODULE_ALIAS("dmi:*:svnVMware*:*");MODULE_ALIAS ("vmware_vmmemctl" );MODULE_LICENSE ("GPL" ); +bool __read_mostly vmwballoon_shrinker_enable; +module_param (vmwballoon_shrinker_enable, bool,0444 ); +MODULE_PARM_DESC (vmwballoon_shrinker_enable, +"Enable non-cooperative out-of-memory protection. This feature " +"is disabled by default as it might negatively impact " +"performance." ); + +/* Delay in seconds after shrink before inflation. */ +#define VMBALLOON_SHRINK_DELAY (5) + +/* Maximum number of refused pages we accumulate during inflation cycle */ #define VMW_BALLOON_MAX_REFUSED 16/* Magic number for the balloon mount-point */
@@ -217,12 +228,13 @@ enum vmballoon_stat_general {VMW_BALLOON_STAT_TIMER ,VMW_BALLOON_STAT_DOORBELL ,VMW_BALLOON_STAT_RESET , - VMW_BALLOON_STAT_LAST = VMW_BALLOON_STAT_RESET +VMW_BALLOON_STAT_SHRINK , +VMW_BALLOON_STAT_SHRINK_FREE , + VMW_BALLOON_STAT_LAST = VMW_BALLOON_STAT_SHRINK_FREE };#define VMW_BALLOON_STAT_NUM (VMW_BALLOON_STAT_LAST + 1) -static DEFINE_STATIC_KEY_TRUE (vmw_balloon_batching);static DEFINE_STATIC_KEY_FALSE (balloon_stat_enabled);
@@ -321,6 +333,15 @@ struct vmballoon {*/ struct page *page; +/** +* @shrink_timeout: timeout until the next inflation. +* +* After an shrink event, indicates the time in jiffies after which +* inflation is allowed again. Can be written concurrently with reads, +* so must use READ_ONCE/WRITE_ONCE when accessing. +*/ +unsigned long shrink_timeout; +/* statistics */ struct vmballoon_stats *stats;
@@ -361,6 +382,20 @@ struct vmballoon {* Lock ordering: @conf_sem -> @comm_lock . */ spinlock_t comm_lock; + +/** +* @shrinker: shrinker interface that is used to avoid over-inflation. +*/ +struct shrinker shrinker; + +/** +* @shrinker_registered: whether the shrinker was registered. +* +* The shrinker interface does not handle gracefully the removal of +* shrinker that was not registered before. This indication allows to +* simplify the unregistration process. +*/ +bool shrinker_registered; };static struct vmballoon balloon;
@@ -903,6 +938,10 @@ static int64_t vmballoon_change(struct vmballoon *b) size - target < vmballoon_page_in_frames(VMW_BALLOON_2M_PAGE))return 0 ; +/* If an out-of-memory recently occurred, inflation is disallowed. */ +if (target > size &&time_before (jiffies,READ_ONCE (b->shrink_timeout))) +return 0 ; +return target - size; }
@@ -1397,6 +1436,90 @@ static void vmballoon_work(struct work_struct *work) } +/** +* vmballoon_shrinker_scan() - deflate the balloon due to memory pressure. +* @shrinker: pointer to the balloon shrinker. +* @sc: page reclaim information. +* +* Returns: number of pages that were freed during deflation. +*/ +static unsigned long vmballoon_shrinker_scan (struct shrinker *shrinker, +struct shrink_control *sc) +{ +struct vmballoon *b = &balloon; +unsigned long deflated_frames; + +pr_debug ("%s - size: %llu" , __func__,atomic64_read (&b->size)); + +vmballoon_stats_gen_inc (b,VMW_BALLOON_STAT_SHRINK ); + +/* +* If the lock is also contended for read, we cannot easily reclaim and +* we bail out. +*/ +if (!down_read_trylock (&b->conf_sem)) +return 0 ; + + deflated_frames =vmballoon_deflate (b, sc->nr_to_scan, true); + +vmballoon_stats_gen_add (b,VMW_BALLOON_STAT_SHRINK_FREE , + deflated_frames); + +/* +* Delay future inflation for some time to mitigate the situations in +* which balloon continuously grows and shrinks. Use WRITE_ONCE() since +* the access is asynchronous. +*/ +WRITE_ONCE (b->shrink_timeout, jiffies +HZ *VMBALLOON_SHRINK_DELAY ); + +up_read (&b->conf_sem); + +return deflated_frames; +} + +/** +* vmballoon_shrinker_count() - return the number of ballooned pages. +* @shrinker: pointer to the balloon shrinker. +* @sc: page reclaim information. +* +* Returns: number of 4k pages that are allocated for the balloon and can +* therefore be reclaimed under pressure. +*/ +static unsigned long vmballoon_shrinker_count (struct shrinker *shrinker, +struct shrink_control *sc) +{ +struct vmballoon *b = &balloon; + +return atomic64_read (&b->size); +} + +static void vmballoon_unregister_shrinker (struct vmballoon *b) +{ +if (b->shrinker_registered) +unregister_shrinker (&b->shrinker); + b->shrinker_registered = false; +} + +static int vmballoon_register_shrinker (struct vmballoon *b) +{ +int r; + +/* Do nothing if the shrinker is not enabled */ +if (!vmwballoon_shrinker_enable) +return 0 ; + + b->shrinker.scan_objects = vmballoon_shrinker_scan; + b->shrinker.count_objects = vmballoon_shrinker_count; + b->shrinker.seeks =DEFAULT_SEEKS ; + + r =register_shrinker (&b->shrinker); + +if (r ==0 ) + b->shrinker_registered = true; + +return r; +} +/* * DEBUGFS Interface */
@@ -1414,6 +1537,8 @@ static const char * const vmballoon_stat_names[] = { [VMW_BALLOON_STAT_TIMER] = "timer", [VMW_BALLOON_STAT_DOORBELL] = "doorbell", [VMW_BALLOON_STAT_RESET] = "reset", + [VMW_BALLOON_STAT_SHRINK] = "shrink", + [VMW_BALLOON_STAT_SHRINK_FREE] = "shrinkFree" };static int vmballoon_enable_stats (struct vmballoon *b)
@@ -1747,6 +1872,10 @@ static int __init vmballoon_init(void)INIT_DELAYED_WORK (&balloon.dwork, vmballoon_work); + error =vmballoon_register_shrinker (&balloon); +if (error) + goto fail; + error =vmballoon_debugfs_init (&balloon);if (error) goto fail;
@@ -1772,6 +1901,7 @@ static int __init vmballoon_init(void)return 0 ; fail: +vmballoon_unregister_shrinker (&balloon);vmballoon_compaction_deinit (&balloon);return error; }
@@ -1786,6 +1916,7 @@ late_initcall(vmballoon_init); static void __exit vmballoon_exit(void) { +vmballoon_unregister_shrinker (&balloon);vmballoon_vmci_cleanup (&balloon);cancel_delayed_work_sync (&balloon.dwork);
Signature · 1 line
2.17.1
PATCH 2/6 vmw_balloon: support 64-bit memory limit
In reply to Nadav AmitFrom: Xavier Deguillard <[email protected]>
Currently, the balloon driver would fail to run if memory is greater than 16TB of vRAM. Previous patches have already converted the balloon target and size to 64-bit, so all that is left to do add is to avoid asserting memory is smaller than 16TB if the hypervisor supports 64-bits target.
The driver advertises a new capability VMW_BALLOON_64_BITS_TARGET. Hypervisors that support 16TB of memory or more will report that this capability is enabled.
--- drivers/misc/vmw_balloon.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-)
drivers/misc/vmw_balloon.c +15 -3
@@ -72,15 +72,26 @@ enum vmwballoon_capabilities {VMW_BALLOON_BATCHED_CMDS = (1 <<2 ),VMW_BALLOON_BATCHED_2M_CMDS = (1 <<3 ),VMW_BALLOON_SIGNALLED_WAKEUP_CMD = (1 <<4 ), +VMW_BALLOON_64_BIT_TARGET = (1 <<5 ) }; -#define VMW_BALLOON_CAPABILITIES (VMW_BALLOON_BASIC_CMDS \ +#define VMW_BALLOON_CAPABILITIES_COMMON (VMW_BALLOON_BASIC_CMDS \ | VMW_BALLOON_BATCHED_CMDS \ | VMW_BALLOON_BATCHED_2M_CMDS \ | VMW_BALLOON_SIGNALLED_WAKEUP_CMD)#define VMW_BALLOON_2M_ORDER (PMD_SHIFT - PAGE_SHIFT) +/* +* 64-bit targets are only supported in 64-bit +*/ +#ifdef CONFIG_64BIT +#define VMW_BALLOON_CAPABILITIES (VMW_BALLOON_CAPABILITIES_COMMON \ + | VMW_BALLOON_64_BIT_TARGET) +#else +#define VMW_BALLOON_CAPABILITIES VMW_BALLOON_CAPABILITIES_COMMON +#endif +enum vmballoon_page_size_type {VMW_BALLOON_4K_PAGE , VMW_BALLOON_2M_PAGE,
@@ -571,8 +582,9 @@ static int vmballoon_send_get_target(struct vmballoon *b) limit =totalram_pages (); -/* Ensure limit fits in 32-bits */ -if (limit != (u32 )limit) +/* Ensure limit fits in 32-bits if 64-bit targets are not supported */ +if (!(b->capabilities &VMW_BALLOON_64_BIT_TARGET ) && + limit != (u32 )limit)return -EINVAL ; status =vmballoon_cmd (b,VMW_BALLOON_CMD_GET_TARGET , limit,0 );
Signature · 1 line
2.17.1
Michael S. Tsirkin
maintainerRe: [PATCH 3/6] mm/balloon_compaction: list interfaces
In reply to Nadav AmitQuoted 67 lines · Nadav Amit
Introduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
Cc "Michael S. Tsirkin" <[email protected]>Cc Jason Wang <[email protected]>Reviewed-by Xavier Deguillard <[email protected]>Signed-off-by Nadav Amit <[email protected]>--- include/linux/balloon_compaction.h | 4 + mm/balloon_compaction.c | 139 +++++++++++++++++++++-------- 2 files changed, 105 insertions(+), 38 deletions(-)include/linux/balloon_compaction.h +4
-0@@ -72,6 +72,10 @@ extern struct page *balloon_page_alloc(void);extern void balloon_page_enqueue (struct balloon_dev_info *b_dev_info,struct page *page);extern struct page *balloon_page_dequeue (struct balloon_dev_info *b_dev_info); +extern void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages); +extern int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages);static inline void balloon_devinfo_init (struct balloon_dev_info *balloon) {mm/balloon_compaction.c +28
-0@@ -10,6 +10,100 @@#include <linux/export.h> #include <linux/balloon_compaction.h> +static int balloon_page_enqueue_one (struct balloon_dev_info *b_dev_info, +struct page *page) +{ +/* +* Block others from accessing the 'page' when we get around to +* establishing additional references. We should be the only one +* holding a reference to the 'page' at this point. +*/ +if (!trylock_page (page)) { +WARN_ONCE (1 ,"balloon inflation failed to enqueue page\n" ); +return -EFAULT ; + } +list_del (&page->lru); +balloon_page_insert (b_dev_info, page); +unlock_page (page); +__count_vm_event (BALLOON_INFLATE ); +return 0 ; +} + +/** +* balloon_page_list_enqueue() - inserts a list of pages into the balloon page +* list. +* @b_dev_info: balloon device descriptor where we will insert a new page to +* @pages: pages to enqueue - allocated using balloon_page_alloc. +* +* Driver must call it to properly enqueue a balloon pages before definitively +* removing it from the guest system. +*/
mm/balloon_compaction.c line 50
Quoted 10 lines
mm/balloon_compaction.c +10
-0+void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages) +{ +struct page *page, *tmp; +unsigned long flags; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, pages, lru) +balloon_page_enqueue_one (b_dev_info, page); +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags);
As this is scanning pages one by one anyway, it will be useful to have this return the # of pages enqueued.
Quoted 12 lines
mm/balloon_compaction.c +12
-0+} +EXPORT_SYMBOL_GPL (balloon_page_list_enqueue); + +/** +* balloon_page_list_dequeue() - removes pages from balloon's page list and +* returns a list of the pages. +* @b_dev_info: balloon device decriptor where we will grab a page from. +* @pages: pointer to the list of pages that would be returned to the caller. +* @n_req_pages: number of requested pages. +* +* Driver must call it to properly de-allocate a previous enlisted balloon pages +* before definetively releasing it back to the guest system. This function
mm/balloon_compaction.c line 72
Quoted 10 lines
mm/balloon_compaction.c +10
-0+* tries to remove @n_req_pages from the ballooned pages and return it to the +* caller in the @pages list. +* +* Note that this function may fail to dequeue some pages temporarily empty due +* to compaction isolated pages. +* +* Return: number of pages that were added to the @pages list. +*/ +int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages)
Are we sure this int never overflows? Why not just use u64 or size_t straight away?
Quoted 24 lines
mm/balloon_compaction.c +24
-0+{ +struct page *page, *tmp; +unsigned long flags; +int n_pages =0 ; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { +/* +* Block others from accessing the 'page' while we get around +* establishing additional references and preparing the 'page' +* to be released by the balloon driver. +*/ +if (!trylock_page (page)) +continue ; + +if (IS_ENABLED (CONFIG_BALLOON_COMPACTION ) && +PageIsolated (page)) { +/* raced with isolation */ +unlock_page (page); +continue ; + } +balloon_page_delete (page); +__count_vm_event (BALLOON_DEFLATE ); +unlock_page (page);
mm/balloon_compaction.c line 106
Quoted 10 lines
mm/balloon_compaction.c +10
-0+list_add (&page->lru, pages); +if (++n_pages >= n_req_pages) +break ; + } +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + +return n_pages; +} +EXPORT_SYMBOL_GPL (balloon_page_list_dequeue); +
This looks quite reasonable. In fact virtio can be reworked to use this too and then the original one can be dropped.
Have the time?
Quoted 77 lines
mm/balloon_compaction.c +7
-38/* * balloon_page_alloc - allocates a new page for insertion into the balloon * page list. @@ -43,17 +137,9 @@ void balloon_page_enqueue(struct balloon_dev_info *b_dev_info, {unsigned long flags; -/* -* Block others from accessing the 'page' when we get around to -* establishing additional references. We should be the only one -* holding a reference to the 'page' at this point. -*/ -BUG_ON (!trylock_page (page));spin_lock_irqsave (&b_dev_info->pages_lock, flags); -balloon_page_insert (b_dev_info, page); -__count_vm_event (BALLOON_INFLATE ); +balloon_page_enqueue_one (b_dev_info, page);spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); -unlock_page (page); }EXPORT_SYMBOL_GPL (balloon_page_enqueue);@@ -70,36 +156,13 @@ EXPORT_SYMBOL_GPL(balloon_page_enqueue);*/ struct page *balloon_page_dequeue (struct balloon_dev_info *b_dev_info) { -struct page *page, *tmp;unsigned long flags; -bool dequeued_page; +LIST_HEAD (pages); +int n_pages; - dequeued_page = false; -spin_lock_irqsave (&b_dev_info->pages_lock, flags); -list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { -/* -* Block others from accessing the 'page' while we get around -* establishing additional references and preparing the 'page' -* to be released by the balloon driver. -*/ -if (trylock_page (page)) { -#ifdef CONFIG_BALLOON_COMPACTION -if (PageIsolated (page)) { -/* raced with isolation */ -unlock_page (page); -continue ; - } -#endif -balloon_page_delete (page); -__count_vm_event (BALLOON_DEFLATE ); -unlock_page (page); - dequeued_page = true; -break ; - } - } -spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + n_pages =balloon_page_list_dequeue (b_dev_info, &pages,1 ); -if (!dequeued_page) { +if (n_pages !=1 ) {/* * If we are unable to dequeue a balloon page because the page * list is empty and there is no isolated pages, then something @@ -112,9 +175,9 @@ struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info) !b_dev_info->isolated_pages))BUG ();spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); - page =NULL ; +return NULL ; } -return page; + return list_first_entry(&pages, struct page, lru); }EXPORT_SYMBOL_GPL (balloon_page_dequeue);Signature · 1 line
2.17.1
Michael S. Tsirkin
maintainerRe: [PATCH 3/6] mm/balloon_compaction: list interfaces
In reply to Nadav AmitQuoted 67 lines · Nadav Amit
Introduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
Cc "Michael S. Tsirkin" <[email protected]>Cc Jason Wang <[email protected]>Reviewed-by Xavier Deguillard <[email protected]>Signed-off-by Nadav Amit <[email protected]>--- include/linux/balloon_compaction.h | 4 + mm/balloon_compaction.c | 139 +++++++++++++++++++++-------- 2 files changed, 105 insertions(+), 38 deletions(-)include/linux/balloon_compaction.h +4
-0@@ -72,6 +72,10 @@ extern struct page *balloon_page_alloc(void);extern void balloon_page_enqueue (struct balloon_dev_info *b_dev_info,struct page *page);extern struct page *balloon_page_dequeue (struct balloon_dev_info *b_dev_info); +extern void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages); +extern int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages);static inline void balloon_devinfo_init (struct balloon_dev_info *balloon) {mm/balloon_compaction.c +28
-0@@ -10,6 +10,100 @@#include <linux/export.h> #include <linux/balloon_compaction.h> +static int balloon_page_enqueue_one (struct balloon_dev_info *b_dev_info, +struct page *page) +{ +/* +* Block others from accessing the 'page' when we get around to +* establishing additional references. We should be the only one +* holding a reference to the 'page' at this point. +*/ +if (!trylock_page (page)) { +WARN_ONCE (1 ,"balloon inflation failed to enqueue page\n" ); +return -EFAULT ; + } +list_del (&page->lru); +balloon_page_insert (b_dev_info, page); +unlock_page (page); +__count_vm_event (BALLOON_INFLATE ); +return 0 ; +} + +/** +* balloon_page_list_enqueue() - inserts a list of pages into the balloon page +* list. +* @b_dev_info: balloon device descriptor where we will insert a new page to +* @pages: pages to enqueue - allocated using balloon_page_alloc. +* +* Driver must call it to properly enqueue a balloon pages before definitively +* removing it from the guest system. +*/
mm/balloon_compaction.c line 50
Quoted 10 lines
mm/balloon_compaction.c +10
-0+void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages) +{ +struct page *page, *tmp; +unsigned long flags; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, pages, lru) +balloon_page_enqueue_one (b_dev_info, page); +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags);
As this is scanning pages one by one anyway, it will be useful to have this return the # of pages enqueued.
Quoted 12 lines
mm/balloon_compaction.c +12
-0+} +EXPORT_SYMBOL_GPL (balloon_page_list_enqueue); + +/** +* balloon_page_list_dequeue() - removes pages from balloon's page list and +* returns a list of the pages. +* @b_dev_info: balloon device decriptor where we will grab a page from. +* @pages: pointer to the list of pages that would be returned to the caller. +* @n_req_pages: number of requested pages. +* +* Driver must call it to properly de-allocate a previous enlisted balloon pages +* before definetively releasing it back to the guest system. This function
mm/balloon_compaction.c line 72
Quoted 10 lines
mm/balloon_compaction.c +10
-0+* tries to remove @n_req_pages from the ballooned pages and return it to the +* caller in the @pages list. +* +* Note that this function may fail to dequeue some pages temporarily empty due +* to compaction isolated pages. +* +* Return: number of pages that were added to the @pages list. +*/ +int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages)
Are we sure this int never overflows? Why not just use u64 or size_t straight away?
Quoted 24 lines
mm/balloon_compaction.c +24
-0+{ +struct page *page, *tmp; +unsigned long flags; +int n_pages =0 ; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { +/* +* Block others from accessing the 'page' while we get around +* establishing additional references and preparing the 'page' +* to be released by the balloon driver. +*/ +if (!trylock_page (page)) +continue ; + +if (IS_ENABLED (CONFIG_BALLOON_COMPACTION ) && +PageIsolated (page)) { +/* raced with isolation */ +unlock_page (page); +continue ; + } +balloon_page_delete (page); +__count_vm_event (BALLOON_DEFLATE ); +unlock_page (page);
mm/balloon_compaction.c line 106
Quoted 10 lines
mm/balloon_compaction.c +10
-0+list_add (&page->lru, pages); +if (++n_pages >= n_req_pages) +break ; + } +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + +return n_pages; +} +EXPORT_SYMBOL_GPL (balloon_page_list_dequeue); +
This looks quite reasonable. In fact virtio can be reworked to use this too and then the original one can be dropped.
Have the time?
Quoted 77 lines
mm/balloon_compaction.c +7
-38/* * balloon_page_alloc - allocates a new page for insertion into the balloon * page list. @@ -43,17 +137,9 @@ void balloon_page_enqueue(struct balloon_dev_info *b_dev_info, {unsigned long flags; -/* -* Block others from accessing the 'page' when we get around to -* establishing additional references. We should be the only one -* holding a reference to the 'page' at this point. -*/ -BUG_ON (!trylock_page (page));spin_lock_irqsave (&b_dev_info->pages_lock, flags); -balloon_page_insert (b_dev_info, page); -__count_vm_event (BALLOON_INFLATE ); +balloon_page_enqueue_one (b_dev_info, page);spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); -unlock_page (page); }EXPORT_SYMBOL_GPL (balloon_page_enqueue);@@ -70,36 +156,13 @@ EXPORT_SYMBOL_GPL(balloon_page_enqueue);*/ struct page *balloon_page_dequeue (struct balloon_dev_info *b_dev_info) { -struct page *page, *tmp;unsigned long flags; -bool dequeued_page; +LIST_HEAD (pages); +int n_pages; - dequeued_page = false; -spin_lock_irqsave (&b_dev_info->pages_lock, flags); -list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { -/* -* Block others from accessing the 'page' while we get around -* establishing additional references and preparing the 'page' -* to be released by the balloon driver. -*/ -if (trylock_page (page)) { -#ifdef CONFIG_BALLOON_COMPACTION -if (PageIsolated (page)) { -/* raced with isolation */ -unlock_page (page); -continue ; - } -#endif -balloon_page_delete (page); -__count_vm_event (BALLOON_DEFLATE ); -unlock_page (page); - dequeued_page = true; -break ; - } - } -spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + n_pages =balloon_page_list_dequeue (b_dev_info, &pages,1 ); -if (!dequeued_page) { +if (n_pages !=1 ) {/* * If we are unable to dequeue a balloon page because the page * list is empty and there is no isolated pages, then something @@ -112,9 +175,9 @@ struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info) !b_dev_info->isolated_pages))BUG ();spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); - page =NULL ; +return NULL ; } -return page; + return list_first_entry(&pages, struct page, lru); }EXPORT_SYMBOL_GPL (balloon_page_dequeue);Signature · 1 line
2.17.1
Re: [PATCH 3/6] mm/balloon_compaction: list interfaces
Quoted 8 lines · Michael S. Tsirkin
Quoted 5 lines · Nadav Amit
Introduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
[Snip]
First, thanks for the quick feedback.
Quoted 15 lines
Quoted 15 lines
mm/balloon_compaction.c +15
-0+ +/** +* balloon_page_list_enqueue() - inserts a list of pages into the balloon page +* list. +* @b_dev_info: balloon device descriptor where we will insert a new page to +* @pages: pages to enqueue - allocated using balloon_page_alloc. +* +* Driver must call it to properly enqueue a balloon pages before definitively +* removing it from the guest system. +*/ +void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages) +{ +struct page *page, *tmp; +unsigned long flags;
Quoted 8 lines
mm/balloon_compaction.c line 50
Quoted 5 lines
mm/balloon_compaction.c +5
-0+ +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, pages, lru) +balloon_page_enqueue_one (b_dev_info, page); +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags);As this is scanning pages one by one anyway, it will be useful to have this return the # of pages enqueued.
Sure.
Quoted 18 lines
Quoted 18 lines
mm/balloon_compaction.c +17
-0+} +EXPORT_SYMBOL_GPL (balloon_page_list_enqueue); + +/** +* balloon_page_list_dequeue() - removes pages from balloon's page list and +* returns a list of the pages. +* @b_dev_info: balloon device decriptor where we will grab a page from. +* @pages: pointer to the list of pages that would be returned to the caller. +* @n_req_pages: number of requested pages. +* +* Driver must call it to properly de-allocate a previous enlisted balloon pages +* before definetively releasing it back to the guest system. This function +* tries to remove @n_req_pages from the ballooned pages and return it to the +* caller in the @pages list. +* +* Note that this function may fail to dequeue some pages temporarily empty due +* to compaction isolated pages.
Quoted 8 lines
mm/balloon_compaction.c line 72
Quoted 5 lines
+ *
+ * Return: number of pages that were added to the @pages list.
+ */mm/balloon_compaction.c +2
-0+int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages)Are we sure this int never overflows? Why not just use u64 or
size_tstraight away?
size_t it is.
Quoted 39 lines
Quoted 25 lines
mm/balloon_compaction.c +24
-0+{ +struct page *page, *tmp; +unsigned long flags; +int n_pages =0 ; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { +/* +* Block others from accessing the 'page' while we get around +* establishing additional references and preparing the 'page' +* to be released by the balloon driver. +*/ +if (!trylock_page (page)) +continue ; + +if (IS_ENABLED (CONFIG_BALLOON_COMPACTION ) && +PageIsolated (page)) { +/* raced with isolation */ +unlock_page (page); +continue ; + } +balloon_page_delete (page); +__count_vm_event (BALLOON_DEFLATE ); +unlock_page (page);mm/balloon_compaction.c line 106
Quoted 10 lines
mm/balloon_compaction.c +10
-0+list_add (&page->lru, pages); +if (++n_pages >= n_req_pages) +break ; + } +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + +return n_pages; +} +EXPORT_SYMBOL_GPL (balloon_page_list_dequeue); +This looks quite reasonable. In fact virtio can be reworked to use this too and then the original one can be dropped.
Quoted 1 line
Have the time?
Obviously not, but I am willing to make the time. What I cannot “make" is an approval to send patches for other hypervisors. Let me run a quick check with our FOSS people here.
Anyhow, I hope it would not prevent the patches from getting to the next release.
Michael S. Tsirkin
maintainerRe: [PATCH 3/6] mm/balloon_compaction: list interfaces
Quoted 107 lines · Nadav Amit
Quoted 8 lines · Michael S. Tsirkin
Quoted 5 lines · Nadav Amit
Introduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
[Snip]
First, thanks for the quick feedback.
Quoted 15 lines
Quoted 15 lines
mm/balloon_compaction.c +15
-0+ +/** +* balloon_page_list_enqueue() - inserts a list of pages into the balloon page +* list. +* @b_dev_info: balloon device descriptor where we will insert a new page to +* @pages: pages to enqueue - allocated using balloon_page_alloc. +* +* Driver must call it to properly enqueue a balloon pages before definitively +* removing it from the guest system. +*/ +void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages) +{ +struct page *page, *tmp; +unsigned long flags;Quoted 8 lines
mm/balloon_compaction.c line 50
Quoted 5 lines
mm/balloon_compaction.c +5
-0+ +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, pages, lru) +balloon_page_enqueue_one (b_dev_info, page); +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags);As this is scanning pages one by one anyway, it will be useful to have this return the # of pages enqueued.
Sure.
Quoted 18 lines
Quoted 18 lines
mm/balloon_compaction.c +17
-0+} +EXPORT_SYMBOL_GPL (balloon_page_list_enqueue); + +/** +* balloon_page_list_dequeue() - removes pages from balloon's page list and +* returns a list of the pages. +* @b_dev_info: balloon device decriptor where we will grab a page from. +* @pages: pointer to the list of pages that would be returned to the caller. +* @n_req_pages: number of requested pages. +* +* Driver must call it to properly de-allocate a previous enlisted balloon pages +* before definetively releasing it back to the guest system. This function +* tries to remove @n_req_pages from the ballooned pages and return it to the +* caller in the @pages list. +* +* Note that this function may fail to dequeue some pages temporarily empty due +* to compaction isolated pages. Quoted 8 lines
mm/balloon_compaction.c line 72
Quoted 5 lines
+ *
+ * Return: number of pages that were added to the @pages list.
+ */mm/balloon_compaction.c +2
-0+int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages)Are we sure this int never overflows? Why not just use u64 or
size_tstraight away?
size_tit is.Quoted 39 lines
Quoted 25 lines
mm/balloon_compaction.c +24
-0+{ +struct page *page, *tmp; +unsigned long flags; +int n_pages =0 ; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { +/* +* Block others from accessing the 'page' while we get around +* establishing additional references and preparing the 'page' +* to be released by the balloon driver. +*/ +if (!trylock_page (page)) +continue ; + +if (IS_ENABLED (CONFIG_BALLOON_COMPACTION ) && +PageIsolated (page)) { +/* raced with isolation */ +unlock_page (page); +continue ; + } +balloon_page_delete (page); +__count_vm_event (BALLOON_DEFLATE ); +unlock_page (page);mm/balloon_compaction.c line 106
Quoted 10 lines
mm/balloon_compaction.c +10
-0+list_add (&page->lru, pages); +if (++n_pages >= n_req_pages) +break ; + } +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + +return n_pages; +} +EXPORT_SYMBOL_GPL (balloon_page_list_dequeue); +This looks quite reasonable. In fact virtio can be reworked to use this too and then the original one can be dropped.
Quoted 9 lines
Quoted 1 line
Have the time?
Obviously not, but I am willing to make the time. What I cannot “make" is an approval to send patches for other hypervisors. Let me run a quick check with our FOSS people here.
Anyhow, I hope it would not prevent the patches from getting to the next release.
No, that's not a blocker.
Signature · 5 lines
MST _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Michael S. Tsirkin
maintainerRe: [PATCH 3/6] mm/balloon_compaction: list interfaces
In reply to Nadav AmitQuoted 107 lines · Nadav Amit
Quoted 8 lines · Michael S. Tsirkin
Quoted 5 lines · Nadav Amit
Introduce interfaces for ballooning enqueueing and dequeueing of a list of pages. These interfaces reduce the overhead of storing and restoring IRQs by batching the operations. In addition they do not panic if the list of pages is empty.
[Snip]
First, thanks for the quick feedback.
Quoted 15 lines
Quoted 15 lines
mm/balloon_compaction.c +15
-0+ +/** +* balloon_page_list_enqueue() - inserts a list of pages into the balloon page +* list. +* @b_dev_info: balloon device descriptor where we will insert a new page to +* @pages: pages to enqueue - allocated using balloon_page_alloc. +* +* Driver must call it to properly enqueue a balloon pages before definitively +* removing it from the guest system. +*/ +void balloon_page_list_enqueue (struct balloon_dev_info *b_dev_info, +struct list_head *pages) +{ +struct page *page, *tmp; +unsigned long flags;Quoted 8 lines
mm/balloon_compaction.c line 50
Quoted 5 lines
mm/balloon_compaction.c +5
-0+ +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, pages, lru) +balloon_page_enqueue_one (b_dev_info, page); +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags);As this is scanning pages one by one anyway, it will be useful to have this return the # of pages enqueued.
Sure.
Quoted 18 lines
Quoted 18 lines
mm/balloon_compaction.c +17
-0+} +EXPORT_SYMBOL_GPL (balloon_page_list_enqueue); + +/** +* balloon_page_list_dequeue() - removes pages from balloon's page list and +* returns a list of the pages. +* @b_dev_info: balloon device decriptor where we will grab a page from. +* @pages: pointer to the list of pages that would be returned to the caller. +* @n_req_pages: number of requested pages. +* +* Driver must call it to properly de-allocate a previous enlisted balloon pages +* before definetively releasing it back to the guest system. This function +* tries to remove @n_req_pages from the ballooned pages and return it to the +* caller in the @pages list. +* +* Note that this function may fail to dequeue some pages temporarily empty due +* to compaction isolated pages. Quoted 8 lines
mm/balloon_compaction.c line 72
Quoted 5 lines
+ *
+ * Return: number of pages that were added to the @pages list.
+ */mm/balloon_compaction.c +2
-0+int balloon_page_list_dequeue (struct balloon_dev_info *b_dev_info, +struct list_head *pages,int n_req_pages)Are we sure this int never overflows? Why not just use u64 or
size_tstraight away?
size_tit is.Quoted 39 lines
Quoted 25 lines
mm/balloon_compaction.c +24
-0+{ +struct page *page, *tmp; +unsigned long flags; +int n_pages =0 ; + +spin_lock_irqsave (&b_dev_info->pages_lock, flags); +list_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) { +/* +* Block others from accessing the 'page' while we get around +* establishing additional references and preparing the 'page' +* to be released by the balloon driver. +*/ +if (!trylock_page (page)) +continue ; + +if (IS_ENABLED (CONFIG_BALLOON_COMPACTION ) && +PageIsolated (page)) { +/* raced with isolation */ +unlock_page (page); +continue ; + } +balloon_page_delete (page); +__count_vm_event (BALLOON_DEFLATE ); +unlock_page (page);mm/balloon_compaction.c line 106
Quoted 10 lines
mm/balloon_compaction.c +10
-0+list_add (&page->lru, pages); +if (++n_pages >= n_req_pages) +break ; + } +spin_unlock_irqrestore (&b_dev_info->pages_lock, flags); + +return n_pages; +} +EXPORT_SYMBOL_GPL (balloon_page_list_dequeue); +This looks quite reasonable. In fact virtio can be reworked to use this too and then the original one can be dropped.
Quoted 9 lines
Quoted 1 line
Have the time?
Obviously not, but I am willing to make the time. What I cannot “make" is an approval to send patches for other hypervisors. Let me run a quick check with our FOSS people here.
Anyhow, I hope it would not prevent the patches from getting to the next release.
No, that's not a blocker.
Signature · 1 line
MST
Greg Kroah-Hartman
maintainerRe: [PATCH 2/6] vmw_balloon: support 64-bit memory limit
In reply to Nadav AmitQuoted 23 lines · Nadav Amit
From: Xavier Deguillard <[email protected]>
Currently, the balloon driver would fail to run if memory is greater than 16TB of vRAM. Previous patches have already converted the balloon target and size to 64-bit, so all that is left to do add is to avoid asserting memory is smaller than 16TB if the hypervisor supports 64-bits target.
The driver advertises a new capability
VMW_BALLOON_64_BITS_TARGET. Hypervisors that support 16TB of memory or more will report that this capability is enabled.Signed-off-by Xavier Deguillard <[email protected]>Signed-off-by Nadav Amit <[email protected]>--- drivers/misc/vmw_balloon.c | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-)drivers/misc/vmw_balloon.c +0
-0
drivers/misc/vmw_balloon.c enum vmwballoon_capabilities { · line 75
Quoted 4 lines
drivers/misc/vmw_balloon.c +1
-0@@ -72,15 +72,26 @@ enum vmwballoon_capabilities {VMW_BALLOON_BATCHED_CMDS = (1 <<2 ),VMW_BALLOON_BATCHED_2M_CMDS = (1 <<3 ),VMW_BALLOON_SIGNALLED_WAKEUP_CMD = (1 <<4 ), +VMW_BALLOON_64_BIT_TARGET = (1 <<5 )
Nit, this should be BIT(5), right?
You can change that in a later patch...
thanks,
greg k-h
Re: [PATCH 2/6] vmw_balloon: support 64-bit memory limit
Quoted 33 lines · Greg Kroah-Hartman
Quoted 23 lines · Nadav Amit
From: Xavier Deguillard <[email protected]>
Currently, the balloon driver would fail to run if memory is greater than 16TB of vRAM. Previous patches have already converted the balloon target and size to 64-bit, so all that is left to do add is to avoid asserting memory is smaller than 16TB if the hypervisor supports 64-bits target.
The driver advertises a new capability
VMW_BALLOON_64_BITS_TARGET. Hypervisors that support 16TB of memory or more will report that this capability is enabled.Signed-off-by Xavier Deguillard <[email protected]>Signed-off-by Nadav Amit <[email protected]>---
drivers/misc/vmw_balloon.c| 18 +++++++++++++++---1 file changed, 15 insertions(+), 3 deletions(-)drivers/misc/vmw_balloon.c +0
-0drivers/misc/vmw_balloon.c enum vmwballoon_capabilities { · line 75
Quoted 4 lines
drivers/misc/vmw_balloon.c +1
-0@@ -72,15 +72,26 @@ enum vmwballoon_capabilities {VMW_BALLOON_BATCHED_CMDS = (1 <<2 ),VMW_BALLOON_BATCHED_2M_CMDS = (1 <<3 ),VMW_BALLOON_SIGNALLED_WAKEUP_CMD = (1 <<4 ), +VMW_BALLOON_64_BIT_TARGET = (1 <<5 )Nit, this should be BIT(5), right?
Quoted 1 line
You can change that in a later patch...
Will do.