introduce memory hinting API for external process
Subsystems (21)
v9 cover introduce memory hinting API for external process
Now, we have MADV_PAGEOUT and MADV_COLD as madvise hinting API. With that, application could give hints to kernel what memory range are preferred to be reclaimed. However, in some platform(e.g., Android), the information required to make the hinting decision is not known to the app.
Instead, it is known to a centralized userspace daemon(e.g., ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
To solve the concern, this patch introduces new syscall - process_madvise(2). Bascially, it's same with madvise(2) syscall but it has some differences.
1. It needs pidfd of target process to provide the hint
2. It supports only MADV_{COLD|PAGEOUT} at this moment.
Other hints in madvise will be opened when there are explicit requests from community to prevent unexpected bugs we couldn't support.
3. Only privileged processes can do something for other process's address space.
For more detail of the new API, please see "mm: introduce external memory hinting API" description in this patchset.
* from v8 - https://lore.kernel.org/linux-api/[email protected]/
* drop passing task_struct to do_madvise - Linus
* remove compat syscall entry - Christian
* drop mmget_still_valid since we don't need any longer
* https://patchwork.kernel.org/patch/11740595/
* from v7 - http://lore.kernel.org/r/[email protected]
* dropping pid support from new syscall and fold releated patches into syscall patch
* dropping KSM patch by discussion - Oleksandr, I lost the discussion. Please resend the single patch against of the patchset if you resolves the discussion.
https://lore.kernel.org/linux-api/[email protected]/
* from v6 - https://lore.kernel.org/linux-api/[email protected]/
* fix comments and descriptions - Suren
* Add Reviewed-by - Suren
* fix build break reported by 0-day
* from v5 - https://lore.kernel.org/linux-mm/[email protected]/
* use null task and requestor's mm for io_madvise - Jann and Jens
* use right commit description for moving pidfd_get_pid - Christian
* from v4 - https://lore.kernel.org/linux-mm/[email protected]/
* pass mm down to functions, not accessing task->mm - Jann
* clean up - Alexander
* add Reviewed-by - Alexander, SeongJae
* patch reordering
* from v3 - https://lore.kernel.org/linux-mm/[email protected]/
* verify task->mm aftere access_mm - Oleg
* split some patches for easy review - Alexander
* clean up fatal signal checking - Suren
* from v2 - https://lore.kernel.org/linux-mm/[email protected]/
* check signal callee and caller to bail out - Kirill Tkhai
* put more clarification for justification of new API
* from v1 - https://lore.kernel.org/linux-mm/[email protected]/
* fix syscall number - SeongJae
* use get_pid_task - Kirill Tkhai
* extend API to support pid as well as pidfd - Kirill Tkhai
This patchset is against on v5.9-rc2-mmots-2020-08-30-18-40.
Minchan Kim (3):
mm/madvise: pass mm to do_madvise
pid: move pidfd_get_pid() to pid.c
mm/madvise: introduce process_madvise() syscall: an external memory
hinting API
arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/include/asm/unistd.h | 2 +- arch/arm64/include/asm/unistd32.h | 2 + arch/ia64/kernel/syscalls/syscall.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + fs/io_uring.c | 2 +- include/linux/mm.h | 2 +- include/linux/pid.h | 1 + include/linux/syscalls.h | 2 + include/uapi/asm-generic/unistd.h | 4 +- kernel/exit.c | 17 --- kernel/pid.c | 17 +++ kernel/sys_ni.c | 1 + mm/madvise.c | 141 ++++++++++++++++++-- 26 files changed, 171 insertions(+), 35 deletions(-)
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v9 1/3 mm/madvise: pass mm to do_madvise
Patch series "introduce memory hinting API for external process", v9.
Now, we have MADV_PAGEOUT and MADV_COLD as madvise hinting API. With that, application could give hints to kernel what memory range are preferred to be reclaimed. However, in some platform(e.g., Android), the information required to make the hinting decision is not known to the app. Instead, it is known to a centralized userspace daemon(e.g., ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
To solve the concern, this patch introduces new syscall - process_madvise(2). Bascially, it's same with madvise(2) syscall but it has some differences.
1. It needs pidfd of target process to provide the hint
2. It supports only MADV_{COLD|PAGEOUT|MERGEABLE|UNMEREABLE} at this moment. Other hints in madvise will be opened when there are explicit requests from community to prevent unexpected bugs we couldn't support.
3. Only privileged processes can do something for other process's address space.
For more detail of the new API, please see "mm: introduce external memory hinting API" description in this patchset.
This patch (of 4):
In upcoming patches, do_madvise will be called from external process context so we shouldn't asssume "current" is always hinted process's task_struct.
Furthermore, we must not access mm_struct via task->mm, but obtain it via access_mm() once (in the following patch) and only use that pointer [1], so pass it to do_madvise() as well. Note the vma->vm_mm pointers are safe, so we can use them further down the call stack.
And let's pass current->mm as arguments of do_madvise so it shouldn't change existing behavior but prepare next patch to make review easy.
--- fs/io_uring.c | 2 +- include/linux/mm.h | 2 +- mm/madvise.c | 32 ++++++++++++++++++-------------- 3 files changed, 20 insertions(+), 16 deletions(-)
fs/io_uring.c +1 -1
@@ -3823,7 +3823,7 @@ static int io_madvise(struct io_kiocb *req, bool force_nonblock)if (force_nonblock)return -EAGAIN ; - ret =do_madvise (ma->addr, ma->len, ma->advice); + ret =do_madvise (current->mm, ma->addr, ma->len, ma->advice);if (ret <0 )req_set_fail_links (req);io_req_complete (req, ret);
include/linux/mm.h +1 -1
@@ -2570,7 +2570,7 @@ extern int __do_munmap(struct mm_struct *, unsigned long, size_t, struct list_head *uf, bool downgrade);extern int do_munmap (struct mm_struct *,unsigned long ,size_t ,struct list_head *uf); -extern int do_madvise (unsigned long start,size_t len_in,int behavior); +extern int do_madvise (struct mm_struct *mm,unsigned long start,size_t len_in,int behavior);#ifdef CONFIG_MMU extern int __mm_populate(unsigned long addr, unsigned long len,
mm/madvise.c +18 -14
@@ -255,6 +255,7 @@ static long madvise_willneed(struct vm_area_struct *vma,struct vm_area_struct **prev, unsigned long start, unsigned long end) { + struct mm_struct *mm = vma->vm_mm;struct file *file = vma->vm_file;loff_t offset;
@@ -291,10 +292,10 @@ static long madvise_willneed(struct vm_area_struct *vma,get_file (file); offset = (loff_t)(start - vma->vm_start) + ((loff_t )vma->vm_pgoff <<PAGE_SHIFT ); -mmap_read_unlock (current->mm); +mmap_read_unlock (mm);vfs_fadvise (file, offset, end - start,POSIX_FADV_WILLNEED );fput (file); -mmap_read_lock (current->mm); +mmap_read_lock (mm);return 0 ; }
@@ -763,6 +764,8 @@ static long madvise_dontneed_free(struct vm_area_struct *vma, unsigned long start, unsigned long end, int behavior) { + struct mm_struct *mm = vma->vm_mm; + *prev = vma;if (!can_madv_lru_vma (vma))return -EINVAL ;
@@ -770,8 +773,8 @@ static long madvise_dontneed_free(struct vm_area_struct *vma,if (!userfaultfd_remove (vma, start, end)) { *prev =NULL ;/* mmap_lock has been dropped, prev is stale */ -mmap_read_lock (current->mm); - vma =find_vma (current->mm, start); +mmap_read_lock (mm); + vma =find_vma (mm, start);if (!vma)return -ENOMEM ;if (start < vma->vm_start) {
@@ -825,6 +828,7 @@ static long madvise_remove(struct vm_area_struct *vma,loff_t offset;int error;struct file *f; +struct mm_struct *mm = vma->vm_mm; *prev =NULL ;/* tell sys_madvise we drop mmap_lock */
@@ -852,13 +856,13 @@ static long madvise_remove(struct vm_area_struct *vma,get_file (f);if (userfaultfd_remove (vma, start, end)) {/* mmap_lock was not released by userfaultfd_remove() */ -mmap_read_unlock (current->mm); +mmap_read_unlock (mm); } error =vfs_fallocate (f,FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , offset, end - start);fput (f); -mmap_read_lock (current->mm); +mmap_read_lock (mm);return error; }
@@ -1046,7 +1050,7 @@ madvise_behavior_valid(int behavior)* -EBADF - map exists, but area maps something that isn't a file. * -EAGAIN - a kernel resource was temporarily unavailable. */ -int do_madvise (unsigned long start,size_t len_in,int behavior) +int do_madvise (struct mm_struct *mm,unsigned long start,size_t len_in,int behavior) {unsigned long end, tmp;struct vm_area_struct *vma, *prev;
@@ -1084,10 +1088,10 @@ int do_madvise(unsigned long start, size_t len_in, int behavior) write =madvise_need_mmap_write (behavior);if (write) { -if (mmap_write_lock_killable (current->mm)) +if (mmap_write_lock_killable (mm))return -EINTR ; }else { -mmap_read_lock (current->mm); +mmap_read_lock (mm); }/*
@@ -1095,7 +1099,7 @@ int do_madvise(unsigned long start, size_t len_in, int behavior)* ranges, just ignore them, but return -ENOMEM at the end. * - different from the way of handling in mlock etc. */ - vma =find_vma_prev (current->mm, start, &prev); + vma =find_vma_prev (mm, start, &prev);if (vma && start > vma->vm_start) prev = vma;
@@ -1132,19 +1136,19 @@ int do_madvise(unsigned long start, size_t len_in, int behavior)if (prev) vma = prev->vm_next;else /* madvise_remove dropped mmap_lock */ - vma =find_vma (current->mm, start); + vma =find_vma (mm, start); } out:blk_finish_plug (&plug);if (write) -mmap_write_unlock (current->mm); +mmap_write_unlock (mm);else -mmap_read_unlock (current->mm); +mmap_read_unlock (mm);return error; } SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) { -return do_madvise (start, len_in, behavior); +return do_madvise (current->mm, start, len_in, behavior); }
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v9 2/3 pid: move pidfd_get_pid() to pid.c
In reply to Minchan Kimprocess_madvise syscall needs pidfd_get_pid function to translate pidfd to pid so this patch move the function to kernel/pid.c.
--- include/linux/pid.h | 1 + kernel/exit.c | 17 ----------------- kernel/pid.c | 17 +++++++++++++++++ 3 files changed, 18 insertions(+), 17 deletions(-)
include/linux/pid.h +1 -0
@@ -77,6 +77,7 @@ extern const struct file_operations pidfd_fops;struct file ;extern struct pid *pidfd_pid (const struct file *file); +struct pid *pidfd_get_pid (unsigned int fd);static inline struct pid *get_pid (struct pid *pid) {
kernel/exit.c +0 -17
@@ -1474,23 +1474,6 @@ static long do_wait(struct wait_opts *wo)return retval; } -static struct pid *pidfd_get_pid (unsigned int fd) -{ -struct fd f; -struct pid *pid; - - f =fdget (fd); -if (!f.file) -return ERR_PTR (-EBADF ); - - pid =pidfd_pid (f.file); -if (!IS_ERR (pid)) -get_pid (pid); - -fdput (f); -return pid; -} -static long kernel_waitid (int which,pid_t upid,struct waitid_info *infop,int options,struct rusage *ru) {
kernel/pid.c +17 -0
@@ -519,6 +519,23 @@ struct pid *find_ge_pid(int nr, struct pid_namespace *ns)return idr_get_next (&ns->idr, &nr); } +struct pid *pidfd_get_pid (unsigned int fd) +{ +struct fd f; +struct pid *pid; + + f =fdget (fd); +if (!f.file) +return ERR_PTR (-EBADF ); + + pid =pidfd_pid (f.file); +if (!IS_ERR (pid)) +get_pid (pid); + +fdput (f); +return pid; +} +/** * pidfd_create() - Create a new pid file descriptor. *
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v9 3/3 mm/madvise: introduce process_madvise() syscall: an external memory hinting API
In reply to Minchan KimThere is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
To solve the issue, this patch introduces a new syscall process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).
Another potential use case for the vector range is to amortize the cost ofTLB shootdowns for multiple ranges when using MADV_DONTNEED; this could benefit users like TCP receive zerocopy and malloc implementations. In future, we could find more usecases for other advises so let's make it happens as API since we introduce a new syscall at this moment. With that, existing madvise(2) user could replace it with process_madvise(2) with their own pid if they want to have batch address ranges support feature.
ince it could affect other process's address range, only privileged process(PTRACE_MODE_ATTACH_FSCREDS) or something else(e.g., being the same UID) gives it the right to ptrace the process could use it successfully. The flag argument is reserved for future use if we need to extend the API.
I think supporting all hints madvise has/will supported/support to process_madvise is rather risky. Because we are not sure all hints make sense from external process and implementation for the hint may rely on the caller being in the current context so it could be error-prone. Thus, I just limited hints as MADV_[COLD|PAGEOUT] in this patch.
If someone want to add other hints, we could hear the usecase and review it for each hint. It's safer for maintenance rather than introducing a buggy syscall but hard to fix it later.
So finally, the API is as follows,
ssize_t process_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
DESCRIPTION
The process_madvise() system call is used to give advice or directions to the kernel about the address ranges from external process as well as local process. It provides the advice to address ranges of process described by iovec and vlen. The goal of such advice is to improve system or application performance.
The pidfd selects the process referred to by the PID file descriptor specified in pidfd. (See pidofd_open(2) for further information)
The pointer iovec points to an array of iovec structures, defined in <sys/uio.h> as:
struct iovec {
void *iov_base; /* starting address */
size_t iov_len; /* number of bytes to be advised */
};
The iovec describes address ranges beginning at address(iov_base) and with size length of bytes(iov_len).
The vlen represents the number of elements in iovec.
The advice is indicated in the advice argument, which is one of the following at this moment if the target process specified by pidfd is external.
MADV_COLD
MADV_PAGEOUT
Permission to provide a hint to external process is governed by a ptrace access mode PTRACE_MODE_ATTACH_FSCREDS check; see ptrace(2).
The process_madvise supports every advice madvise(2) has if target process is in same thread group with calling process so user could use process_madvise(2) to extend existing madvise(2) to support vector address ranges.
RETURN VALUE
On success, process_madvise() returns the number of bytes advised. This return value may be less than the total number of requested bytes, if an error occurred. The caller should check return value to determine whether a partial advice occurred.
FAQ:
Q.1 - Why does any external entity have better knowledge?
Quote from Sandeep
"For Android, every application (including the special SystemServer) are forked from Zygote. The reason of course is to share as many libraries and classes between the two as possible to benefit from the preloading during boot.
After applications start, (almost) all of the APIs end up calling into this SystemServer process over IPC (binder) and back to the application.
In a fully running system, the SystemServer monitors every single process periodically to calculate their PSS / RSS and also decides which process is "important" to the user for interactivity.
So, because of how these processes start _and_ the fact that the SystemServer is looping to monitor each process, it does tend to *know* which address range of the application is not used / useful.
Besides, we can never rely on applications to clean things up themselves. We've had the "hey app1, the system is low on memory, please trim your memory usage down" notifications for a long time[1]. They rely on applications honoring the broadcasts and very few do.
So, if we want to avoid the inevitable killing of the application and restarting it, some way to be able to tell the OS about unimportant memory in these applications will be useful.
- ssp
Q.2 - How to guarantee the race(i.e., object validation) between when giving a hint from an external process and get the hint from the target process?
process_madvise operates on the target process's address space as it exists at the instant that process_madvise is called. If the space target process can run between the time the process_madvise process inspects the target process address space and the time that process_madvise is actually called, process_madvise may operate on memory regions that the calling process does not expect. It's the responsibility of the process calling process_madvise to close this race condition. For example, the calling process can suspend the target process with ptrace, SIGSTOP, or the freezer cgroup so that it doesn't have an opportunity to change its own address space before process_madvise is called. Another option is to operate on memory regions that the caller knows a priori will be unchanged in the target process. Yet another option is to accept the race for certain process_madvise calls after reasoning that mistargeting will do no harm. The suggested API itself does not provide synchronization. It also apply other APIs like move_pages, process_vm_write.
The race isn't really a problem though. Why is it so wrong to require that callers do their own synchronization in some manner? Nobody objects to write(2) merely because it's possible for two processes to open the same file and clobber each other's writes --- instead, we tell people to use flock or something. Think about mmap. It never guarantees newly allocated address space is still valid when the user tries to access it because other threads could unmap the memory right before. That's where we need synchronization by using other API or design from userside. It shouldn't be part of API itself. If someone needs more fine-grained synchronization rather than process level, there were two ideas suggested - cookie[2] and anon-fd[3]. Both are applicable via using last reserved argument of the API but I don't think it's necessary right now since we have already ways to prevent the race so don't want to add additional complexity with more fine-grained optimization model.
To make the API extend, it reserved an unsigned long as last argument so we could support it in future if someone really needs it.
Q.3 - Why doesn't ptrace work?
Injecting an madvise in the target process using ptrace would not work for us because such injected madvise would have to be executed by the target process, which means that process would have to be runnable and that creates the risk of the abovementioned race and hinting a wrong VMA. Furthermore, we want to act the hint in caller's context, not the callee's, because the callee is usually limited in cpuset/cgroups or even freezed state so they can't act by themselves quick enough, which causes more thrashing/kill. It doesn't work if the target process are ptraced(e.g., strace, debugger, minidump) because a process can have at most one ptracer.
[1] https://developer.android.com/topic/performance/memory"
[2] process_getinfo for getting the cookie which is updated whenever vma of process address layout are changed - Daniel Colascione -
https://lore.kernel.org/lkml/[email protected]/T/#m7694416fd179b2066a2c62b5b139b14e3894e224
[3] anonymous fd which is used for the object(i.e., address range) validation - Michal Hocko -
https://lore.kernel.org/lkml/[email protected]/
--- arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/include/asm/unistd.h | 2 +- arch/arm64/include/asm/unistd32.h | 2 + arch/ia64/kernel/syscalls/syscall.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + include/linux/syscalls.h | 2 + include/uapi/asm-generic/unistd.h | 4 +- kernel/sys_ni.c | 1 + mm/madvise.c | 109 ++++++++++++++++++++ 21 files changed, 133 insertions(+), 2 deletions(-)
arch/alpha/kernel/syscalls/syscall.tbl +1 -0
@@ -480,3 +480,4 @@ 548 common pidfd_getfd sys_pidfd_getfd 549 common faccessat2 sys_faccessat2 550 common watch_mount sys_watch_mount +551 common process_madvise sys_process_madvise
arch/arm/tools/syscall.tbl +1 -0
@@ -454,3 +454,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/arm64/include/asm/unistd.h +1 -1
@@ -38,7 +38,7 @@#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800) -#define __NR_compat_syscalls 441 +#define __NR_compat_syscalls 442#endif #define __ARCH_WANT_SYS_CLONE
arch/arm64/include/asm/unistd32.h +2 -0
@@ -889,6 +889,8 @@ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd) __SYSCALL(__NR_faccessat2, sys_faccessat2)#define __NR_watch_mount 440 __SYSCALL(__NR_watch_mount, sys_watch_mount) +#define __NR_watch_mount 441 +__SYSCALL (__NR_process_madvise, sys_process_madvise)/* * Please add new compat syscalls above this comment and update
arch/ia64/kernel/syscalls/syscall.tbl +1 -0
@@ -361,3 +361,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/m68k/kernel/syscalls/syscall.tbl +1 -0
@@ -440,3 +440,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/microblaze/kernel/syscalls/syscall.tbl +1 -0
@@ -446,3 +446,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/mips/kernel/syscalls/syscall_n32.tbl +1 -0
@@ -379,3 +379,4 @@ 438 n32 pidfd_getfd sys_pidfd_getfd 439 n32 faccessat2 sys_faccessat2 440 n32 watch_mount sys_watch_mount +441 n32 process_madvise sys_process_madvise
arch/mips/kernel/syscalls/syscall_o32.tbl +1 -0
@@ -428,3 +428,4 @@ 438 o32 pidfd_getfd sys_pidfd_getfd 439 o32 faccessat2 sys_faccessat2 440 o32 watch_mount sys_watch_mount +441 o32 process_madvise sys_process_madvise
arch/parisc/kernel/syscalls/syscall.tbl +1 -0
@@ -438,3 +438,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/powerpc/kernel/syscalls/syscall.tbl +1 -0
@@ -530,3 +530,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/s390/kernel/syscalls/syscall.tbl +1 -0
@@ -443,3 +443,4 @@ 438 common pidfd_getfd sys_pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise sys_process_madvise
arch/sh/kernel/syscalls/syscall.tbl +1 -0
@@ -443,3 +443,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/sparc/kernel/syscalls/syscall.tbl +1 -0
@@ -486,3 +486,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
@@ -445,3 +445,4 @@ 438 i386 pidfd_getfd sys_pidfd_getfd 439 i386 faccessat2 sys_faccessat2 440 i386 watch_mount sys_watch_mount +441 i386 process_madvise sys_process_madvise
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
@@ -362,6 +362,7 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise # # x32-specific system call numbers start at 512 to avoid cache impact
arch/xtensa/kernel/syscalls/syscall.tbl +1 -0
@@ -411,3 +411,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
include/linux/syscalls.h +2 -0
@@ -879,6 +879,8 @@ asmlinkage long sys_munlockall(void);asmlinkage long sys_mincore (unsigned long start,size_t len,unsigned char __user * vec);asmlinkage long sys_madvise (unsigned long start,size_t len,int behavior); +asmlinkage long sys_process_madvise (int pidfd,const struct iovec __user *vec, +unsigned long vlen,int behavior,unsigned int flags);asmlinkage long sys_remap_file_pages (unsigned long start,unsigned long size,unsigned long prot,unsigned long pgoff,unsigned long flags);
include/uapi/asm-generic/unistd.h +3 -1
@@ -861,9 +861,11 @@ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd) __SYSCALL(__NR_faccessat2, sys_faccessat2)#define __NR_watch_mount 440 __SYSCALL(__NR_watch_mount, sys_watch_mount) +#define __NR_watch_mount 441 +__SYSCALL(__NR_process_madvise, sys_process_madvise)#undef __NR_syscalls -#define __NR_syscalls 441 +#define __NR_syscalls 442/* * 32 bit systems traditionally used different
kernel/sys_ni.c +1 -0
@@ -283,6 +283,7 @@ COND_SYSCALL(mlockall);COND_SYSCALL (munlockall);COND_SYSCALL (mincore);COND_SYSCALL (madvise); +COND_SYSCALL (process_madvise);COND_SYSCALL (remap_file_pages);COND_SYSCALL (mbind);COND_SYSCALL_COMPAT (mbind);
mm/madvise.c +109 -0
130 lines not on this page · raw message
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
* Minchan Kim:
Quoted 2 lines
ssize_tprocess_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
size_t for vlen provides a clearer hint regarding the type of special treatment needed for ILP32 here (zero extension, not changing the type to long long).
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 9 lines · Florian Weimer
* Minchan Kim:
Quoted 2 lines
ssize_tprocess_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
size_tfor vlen provides a clearer hint regarding the type of special treatment needed for ILP32 here (zero extension, not changing the type to long long).
All existing system calls using iove in Linux uses unsigned long so I want to be consistent with them unless process_madvise need something speicial.
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
* Minchan Kim:
Quoted 6 lines · Florian Weimer
Quoted 5 lines
* Minchan Kim:
Quoted 2 lines
ssize_tprocess_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
Quoted 8 lines
Quoted 4 lines
size_tfor vlen provides a clearer hint regarding the type of special treatment needed for ILP32 here (zero extension, not changing the type to long long).All existing system calls using iove in Linux uses unsigned long so I want to be consistent with them unless
process_madviseneed something speicial.
Userspace uses int, following POSIX (where applicable). There is no consistency to be had here.
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 13 lines · Florian Weimer
* Minchan Kim:
Quoted 11 lines · Florian Weimer
Quoted 9 lines
* Minchan Kim:
Quoted 2 lines
ssize_tprocess_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
size_tfor vlen provides a clearer hint regarding the type of special treatment needed for ILP32 here (zero extension, not changing the type to long long).
Quoted 6 lines
Quoted 3 lines
All existing system calls using iove in Linux uses unsigned long so I want to be consistent with them unless
process_madviseneed something speicial.Userspace uses int, following POSIX (where applicable). There is no consistency to be had here.
Okay, I changed it with size_t.
From c9f079a2008fd05a38d3f0fd69c2c0e586e8ee7a Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Mon, 31 Aug 2020 15:36:30 -0700
Subject: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an
external memory hinting API
There is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
To solve the issue, this patch introduces a new syscall process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).
Another potential use case for the vector range is to amortize the cost ofTLB shootdowns for multiple ranges when using MADV_DONTNEED; this could benefit users like TCP receive zerocopy and malloc implementations. In future, we could find more usecases for other advises so let's make it happens as API since we introduce a new syscall at this moment. With that, existing madvise(2) user could replace it with process_madvise(2) with their own pid if they want to have batch address ranges support feature.
ince it could affect other process's address range, only privileged process(PTRACE_MODE_ATTACH_FSCREDS) or something else(e.g., being the same UID) gives it the right to ptrace the process could use it successfully. The flag argument is reserved for future use if we need to extend the API.
I think supporting all hints madvise has/will supported/support to process_madvise is rather risky. Because we are not sure all hints make sense from external process and implementation for the hint may rely on the caller being in the current context so it could be error-prone. Thus, I just limited hints as MADV_[COLD|PAGEOUT] in this patch.
If someone want to add other hints, we could hear the usecase and review it for each hint. It's safer for maintenance rather than introducing a buggy syscall but hard to fix it later.
So finally, the API is as follows,
ssize_t process_madvise(int pidfd, const struct iovec *iovec,
size_t vlen, int advice, unsigned int flags);
DESCRIPTION
The process_madvise() system call is used to give advice or directions to the kernel about the address ranges from external process as well as local process. It provides the advice to address ranges of process described by iovec and vlen. The goal of such advice is to improve system or application performance.
The pidfd selects the process referred to by the PID file descriptor specified in pidfd. (See pidofd_open(2) for further information)
The pointer iovec points to an array of iovec structures, defined in <sys/uio.h> as:
struct iovec {
void *iov_base; /* starting address */
size_t iov_len; /* number of bytes to be advised */
};
The iovec describes address ranges beginning at address(iov_base) and with size length of bytes(iov_len).
The vlen represents the number of elements in iovec.
The advice is indicated in the advice argument, which is one of the following at this moment if the target process specified by pidfd is external.
MADV_COLD
MADV_PAGEOUT
Permission to provide a hint to external process is governed by a ptrace access mode PTRACE_MODE_ATTACH_FSCREDS check; see ptrace(2).
The process_madvise supports every advice madvise(2) has if target process is in same thread group with calling process so user could use process_madvise(2) to extend existing madvise(2) to support vector address ranges.
RETURN VALUE
On success, process_madvise() returns the number of bytes advised. This return value may be less than the total number of requested bytes, if an error occurred. The caller should check return value to determine whether a partial advice occurred.
FAQ:
Q.1 - Why does any external entity have better knowledge?
Quote from Sandeep
"For Android, every application (including the special SystemServer) are forked from Zygote. The reason of course is to share as many libraries and classes between the two as possible to benefit from the preloading during boot.
After applications start, (almost) all of the APIs end up calling into this SystemServer process over IPC (binder) and back to the application.
In a fully running system, the SystemServer monitors every single process periodically to calculate their PSS / RSS and also decides which process is "important" to the user for interactivity.
So, because of how these processes start _and_ the fact that the SystemServer is looping to monitor each process, it does tend to *know* which address range of the application is not used / useful.
Besides, we can never rely on applications to clean things up themselves. We've had the "hey app1, the system is low on memory, please trim your memory usage down" notifications for a long time[1]. They rely on applications honoring the broadcasts and very few do.
So, if we want to avoid the inevitable killing of the application and restarting it, some way to be able to tell the OS about unimportant memory in these applications will be useful.
- ssp
Q.2 - How to guarantee the race(i.e., object validation) between when giving a hint from an external process and get the hint from the target process?
process_madvise operates on the target process's address space as it exists at the instant that process_madvise is called. If the space target process can run between the time the process_madvise process inspects the target process address space and the time that process_madvise is actually called, process_madvise may operate on memory regions that the calling process does not expect. It's the responsibility of the process calling process_madvise to close this race condition. For example, the calling process can suspend the target process with ptrace, SIGSTOP, or the freezer cgroup so that it doesn't have an opportunity to change its own address space before process_madvise is called. Another option is to operate on memory regions that the caller knows a priori will be unchanged in the target process. Yet another option is to accept the race for certain process_madvise calls after reasoning that mistargeting will do no harm. The suggested API itself does not provide synchronization. It also apply other APIs like move_pages, process_vm_write.
The race isn't really a problem though. Why is it so wrong to require that callers do their own synchronization in some manner? Nobody objects to write(2) merely because it's possible for two processes to open the same file and clobber each other's writes --- instead, we tell people to use flock or something. Think about mmap. It never guarantees newly allocated address space is still valid when the user tries to access it because other threads could unmap the memory right before. That's where we need synchronization by using other API or design from userside. It shouldn't be part of API itself. If someone needs more fine-grained synchronization rather than process level, there were two ideas suggested - cookie[2] and anon-fd[3]. Both are applicable via using last reserved argument of the API but I don't think it's necessary right now since we have already ways to prevent the race so don't want to add additional complexity with more fine-grained optimization model.
To make the API extend, it reserved an unsigned long as last argument so we could support it in future if someone really needs it.
Q.3 - Why doesn't ptrace work?
Injecting an madvise in the target process using ptrace would not work for us because such injected madvise would have to be executed by the target process, which means that process would have to be runnable and that creates the risk of the abovementioned race and hinting a wrong VMA. Furthermore, we want to act the hint in caller's context, not the callee's, because the callee is usually limited in cpuset/cgroups or even freezed state so they can't act by themselves quick enough, which causes more thrashing/kill. It doesn't work if the target process are ptraced(e.g., strace, debugger, minidump) because a process can have at most one ptracer.
[1] https://developer.android.com/topic/performance/memory"
[2] process_getinfo for getting the cookie which is updated whenever vma of process address layout are changed - Daniel Colascione -
https://lore.kernel.org/lkml/[email protected]/T/#m7694416fd179b2066a2c62b5b139b14e3894e224
[3] anonymous fd which is used for the object(i.e., address range) validation - Michal Hocko -
https://lore.kernel.org/lkml/[email protected]/
--- arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/include/asm/unistd.h | 2 +- arch/arm64/include/asm/unistd32.h | 2 + arch/ia64/kernel/syscalls/syscall.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + include/linux/syscalls.h | 2 + include/uapi/asm-generic/unistd.h | 4 +- kernel/sys_ni.c | 1 + mm/madvise.c | 109 ++++++++++++++++++++ 21 files changed, 133 insertions(+), 2 deletions(-)
arch/alpha/kernel/syscalls/syscall.tbl +1 -0
@@ -480,3 +480,4 @@ 548 common pidfd_getfd sys_pidfd_getfd 549 common faccessat2 sys_faccessat2 550 common watch_mount sys_watch_mount +551 common process_madvise sys_process_madvise
arch/arm/tools/syscall.tbl +1 -0
@@ -454,3 +454,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/arm64/include/asm/unistd.h +1 -1
@@ -38,7 +38,7 @@#define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)#define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800) -#define __NR_compat_syscalls 441 +#define __NR_compat_syscalls 442#endif #define __ARCH_WANT_SYS_CLONE
arch/arm64/include/asm/unistd32.h +2 -0
@@ -889,6 +889,8 @@ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd) __SYSCALL(__NR_faccessat2, sys_faccessat2)#define __NR_watch_mount 440 __SYSCALL(__NR_watch_mount, sys_watch_mount) +#define __NR_watch_mount 441 +__SYSCALL (__NR_process_madvise, sys_process_madvise)/* * Please add new compat syscalls above this comment and update
arch/ia64/kernel/syscalls/syscall.tbl +1 -0
@@ -361,3 +361,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/m68k/kernel/syscalls/syscall.tbl +1 -0
@@ -440,3 +440,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/microblaze/kernel/syscalls/syscall.tbl +1 -0
@@ -446,3 +446,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/mips/kernel/syscalls/syscall_n32.tbl +1 -0
@@ -379,3 +379,4 @@ 438 n32 pidfd_getfd sys_pidfd_getfd 439 n32 faccessat2 sys_faccessat2 440 n32 watch_mount sys_watch_mount +441 n32 process_madvise sys_process_madvise
arch/mips/kernel/syscalls/syscall_o32.tbl +1 -0
@@ -428,3 +428,4 @@ 438 o32 pidfd_getfd sys_pidfd_getfd 439 o32 faccessat2 sys_faccessat2 440 o32 watch_mount sys_watch_mount +441 o32 process_madvise sys_process_madvise
arch/parisc/kernel/syscalls/syscall.tbl +1 -0
@@ -438,3 +438,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/powerpc/kernel/syscalls/syscall.tbl +1 -0
@@ -530,3 +530,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/s390/kernel/syscalls/syscall.tbl +1 -0
@@ -443,3 +443,4 @@ 438 common pidfd_getfd sys_pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise sys_process_madvise
arch/sh/kernel/syscalls/syscall.tbl +1 -0
@@ -443,3 +443,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/sparc/kernel/syscalls/syscall.tbl +1 -0
@@ -486,3 +486,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
@@ -445,3 +445,4 @@ 438 i386 pidfd_getfd sys_pidfd_getfd 439 i386 faccessat2 sys_faccessat2 440 i386 watch_mount sys_watch_mount +441 i386 process_madvise sys_process_madvise
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
@@ -362,6 +362,7 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise # # x32-specific system call numbers start at 512 to avoid cache impact
arch/xtensa/kernel/syscalls/syscall.tbl +1 -0
@@ -411,3 +411,4 @@ 438 common pidfd_getfd sys_pidfd_getfd 439 common faccessat2 sys_faccessat2 440 common watch_mount sys_watch_mount +441 common process_madvise sys_process_madvise
include/linux/syscalls.h +2 -0
@@ -879,6 +879,8 @@ asmlinkage long sys_munlockall(void);asmlinkage long sys_mincore (unsigned long start,size_t len,unsigned char __user * vec);asmlinkage long sys_madvise (unsigned long start,size_t len,int behavior); +asmlinkage long sys_process_madvise (int pidfd,const struct iovec __user *vec, +size_t vlen,int behavior,unsigned int flags);asmlinkage long sys_remap_file_pages (unsigned long start,unsigned long size,unsigned long prot,unsigned long pgoff,unsigned long flags);
include/uapi/asm-generic/unistd.h +3 -1
@@ -861,9 +861,11 @@ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd) __SYSCALL(__NR_faccessat2, sys_faccessat2)#define __NR_watch_mount 440 __SYSCALL(__NR_watch_mount, sys_watch_mount) +#define __NR_watch_mount 441 +__SYSCALL(__NR_process_madvise, sys_process_madvise)#undef __NR_syscalls -#define __NR_syscalls 441 +#define __NR_syscalls 442/* * 32 bit systems traditionally used different
kernel/sys_ni.c +1 -0
@@ -283,6 +283,7 @@ COND_SYSCALL(mlockall);COND_SYSCALL (munlockall);COND_SYSCALL (mincore);COND_SYSCALL (madvise); +COND_SYSCALL (process_madvise);COND_SYSCALL (remap_file_pages);COND_SYSCALL (mbind);COND_SYSCALL_COMPAT (mbind);
mm/madvise.c +109 -0
130 lines not on this page · raw message
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 14 lines · Minchan Kim
Quoted 13 lines · Florian Weimer
* Minchan Kim:
Quoted 11 lines · Florian Weimer
Quoted 9 lines
* Minchan Kim:
Quoted 2 lines
ssize_tprocess_madvise(int pidfd, const struct iovec *iovec,
unsigned long vlen, int advice, unsigned int flags);
size_tfor vlen provides a clearer hint regarding the type of special treatment needed for ILP32 here (zero extension, not changing the type to long long).
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
All existing system calls using iove in Linux uses unsigned long so I want to be consistent with them unless
process_madviseneed something speicial.Userspace uses int, following POSIX (where applicable). There is no consistency to be had here.
Okay, I changed it with
size_t.
Maybe some context helps. We had the discussion about syscall conventions during LPC both in the KernelSummit and in the glibc toolchain session and one of wishlist conventions from libc was to always use size_t and not unsigned long for sizes.
I know this has been a little frustrating having to change types and so on for the syscall quite a bit but I'm going to start drafting an updated version of our howto for adding syscalls now so things like this are more transparent going forward. I just hadn't gotten around to it right after Plumbers.
Christian
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
In reply to Minchan KimQuoted 9 lines · Minchan Kim
There is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
Quoted 8 lines
To solve the issue, this patch introduces a new syscall
process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).
I'm really not sure this syscall is a good idea. If you want central control you should implement an IPC mechanisms that allows your supervisor daemon to tell the application to perform the madvice instead of forcing the behavior on it.
mm/madvise.c madvise_behavior_valid(int behavior) · line 1056
Quoted 12 lines
/*
* The madvise(2) system call.
*mm/madvise.c +5
-0@@ -1036,6 +1049,11 @@ madvise_behavior_valid(int behavior)* MADV_DONTDUMP - the application wants to prevent pages in the given range * from being included in its core dump. * MADV_DODUMP - cancel MADV_DONTDUMP: no longer exclude from core dump. +* MADV_COLD - the application is not expected to use this memory soon, +* deactivate pages in this range so that they can be reclaimed +* easily if memory pressure hanppens. +* MADV_PAGEOUT - the application is not expected to use this memory soon, +* page out the pages in this range immediately.
This should really go into a separate patch, as it has nothing to do with the new syscall.
Quoted 4 lines
mm/madvise.c +4
-0+static int process_madvise_vec (struct mm_struct *mm,struct iov_iter *iter,int behavior) +{ +struct iovec iovec; +int ret =0 ;
mm/madvise.c SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) · line 1187
Quoted 10 lines
mm/madvise.c +10
-0+ +while (iov_iter_count (iter)) { + iovec =iov_iter_iovec (iter); + ret =do_madvise (mm, (unsigned long )iovec.iov_base, iovec.iov_len, behavior); +if (ret <0 ) +break ; +iov_iter_advance (iter, iovec.iov_len); + } + +return ret;
Please avoid the entirely pointless overly long line.
mm/madvise.c SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) · line 1243
Quoted 8 lines
mm/madvise.c +8
-0+static inline int madv_import_iovec (int type,const struct iovec __user *uvec,unsigned int nr_segs, +unsigned int fast_segs,struct iovec **iov,struct iov_iter *i) +{ +#ifdef CONFIG_COMPAT +if (in_compat_syscall ()) +return compat_import_iovec (type, (struct compat_iovec __user *)uvec, nr_segs, + fast_segs, iov, i); +#endif
More of the same.
Quoted 5 lines
mm/madvise.c +5
-0+SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + unsigned long, vlen, int, behavior, unsigned int, flags) +{ +ssize_t ret; +struct iovec iovstack[UIO_FASTIOV ];
mm/madvise.c SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) · line 1262
Quoted 10 lines
mm/madvise.c +10
-0+struct iovec *iov = iovstack; +struct iov_iter iter; + + ret =madv_import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), &iov, &iter); +if (ret <0 ) +return ret; + + ret =do_process_madvise (pidfd, &iter, behavior, flags); +kfree (iov); +return ret;
Even more here. But more importantly there seems to be absolutely no reason for the madv_import_iovec and do_process_madvise helpers that both are tiny and have this even smaller function as the only caller.
Michal Hocko
reviewerRe: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 19 lines · Christoph Hellwig
Quoted 9 lines · Minchan Kim
There is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
Quoted 8 lines
To solve the issue, this patch introduces a new syscall
process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).
Quoted 4 lines
I'm really not sure this syscall is a good idea. If you want central control you should implement an IPC mechanisms that allows your supervisor daemon to tell the application to perform the madvice instead of forcing the behavior on it.
Even though I am not entirely happy about the interface [1]. As it seems I am in minority in my concern I backed off and decided to not block this work because I do not see the problem with the functionality itself. And I find it very useful for userspace driven memory management people are asking for a long time.
This functionality shouldn't be much different from the standard memory reclaim. It has some limitations (e.g. it can only handle mapped memory) but allows to pro-actively swap out or reclaim disk based memory based on a specific knowlege of the workload. Kernel is not able to do the same.
[1] http://lkml.kernel.org/r/[email protected]
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
In reply to Christoph HellwigQuoted 19 lines · Christoph Hellwig
Quoted 9 lines · Minchan Kim
There is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
Quoted 8 lines
To solve the issue, this patch introduces a new syscall
process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).
Quoted 4 lines
I'm really not sure this syscall is a good idea. If you want central control you should implement an IPC mechanisms that allows your supervisor daemon to tell the application to perform the madvice instead of forcing the behavior on it.
There was dicussion about the approach. There were several issues. One of them was the target app was already freezed and we wanted to run the syscall in caller's context, not callee.
Quoted 16 lines
Review madvise_behavior_valid(int behavior) · line 1056
Quoted 13 lines
/*
* The madvise(2) system call.
*(quoted diff) +5
-0@@ -1036,6 +1049,11 @@ madvise_behavior_valid(int behavior) * MADV_DONTDUMP - the application wants to prevent pages in the given range * from being included in its core dump. * MADV_DODUMP - cancel MADV_DONTDUMP: no longer exclude from core dump. + * MADV_COLD - the application is not expected to use this memory soon, + * deactivate pages in this range so that they can be reclaimed + * easily if memory pressure hanppens. + * MADV_PAGEOUT - the application is not expected to use this memory soon, + * page out the pages in this range immediately.This should really go into a separate patch, as it has nothing to do with the new syscall.
Technically, right but I expected it's not worth to have separate patch.
Quoted 41 lines
Quoted 5 lines
(quoted diff) +4
-0+static int process_madvise_vec(struct mm_struct *mm, struct iov_iter *iter, int behavior) +{ + struct iovec iovec; + int ret = 0;Review madvise_behavior_valid(int behavior)
Quoted 10 lines
(quoted diff) +10
-0+ + while (iov_iter_count(iter)) { + iovec = iov_iter_iovec(iter); + ret = do_madvise(mm, (unsigned long)iovec.iov_base, iovec.iov_len, behavior); + if (ret < 0) + break; + iov_iter_advance(iter, iovec.iov_len); + } + + return ret;Please avoid the entirely pointless overly long line.
Review
Quoted 8 lines
(quoted diff) +8
-0+static inline int madv_import_iovec(int type, const struct iovec __user *uvec, unsigned int nr_segs, + unsigned int fast_segs, struct iovec **iov, struct iov_iter *i) +{ +#ifdef CONFIG_COMPAT + if (in_compat_syscall()) + return compat_import_iovec(type, (struct compat_iovec __user *)uvec, nr_segs, + fast_segs, iov, i); +#endifMore of the same.
Quoted 12 lines
(quoted diff) +12
-0+SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + unsigned long, vlen, int, behavior, unsigned int, flags) +{ + ssize_t ret; + struct iovec iovstack[UIO_FASTIOV]; + struct iovec *iov = iovstack; + struct iov_iter iter; + + ret = madv_import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter); + if (ret < 0) + return ret; +
Quoted 8 lines
Review
Quoted 3 lines
(quoted diff) +3
-0+ ret = do_process_madvise(pidfd, &iter, behavior, flags); + kfree(iov); + return ret;Even more here. But more importantly there seems to be absolutely no reason for the
madv_import_iovecanddo_process_madvisehelpers that both are tiny and have this even smaller function as the only caller.
Fair enough.
Andrew, could you fold this patch?
Thank you.
From 02d63c6b3f61a1085f4eab80f5171bd2627b5ab0 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Mon, 21 Sep 2020 09:31:25 -0700
Subject: [PATCH] mm: do not use helper functions for process_madvise
This patch removes helper functions process_madvise_vec, do_process_madvise and madv_import_iovec and use them inline.
--- mm/madvise.c | 97 +++++++++++++++++++++++----------------------------- 1 file changed, 43 insertions(+), 54 deletions(-)
mm/madvise.c +43 -54
@@ -1166,37 +1166,40 @@ SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)return do_madvise (current->mm, start, len_in, behavior); } -static int process_madvise_vec (struct mm_struct *mm,struct iov_iter *iter,int behavior) -{ -struct iovec iovec; -int ret =0 ; - -while (iov_iter_count (iter)) { - iovec =iov_iter_iovec (iter); - ret =do_madvise (mm, (unsigned long )iovec.iov_base, iovec.iov_len, behavior); -if (ret <0 ) -break ; -iov_iter_advance (iter, iovec.iov_len); - } - -return ret; -} - -static ssize_t do_process_madvise (int pidfd,struct iov_iter *iter, -int behavior,unsigned int flags) +SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + size_t, vlen, int, behavior, unsigned int, flags) {ssize_t ret; +struct iovec iovstack[UIO_FASTIOV ], iovec; +struct iovec *iov = iovstack; +struct iov_iter iter;struct pid *pid;struct task_struct *task;struct mm_struct *mm; -size_t total_len =iov_iter_count (iter); +size_t total_len; -if (flags !=0 ) -return -EINVAL ; +if (flags !=0 ) { + ret = -EINVAL ; + goto out; + } + +#ifdef CONFIG_COMPAT +if (in_compat_syscall ()) + ret =compat_import_iovec (READ , + (struct compat_iovec __user *)vec, vlen, +ARRAY_SIZE (iovstack), &iov, &iter); + else +#endif + ret =import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), + &iov, &iter); +if (ret <0 ) + goto out; pid =pidfd_get_pid (pidfd); -if (IS_ERR (pid)) -return PTR_ERR (pid); +if (IS_ERR (pid)) { + ret =PTR_ERR (pid); + goto free_iov; + } task =get_pid_task (pid,PIDTYPE_PID );if (!task) {
@@ -1216,43 +1219,29 @@ static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, goto release_task; } - ret =process_madvise_vec (mm, iter, behavior); -if (ret >=0 ) - ret = total_len -iov_iter_count (iter); + total_len =iov_iter_count (&iter); + +while (iov_iter_count (&iter)) { + iovec =iov_iter_iovec (&iter); + ret =do_madvise (mm, (unsigned long )iovec.iov_base, + iovec.iov_len, behavior); +if (ret <0 ) +break ; +iov_iter_advance (&iter, iovec.iov_len); + } + +if (ret ==0 ) + ret = total_len -iov_iter_count (&iter);mmput (mm); +return ret; + release_task:put_task_struct (task); put_pid:put_pid (pid); -return ret; -} - -static inline int madv_import_iovec (int type,const struct iovec __user *uvec,size_t nr_segs, -unsigned int fast_segs,struct iovec **iov,struct iov_iter *i) -{ -#ifdef CONFIG_COMPAT -if (in_compat_syscall ()) -return compat_import_iovec (type, (struct compat_iovec __user *)uvec, nr_segs, - fast_segs, iov, i); -#endif - -return import_iovec (type, uvec, nr_segs, fast_segs, iov, i); -} - -SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, - size_t, vlen, int, behavior, unsigned int, flags) -{ -ssize_t ret; -struct iovec iovstack[UIO_FASTIOV ]; -struct iovec *iov = iovstack; -struct iov_iter iter; - - ret =madv_import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), &iov, &iter); -if (ret <0 ) -return ret; - - ret =do_process_madvise (pidfd, &iter, behavior, flags); +free_iov:kfree (iov); +out:return ret; }
Signature · 1 line
2.28.0.681.g6f77f65b4e-goog
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 198 lines · Minchan Kim
Quoted 19 lines · Christoph Hellwig
Quoted 9 lines · Minchan Kim
There is usecase that System Management Software(SMS) want to give a memory hint like MADV_[COLD|PAGEEOUT] to other processes and in the case of Android, it is the ActivityManagerService.
The information required to make the reclaim decision is not known to the app. Instead, it is known to the centralized userspace daemon(ActivityManagerService), and that daemon must be able to initiate reclaim on its own without any app involvement.
Quoted 8 lines
To solve the issue, this patch introduces a new syscall
process_madvise(2). It uses pidfd of an external process to give the hint. It also supports vector address range because Android app has thousands of vmas due to zygote so it's totally waste of CPU and power if we should call the syscall one by one for each vma.(With testing 2000-vma syscall vs 1-vector syscall, it showed 15% performance improvement. I think it would be bigger in real practice because the testing ran very cache friendly environment).Quoted 4 lines
I'm really not sure this syscall is a good idea. If you want central control you should implement an IPC mechanisms that allows your supervisor daemon to tell the application to perform the madvice instead of forcing the behavior on it.
There was dicussion about the approach. There were several issues. One of them was the target app was already freezed and we wanted to run the syscall in caller's context, not callee.
Quoted 16 lines
Review madvise_behavior_valid(int behavior) · line 1056
Quoted 13 lines
/*
* The madvise(2) system call.
*(quoted diff) +5
-0@@ -1036,6 +1049,11 @@ madvise_behavior_valid(int behavior) * MADV_DONTDUMP - the application wants to prevent pages in the given range * from being included in its core dump. * MADV_DODUMP - cancel MADV_DONTDUMP: no longer exclude from core dump. + * MADV_COLD - the application is not expected to use this memory soon, + * deactivate pages in this range so that they can be reclaimed + * easily if memory pressure hanppens. + * MADV_PAGEOUT - the application is not expected to use this memory soon, + * page out the pages in this range immediately.This should really go into a separate patch, as it has nothing to do with the new syscall.
Technically, right but I expected it's not worth to have separate patch.
Quoted 41 lines
Quoted 5 lines
(quoted diff) +4
-0+static int process_madvise_vec(struct mm_struct *mm, struct iov_iter *iter, int behavior) +{ + struct iovec iovec; + int ret = 0;Review madvise_behavior_valid(int behavior)
Quoted 10 lines
(quoted diff) +10
-0+ + while (iov_iter_count(iter)) { + iovec = iov_iter_iovec(iter); + ret = do_madvise(mm, (unsigned long)iovec.iov_base, iovec.iov_len, behavior); + if (ret < 0) + break; + iov_iter_advance(iter, iovec.iov_len); + } + + return ret;Please avoid the entirely pointless overly long line.
Review
Quoted 8 lines
(quoted diff) +8
-0+static inline int madv_import_iovec(int type, const struct iovec __user *uvec, unsigned int nr_segs, + unsigned int fast_segs, struct iovec **iov, struct iov_iter *i) +{ +#ifdef CONFIG_COMPAT + if (in_compat_syscall()) + return compat_import_iovec(type, (struct compat_iovec __user *)uvec, nr_segs, + fast_segs, iov, i); +#endifMore of the same.
Quoted 12 lines
(quoted diff) +12
-0+SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + unsigned long, vlen, int, behavior, unsigned int, flags) +{ + ssize_t ret; + struct iovec iovstack[UIO_FASTIOV]; + struct iovec *iov = iovstack; + struct iov_iter iter; + + ret = madv_import_iovec(READ, vec, vlen, ARRAY_SIZE(iovstack), &iov, &iter); + if (ret < 0) + return ret; +Quoted 8 lines
Review
Quoted 3 lines
(quoted diff) +3
-0+ ret = do_process_madvise(pidfd, &iter, behavior, flags); + kfree(iov); + return ret;Even more here. But more importantly there seems to be absolutely no reason for the
madv_import_iovecanddo_process_madvisehelpers that both are tiny and have this even smaller function as the only caller.Fair enough.
Andrew, could you fold this patch?
Thank you.From
02d63c6b3f61a1085f4eab80f5171bd2627b5ab0Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Mon, 21 Sep 2020 09:31:25 -0700
Subject: [PATCH] mm: do not use helper functions forprocess_madviseThis patch removes helper functions
process_madvise_vec,do_process_madviseandmadv_import_iovecand use them inline.Signed-off-by Minchan Kim <[email protected]>--- mm/madvise.c | 97 +++++++++++++++++++++++----------------------------- 1 file changed, 43 insertions(+), 54 deletions(-)mm/madvise.c +32
-26@@ -1166,37 +1166,40 @@ SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)return do_madvise (current->mm, start, len_in, behavior); } -static int process_madvise_vec (struct mm_struct *mm,struct iov_iter *iter,int behavior) -{ -struct iovec iovec; -int ret =0 ; - -while (iov_iter_count (iter)) { - iovec =iov_iter_iovec (iter); - ret =do_madvise (mm, (unsigned long )iovec.iov_base, iovec.iov_len, behavior); -if (ret <0 ) -break ; -iov_iter_advance (iter, iovec.iov_len); - } - -return ret; -} - -static ssize_t do_process_madvise (int pidfd,struct iov_iter *iter, -int behavior,unsigned int flags) +SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + size_t, vlen, int, behavior, unsigned int, flags) {ssize_t ret; +struct iovec iovstack[UIO_FASTIOV ], iovec; +struct iovec *iov = iovstack; +struct iov_iter iter;struct pid *pid;struct task_struct *task;struct mm_struct *mm; -size_t total_len =iov_iter_count (iter); +size_t total_len; -if (flags !=0 ) -return -EINVAL ; +if (flags !=0 ) { + ret = -EINVAL ; + goto out; + } + +#ifdef CONFIG_COMPAT +if (in_compat_syscall ()) + ret =compat_import_iovec (READ , + (struct compat_iovec __user *)vec, vlen, +ARRAY_SIZE (iovstack), &iov, &iter); + else +#endif + ret =import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), + &iov, &iter); +if (ret <0 ) + goto out; pid =pidfd_get_pid (pidfd); -if (IS_ERR (pid)) -return PTR_ERR (pid); +if (IS_ERR (pid)) { + ret =PTR_ERR (pid); + goto free_iov; + } task =get_pid_task (pid,PIDTYPE_PID );if (!task) {@@ -1216,43 +1219,29 @@ static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, goto release_task; } - ret =process_madvise_vec (mm, iter, behavior); -if (ret >=0 ) - ret = total_len -iov_iter_count (iter); + total_len =iov_iter_count (&iter); + +while (iov_iter_count (&iter)) { + iovec =iov_iter_iovec (&iter); + ret =do_madvise (mm, (unsigned long )iovec.iov_base, + iovec.iov_len, behavior);
mm/madvise.c static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, · line 1237
Quoted 10 lines
mm/madvise.c +8
-0+if (ret <0 ) +break ; +iov_iter_advance (&iter, iovec.iov_len); + } + +if (ret ==0 ) + ret = total_len -iov_iter_count (&iter);mmput (mm); +return ret;
This "return ret;" seems quite wrong...
I will send the following :
mm/madvise.c +0 -1
@@ -1231,7 +1231,6 @@ SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, ret = total_len -iov_iter_count (&iter);mmput (mm); -return ret; release_task:put_task_struct (task);
Quoted 39 lines
mm/madvise.c +3
-28+ release_task:put_task_struct (task); put_pid:put_pid (pid); -return ret; -} - -static inline int madv_import_iovec (int type,const struct iovec __user *uvec,size_t nr_segs, -unsigned int fast_segs,struct iovec **iov,struct iov_iter *i) -{ -#ifdef CONFIG_COMPAT -if (in_compat_syscall ()) -return compat_import_iovec (type, (struct compat_iovec __user *)uvec, nr_segs, - fast_segs, iov, i); -#endif - -return import_iovec (type, uvec, nr_segs, fast_segs, iov, i); -} - -SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, - size_t, vlen, int, behavior, unsigned int, flags) -{ -ssize_t ret; -struct iovec iovstack[UIO_FASTIOV ]; -struct iovec *iov = iovstack; -struct iov_iter iter; - - ret =madv_import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), &iov, &iter); -if (ret <0 ) -return ret; - - ret =do_process_madvise (pidfd, &iter, behavior, flags); +free_iov:kfree (iov); +out:return ret; }
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
On Mon, Nov 16, 2020 at 10:02:42AM +0100, Eric Dumazet wrote:
< snip >
Quoted 102 lines
Quoted 102 lines
From
02d63c6b3f61a1085f4eab80f5171bd2627b5ab0Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Mon, 21 Sep 2020 09:31:25 -0700
Subject: [PATCH] mm: do not use helper functions forprocess_madviseThis patch removes helper functions
process_madvise_vec,do_process_madviseandmadv_import_iovecand use them inline.Signed-off-by Minchan Kim <[email protected]>--- mm/madvise.c | 97 +++++++++++++++++++++++----------------------------- 1 file changed, 43 insertions(+), 54 deletions(-)mm/madvise.c +39
-26@@ -1166,37 +1166,40 @@ SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)return do_madvise (current->mm, start, len_in, behavior); } -static int process_madvise_vec (struct mm_struct *mm,struct iov_iter *iter,int behavior) -{ -struct iovec iovec; -int ret =0 ; - -while (iov_iter_count (iter)) { - iovec =iov_iter_iovec (iter); - ret =do_madvise (mm, (unsigned long )iovec.iov_base, iovec.iov_len, behavior); -if (ret <0 ) -break ; -iov_iter_advance (iter, iovec.iov_len); - } - -return ret; -} - -static ssize_t do_process_madvise (int pidfd,struct iov_iter *iter, -int behavior,unsigned int flags) +SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, + size_t, vlen, int, behavior, unsigned int, flags) {ssize_t ret; +struct iovec iovstack[UIO_FASTIOV ], iovec; +struct iovec *iov = iovstack; +struct iov_iter iter;struct pid *pid;struct task_struct *task;struct mm_struct *mm; -size_t total_len =iov_iter_count (iter); +size_t total_len; -if (flags !=0 ) -return -EINVAL ; +if (flags !=0 ) { + ret = -EINVAL ; + goto out; + } + +#ifdef CONFIG_COMPAT +if (in_compat_syscall ()) + ret =compat_import_iovec (READ , + (struct compat_iovec __user *)vec, vlen, +ARRAY_SIZE (iovstack), &iov, &iter); + else +#endif + ret =import_iovec (READ , vec, vlen,ARRAY_SIZE (iovstack), + &iov, &iter); +if (ret <0 ) + goto out; pid =pidfd_get_pid (pidfd); -if (IS_ERR (pid)) -return PTR_ERR (pid); +if (IS_ERR (pid)) { + ret =PTR_ERR (pid); + goto free_iov; + } task =get_pid_task (pid,PIDTYPE_PID );if (!task) {@@ -1216,43 +1219,29 @@ static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, goto release_task; } - ret =process_madvise_vec (mm, iter, behavior); -if (ret >=0 ) - ret = total_len -iov_iter_count (iter); + total_len =iov_iter_count (&iter); + +while (iov_iter_count (&iter)) { + iovec =iov_iter_iovec (&iter); + ret =do_madvise (mm, (unsigned long )iovec.iov_base, + iovec.iov_len, behavior); +if (ret <0 ) +break ; +iov_iter_advance (&iter, iovec.iov_len); + } + +if (ret ==0 ) + ret = total_len -iov_iter_count (&iter);
Quoted 4 lines
mm/madvise.c static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, · line 1237
Quoted 2 lines
mm/madvise.c +1
-0mmput (mm); +return ret;This "return ret;" seems quite wrong...
/me slaps self.
Quoted 19 lines
I will send the following :
mm/madvise.c +0
-1@@ -1231,7 +1231,6 @@ SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, ret = total_len -iov_iter_count (&iter);mmput (mm); -return ret; release_task:put_task_struct (task);
Quoted 7 lines
mm/madvise.c static ssize_t do_process_madvise(int pidfd, struct iov_iter *iter, · line 1229
Quoted 7 lines
mm/madvise.c +1
-2+ release_task:put_task_struct (task); put_pid:put_pid (pid); -return ret; -}
Thanks, Eric!
Let me send a patch with your SoB if you don't mind.
From 0f37d5295324721ee19a3ad40fe58e3002cd9934 Mon Sep 17 00:00:00 2001
From: Eric Dumazet <[email protected]>
Date: Mon, 16 Nov 2020 07:34:02 -0800
Subject: [PATCH] mm/madvise: fix memory leak from process_madvise
The eary return in process_madvise will produce memory leak. Fix it.
--- mm/madvise.c | 2 -- 1 file changed, 2 deletions(-)
mm/madvise.c +0 -2
@@ -1231,8 +1231,6 @@ SYSCALL_DEFINE5(process_madvise, int, pidfd, const struct iovec __user *, vec, ret = total_len -iov_iter_count (&iter);mmput (mm); -return ret; - release_task:put_task_struct (task); put_pid:
Signature · 1 line
2.29.2.299.gdc1121823c-goog
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 2 lines · Minchan Kim
Let me send a patch with your SoB if you don't mind.
Eric, can you ack this SoB and I'll apply it to me tree?
Or is it already queued up somewhere else?
Linus
Re: [PATCH v9 3/3] mm/madvise: introduce process_madvise() syscall: an external memory hinting API
Quoted 7 lines · Linus Torvalds
Quoted 2 lines · Minchan Kim
Let me send a patch with your SoB if you don't mind.
Eric, can you ack this SoB and I'll apply it to me tree?
Or is it already queued up somewhere else?
Andrew, picked it up.
https://ozlabs.org/~akpm/mmots/broken-out/mm-madvise-fix-memory-leak-from-process_madvise.patch