From patchwork Thu Oct 3 00:51:39 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 20760 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-qc0-f198.google.com (mail-qc0-f198.google.com [209.85.216.198]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 44C57238F9 for ; Thu, 3 Oct 2013 00:52:24 +0000 (UTC) Received: by mail-qc0-f198.google.com with SMTP id l13sf3261917qcy.5 for ; Wed, 02 Oct 2013 17:52:24 -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=R37piy5uzpeQ6/Lqf/bsPB3lOlixddTeRqXZSEpiu8I=; b=mM5tkev5QKCvHejlvs6j343N2mSp8g7EYIlW60FAhNNkYbDXFiQy8fQfkMaMVcGf7d E36626Hmcsn5WhuXSyFbW/kSHLGlRMxF+AQgZGhLJk+/dbj4xqykvexY5sjOVb/9fd/A JzIRZR1efr6fh7MN1V7BaV80kAm35fBT1SSCxBoMOxqvLyKuXyvYngVHHABwdeasNqvj iiN6HgwYqo0BKMcrG9/5YszYI4QN1C3pIOr/IttTff41Hriov9VkvQDPgjAQ7npck3Yz YMSU6i22NkATJL2DftKX2jvI4uBTf5UBVY0uKKYtPZFtPkjDTyYjXcg6C8WALImerei5 WZFw== X-Received: by 10.236.41.100 with SMTP id g64mr4716477yhb.31.1380761544118; Wed, 02 Oct 2013 17:52:24 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.49.128.229 with SMTP id nr5ls761102qeb.94.gmail; Wed, 02 Oct 2013 17:52:24 -0700 (PDT) X-Received: by 10.220.196.66 with SMTP id ef2mr4743673vcb.7.1380761544019; Wed, 02 Oct 2013 17:52:24 -0700 (PDT) Received: from mail-vc0-f173.google.com (mail-vc0-f173.google.com [209.85.220.173]) by mx.google.com with ESMTPS id cl2si1043787vdc.49.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 02 Oct 2013 17:52:24 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.220.173 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=209.85.220.173; Received: by mail-vc0-f173.google.com with SMTP id if17so577216vcb.4 for ; Wed, 02 Oct 2013 17:52:23 -0700 (PDT) X-Gm-Message-State: ALoCoQk9jBmi1HM/CSvydvJIXXbcikiuwQToVY4paVcngr1j49HxPeS3Mc2dNLq2QPU0M8hOLPHc X-Received: by 10.58.137.167 with SMTP id qj7mr4613553veb.1.1380761543890; Wed, 02 Oct 2013 17:52:23 -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 u4csp137533vcz; Wed, 2 Oct 2013 17:52:23 -0700 (PDT) X-Received: by 10.66.17.166 with SMTP id p6mr5769248pad.149.1380761542954; Wed, 02 Oct 2013 17:52:22 -0700 (PDT) Received: from mail-pd0-f169.google.com (mail-pd0-f169.google.com [209.85.192.169]) by mx.google.com with ESMTPS id gv2si2501024pbb.311.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Wed, 02 Oct 2013 17:52:22 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.192.169 is neither permitted nor denied by best guess record for domain of john.stultz@linaro.org) client-ip=209.85.192.169; Received: by mail-pd0-f169.google.com with SMTP id r10so1686597pdi.28 for ; Wed, 02 Oct 2013 17:52:22 -0700 (PDT) X-Received: by 10.68.254.132 with SMTP id ai4mr5450894pbd.51.1380761542535; Wed, 02 Oct 2013 17:52:22 -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:21 -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 10/14] vrange: Add core shrinking logic for swapless system Date: Wed, 2 Oct 2013 17:51:39 -0700 Message-Id: <1380761503-14509-11-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.220.173 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 the core volatile range shrinking logic needed to allow volatile range purging to function on swapless systems. This patch does not wire in the specific range purging logic, but that will be added in the following patches. The reason I use shrinker is that Dave and Glauber are trying to make slab shrinker being aware of node/memcg so if the patchset reach on mainline, we also can support node/memcg in vrange, easily. Another reason I selected slab shrinker is that normally slab shrinker is called after normal reclaim of file-backed page(ex, page cache) so reclaiming preference would be this, I expect.(TODO: invstigate and might need more tunes in reclaim path) page cache -> vrange by slab shrinking -> anon page It does make sense because page cache can have stream data so there is no point to shrink vrange pages if there are lots of streaming pages in page cache. In this version, I didn't check it works well but it's design concept so we can make it work via modify page reclaim path. I will have more experiment. One of disadvantage with using slab shrink is that slab shrinker isn't called in using memcg so memcg-noswap system cannot take advantage of it. Hmm, Maybe I will jump into relcaim code to hook some point to control vrange page shrinking more freely. 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 [jstultz: Renamed some functions and minor cleanups] Signed-off-by: John Stultz --- mm/vrange.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 86 insertions(+), 3 deletions(-) diff --git a/mm/vrange.c b/mm/vrange.c index 33e3ac1..e7c5a25 100644 --- a/mm/vrange.c +++ b/mm/vrange.c @@ -25,11 +25,19 @@ static inline unsigned int vrange_size(struct vrange *range) return range->node.last + 1 - range->node.start; } +static int shrink_vrange(struct shrinker *s, struct shrink_control *sc); + +static struct shrinker vrange_shrinker = { + .shrink = shrink_vrange, + .seeks = DEFAULT_SEEKS +}; + static int __init vrange_init(void) { INIT_LIST_HEAD(&vrange_list.list); mutex_init(&vrange_list.lock); vrange_cachep = KMEM_CACHE(vrange, SLAB_PANIC); + register_shrinker(&vrange_shrinker); return 0; } module_init(vrange_init); @@ -58,9 +66,14 @@ static void __vrange_free(struct vrange *range) static inline void __vrange_lru_add(struct vrange *range) { mutex_lock(&vrange_list.lock); - WARN_ON(!list_empty(&range->lru)); - list_add(&range->lru, &vrange_list.list); - vrange_list.size += vrange_size(range); + /* + * We need this check because it could be raced with + * shrink_vrange and vrange_resize + */ + if (list_empty(&range->lru)) { + list_add(&range->lru, &vrange_list.list); + vrange_list.size += vrange_size(range); + } mutex_unlock(&vrange_list.lock); } @@ -84,6 +97,14 @@ static void __vrange_add(struct vrange *range, struct vrange_root *vroot) __vrange_lru_add(range); } +static inline int __vrange_get(struct vrange *vrange) +{ + if (!atomic_inc_not_zero(&vrange->refcount)) + return 0; + + return 1; +} + static inline void __vrange_put(struct vrange *range) { if (atomic_dec_and_test(&range->refcount)) { @@ -647,3 +668,65 @@ int discard_vpage(struct page *page) return 1; } + +static struct vrange *vrange_isolate(void) +{ + struct vrange *vrange = NULL; + mutex_lock(&vrange_list.lock); + while (!list_empty(&vrange_list.list)) { + vrange = list_entry(vrange_list.list.prev, + struct vrange, lru); + list_del_init(&vrange->lru); + vrange_list.size -= vrange_size(vrange); + + /* vrange is going to destroy */ + if (__vrange_get(vrange)) + break; + + vrange = NULL; + } + + mutex_unlock(&vrange_list.lock); + return vrange; +} + +static unsigned int discard_vrange(struct vrange *vrange) +{ + return 0; +} + +static int shrink_vrange(struct shrinker *s, struct shrink_control *sc) +{ + struct vrange *range = NULL; + long nr_to_scan = sc->nr_to_scan; + long size = vrange_list.size; + + if (!nr_to_scan) + return size; + + if (sc->nr_to_scan && !(sc->gfp_mask & __GFP_IO)) + return -1; + + while (size > 0 && nr_to_scan > 0) { + range = vrange_isolate(); + if (!range) + break; + + /* range is removing so don't bother */ + if (!range->owner) { + __vrange_put(range); + size -= vrange_size(range); + nr_to_scan -= vrange_size(range); + continue; + } + + if (discard_vrange(range) < 0) + __vrange_lru_add(range); + __vrange_put(range); + + size -= vrange_size(range); + nr_to_scan -= vrange_size(range); + } + + return size; +}