lkml.org 
[lkml]   [2018]   [Sep]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 18/19] vmw_balloon: memory shrinker
    Date
    Adding 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.

    Reviewed-by: Xavier Deguillard <xdeguillard@vmware.com>
    Signed-off-by: Nadav Amit <namit@vmware.com>
    ---
    drivers/misc/vmw_balloon.c | 124 ++++++++++++++++++++++++++++++++++++-
    1 file changed, 122 insertions(+), 2 deletions(-)

    diff --git a/drivers/misc/vmw_balloon.c b/drivers/misc/vmw_balloon.c
    index 372282de649e..890423453ad6 100644
    --- a/drivers/misc/vmw_balloon.c
    +++ b/drivers/misc/vmw_balloon.c
    @@ -42,6 +42,10 @@ MODULE_ALIAS("dmi:*:svnVMware*:*");
    MODULE_ALIAS("vmware_vmmemctl");
    MODULE_LICENSE("GPL");

    +/* 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

    /*
    @@ -214,12 +218,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);

    @@ -318,6 +323,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;

    @@ -358,6 +372,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;
    @@ -887,6 +915,10 @@ static int64_t vmballoon_change(struct vmballoon *b)
    if (target < size && size - target < HPAGE_PMD_NR && target != 0)
    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;
    }

    @@ -1379,6 +1411,86 @@ 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;
    +
    + 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
    */
    @@ -1396,6 +1508,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)
    @@ -1740,6 +1854,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;
    @@ -1765,6 +1883,7 @@ static int __init vmballoon_init(void)

    return 0;
    fail:
    + vmballoon_unregister_shrinker(&balloon);
    vmballoon_compaction_deinit(&balloon);
    return error;
    }
    @@ -1779,6 +1898,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);

    --
    2.17.1
    \
     
     \ /
      Last update: 2018-09-18 08:42    [W:4.176 / U:0.052 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site