From patchwork Tue Oct 1 18:38:54 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 20735 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-qc0-f200.google.com (mail-qc0-f200.google.com [209.85.216.200]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id B579023920 for ; Tue, 1 Oct 2013 18:39:16 +0000 (UTC) Received: by mail-qc0-f200.google.com with SMTP id x20sf8297826qcv.7 for ; Tue, 01 Oct 2013 11:39:16 -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: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=pRf/aTeMDzx4bh2WpnZZQwvy+YoihHIB+WmTPEji+LY=; b=HoDy9O/JGjbJbyefQZDofW3kwnbqBikSdBksVWZVF9NG+Ao8xz9mMQVKCgxGkJIv3O i0BCJr8Uuq8g1cdXPeekZkrt8sD2zqnLviNp4+NreSknTFPhg5RnlejDSFoiVvlAEWbi T2IsI/z0uEF1o80nCAj+sxWWZm4eMH5pJltICNwXvsf0aTnIXmNJ0yJLukaAiTOBopQg ML3HnSi88so36P97+v4Sb375KpEMOQdjUM7aACHlrDtNzgOpnOl1H5vXWyM3LTVZV41h hN8qOg8DpEXD/G69B4LNvsN4c/yCSBmFyTX+3NGBpQtO5Spd6lCm7gTvznMm4cJPvrXI c8WQ== X-Received: by 10.58.238.199 with SMTP id vm7mr2326417vec.17.1380652756546; Tue, 01 Oct 2013 11:39:16 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.49.1.102 with SMTP id 6ls204458qel.40.gmail; Tue, 01 Oct 2013 11:39:16 -0700 (PDT) X-Received: by 10.59.9.138 with SMTP id ds10mr29322008ved.5.1380652756424; Tue, 01 Oct 2013 11:39:16 -0700 (PDT) Received: from mail-vb0-f49.google.com (mail-vb0-f49.google.com [209.85.212.49]) by mx.google.com with ESMTPS id dt10si1602109vdb.151.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 01 Oct 2013 11:39:16 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.212.49 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.49; Received: by mail-vb0-f49.google.com with SMTP id w16so5011911vbb.8 for ; Tue, 01 Oct 2013 11:39:16 -0700 (PDT) X-Gm-Message-State: ALoCoQmP3WoAK2FeMp/6Zm+QaF964KydaFxHiHRNajf2OJyzaFFG/OjLRHiNSnVAhNWV/3heXH1Q X-Received: by 10.58.179.104 with SMTP id df8mr1771734vec.26.1380652756293; Tue, 01 Oct 2013 11:39:16 -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 u4csp38611vcz; Tue, 1 Oct 2013 11:39:15 -0700 (PDT) X-Received: by 10.68.255.69 with SMTP id ao5mr31081414pbd.66.1380652754674; Tue, 01 Oct 2013 11:39:14 -0700 (PDT) Received: from mail-pb0-f45.google.com (mail-pb0-f45.google.com [209.85.160.45]) by mx.google.com with ESMTPS id ei3si5543891pbc.140.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 01 Oct 2013 11:39:14 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.160.45 is neither permitted nor denied by best guess record for domain of john.stultz@linaro.org) client-ip=209.85.160.45; Received: by mail-pb0-f45.google.com with SMTP id mc17so7499375pbc.4 for ; Tue, 01 Oct 2013 11:39:14 -0700 (PDT) X-Received: by 10.67.24.7 with SMTP id ie7mr34865362pad.112.1380652754255; Tue, 01 Oct 2013 11:39:14 -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 ed3sm8282606pbc.6.1969.12.31.16.00.00 (version=TLSv1.1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 01 Oct 2013 11:39:13 -0700 (PDT) From: John Stultz To: Minchan Kim , Dhaval Giani Subject: [PATCH 10/14] vrange: Add core shrinking logic for swapless system Date: Tue, 1 Oct 2013 11:38:54 -0700 Message-Id: <1380652738-8000-11-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 1.8.1.2 In-Reply-To: <1380652738-8000-1-git-send-email-john.stultz@linaro.org> References: <1380652738-8000-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.49 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 | 93 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 90 insertions(+), 3 deletions(-) diff --git a/mm/vrange.c b/mm/vrange.c index 28041c1..688ddb8 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,69 @@ 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; + + /* current is dying so it will release memory soon */ + if (fatal_signal_pending(current)) + return -1; + + 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; +}