incoming
Subsystems (11)
Andrew Morton
maintainer15 patches, based on a90af8f15bdc9449ee2d24e1d73fa3f7e8633f81.
Subsystems affected by this patch series:
mm/swap
ipc
mm/slab-generic
hexagon
mm/kmemleak
mm/hugetlb
mm/kasan
mm/damon
mm/highmem
proc
Subsystem: mm/swap
Matthew Wilcox <[email protected]>:
mm/swap.c:put_pages_list(): reinitialise the page list
Subsystem: ipc
Alexander Mikhalitsyn <[email protected]>:
Patch series "shm: shm_rmid_forced feature fixes":
ipc: WARN if trying to remove ipc object which is absent
shm: extend forced shm destroy to support objects from several IPC nses
Subsystem: mm/slab-generic
Yunfeng Ye <[email protected]>:
mm: emit the "free" trace report before freeing memory in kmem_cache_free()
Subsystem: hexagon
Nathan Chancellor <[email protected]>:
Patch series "Fixes for ARCH=hexagon allmodconfig", v2:
hexagon: export raw I/O routines for modules
hexagon: clean up timer-regs.h
hexagon: ignore vmlinux.lds
Subsystem: mm/kmemleak
Rustam Kovhaev <[email protected]>:
mm: kmemleak: slob: respect SLAB_NOLEAKTRACE flag
Subsystem: mm/hugetlb
Bui Quang Minh <[email protected]>:
hugetlb: fix hugetlb cgroup refcounting during mremap
Mina Almasry <[email protected]>:
hugetlb, userfaultfd: fix reservation restore on userfaultfd error
Subsystem: mm/kasan
Kees Cook <[email protected]>:
kasan: test: silence intentional read overflow warnings
Subsystem: mm/damon
SeongJae Park <[email protected]>:
Patch series "DAMON fixes":
mm/damon/dbgfs: use '__GFP_NOWARN' for user-specified size buffer allocation mm/damon/dbgfs: fix missed use of damon_dbgfs_lock
Subsystem: mm/highmem
Ard Biesheuvel <[email protected]>:
kmap_local: don't assume kmap PTEs are linear arrays in memory
Subsystem: proc
David Hildenbrand <[email protected]>:
proc/vmcore: fix clearing user buffer by properly using clear_user()
arch/arm/Kconfig | 1 arch/hexagon/include/asm/timer-regs.h | 26 ---- arch/hexagon/include/asm/timex.h | 3 arch/hexagon/kernel/.gitignore | 1 arch/hexagon/kernel/time.c | 12 +- arch/hexagon/lib/io.c | 4 fs/proc/vmcore.c | 20 ++- include/linux/hugetlb_cgroup.h | 12 ++ include/linux/ipc_namespace.h | 15 ++ include/linux/sched/task.h | 2 ipc/shm.c | 189 +++++++++++++++++++++++++--------- ipc/util.c | 6 - lib/test_kasan.c | 2 mm/Kconfig | 3 mm/damon/dbgfs.c | 20 ++- mm/highmem.c | 32 +++-- mm/hugetlb.c | 11 + mm/slab.c | 3 mm/slab.h | 2 mm/slob.c | 3 mm/slub.c | 2 mm/swap.c | 1 22 files changed, 254 insertions(+), 116 deletions(-)
Andrew Morton
maintainerPATCH 1/15 mm/swap.c:put_pages_list(): reinitialise the page list
From: Matthew Wilcox <[email protected]>
Subject: mm/swap.c:put_pages_list(): reinitialise the page list
While free_unref_page_list() puts pages onto the CPU local LRU list, it does not remove them from the list they were passed in on. That makes the list_head appear to be non-empty, and would lead to various corruption problems if we didn't have an assertion that the list was empty.
Reinitialise the list after calling free_unref_page_list() to avoid this problem.
---
mm/swap.c | 1 + 1 file changed, 1 insertion(+)
mm/swap.c renamed from mm/swap.c~hitting-bug_on-trap-in-read_pages-mm-optimise-put_pages_list +1 -0
@@ -156,6 +156,7 @@ void put_pages_list(struct list_head *pa }free_unref_page_list (pages); +INIT_LIST_HEAD (pages); }EXPORT_SYMBOL (put_pages_list);
_
Andrew Morton
maintainerPATCH 2/15 ipc: WARN if trying to remove ipc object which is absent
In reply to Andrew MortonFrom: Alexander Mikhalitsyn <[email protected]>
Subject: ipc: WARN if trying to remove ipc object which is absent
Patch series "shm: shm_rmid_forced feature fixes".
Some time ago I met kernel crash after CRIU restore procedure, fortunately, it was CRIU restore, so, I had dump files and could do restore many times and crash reproduced easily. After some investigation I've constructed the minimal reproducer. It was found that it's use-after-free and it happens only if sysctl kernel.shm_rmid_forced = 1.
The key of the problem is that the exit_shm() function not handles shp's object destroy when task->sysvshm.shm_clist contains items from different IPC namespaces. In most cases this list will contain only items from one IPC namespace.
Why this list may contain object from different namespaces? Function exit_shm() designed to clean up this list always when process leaves IPC namespace. But we made a mistake a long time ago and not add exit_shm() call into setns() syscall procedures. 1st second idea was just to add this call to setns() syscall but it's obviously changes semantics of setns() syscall and that's userspace-visible change. So, I gave up this idea.
First real attempt to address the issue was just to omit forced destroy if we meet shp object not from current task IPC namespace [1]. But that was not the best idea because task->sysvshm.shm_clist was protected by rwsem which belongs to current task IPC namespace. It means that list corruption may occur.
Second approach is just extend exit_shm() to properly handle shp's from different IPC namespaces [2]. This is really non-trivial thing, I've put a lot of effort into that but not believed that it's possible to make it fully safe, clean and clear.
Thanks to the efforts of Manfred Spraul working an elegant solution was designed. Thanks a lot, Manfred!
Eric also suggested the way to address the issue in ("[RFC][PATCH] shm: In shm_exit destroy all created and never attached segments") Eric's idea was to maintain a list of shm_clists one per IPC namespace, use lock-less lists. But there is some extra memory consumption-related concerns.
Alternative solution which was suggested by me was implemented in ("shm:
reset shm_clist on setns but omit forced shm destroy") Idea is pretty simple, we add exit_shm() syscall to setns() but DO NOT destroy shm segments even if sysctl kernel.shm_rmid_forced = 1, we just clean up the task->sysvshm.shm_clist list. This chages semantics of setns() syscall a little bit but in comparision to "naive" solution when we just add exit_shm() without any special exclusions this looks like a safer option.
[1] https://lkml.org/lkml/2021/7/6/1108
[2] https://lkml.org/lkml/2021/7/14/736
This patch (of 2):
Let's produce a warning if we trying to remove non-existing IPC object from IPC namespace kht/idr structures.
This allows to catch possible bugs when ipc_rmid() function was called with inconsistent struct ipc_ids*, struct kern_ipc_perm* arguments.
---
ipc/util.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
ipc/util.c renamed from ipc/util.c~ipc-warn-if-trying-to-remove-ipc-object-which-is-absent +3 -3
@@ -447,8 +447,8 @@ static int ipcget_public(struct ipc_namestatic void ipc_kht_remove (struct ipc_ids *ids,struct kern_ipc_perm *ipcp) {if (ipcp->key !=IPC_PRIVATE ) -rhashtable_remove_fast (&ids->key_ht, &ipcp->khtnode, - ipc_kht_params); +WARN_ON_ONCE (rhashtable_remove_fast (&ids->key_ht, &ipcp->khtnode, + ipc_kht_params)); }/**
@@ -498,7 +498,7 @@ void ipc_rmid(struct ipc_ids *ids, struc {int idx =ipcid_to_idx (ipcp->id); -idr_remove (&ids->ipcs_idr, idx); +WARN_ON_ONCE (idr_remove (&ids->ipcs_idr, idx) != ipcp);ipc_kht_remove (ids, ipcp); ids->in_use--; ipcp->deleted = true;
_
Andrew Morton
maintainerPATCH 3/15 shm: extend forced shm destroy to support objects from several IPC nses
In reply to Andrew MortonFrom: Alexander Mikhalitsyn <[email protected]>
Subject: shm: extend forced shm destroy to support objects from several IPC nses
Currently, exit_shm function not designed to work properly when task->sysvshm.shm_clist holds shm objects from different IPC namespaces.
This is a real pain when sysctl kernel.shm_rmid_forced = 1, because it leads to use-after-free (reproducer exists).
That particular patch is attempt to fix the problem by extending exit_shm mechanism to handle shm's destroy from several IPC ns'es.
To achieve that we do several things:
1. add namespace (non-refcounted) pointer to the struct shmid_kernel
2. during new shm object creation (newseg()/shmget syscall) we initialize this pointer by current task IPC ns
3. exit_shm() fully reworked such that it traverses over all shp's in task->sysvshm.shm_clist and gets IPC namespace not from current task as it was before but from shp's object itself, then call shm_destroy(shp, ns).
Note. We need to be really careful here, because as it was said before (1), our pointer to IPC ns non-refcnt'ed. To be on the safe side we using special helper get_ipc_ns_not_zero() which allows to get IPC ns refcounter only if IPC ns not in the "state of destruction".
Q/A
Q: Why we can access shp->ns memory using non-refcounted pointer?
A: Because shp object lifetime is always shorther
than IPC namespace lifetime, so, if we get shp object from the task->sysvshm.shm_clist while holding task_lock(task) nobody can steal our namespace.
Q: Does this patch change semantics of unshare/setns/clone syscalls?
A: Not. It's just fixes non-covered case when process may leave IPC namespace without getting task->sysvshm.shm_clist list cleaned up.
---
include/linux/ipc_namespace.h | 15 ++ include/linux/sched/task.h | 2 ipc/shm.c | 189 ++++++++++++++++++++++++-------- 3 files changed, 159 insertions(+), 47 deletions(-)
include/linux/ipc_namespace.h renamed from include/linux/ipc_namespace.h~shm-extend-forced-shm-destroy-to-support-objects-from-several-ipc-nses-simplified +15 -0
@@ -131,6 +131,16 @@ static inline struct ipc_namespace *get_return ns; } +static inline struct ipc_namespace *get_ipc_ns_not_zero (struct ipc_namespace *ns) +{ +if (ns) { +if (refcount_inc_not_zero (&ns->ns.count)) +return ns; + } + +return NULL ; +} +extern void put_ipc_ns (struct ipc_namespace *ns);#else static inline struct ipc_namespace *copy_ipcs(unsigned long flags,
@@ -146,6 +156,11 @@ static inline struct ipc_namespace *get_ {return ns; } + +static inline struct ipc_namespace *get_ipc_ns_not_zero (struct ipc_namespace *ns) +{ +return ns; +}static inline void put_ipc_ns (struct ipc_namespace *ns) {
include/linux/sched/task.h renamed from include/linux/sched/task.h~shm-extend-forced-shm-destroy-to-support-objects-from-several-ipc-nses-simplified +1 -1
@@ -158,7 +158,7 @@ static inline struct vm_struct *task_sta* Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring * subscriptions and synchronises with wait4(). Also used in procfs. Also * pins the final release of task.io_context. Also protects ->cpuset and -* ->cgroup.subsys[]. And ->vfork_done. +* ->cgroup.subsys[]. And ->vfork_done. And ->sysvshm.shm_clist. * * Nests both inside and outside of read_lock(&tasklist_lock). * It must not be nested with write_lock_irq(&tasklist_lock),
ipc/shm.c renamed from ipc/shm.c~shm-extend-forced-shm-destroy-to-support-objects-from-several-ipc-nses-simplified +143 -46
264 lines not on this page · raw message
_
Andrew Morton
maintainerPATCH 4/15 mm: emit the "free" trace report before freeing memory in kmem_cache_free()
In reply to Andrew MortonFrom: Yunfeng Ye <[email protected]>
Subject: mm: emit the "free" trace report before freeing memory in kmem_cache_free()
After the memory is freed, it can be immediately allocated by other CPUs, before the "free" trace report has been emitted. This causes inaccurate traces.
For example, if the following sequence of events occurs:
CPU 0 CPU 1
(1) alloc xxxxxx
(2) free xxxxxx
(3) alloc xxxxxx
(4) free xxxxxx
Then they will be inaccurately reported via tracing, so that they appear to have happened in this order:
CPU 0 CPU 1
(1) alloc xxxxxx
(2) alloc xxxxxx
(3) free xxxxxx
(4) free xxxxxx
This makes it look like CPU 1 somehow managed to allocate memory that CPU 0 still had allocated for itself.
In order to avoid this, emit the "free xxxxxx" tracing report just before the actual call to free the memory, instead of just after it.
---
mm/slab.c | 3 +-- mm/slob.c | 3 +-- mm/slub.c | 2 +- 3 files changed, 3 insertions(+), 5 deletions(-)
mm/slab.c renamed from mm/slab.c~mm-emit-the-free-trace-report-before-freeing-memory-in-kmem_cache_free +1 -2
@@ -3733,14 +3733,13 @@ void kmem_cache_free(struct kmem_cache *if (!cachep)return ; +trace_kmem_cache_free (_RET_IP_, objp, cachep->name);local_irq_save (flags);debug_check_no_locks_freed (objp, cachep->object_size);if (!(cachep->flags &SLAB_DEBUG_OBJECTS ))debug_check_no_obj_freed (objp, cachep->object_size);__cache_free (cachep, objp, _RET_IP_);local_irq_restore (flags); - -trace_kmem_cache_free (_RET_IP_, objp, cachep->name); }EXPORT_SYMBOL (kmem_cache_free);
mm/slob.c renamed from mm/slob.c~mm-emit-the-free-trace-report-before-freeing-memory-in-kmem_cache_free +1 -2
@@ -666,6 +666,7 @@ static void kmem_rcu_free(struct rcu_heavoid kmem_cache_free (struct kmem_cache *c,void *b) {kmemleak_free_recursive (b, c->flags); +trace_kmem_cache_free (_RET_IP_, b, c->name);if (unlikely (c->flags &SLAB_TYPESAFE_BY_RCU )) {struct slob_rcu *slob_rcu; slob_rcu = b + (c->size -sizeof (struct slob_rcu ));
@@ -674,8 +675,6 @@ void kmem_cache_free(struct kmem_cache * }else {__kmem_cache_free (b, c->size); } - -trace_kmem_cache_free (_RET_IP_, b, c->name); }EXPORT_SYMBOL (kmem_cache_free);
mm/slub.c renamed from mm/slub.c~mm-emit-the-free-trace-report-before-freeing-memory-in-kmem_cache_free +1 -1
@@ -3526,8 +3526,8 @@ void kmem_cache_free(struct kmem_cache * s =cache_from_obj (s, x);if (!s)return ; -slab_free (s,virt_to_head_page (x), x,NULL ,1 , _RET_IP_);trace_kmem_cache_free (_RET_IP_, x, s->name); +slab_free (s,virt_to_head_page (x), x,NULL ,1 , _RET_IP_); }EXPORT_SYMBOL (kmem_cache_free);
_
Andrew Morton
maintainerPATCH 5/15 hexagon: export raw I/O routines for modules
In reply to Andrew MortonFrom: Nathan Chancellor <[email protected]>
Subject: hexagon: export raw I/O routines for modules
Patch series "Fixes for ARCH=hexagon allmodconfig", v2.
This series fixes some issues noticed with ARCH=hexagon allmodconfig.
This patch (of 3):
When building ARCH=hexagon allmodconfig, the following errors occur:
ERROR: modpost: "__raw_readsl" [drivers/i3c/master/svc-i3c-master.ko] undefined!
ERROR: modpost: "__raw_writesl" [drivers/i3c/master/dw-i3c-master.ko] undefined!
ERROR: modpost: "__raw_readsl" [drivers/i3c/master/dw-i3c-master.ko] undefined!
ERROR: modpost: "__raw_writesl" [drivers/i3c/master/i3c-master-cdns.ko] undefined!
ERROR: modpost: "__raw_readsl" [drivers/i3c/master/i3c-master-cdns.ko] undefined!
Export these symbols so that modules can use them without any errors.
---
arch/hexagon/lib/io.c | 4 ++++ 1 file changed, 4 insertions(+)
arch/hexagon/lib/io.c renamed from arch/hexagon/lib/io.c~hexagon-export-raw-i-o-routines-for-modules +4 -0
@@ -27,6 +27,7 @@ void __raw_readsw(const void __iomem *ad *dst++ = *src; } +EXPORT_SYMBOL (__raw_readsw);/* * __raw_writesw - read words a short at a time
@@ -47,6 +48,7 @@ void __raw_writesw(void __iomem *addr, c } +EXPORT_SYMBOL (__raw_writesw);/* Pretty sure len is pre-adjusted for the length of the access already */ void __raw_readsl (const void __iomem *addr,void *data,int len)
@@ -62,6 +64,7 @@ void __raw_readsl(const void __iomem *ad } +EXPORT_SYMBOL (__raw_readsl);void __raw_writesl (void __iomem *addr,const void *data,int len) {
@@ -76,3 +79,4 @@ void __raw_writesl(void __iomem *addr, c } +EXPORT_SYMBOL (__raw_writesl);
_
Andrew Morton
maintainerPATCH 6/15 hexagon: clean up timer-regs.h
In reply to Andrew MortonFrom: Nathan Chancellor <[email protected]>
Subject: hexagon: clean up timer-regs.h
When building allmodconfig, there is a warning about TIMER_ENABLE being redefined:
drivers/clocksource/timer-oxnas-rps.c:39:9: error: 'TIMER_ENABLE' macro redefined [-Werror,-Wmacro-redefined]
#define TIMER_ENABLE BIT(7)
^
./arch/hexagon/include/asm/timer-regs.h:13:9: note: previous definition is here
#define TIMER_ENABLE 0
^1 error generated.
The values in this header are only used in one file each, if they are used at all. Remove the header and sink all of the constants into their respective files.
TCX0_CLK_RATE is only used in arch/hexagon/include/asm/timex.h
TIMER_ENABLE, RTOS_TIMER_INT, RTOS_TIMER_REGS_ADDR are only used in arch/hexagon/kernel/time.c.
SLEEP_CLK_RATE and TIMER_CLR_ON_MATCH have both been unused since the file's introduction in commit 71e4a47f32f4 ("Hexagon: Add time and timer functions").
TIMER_ENABLE is redefined as BIT(0) so the shift is moved into the definition, rather than its use.
---
arch/hexagon/include/asm/timer-regs.h | 26 ------------------------ arch/hexagon/include/asm/timex.h | 3 -- arch/hexagon/kernel/time.c | 12 +++++++++-- 3 files changed, 11 insertions(+), 30 deletions(-)
arch/hexagon/include/asm/timer-regs.h deleted +0 -26
@@ -1,26 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* -* Timer support for Hexagon -* -* Copyright (c) 2010-2011, The Linux Foundation. All rights reserved. -*/ - -#ifndef _ASM_TIMER_REGS_H -#define _ASM_TIMER_REGS_H - -/* This stuff should go into a platform specific file */ -#define TCX0_CLK_RATE 19200 -#define TIMER_ENABLE 0 -#define TIMER_CLR_ON_MATCH 1 - -/* -* 8x50 HDD Specs 5-8. Simulator co-sim not fixed until -* release 1.1, and then it's "adjustable" and probably not defaulted. -*/ -#define RTOS_TIMER_INT 3 -#ifdef CONFIG_HEXAGON_COMET -#define RTOS_TIMER_REGS_ADDR 0xAB000000UL -#endif -#define SLEEP_CLK_RATE 32000 - -#endif
arch/hexagon/include/asm/timex.h renamed from arch/hexagon/include/asm/timex.h~hexagon-clean-up-timer-regsh +1 -2
@@ -7,11 +7,10 @@#define _ASM_TIMEX_H#include <asm-generic/timex.h> -#include <asm/timer-regs.h> #include <asm/hexagon_vm.h> /* Using TCX0 as our clock. CLOCK_TICK_RATE scheduled to be removed. */ -#define CLOCK_TICK_RATE TCX0_CLK_RATE +#define CLOCK_TICK_RATE 19200#define ARCH_HAS_READ_CURRENT_TIMER
arch/hexagon/kernel/time.c renamed from arch/hexagon/kernel/time.c~hexagon-clean-up-timer-regsh +10 -2
@@ -17,9 +17,10 @@#include <linux/of_irq.h> #include <linux/module.h> -#include <asm/timer-regs.h> #include <asm/hexagon_vm.h> +#define TIMER_ENABLE BIT(0) +/* * For the clocksource we need: * pcycle frequency (600MHz)
@@ -33,6 +34,13 @@ cycles_t pcycle_freq_mhz;cycles_t thread_freq_mhz;cycles_t sleep_clk_freq; +/* +* 8x50 HDD Specs 5-8. Simulator co-sim not fixed until +* release 1.1, and then it's "adjustable" and probably not defaulted. +*/ +#define RTOS_TIMER_INT 3 +#define RTOS_TIMER_REGS_ADDR 0xAB000000UL +static struct resource rtos_timer_resources[] = { { .start =RTOS_TIMER_REGS_ADDR ,
@@ -80,7 +88,7 @@ static int set_next_event(unsigned longiowrite32 (0 , &rtos_timer->clear);iowrite32 (delta, &rtos_timer->match); -iowrite32 (1 <<TIMER_ENABLE , &rtos_timer->enable); +iowrite32 (TIMER_ENABLE , &rtos_timer->enable);return 0 ; }
_
Andrew Morton
maintainerPATCH 7/15 hexagon: ignore vmlinux.lds
In reply to Andrew MortonFrom: Nathan Chancellor <[email protected]>
Subject: hexagon: ignore vmlinux.lds
After building allmodconfig, there is an untracked vmlinux.lds file in arch/hexagon/kernel:
$ git ls-files . --exclude-standard --others arch/hexagon/kernel/vmlinux.lds
Ignore it as all other architectures have.
---
arch/hexagon/kernel/.gitignore | 1 + 1 file changed, 1 insertion(+)
arch/hexagon/kernel/.gitignore new file +1 -0
@@ -0,0 +1 @@ +vmlinux.lds
_
Andrew Morton
maintainerPATCH 8/15 mm: kmemleak: slob: respect SLAB_NOLEAKTRACE flag
In reply to Andrew MortonFrom: Rustam Kovhaev <[email protected]>
Subject: mm: kmemleak: slob: respect SLAB_NOLEAKTRACE flag
When kmemleak is enabled for SLOB, system does not boot and does not print anything to the console. At the very early stage in the boot process we hit infinite recursion from kmemleak_init() and eventually kernel crashes.
kmemleak_init() specifies SLAB_NOLEAKTRACE for KMEM_CACHE(), but kmem_cache_create_usercopy() removes it because CACHE_CREATE_MASK is not valid for SLOB.
Let's fix CACHE_CREATE_MASK and make kmemleak work with SLOB
---
mm/slab.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/slab.h renamed from mm/slab.h~mm-kmemleak-slob-respect-slab_noleaktrace-flag +1 -1
@@ -147,7 +147,7 @@ static inline slab_flags_t kmem_cache_fl#define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE | SLAB_RECLAIM_ACCOUNT | \ SLAB_TEMPORARY | SLAB_ACCOUNT)#else -#define SLAB_CACHE_FLAGS (0) +#define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE)#endif /* Common flags available with current configuration */
_
Andrew Morton
maintainerPATCH 9/15 hugetlb: fix hugetlb cgroup refcounting during mremap
In reply to Andrew MortonFrom: Bui Quang Minh <[email protected]>
Subject: hugetlb: fix hugetlb cgroup refcounting during mremap
When hugetlb_vm_op_open() is called during copy_vma(), we may take the reference to resv_map->css. Later, when clearing the reservation pointer of old_vma after transferring it to new_vma, we forget to drop the reference to resv_map->css. This leads to a reference leak of css.
Fixes this by adding a check to drop reservation css reference in clear_vma_resv_huge_pages()
---
include/linux/hugetlb_cgroup.h | 12 ++++++++++++ mm/hugetlb.c | 4 +++- 2 files changed, 15 insertions(+), 1 deletion(-)
include/linux/hugetlb_cgroup.h renamed from include/linux/hugetlb_cgroup.h~hugetlb-fix-hugetlb-cgroup-refcounting-during-mremap +12 -0
@@ -128,6 +128,13 @@ static inline void resv_map_dup_hugetlb_css_get (resv_map->css); } +static inline void resv_map_put_hugetlb_cgroup_uncharge_info ( +struct resv_map *resv_map) +{ +if (resv_map->css) +css_put (resv_map->css); +} +extern int hugetlb_cgroup_charge_cgroup (int idx,unsigned long nr_pages,struct hugetlb_cgroup **ptr); extern int hugetlb_cgroup_charge_cgroup_rsvd(int idx, unsigned long nr_pages,
@@ -210,6 +217,11 @@ static inline void resv_map_dup_hugetlb_ struct resv_map *resv_map) { } + +static inline void resv_map_put_hugetlb_cgroup_uncharge_info ( +struct resv_map *resv_map) +{ +}static inline int hugetlb_cgroup_charge_cgroup (int idx,unsigned long nr_pages,struct hugetlb_cgroup **ptr)
mm/hugetlb.c renamed from mm/hugetlb.c~hugetlb-fix-hugetlb-cgroup-refcounting-during-mremap +3 -1
@@ -1037,8 +1037,10 @@ void clear_vma_resv_huge_pages(struct vm*/ struct resv_map *reservations =vma_resv_map (vma); -if (reservations &&is_vma_resv_set (vma,HPAGE_RESV_OWNER )) +if (reservations &&is_vma_resv_set (vma,HPAGE_RESV_OWNER )) { +resv_map_put_hugetlb_cgroup_uncharge_info (reservations);kref_put (&reservations->refs, resv_map_release); + }reset_vma_resv_huge_pages (vma); }
_
Andrew Morton
maintainerPATCH 10/15 hugetlb, userfaultfd: fix reservation restore on userfaultfd error
In reply to Andrew MortonFrom: Mina Almasry <[email protected]>
Subject: hugetlb, userfaultfd: fix reservation restore on userfaultfd error
Currently in the is_continue case in hugetlb_mcopy_atomic_pte(), if we bail out using "goto out_release_unlock;" in the cases where idx >= size, or !huge_pte_none(), the code will detect that new_pagecache_page == false, and so call restore_reserve_on_error(). In this case I see restore_reserve_on_error() delete the reservation, and the following call to remove_inode_hugepages() will increment h->resv_hugepages causing a 100% reproducible leak.
We should treat the is_continue case similar to adding a page into the pagecache and set new_pagecache_page to true, to indicate that there is no reservation to restore on the error path, and we need not call restore_reserve_on_error(). Rename new_pagecache_page to page_in_pagecache to make that clear.
---
mm/hugetlb.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
mm/hugetlb.c renamed from mm/hugetlb.c~hugetlb-userfaultfd-fix-reservation-restore-on-userfaultfd-error +4 -3
@@ -5736,13 +5736,14 @@ int hugetlb_mcopy_atomic_pte(struct mm_sint ret = -ENOMEM ;struct page *page;int writable; -bool new_pagecache_page = false; +bool page_in_pagecache = false;if (is_continue) { ret = -EFAULT ; page =find_lock_page (mapping, idx);if (!page) goto out; + page_in_pagecache = true; }else if (!*pagep) {/* If a page already exists, then it's UFFDIO_COPY for * a non-missing case. Return -EEXIST.
@@ -5830,7 +5831,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_s ret =huge_add_to_page_cache (page, mapping, idx);if (ret) goto out_release_nounlock; - new_pagecache_page = true; + page_in_pagecache = true; } ptl =huge_pte_lockptr (h, dst_mm, dst_pte);
@@ -5894,7 +5895,7 @@ out_release_unlock:if (vm_shared || is_continue)unlock_page (page); out_release_nounlock: -if (!new_pagecache_page) +if (!page_in_pagecache)restore_reserve_on_error (h, dst_vma, dst_addr, page);put_page (page); goto out;
_
Andrew Morton
maintainerPATCH 11/15 kasan: test: silence intentional read overflow warnings
In reply to Andrew MortonFrom: Kees Cook <[email protected]>
Subject: kasan: test: silence intentional read overflow warnings
As done in commit d73dad4eb5ad ("kasan: test: bypass __alloc_size checks") for __write_overflow warnings, also silence some more cases that trip the __read_overflow warnings seen in 5.16-rc1[1]:
In file included from /kisskb/src/include/linux/string.h:253,
from /kisskb/src/include/linux/bitmap.h:10,
from /kisskb/src/include/linux/cpumask.h:12,
from /kisskb/src/include/linux/mm_types_task.h:14,
from /kisskb/src/include/linux/mm_types.h:5,
from /kisskb/src/include/linux/page-flags.h:13,
from /kisskb/src/arch/arm64/include/asm/mte.h:14,
from /kisskb/src/arch/arm64/include/asm/pgtable.h:12,
from /kisskb/src/include/linux/pgtable.h:6,
from /kisskb/src/include/linux/kasan.h:29,
from /kisskb/src/lib/test_kasan.c:10:
In function 'memcmp',
inlined from 'kasan_memcmp' at /kisskb/src/lib/test_kasan.c:897:2:
/kisskb/src/include/linux/fortify-string.h:263:25: error: call to '__read_overflow' declared with attribute error: detected read beyond size of object (1st parameter)
263 | __read_overflow();
| ^~~~~~~~~~~~~~~~~
In function 'memchr',
inlined from 'kasan_memchr' at /kisskb/src/lib/test_kasan.c:872:2:
/kisskb/src/include/linux/fortify-string.h:277:17: error: call to '__read_overflow' declared with attribute error: detected read beyond size of object (1st parameter)
277 | __read_overflow();
| ^~~~~~~~~~~~~~~~~[1] http://kisskb.ellerman.id.au/kisskb/buildresult/14660585/log/
---
lib/test_kasan.c | 2 ++ 1 file changed, 2 insertions(+)
lib/test_kasan.c renamed from lib/test_kasan.c~kasan-test-silence-intentional-read-overflow-warnings +2 -0
@@ -869,6 +869,7 @@ static void kasan_memchr(struct kunit *t ptr =kmalloc (size,GFP_KERNEL | __GFP_ZERO);KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr); +OPTIMIZER_HIDE_VAR (size);KUNIT_EXPECT_KASAN_FAIL (test, kasan_ptr_result =memchr (ptr,'1' , size +1 ));
@@ -894,6 +895,7 @@ static void kasan_memcmp(struct kunit *tKUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr);memset (arr,0 ,sizeof (arr)); +OPTIMIZER_HIDE_VAR (size);KUNIT_EXPECT_KASAN_FAIL (test, kasan_int_result =memcmp (ptr, arr, size+1 ));kfree (ptr);
_
Andrew Morton
maintainerPATCH 12/15 mm/damon/dbgfs: use '__GFP_NOWARN' for user-specified size buffer allocation
In reply to Andrew MortonFrom: SeongJae Park <[email protected]>
Subject: mm/damon/dbgfs: use '__GFP_NOWARN' for user-specified size buffer allocation
Patch series "DAMON fixes".
This patch (of 2):
DAMON users can trigger below warning in '__alloc_pages()' by invoking write() to some DAMON debugfs files with arbitrarily high count argument, because DAMON debugfs interface allocates some buffers based on the user-specified 'count'.
if (unlikely(order >= MAX_ORDER)) {
WARN_ON_ONCE(!(gfp & __GFP_NOWARN));
return NULL;
}Because the DAMON debugfs interface code checks failure of the 'kmalloc()', this commit simply suppresses the warnings by adding '__GFP_NOWARN' flag.
---
mm/damon/dbgfs.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
mm/damon/dbgfs.c renamed from mm/damon/dbgfs.c~mm-damon-dbgfs-use-__gfp_nowarn-for-user-specified-size-buffer-allocation +4 -4
@@ -32,7 +32,7 @@ static char *user_input_str(const char _if (*ppos)return ERR_PTR (-EINVAL ); - kbuf =kmalloc (count +1 ,GFP_KERNEL ); + kbuf =kmalloc (count +1 ,GFP_KERNEL | __GFP_NOWARN);if (!kbuf)return ERR_PTR (-ENOMEM );
@@ -133,7 +133,7 @@ static ssize_t dbgfs_schemes_read(structchar *kbuf;ssize_t len; - kbuf =kmalloc (count,GFP_KERNEL ); + kbuf =kmalloc (count,GFP_KERNEL | __GFP_NOWARN);if (!kbuf)return -ENOMEM ;
@@ -452,7 +452,7 @@ static ssize_t dbgfs_init_regions_read(schar *kbuf;ssize_t len; - kbuf =kmalloc (count,GFP_KERNEL ); + kbuf =kmalloc (count,GFP_KERNEL | __GFP_NOWARN);if (!kbuf)return -ENOMEM ;
@@ -578,7 +578,7 @@ static ssize_t dbgfs_kdamond_pid_read(stchar *kbuf;ssize_t len; - kbuf =kmalloc (count,GFP_KERNEL ); + kbuf =kmalloc (count,GFP_KERNEL | __GFP_NOWARN);if (!kbuf)return -ENOMEM ;
_
Andrew Morton
maintainerPATCH 13/15 mm/damon/dbgfs: fix missed use of damon_dbgfs_lock
In reply to Andrew MortonFrom: SeongJae Park <[email protected]>
Subject: mm/damon/dbgfs: fix missed use of damon_dbgfs_lock
DAMON debugfs is supposed to protect dbgfs_ctxs, dbgfs_nr_ctxs, and dbgfs_dirs using damon_dbgfs_lock. However, some of the code is accessing the variables without the protection. This commit fixes it by protecting all such accesses.
---
mm/damon/dbgfs.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
mm/damon/dbgfs.c renamed from mm/damon/dbgfs.c~mm-damon-dbgfs-fix-missed-use-of-damon_dbgfs_lock +9 -3
@@ -877,12 +877,14 @@ static ssize_t dbgfs_monitor_on_write(streturn -EINVAL ; } +mutex_lock (&damon_dbgfs_lock);if (!strncmp (kbuf,"on" , count)) {int i;for (i =0 ; i < dbgfs_nr_ctxs; i++) {if (damon_targets_empty (dbgfs_ctxs[i])) {kfree (kbuf); +mutex_unlock (&damon_dbgfs_lock);return -EINVAL ; } }
@@ -892,6 +894,7 @@ static ssize_t dbgfs_monitor_on_write(st }else { ret = -EINVAL ; } +mutex_unlock (&damon_dbgfs_lock);if (!ret) ret = count;
@@ -944,15 +947,16 @@ static int __init __damon_dbgfs_init(voistatic int __init damon_dbgfs_init (void ) { -int rc; +int rc = -ENOMEM ; +mutex_lock (&damon_dbgfs_lock); dbgfs_ctxs =kmalloc (sizeof (*dbgfs_ctxs),GFP_KERNEL );if (!dbgfs_ctxs) -return -ENOMEM ; + goto out; dbgfs_ctxs[0 ] =dbgfs_new_ctx ();if (!dbgfs_ctxs[0 ]) {kfree (dbgfs_ctxs); -return -ENOMEM ; + goto out; } dbgfs_nr_ctxs =1 ;
@@ -963,6 +967,8 @@ static int __init damon_dbgfs_init(void)pr_err ("%s: dbgfs init failed\n" , __func__); } +out: +mutex_unlock (&damon_dbgfs_lock);return rc; }
_
Andrew Morton
maintainerPATCH 14/15 kmap_local: don't assume kmap PTEs are linear arrays in memory
In reply to Andrew MortonFrom: Ard Biesheuvel <[email protected]>
Subject: kmap_local: don't assume kmap PTEs are linear arrays in memory
The kmap_local conversion broke the ARM architecture, because the new code assumes that all PTEs used for creating kmaps form a linear array in memory, and uses array indexing to look up the kmap PTE belonging to a certain kmap index.
On ARM, this cannot work, not only because the PTE pages may be non-adjacent in memory, but also because ARM/!LPAE interleaves hardware entries and extended entries (carrying software-only bits) in a way that is not compatible with array indexing.
Fortunately, this only seems to affect configurations with more than 8 CPUs, due to the way the per-CPU kmap slots are organized in memory.
Work around this by permitting an architecture to set a Kconfig symbol that signifies that the kmap PTEs do not form a lineary array in memory, and so the only way to locate the appropriate one is to walk the page tables.
---
arch/arm/Kconfig | 1 + mm/Kconfig | 3 +++ mm/highmem.c | 32 +++++++++++++++++++++----------- 3 files changed, 25 insertions(+), 11 deletions(-)
arch/arm/Kconfig renamed from arch/arm/Kconfig~kmap_local-dont-assume-kmap-ptes-are-linear-arrays-in-memory +1 -0
@@ -1463,6 +1463,7 @@ config HIGHMEM bool "High Memory Support" depends on MMU select KMAP_LOCAL + select KMAP_LOCAL_NON_LINEAR_PTE_ARRAY help The address space of ARM processors is only 4 Gigabytes large and it has to accommodate user address space, kernel address
mm/highmem.c renamed from mm/highmem.c~kmap_local-dont-assume-kmap-ptes-are-linear-arrays-in-memory +21 -11
@@ -503,16 +503,22 @@ static inline int kmap_local_calc_idx(instatic pte_t *__kmap_pte; -static pte_t *kmap_get_pte (void ) +static pte_t *kmap_get_pte (unsigned long vaddr,int idx) { +if (IS_ENABLED (CONFIG_KMAP_LOCAL_NON_LINEAR_PTE_ARRAY )) +/* +* Set by the arch if __kmap_pte[-idx] does not produce +* the correct entry. +*/ +return virt_to_kpte (vaddr);if (!__kmap_pte) __kmap_pte =virt_to_kpte (__fix_to_virt (FIX_KMAP_BEGIN )); -return __kmap_pte; +return &__kmap_pte[-idx]; }void *__kmap_local_pfn_prot (unsigned long pfn,pgprot_t prot) { -pte_t pteval, *kmap_pte =kmap_get_pte (); +pte_t pteval, *kmap_pte;unsigned long vaddr;int idx;
@@ -524,9 +530,10 @@ void *__kmap_local_pfn_prot(unsigned lonpreempt_disable (); idx =arch_kmap_local_map_idx (kmap_local_idx_push (), pfn); vaddr =__fix_to_virt (FIX_KMAP_BEGIN + idx); -BUG_ON (!pte_none (*(kmap_pte - idx))); + kmap_pte =kmap_get_pte (vaddr, idx); +BUG_ON (!pte_none (*kmap_pte)); pteval =pfn_pte (pfn, prot); -arch_kmap_local_set_pte (&init_mm, vaddr, kmap_pte - idx, pteval); +arch_kmap_local_set_pte (&init_mm, vaddr, kmap_pte, pteval);arch_kmap_local_post_map (vaddr, pteval); current->kmap_ctrl.pteval[kmap_local_idx ()] = pteval;preempt_enable ();
@@ -559,7 +566,7 @@ EXPORT_SYMBOL(__kmap_local_page_prot);void kunmap_local_indexed (void *vaddr) {unsigned long addr = (unsigned long ) vaddr &PAGE_MASK ; -pte_t *kmap_pte =kmap_get_pte (); +pte_t *kmap_pte;int idx; if (addr < __fix_to_virt(FIX_KMAP_END) ||
@@ -584,8 +591,9 @@ void kunmap_local_indexed(void *vaddr) idx =arch_kmap_local_unmap_idx (kmap_local_idx (), addr);WARN_ON_ONCE (addr !=__fix_to_virt (FIX_KMAP_BEGIN + idx)); + kmap_pte =kmap_get_pte (addr, idx);arch_kmap_local_pre_unmap (addr); -pte_clear (&init_mm, addr, kmap_pte - idx); +pte_clear (&init_mm, addr, kmap_pte);arch_kmap_local_post_unmap (addr); current->kmap_ctrl.pteval[kmap_local_idx ()] =__pte (0 );kmap_local_idx_pop ();
@@ -607,7 +615,7 @@ EXPORT_SYMBOL(kunmap_local_indexed);void __kmap_local_sched_out (void ) {struct task_struct *tsk = current; -pte_t *kmap_pte =kmap_get_pte (); +pte_t *kmap_pte;int i;/* Clear kmaps */
@@ -634,8 +642,9 @@ void __kmap_local_sched_out(void) idx =arch_kmap_local_map_idx (i,pte_pfn (pteval)); addr =__fix_to_virt (FIX_KMAP_BEGIN + idx); + kmap_pte =kmap_get_pte (addr, idx);arch_kmap_local_pre_unmap (addr); -pte_clear (&init_mm, addr, kmap_pte - idx); +pte_clear (&init_mm, addr, kmap_pte);arch_kmap_local_post_unmap (addr); } }
@@ -643,7 +652,7 @@ void __kmap_local_sched_out(void)void __kmap_local_sched_in (void ) {struct task_struct *tsk = current; -pte_t *kmap_pte =kmap_get_pte (); +pte_t *kmap_pte;int i;/* Restore kmaps */
@@ -663,7 +672,8 @@ void __kmap_local_sched_in(void)/* See comment in __kmap_local_sched_out() */ idx =arch_kmap_local_map_idx (i,pte_pfn (pteval)); addr =__fix_to_virt (FIX_KMAP_BEGIN + idx); -set_pte_at (&init_mm, addr, kmap_pte - idx, pteval); + kmap_pte =kmap_get_pte (addr, idx); +set_pte_at (&init_mm, addr, kmap_pte, pteval);arch_kmap_local_post_map (addr, pteval); } }
mm/Kconfig renamed from mm/Kconfig~kmap_local-dont-assume-kmap-ptes-are-linear-arrays-in-memory +3 -0
@@ -890,6 +890,9 @@ config MAPPING_DIRTY_HELPERS config KMAP_LOCAL bool +config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY + bool + # struct io_mapping based helper. Selected by drivers that need them config IO_MAPPING bool
_
Andrew Morton
maintainerPATCH 15/15 proc/vmcore: fix clearing user buffer by properly using clear_user()
In reply to Andrew MortonFrom: David Hildenbrand <[email protected]>
Subject: proc/vmcore: fix clearing user buffer by properly using clear_user()
To clear a user buffer we cannot simply use memset, we have to use clear_user(). With a virtio-mem device that registers a vmcore_cb and has some logically unplugged memory inside an added Linux memory block, I can easily trigger a BUG by copying the vmcore via "cp":
[ 11.327580] systemd[1]: Starting Kdump Vmcore Save Service... [ 11.339697] kdump[420]: Kdump is using the default log level(3). [ 11.370964] kdump[453]: saving to /sysroot/var/crash/127.0.0.1-2021-11-11-14:59:22/ [ 11.373997] kdump[458]: saving vmcore-dmesg.txt to /sysroot/var/crash/127.0.0.1-2021-11-11-14:59:22/ [ 11.385357] kdump[465]: saving vmcore-dmesg.txt complete [ 11.386722] kdump[467]: saving vmcore [ 16.531275] BUG: unable to handle page fault for address: 00007f2374e01000 [ 16.531705] #PF: supervisor write access in kernel mode [ 16.532037] #PF: error_code(0x0003) - permissions violation [ 16.532396] PGD 7a523067 P4D 7a523067 PUD 7a528067 PMD 7a525067 PTE 800000007048f867 [ 16.532872] Oops: 0003 [#1] PREEMPT SMP NOPTI [ 16.533154] CPU: 0 PID: 468 Comm: cp Not tainted 5.15.0+ #6 [ 16.533513] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS rel-1.14.0-27-g64f37cc530f1-prebuilt.qemu.org 04/01/2014 [ 16.534198] RIP: 0010:read_from_oldmem.part.0.cold+0x1d/0x86 [ 16.534552] Code: ff ff ff e8 05 ff fe ff e9 b9 e9 7f ff 48 89 de 48 c7 c7 38 3b 60 82 e8 f1 fe fe ff 83 fd 08 72 3c 49 8d 7d 08 4c 89 e9 89 e8 <49> c7 45 00 00 00 00 00 49 c7 44 05 f8 00 00 00 00 48 83 e7 f81 [ 16.535670] RSP: 0018:ffffc9000073be08 EFLAGS: 00010212 [ 16.535998] RAX: 0000000000001000 RBX: 00000000002fd000 RCX: 00007f2374e01000 [ 16.536441] RDX: 0000000000000001 RSI: 00000000ffffdfff RDI: 00007f2374e01008 [ 16.536878] RBP: 0000000000001000 R08: 0000000000000000 R09: ffffc9000073bc50 [ 16.537315] R10: ffffc9000073bc48 R11: ffffffff829461a8 R12: 000000000000f000 [ 16.537755] R13: 00007f2374e01000 R14: 0000000000000000 R15: ffff88807bd421e8 [ 16.538200] FS: 00007f2374e12140(0000) GS:ffff88807f000000(0000) knlGS:0000000000000000 [ 16.538696] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 16.539055] CR2: 00007f2374e01000 CR3: 000000007a4aa000 CR4: 0000000000350eb0 [ 16.539510] Call Trace: [ 16.539679] <TASK> [ 16.539828] read_vmcore+0x236/0x2c0 [ 16.540063] ? enqueue_hrtimer+0x2f/0x80 [ 16.540323] ? inode_security+0x22/0x60 [ 16.540572] proc_reg_read+0x55/0xa0 [ 16.540807] vfs_read+0x95/0x190 [ 16.541022] ksys_read+0x4f/0xc0 [ 16.541238] do_syscall_64+0x3b/0x90 [ 16.541475] entry_SYSCALL_64_after_hwframe+0x44/0xae
Some x86-64 CPUs have a CPU feature called "Supervisor Mode Access Prevention (SMAP)", which is used to detect wrong access from the kernel to user buffers like this: SMAP triggers a permissions violation on wrong access. In the x86-64 variant of clear_user(), SMAP is properly handled via clac()+stac().
To fix, properly use clear_user() when we're dealing with a user buffer.
---
fs/proc/vmcore.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-)
fs/proc/vmcore.c renamed from fs/proc/vmcore.c~proc-vmcore-fix-clearing-user-buffer-by-properly-using-clear_user +12 -8
@@ -154,9 +154,13 @@ ssize_t read_from_oldmem(char *buf, size nr_bytes = count;/* If pfn is not ram, return zeros for sparse dump files */ -if (!pfn_is_ram (pfn)) -memset (buf,0 , nr_bytes); -else { +if (!pfn_is_ram (pfn)) { + tmp =0 ; +if (!userbuf) +memset (buf,0 , nr_bytes); +else if (clear_user (buf, nr_bytes)) + tmp = -EFAULT ; + }else {if (encrypted) tmp = copy_oldmem_page_encrypted(pfn, buf, nr_bytes,
@@ -165,12 +169,12 @@ ssize_t read_from_oldmem(char *buf, sizeelse tmp =copy_oldmem_page (pfn, buf, nr_bytes, offset, userbuf); - -if (tmp <0 ) { -up_read (&vmcore_cb_rwsem); -return tmp; - } } +if (tmp <0 ) { +up_read (&vmcore_cb_rwsem); +return tmp; + } + *ppos += nr_bytes; count -= nr_bytes; buf += nr_bytes;
_