From: Alexey Gladkov <legion@xxxxxxxxxx> The /proc/meminfo contains information regardless of the cgroups restrictions. This file is still widely used [1]. This means that all these programs will not work correctly inside container [2][3][4]. Some programs try to respect the cgroups limits, but not all of them implement support for all cgroup versions [5]. Correct information can be obtained from cgroups, but this requires the cgroups to be available inside container and the correct version of cgroups to be supported. There is lxcfs [6] that emulates /proc/meminfo using fuse to provide information regarding cgroups. This patch can help them. This patch adds /proc/self/meminfo that contains a subset of /proc/meminfo respecting cgroup restrictions. We cannot just create /proc/self/meminfo and make a symlink at the old location because this will break the existing apparmor rules [7]. Therefore, the patch adds a separate file with the same format. [1] https://codesearch.debian.net/search?q=%2Fproc%2Fmeminfo [2] https://sources.debian.org/src/erlang/1:23.2.6+dfsg-1/lib/os_mon/c_src/memsup.c#L300 [3] https://sources.debian.org/src/p7zip/16.02+dfsg-8/CPP/Windows/System.cpp/#L103 [4] https://sources.debian.org/src/systemd/247.3-5/src/oom/oomd.c/#L138 [5] https://sources.debian.org/src/nodejs/12.21.0%7Edfsg-4/deps/uv/src/unix/linux-core.c/#L1059 [6] https://linuxcontainers.org/lxcfs/ [7] https://gitlab.com/apparmor/apparmor/-/blob/master/profiles/apparmor.d/abstractions/base#L98 Signed-off-by: Alexey Gladkov <legion@xxxxxxxxxx> --- fs/proc/base.c | 2 + fs/proc/internal.h | 6 ++ fs/proc/meminfo.c | 160 +++++++++++++++++++++++-------------- include/linux/memcontrol.h | 2 + include/linux/mm.h | 15 ++++ mm/memcontrol.c | 80 +++++++++++++++++++ mm/page_alloc.c | 28 ++++--- 7 files changed, 222 insertions(+), 71 deletions(-) diff --git a/fs/proc/base.c b/fs/proc/base.c index 58bbf334265b..e95837cf713f 100644 --- a/fs/proc/base.c +++ b/fs/proc/base.c @@ -3269,6 +3269,7 @@ static const struct pid_entry tgid_base_stuff[] = { #ifdef CONFIG_SECCOMP_CACHE_DEBUG ONE("seccomp_cache", S_IRUSR, proc_pid_seccomp_cache), #endif + ONE("meminfo", S_IRUGO, proc_meminfo_show), }; static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx) @@ -3602,6 +3603,7 @@ static const struct pid_entry tid_base_stuff[] = { #ifdef CONFIG_SECCOMP_CACHE_DEBUG ONE("seccomp_cache", S_IRUSR, proc_pid_seccomp_cache), #endif + ONE("meminfo", S_IRUGO, proc_meminfo_show), }; static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx) diff --git a/fs/proc/internal.h b/fs/proc/internal.h index 03415f3fb3a8..a6e8540afbd3 100644 --- a/fs/proc/internal.h +++ b/fs/proc/internal.h @@ -241,6 +241,12 @@ extern int proc_net_init(void); static inline int proc_net_init(void) { return 0; } #endif +/* + * meminfo.c + */ +extern int proc_meminfo_show(struct seq_file *m, struct pid_namespace *ns, + struct pid *pid, struct task_struct *tsk); + /* * proc_self.c */ diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c index 6fa761c9cc78..3587a79d4b96 100644 --- a/fs/proc/meminfo.c +++ b/fs/proc/meminfo.c @@ -16,6 +16,9 @@ #ifdef CONFIG_CMA #include <linux/cma.h> #endif +#ifdef CONFIG_MEMCG +#include <linux/memcontrol.h> +#endif #include <asm/page.h> #include "internal.h" @@ -23,91 +26,112 @@ void __attribute__((weak)) arch_report_meminfo(struct seq_file *m) { } +static void proc_fill_meminfo(struct meminfo *mi) +{ + int lru; + long cached; + + si_meminfo(&mi->si); + si_swapinfo(&mi->si); + + for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++) + mi->pages[lru] = global_node_page_state(NR_LRU_BASE + lru); + + cached = global_node_page_state(NR_FILE_PAGES) - total_swapcache_pages() - mi->si.bufferram; + if (cached < 0) + cached = 0; + + mi->cached = cached; + mi->swapcached = total_swapcache_pages(); + mi->slab_reclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B); + mi->slab_unreclaimable = global_node_page_state_pages(NR_SLAB_UNRECLAIMABLE_B); + mi->anon_pages = global_node_page_state(NR_ANON_MAPPED); + mi->mapped = global_node_page_state(NR_FILE_MAPPED); + mi->nr_pagetable = global_node_page_state(NR_PAGETABLE); + mi->dirty_pages = global_node_page_state(NR_FILE_DIRTY); + mi->writeback_pages = global_node_page_state(NR_WRITEBACK); +} + +#ifdef CONFIG_MEMCG +static inline void fill_meminfo(struct meminfo *mi, struct task_struct *task) +{ + mem_fill_meminfo(mi, task); +} +#else +static inline void fill_meminfo(struct meminfo *mi, struct task_struct *task) +{ + proc_fill_meminfo(mi); +} +#endif + static void show_val_kb(struct seq_file *m, const char *s, unsigned long num) { seq_put_decimal_ull_width(m, s, num << (PAGE_SHIFT - 10), 8); seq_write(m, " kB\n", 4); } +static int meminfo_proc_show_mi(struct seq_file *m, struct meminfo *mi) +{ + show_val_kb(m, "MemTotal: ", mi->si.totalram); + show_val_kb(m, "MemFree: ", mi->si.freeram); + show_val_kb(m, "MemAvailable: ", si_mem_available_mi(mi)); + show_val_kb(m, "Buffers: ", mi->si.bufferram); + show_val_kb(m, "Cached: ", mi->cached); + show_val_kb(m, "SwapCached: ", mi->swapcached); + show_val_kb(m, "Active: ", mi->pages[LRU_ACTIVE_ANON] + mi->pages[LRU_ACTIVE_FILE]); + show_val_kb(m, "Inactive: ", mi->pages[LRU_INACTIVE_ANON] + mi->pages[LRU_INACTIVE_FILE]); + show_val_kb(m, "Active(anon): ", mi->pages[LRU_ACTIVE_ANON]); + show_val_kb(m, "Inactive(anon): ", mi->pages[LRU_INACTIVE_ANON]); + show_val_kb(m, "Active(file): ", mi->pages[LRU_ACTIVE_FILE]); + show_val_kb(m, "Inactive(file): ", mi->pages[LRU_INACTIVE_FILE]); + show_val_kb(m, "Unevictable: ", mi->pages[LRU_UNEVICTABLE]); + +#ifdef CONFIG_HIGHMEM + show_val_kb(m, "HighTotal: ", mi->si.totalhigh); + show_val_kb(m, "HighFree: ", mi->si.freehigh); + show_val_kb(m, "LowTotal: ", mi->si.totalram - mi->si.totalhigh); + show_val_kb(m, "LowFree: ", mi->si.freeram - mi->si.freehigh); +#endif + + show_val_kb(m, "SwapTotal: ", mi->si.totalswap); + show_val_kb(m, "SwapFree: ", mi->si.freeswap); + show_val_kb(m, "Dirty: ", mi->dirty_pages); + show_val_kb(m, "Writeback: ", mi->writeback_pages); + + show_val_kb(m, "AnonPages: ", mi->anon_pages); + show_val_kb(m, "Mapped: ", mi->mapped); + show_val_kb(m, "Shmem: ", mi->si.sharedram); + show_val_kb(m, "Slab: ", mi->slab_reclaimable + mi->slab_unreclaimable); + show_val_kb(m, "SReclaimable: ", mi->slab_reclaimable); + show_val_kb(m, "SUnreclaim: ", mi->slab_unreclaimable); + show_val_kb(m, "PageTables: ", mi->nr_pagetable); + + return 0; +} + static int meminfo_proc_show(struct seq_file *m, void *v) { - struct sysinfo i; - unsigned long committed; - long cached; - long available; - unsigned long pages[NR_LRU_LISTS]; - unsigned long sreclaimable, sunreclaim; - int lru; - si_meminfo(&i); - si_swapinfo(&i); - committed = vm_memory_committed(); + struct meminfo mi; - cached = global_node_page_state(NR_FILE_PAGES) - - total_swapcache_pages() - i.bufferram; - if (cached < 0) - cached = 0; + proc_fill_meminfo(&mi); + meminfo_proc_show_mi(m, &mi); - for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++) - pages[lru] = global_node_page_state(NR_LRU_BASE + lru); - - available = si_mem_available(); - sreclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B); - sunreclaim = global_node_page_state_pages(NR_SLAB_UNRECLAIMABLE_B); - - show_val_kb(m, "MemTotal: ", i.totalram); - show_val_kb(m, "MemFree: ", i.freeram); - show_val_kb(m, "MemAvailable: ", available); - show_val_kb(m, "Buffers: ", i.bufferram); - show_val_kb(m, "Cached: ", cached); - show_val_kb(m, "SwapCached: ", total_swapcache_pages()); - show_val_kb(m, "Active: ", pages[LRU_ACTIVE_ANON] + - pages[LRU_ACTIVE_FILE]); - show_val_kb(m, "Inactive: ", pages[LRU_INACTIVE_ANON] + - pages[LRU_INACTIVE_FILE]); - show_val_kb(m, "Active(anon): ", pages[LRU_ACTIVE_ANON]); - show_val_kb(m, "Inactive(anon): ", pages[LRU_INACTIVE_ANON]); - show_val_kb(m, "Active(file): ", pages[LRU_ACTIVE_FILE]); - show_val_kb(m, "Inactive(file): ", pages[LRU_INACTIVE_FILE]); - show_val_kb(m, "Unevictable: ", pages[LRU_UNEVICTABLE]); show_val_kb(m, "Mlocked: ", global_zone_page_state(NR_MLOCK)); -#ifdef CONFIG_HIGHMEM - show_val_kb(m, "HighTotal: ", i.totalhigh); - show_val_kb(m, "HighFree: ", i.freehigh); - show_val_kb(m, "LowTotal: ", i.totalram - i.totalhigh); - show_val_kb(m, "LowFree: ", i.freeram - i.freehigh); -#endif - #ifndef CONFIG_MMU show_val_kb(m, "MmapCopy: ", (unsigned long)atomic_long_read(&mmap_pages_allocated)); #endif - show_val_kb(m, "SwapTotal: ", i.totalswap); - show_val_kb(m, "SwapFree: ", i.freeswap); - show_val_kb(m, "Dirty: ", - global_node_page_state(NR_FILE_DIRTY)); - show_val_kb(m, "Writeback: ", - global_node_page_state(NR_WRITEBACK)); - show_val_kb(m, "AnonPages: ", - global_node_page_state(NR_ANON_MAPPED)); - show_val_kb(m, "Mapped: ", - global_node_page_state(NR_FILE_MAPPED)); - show_val_kb(m, "Shmem: ", i.sharedram); - show_val_kb(m, "KReclaimable: ", sreclaimable + + show_val_kb(m, "KReclaimable: ", mi.slab_reclaimable + global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE)); - show_val_kb(m, "Slab: ", sreclaimable + sunreclaim); - show_val_kb(m, "SReclaimable: ", sreclaimable); - show_val_kb(m, "SUnreclaim: ", sunreclaim); seq_printf(m, "KernelStack: %8lu kB\n", global_node_page_state(NR_KERNEL_STACK_KB)); #ifdef CONFIG_SHADOW_CALL_STACK seq_printf(m, "ShadowCallStack:%8lu kB\n", global_node_page_state(NR_KERNEL_SCS_KB)); #endif - show_val_kb(m, "PageTables: ", - global_node_page_state(NR_PAGETABLE)); show_val_kb(m, "NFS_Unstable: ", 0); show_val_kb(m, "Bounce: ", @@ -115,7 +139,7 @@ static int meminfo_proc_show(struct seq_file *m, void *v) show_val_kb(m, "WritebackTmp: ", global_node_page_state(NR_WRITEBACK_TEMP)); show_val_kb(m, "CommitLimit: ", vm_commit_limit()); - show_val_kb(m, "Committed_AS: ", committed); + show_val_kb(m, "Committed_AS: ", vm_memory_committed()); seq_printf(m, "VmallocTotal: %8lu kB\n", (unsigned long)VMALLOC_TOTAL >> 10); show_val_kb(m, "VmallocUsed: ", vmalloc_nr_pages()); @@ -153,6 +177,20 @@ static int meminfo_proc_show(struct seq_file *m, void *v) return 0; } +int proc_meminfo_show(struct seq_file *m, struct pid_namespace *ns, + struct pid *pid, struct task_struct *task) +{ + struct meminfo mi; + + fill_meminfo(&mi, task); + + meminfo_proc_show_mi(m, &mi); + hugetlb_report_meminfo(m); + arch_report_meminfo(m); + + return 0; +} + static int __init proc_meminfo_init(void) { proc_create_single("meminfo", 0, NULL, meminfo_proc_show); diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index c193be760709..4a7e2894954f 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -1119,6 +1119,8 @@ unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, gfp_t gfp_mask, unsigned long *total_scanned); +void mem_fill_meminfo(struct meminfo *mi, struct task_struct *task); + #else /* CONFIG_MEMCG */ #define MEM_CGROUP_ID_SHIFT 0 diff --git a/include/linux/mm.h b/include/linux/mm.h index c274f75efcf9..7faeaddd5b88 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2467,6 +2467,20 @@ static inline int early_pfn_to_nid(unsigned long pfn) extern int __meminit early_pfn_to_nid(unsigned long pfn); #endif +struct meminfo { + struct sysinfo si; + unsigned long pages[NR_LRU_LISTS]; + unsigned long cached; + unsigned long swapcached; + unsigned long anon_pages; + unsigned long mapped; + unsigned long nr_pagetable; + unsigned long dirty_pages; + unsigned long writeback_pages; + unsigned long slab_reclaimable; + unsigned long slab_unreclaimable; +}; + extern void set_dma_reserve(unsigned long new_dma_reserve); extern void memmap_init_range(unsigned long, int, unsigned long, unsigned long, unsigned long, enum meminit_context, @@ -2477,6 +2491,7 @@ extern int __meminit init_per_zone_wmark_min(void); extern void mem_init(void); extern void __init mmap_init(void); extern void show_mem(unsigned int flags, nodemask_t *nodemask); +extern long si_mem_available_mi(struct meminfo *mi); extern long si_mem_available(void); extern void si_meminfo(struct sysinfo * val); extern void si_meminfo_node(struct sysinfo *val, int nid); diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 64ada9e650a5..344b546f9e25 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -3750,6 +3750,86 @@ static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg, return nr; } +static void mem_cgroup_nr_pages(struct mem_cgroup *memcg, int nid, unsigned long *pages) +{ + struct mem_cgroup *iter; + int i; + + for_each_mem_cgroup_tree(iter, memcg) { + for (i = 0; i < NR_LRU_LISTS; i++) + pages[i] += mem_cgroup_node_nr_lru_pages(iter, nid, BIT(i), false); + } +} + +static void mem_cgroup_si_meminfo(struct sysinfo *si, struct task_struct *task) +{ + unsigned long memtotal, memused, swapsize; + struct mem_cgroup *memcg; + struct cgroup_subsys_state *css; + + css = task_css(task, memory_cgrp_id); + memcg = mem_cgroup_from_css(css); + + memtotal = READ_ONCE(memcg->memory.max); + + if (memtotal != PAGE_COUNTER_MAX) { + memused = page_counter_read(&memcg->memory); + + si->totalram = memtotal; + si->freeram = (memtotal > memused ? memtotal - memused : 0); + si->sharedram = memcg_page_state(memcg, NR_SHMEM); + + si->bufferram = nr_blockdev_pages(); + si->totalhigh = totalhigh_pages(); + si->freehigh = nr_free_highpages(); + si->mem_unit = PAGE_SIZE; + } else { + si_meminfo(si); + memused = si->totalram - si->freeram; + } + + swapsize = READ_ONCE(memcg->memsw.max); + + if (swapsize != PAGE_COUNTER_MAX) { + unsigned long swaptotal, swapused; + + swaptotal = swapsize - memtotal; + swapused = page_counter_read(&memcg->memsw) - memused; + si->totalswap = swaptotal; + /* Due to global reclaim, memory.memsw.usage can be greater than + * (memory.memsw.max - memory.max). */ + si->freeswap = (swaptotal > swapused ? swaptotal - swapused : 0); + } else { + si_swapinfo(si); + } + + css_put(css); +} + +void mem_fill_meminfo(struct meminfo *mi, struct task_struct *task) +{ + struct cgroup_subsys_state *memcg_css = task_css(task, memory_cgrp_id); + struct mem_cgroup *memcg = mem_cgroup_from_css(memcg_css); + int nid; + + memset(&mi->pages, 0, sizeof(mi->pages)); + + mem_cgroup_si_meminfo(&mi->si, task); + + for_each_online_node(nid) + mem_cgroup_nr_pages(memcg, nid, mi->pages); + + mi->slab_reclaimable = memcg_page_state(memcg, NR_SLAB_RECLAIMABLE_B); + mi->slab_unreclaimable = memcg_page_state(memcg, NR_SLAB_UNRECLAIMABLE_B); + mi->cached = memcg_page_state(memcg, NR_FILE_PAGES); + mi->swapcached = memcg_page_state(memcg, NR_SWAPCACHE); + mi->anon_pages = memcg_page_state(memcg, NR_ANON_MAPPED); + mi->mapped = memcg_page_state(memcg, NR_FILE_MAPPED); + mi->nr_pagetable = memcg_page_state(memcg, NR_PAGETABLE); + mi->dirty_pages = memcg_page_state(memcg, NR_FILE_DIRTY); + mi->writeback_pages = memcg_page_state(memcg, NR_WRITEBACK); +} + static int memcg_numa_stat_show(struct seq_file *m, void *v) { struct numa_stat { diff --git a/mm/page_alloc.c b/mm/page_alloc.c index aaa1655cf682..0a3c9dcd2c13 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -5551,18 +5551,13 @@ static inline void show_node(struct zone *zone) printk("Node %d ", zone_to_nid(zone)); } -long si_mem_available(void) +long si_mem_available_mi(struct meminfo *mi) { long available; unsigned long pagecache; unsigned long wmark_low = 0; - unsigned long pages[NR_LRU_LISTS]; unsigned long reclaimable; struct zone *zone; - int lru; - - for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++) - pages[lru] = global_node_page_state(NR_LRU_BASE + lru); for_each_zone(zone) wmark_low += low_wmark_pages(zone); @@ -5571,14 +5566,14 @@ long si_mem_available(void) * Estimate the amount of memory available for userspace allocations, * without causing swapping. */ - available = global_zone_page_state(NR_FREE_PAGES) - totalreserve_pages; + available = mi->si.freeram - totalreserve_pages; /* * Not all the page cache can be freed, otherwise the system will * start swapping. Assume at least half of the page cache, or the * low watermark worth of cache, needs to stay. */ - pagecache = pages[LRU_ACTIVE_FILE] + pages[LRU_INACTIVE_FILE]; + pagecache = mi->pages[LRU_ACTIVE_FILE] + mi->pages[LRU_INACTIVE_FILE]; pagecache -= min(pagecache / 2, wmark_low); available += pagecache; @@ -5587,14 +5582,27 @@ long si_mem_available(void) * items that are in use, and cannot be freed. Cap this estimate at the * low watermark. */ - reclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B) + - global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE); + reclaimable = mi->slab_reclaimable + global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE); available += reclaimable - min(reclaimable / 2, wmark_low); if (available < 0) available = 0; return available; } + +long si_mem_available(void) +{ + struct meminfo mi; + int lru; + + for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++) + mi.pages[lru] = global_node_page_state(NR_LRU_BASE + lru); + + mi.si.freeram = global_zone_page_state(NR_FREE_PAGES); + mi.slab_reclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B); + + return si_mem_available_mi(&mi); +} EXPORT_SYMBOL_GPL(si_mem_available); void si_meminfo(struct sysinfo *val) -- 2.29.3
