From patchwork Thu Oct 3 00:51:34 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 20755 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-yh0-f70.google.com (mail-yh0-f70.google.com [209.85.213.70]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 3DA68238F9 for ; Thu, 3 Oct 2013 00:52:13 +0000 (UTC) Received: by mail-yh0-f70.google.com with SMTP id i72sf3755446yha.9 for ; Wed, 02 Oct 2013 17:52:13 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=mime-version:x-gm-message-state:delivered-to:from:to:cc:subject :date:message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-unsubscribe; bh=/fD11yJzP2ylfLE4xwf8xibA3dDv/xzV3CFHD9RISR4=; b=KqgojSsny7GguF8FAQZb7UQEh0qZQ1evOZ6wck82Qv5mmGJjAHg3pox1JAYewvONVf a9TQmmPplEMeXia4BECGWOmnZHI9mh857vhrX1yN0Vt2X5Ojn3HCZm8LMq/LNwPXf2sm lRTQf+EXNsqYdjunhwbmDxh+9tUZvZjhP0UGpEQ5ysjyc1mblpFhfQtBvO8/L7BlclO1 YtqLSMsONDG3z77U5q/TPnIV7T+rvsoilo6slJaT8el4Dg/sNcXgoCjUMUW6X0953cTv pMMsXZ/OK+u+EWvwpkR9Wd1OXturg59aPmlmzOkvlXIIN+jEm/uQrAct0Y3geQk39NtW Yx3w== X-Received: by 10.236.176.1 with SMTP id a1mr5209281yhm.10.1380761533054; Wed, 02 Oct 2013 17:52:13 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.49.121.231 with SMTP id ln7ls755396qeb.57.gmail; Wed, 02 Oct 2013 17:52:13 -0700 (PDT) X-Received: by 10.58.75.131 with SMTP id c3mr4711948vew.12.1380761532957; Wed, 02 Oct 2013 17:52:12 -0700 (PDT) Received: from mail-vb0-f42.google.com (mail-vb0-f42.google.com [209.85.212.42]) by mx.google.com with ESMTPS id o3si1051348ves.10.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 02 Oct 2013 17:52:12 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.212.42 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=209.85.212.42; Received: by mail-vb0-f42.google.com with SMTP id e12so1185434vbg.1 for ; Wed, 02 Oct 2013 17:52:12 -0700 (PDT) X-Gm-Message-State: ALoCoQko3lcfEwngHCGvPOuTIIULw60+XJDmZ3hirWuYXBBsQHwODHdF2CTBml66AdqtN/b8tbwH X-Received: by 10.58.201.73 with SMTP id jy9mr4737763vec.20.1380761532831; Wed, 02 Oct 2013 17:52:12 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patches@linaro.org Received: by 10.220.174.196 with SMTP id u4csp137514vcz; Wed, 2 Oct 2013 17:52:12 -0700 (PDT) X-Received: by 10.66.11.202 with SMTP id s10mr6252981pab.86.1380761531698; Wed, 02 Oct 2013 17:52:11 -0700 (PDT) Received: from mail-pa0-f49.google.com (mail-pa0-f49.google.com [209.85.220.49]) by mx.google.com with ESMTPS id hb3si3902174pac.268.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 02 Oct 2013 17:52:11 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.220.49 is neither permitted nor denied by best guess record for domain of john.stultz@linaro.org) client-ip=209.85.220.49; Received: by mail-pa0-f49.google.com with SMTP id ld10so1805309pab.22 for ; Wed, 02 Oct 2013 17:52:11 -0700 (PDT) X-Received: by 10.67.3.34 with SMTP id bt2mr6196345pad.3.1380761531255; Wed, 02 Oct 2013 17:52:11 -0700 (PDT) Received: from localhost.localdomain (c-67-170-153-23.hsd1.or.comcast.net. [67.170.153.23]) by mx.google.com with ESMTPSA id gh2sm4507018pbc.40.1969.12.31.16.00.00 (version=TLSv1.1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 02 Oct 2013 17:52:10 -0700 (PDT) From: John Stultz To: LKML Cc: Minchan Kim , Andrew Morton , Android Kernel Team , Robert Love , Mel Gorman , Hugh Dickins , Dave Hansen , Rik van Riel , Dmitry Adamushko , Dave Chinner , Neil Brown , Andrea Righi , Andrea Arcangeli , "Aneesh Kumar K.V" , Mike Hommey , Taras Glek , Dhaval Giani , Jan Kara , KOSAKI Motohiro , Michel Lespinasse , Rob Clark , "linux-mm@kvack.org" , John Stultz Subject: [PATCH 05/14] vrange: Add new vrange(2) system call Date: Wed, 2 Oct 2013 17:51:34 -0700 Message-Id: <1380761503-14509-6-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 1.8.1.2 In-Reply-To: <1380761503-14509-1-git-send-email-john.stultz@linaro.org> References: <1380761503-14509-1-git-send-email-john.stultz@linaro.org> X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: john.stultz@linaro.org X-Original-Authentication-Results: mx.google.com; spf=neutral (google.com: 209.85.212.42 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Precedence: list Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org List-ID: X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , From: Minchan Kim This patch adds new system call sys_vrange. NAME vrange - Mark or unmark range of memory as volatile SYNOPSIS int vrange(unsigned_long start, size_t length, int mode, int *purged); DESCRIPTION Applications can use vrange(2) to advise the kernel how it should handle paging I/O in this VM area. The idea is to help the kernel discard pages of vrange instead of reclaiming when memory pressure happens. It means kernel doesn't discard any pages of vrange if there is no memory pressure. mode: VRANGE_VOLATILE hint to kernel so VM can discard in vrange pages when memory pressure happens. VRANGE_NONVOLATILE hint to kernel so VM doesn't discard vrange pages any more. If user try to access purged memory without VRANGE_NOVOLATILE call, he can encounter SIGBUS if the page was discarded by kernel. purged: Pointer to an integer which will return 1 if mode == VRANGE_NONVOLATILE and any page in the affected range was purged. If purged returns zero during a mode == VRANGE_NONVOLATILE call, it means all of the pages in the range are intact. RETURN VALUE On success vrange returns the number of bytes marked or unmarked. Similar to write(), it may return fewer bytes then specified if it ran into a problem. If an error is returned, no changes were made. ERRORS EINVAL This error can occur for the following reasons: * The value length is negative or not page size units. * addr is not page-aligned * mode not a valid value. ENOMEM Not enough memory EFAULT purged pointer is invalid Cc: Andrew Morton Cc: Android Kernel Team Cc: Robert Love Cc: Mel Gorman Cc: Hugh Dickins Cc: Dave Hansen Cc: Rik van Riel Cc: Dmitry Adamushko Cc: Dave Chinner Cc: Neil Brown Cc: Andrea Righi Cc: Andrea Arcangeli Cc: Aneesh Kumar K.V Cc: Mike Hommey Cc: Taras Glek Cc: Dhaval Giani Cc: Jan Kara Cc: KOSAKI Motohiro Cc: Michel Lespinasse Cc: Rob Clark Cc: Minchan Kim Cc: linux-mm@kvack.org Signed-off-by: Minchan Kim Signed-off-by: John Stultz --- arch/x86/syscalls/syscall_64.tbl | 1 + include/linux/syscalls.h | 2 + include/uapi/asm-generic/mman-common.h | 3 + kernel/sys_ni.c | 1 + mm/vrange.c | 164 +++++++++++++++++++++++++++++++++ 5 files changed, 171 insertions(+) diff --git a/arch/x86/syscalls/syscall_64.tbl b/arch/x86/syscalls/syscall_64.tbl index 38ae65d..dc332bd 100644 --- a/arch/x86/syscalls/syscall_64.tbl +++ b/arch/x86/syscalls/syscall_64.tbl @@ -320,6 +320,7 @@ 311 64 process_vm_writev sys_process_vm_writev 312 common kcmp sys_kcmp 313 common finit_module sys_finit_module +314 common vrange sys_vrange # # x32-specific system call numbers start at 512 to avoid cache impact diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 84662ec..0997165 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -846,4 +846,6 @@ asmlinkage long sys_process_vm_writev(pid_t pid, asmlinkage long sys_kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2); asmlinkage long sys_finit_module(int fd, const char __user *uargs, int flags); +asmlinkage long sys_vrange(unsigned long start, size_t len, int mode, + int __user *purged); #endif diff --git a/include/uapi/asm-generic/mman-common.h b/include/uapi/asm-generic/mman-common.h index 4164529..9be120b 100644 --- a/include/uapi/asm-generic/mman-common.h +++ b/include/uapi/asm-generic/mman-common.h @@ -66,4 +66,7 @@ #define MAP_HUGE_SHIFT 26 #define MAP_HUGE_MASK 0x3f +#define VRANGE_VOLATILE 0 /* unpin pages so VM can discard them */ +#define VRANGE_NONVOLATILE 1 /* pin pages so VM can't discard them */ + #endif /* __ASM_GENERIC_MMAN_COMMON_H */ diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 7078052..f40070e 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -175,6 +175,7 @@ cond_syscall(sys_mremap); cond_syscall(sys_remap_file_pages); cond_syscall(compat_sys_move_pages); cond_syscall(compat_sys_migrate_pages); +cond_syscall(sys_vrange); /* block-layer dependent */ cond_syscall(sys_bdflush); diff --git a/mm/vrange.c b/mm/vrange.c index f2d1588..17be51c 100644 --- a/mm/vrange.c +++ b/mm/vrange.c @@ -4,6 +4,8 @@ #include #include +#include +#include static struct kmem_cache *vrange_cachep; @@ -229,3 +231,165 @@ fail: vrange_root_cleanup(new); return -ENOMEM; } + +static inline struct vrange_root *__vma_to_vroot(struct vm_area_struct *vma) +{ + struct vrange_root *vroot = NULL; + + if (vma->vm_file && (vma->vm_flags & VM_SHARED)) + vroot = &vma->vm_file->f_mapping->vroot; + else + vroot = &vma->vm_mm->vroot; + return vroot; +} + +static inline unsigned long __vma_addr_to_index(struct vm_area_struct *vma, + unsigned long addr) +{ + if (vma->vm_file && (vma->vm_flags & VM_SHARED)) + return (vma->vm_pgoff << PAGE_SHIFT) + addr - vma->vm_start; + return addr; +} + +static ssize_t do_vrange(struct mm_struct *mm, unsigned long start_idx, + unsigned long end_idx, int mode, int *purged) +{ + struct vm_area_struct *vma; + unsigned long orig_start = start_idx; + ssize_t count = 0, ret = 0; + + down_read(&mm->mmap_sem); + + vma = find_vma(mm, start_idx); + for (;;) { + struct vrange_root *vroot; + unsigned long tmp, vstart_idx, vend_idx; + + if (!vma) + goto out; + + if (vma->vm_flags & (VM_SPECIAL|VM_LOCKED|VM_MIXEDMAP| + VM_HUGETLB)) + goto out; + + /* make sure start is at the front of the current vma*/ + if (start_idx < vma->vm_start) { + start_idx = vma->vm_start; + if (start_idx > end_idx) + goto out; + } + + /* bound tmp to closer of vm_end & end */ + tmp = vma->vm_end - 1; + if (end_idx < tmp) + tmp = end_idx; + + vroot = __vma_to_vroot(vma); + vstart_idx = __vma_addr_to_index(vma, start_idx); + vend_idx = __vma_addr_to_index(vma, tmp); + + /* mark or unmark */ + if (mode == VRANGE_VOLATILE) + ret = vrange_add(vroot, vstart_idx, vend_idx); + else if (mode == VRANGE_NONVOLATILE) + ret = vrange_remove(vroot, vstart_idx, vend_idx, + purged); + + if (ret) + goto out; + + /* update count to distance covered so far*/ + count = tmp - orig_start + 1; + + /* move start up to the end of the vma*/ + start_idx = vma->vm_end; + if (start_idx > end_idx) + goto out; + /* move to the next vma */ + vma = vma->vm_next; + } +out: + up_read(&mm->mmap_sem); + + /* report bytes successfully marked, even if we're exiting on error */ + if (count) + return count; + + return ret; +} + +/* + * The vrange(2) system call. + * + * Applications can use vrange() to advise the kernel how it should + * handle paging I/O in this VM area. The idea is to help the kernel + * discard pages of vrange instead of swapping out when memory pressure + * happens. The information provided is advisory only, and can be safely + * disregarded by the kernel if system has enough free memory. + * + * mode values: + * VRANGE_VOLATILE - hint to kernel so VM can discard vrange pages when + * memory pressure happens. + * VRANGE_NONVOLATILE - Removes any volatile hints previous specified in that + * range. + * + * purged ptr: + * Returns 1 if any page in the range being marked nonvolatile has been purged. + * + * Return values: + * On success vrange returns the number of bytes marked or unmarked. + * Similar to write(), it may return fewer bytes then specified if + * it ran into a problem. + * + * If an error is returned, no changes were made. + * + * Errors: + * -EINVAL - start len < 0, start is not page-aligned, start is greater + * than TASK_SIZE or "mode" is not a valid value. + * -ENOMEM - Short of free memory in system for successful system call. + * -EFAULT - Purged pointer is invalid. + * -ENOSUP - Feature not yet supported. + */ +SYSCALL_DEFINE4(vrange, unsigned long, start, + size_t, len, int, mode, int __user *, purged) +{ + unsigned long end; + struct mm_struct *mm = current->mm; + ssize_t ret = -EINVAL; + int p = 0; + + if (start & ~PAGE_MASK) + goto out; + + len &= PAGE_MASK; + if (!len) + goto out; + + end = start + len; + if (end < start) + goto out; + + if (start >= TASK_SIZE) + goto out; + + if (purged) { + /* Test pointer is valid before making any changes */ + if (put_user(p, purged)) + return -EFAULT; + } + + ret = do_vrange(mm, start, end - 1, mode, &p); + + if (purged) { + if (put_user(p, purged)) { + /* + * This would be bad, since we've modified volatilty + * and the change in purged state would be lost. + */ + BUG(); + } + } + +out: + return ret; +}