meminfo: Add slab_reclaimable to MemAvailable

[asainkujovic]

This PR proposal is created for the problem explained at issue 670

Slab-Reclaimable memory in any system should not be part of "used" but oposite, should be part of "available" memory.

So like said in issue, I am not an expert about all details of memory values, but hope that someone of lxcfs creators can confirm that this is logical needed change.

Kernel send us 'memory.current' file for the cgroup we are inside, witch we (lxcfs code) use it as base 'memused' value.
For calculating MemAvailable we subtracting memused from memorymax, and already we are adding to it total_active/inactive_file values as reclaimable ones. Slab-reclaimable should be added here too (or we will have unreal growth of memory, like explained in connected issue)

[mihalicyn]

I believe this approach is good enough. For reference: https://github.com/torvalds/linux/blob/13563da6ffcf49b8b45772e40b35f96926a7ee1e/mm/show_mem.c#L64

[mihalicyn]

LGTM.

Hi @asainkujovic,

thanks for your work on this one!

Kind regards,
Alex

[asainkujovic]

This PR as it is should be better option than current situation. And I still proposing it as it will solve mentioned issue.
However, full story (as all of you already know) in kernel code MemAvail calculation, is that kernel use watermark calclulated from memory zones, and makes estimation where half of reclaimable values (or memory size as watermark value) stays as reserved. So for completeness i would sum up my view of situation by following pseudocode:

    # init variables for MemAvail calculation:
    memlimit        = file_contents(/sys/fs/cgroup/memory.max)
    memusage        = file_contents(/sys/fs/cgroup/memory.current)
    // low_watermark inside lxc container probably can not be read well from somewhere
    // there is memory.peak file exposed as watermark but that is not watermark that we need
    // kernel calculates it by looping through ZONES, we can collect that info too, but it is global value
    // for whole host (not separated per cgroups)
    watermark       = file_contents(some way to get this value, maybe by adding 'grep low /proc/zoneinfo)
    slab_recl       = file_line_val(/sys/fs/cgroup/memory.stat, line:slab_reclaimable)
    kern_recl       = file_line_val(we do not have this value exposed per cgroup, just global one)
    total_recl      = slab_recl + kern_recl
    total_file      = file_line_val(/sys/fs/cgroup/memory.stat, line:active_file)
                     +file_line_val(/sys/fs/cgroup/memory.stat, line:inactive_file)

    estimated_file  = total_file - min(total_file/2, watermark)
    estimated_recl  = slab_recl  - min(total_recl /2, watermark)
    
    // (1) kernel code calculate something like this:
    MemAvail = memlimit - memusage + estimated_file + estimated_recl

    // (2) current LXCFS version calculates MemAvail like this:
    MemAvail = memlimit - memusage + total_file

    // (3) this PR of lxcfs calculates it like this:
    MemAvail = memlimit - memusage + total_file + slab_recl

So solution (3) is still better than (2) and currently best option, so I am still proposing this PR as it is, as a needed solution. We are not including kern_reclaimable but also do not spliting sreclaimable by half, so that estimation good as we do not have all source values that host's kernel has.

Thanks for the review and approval.