From patchwork Tue May 1 13:18:06 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Anton Vorontsov X-Patchwork-Id: 8315 Return-Path: X-Original-To: patchwork@peony.canonical.com Delivered-To: patchwork@peony.canonical.com Received: from fiordland.canonical.com (fiordland.canonical.com [91.189.94.145]) by peony.canonical.com (Postfix) with ESMTP id D4CB823E00 for ; Tue, 1 May 2012 13:19:32 +0000 (UTC) Received: from mail-yx0-f180.google.com (mail-yx0-f180.google.com [209.85.213.180]) by fiordland.canonical.com (Postfix) with ESMTP id 844DBA183B9 for ; Tue, 1 May 2012 13:19:32 +0000 (UTC) Received: by yenl4 with SMTP id l4so2225534yen.11 for ; Tue, 01 May 2012 06:19:32 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=x-forwarded-to:x-forwarded-for:delivered-to:received-spf:date:from :to:cc:subject:message-id:references:mime-version:content-type :content-disposition:in-reply-to:user-agent:x-gm-message-state; bh=WvDOV5qZJxPQxVnODNkwQPYHoWR7w6EQG0HfPHeMExY=; b=hzguf5/4trF7EjZBFiCopozzEWFaPPgfj9Kfx88fr/K+7JsgMosBXjdIVgH+m8oCHM 6zzgDcICyLrXv0ra3d28yn1wpJMEQmASGtLVf7Ot0WFPm8wp5no44HfgzJBXf3LwBFeI f0usN1oR8aZK+y5T8q3LxtlkYkvoZuB0BKSBmmHqpYK8gj+k94rznlkGa7QH5pY8U60H HtDdu9AZ7yT3J6nmVcknifg3M8pwC6hfcNzn2x3Godk+1YDoa4jEc/DD4tSjXfbCqNqm ntmhvO6YARaCYWNFEGWexPqPmXWjXVig+qNyI2ZRbspmJD8OrXCRWLwOnAQh+j+6NA9d SenA== Received: by 10.50.51.163 with SMTP id l3mr1768976igo.3.1335878371651; Tue, 01 May 2012 06:19:31 -0700 (PDT) X-Forwarded-To: linaro-patchwork@canonical.com X-Forwarded-For: patch@linaro.org linaro-patchwork@canonical.com Delivered-To: patches@linaro.org Received: by 10.231.137.198 with SMTP id x6csp180430ibt; Tue, 1 May 2012 06:19:30 -0700 (PDT) Received: by 10.236.189.2 with SMTP id b2mr26382024yhn.11.1335878369876; Tue, 01 May 2012 06:19:29 -0700 (PDT) Received: from mail-yx0-f178.google.com (mail-yx0-f178.google.com [209.85.213.178]) by mx.google.com with ESMTPS id t1si7045797ano.93.2012.05.01.06.19.29 (version=TLSv1/SSLv3 cipher=OTHER); Tue, 01 May 2012 06:19:29 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.213.178 is neither permitted nor denied by best guess record for domain of anton.vorontsov@linaro.org) client-ip=209.85.213.178; Authentication-Results: mx.google.com; spf=neutral (google.com: 209.85.213.178 is neither permitted nor denied by best guess record for domain of anton.vorontsov@linaro.org) smtp.mail=anton.vorontsov@linaro.org Received: by yenm14 with SMTP id m14so2225332yen.37 for ; Tue, 01 May 2012 06:19:29 -0700 (PDT) Received: by 10.68.228.132 with SMTP id si4mr2326988pbc.86.1335878368994; Tue, 01 May 2012 06:19:28 -0700 (PDT) Received: from localhost (c-71-204-165-222.hsd1.ca.comcast.net. [71.204.165.222]) by mx.google.com with ESMTPS id tt9sm2436347pbc.35.2012.05.01.06.19.26 (version=TLSv1/SSLv3 cipher=OTHER); Tue, 01 May 2012 06:19:27 -0700 (PDT) Date: Tue, 1 May 2012 06:18:06 -0700 From: Anton Vorontsov To: Pekka Enberg Cc: Leonid Moiseichuk , John Stultz , linux-mm@kvack.org, linux-kernel@vger.kernel.org, linaro-kernel@lists.linaro.org, patches@linaro.org, kernel-team@android.com Subject: [PATCH v4] vmevent: Implement greater-than attribute state and one-shot mode Message-ID: <20120501131806.GA22249@lizard> References: <20120418083208.GA24904@lizard> <20120418083523.GB31556@lizard> <20120418224629.GA22150@lizard> <20120419162923.GA26630@lizard> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20120419162923.GA26630@lizard> User-Agent: Mutt/1.5.21 (2010-09-15) X-Gm-Message-State: ALoCoQmouGKppVrCDUEqZPQHLLT/9GuHh0HU8VXQhNFA6XpIwg/m6xINJVAnU8egL1r2FZYG6mHQ This patch implements a new event type, it will trigger whenever a value becomes greater than user-specified threshold, it complements the 'less-then' trigger type. Also, let's implement the one-shot mode for the events, when set, userspace will only receive one notification per crossing the boundaries. Now when both LT and GT are set on the same level, the event type works as a cross event type: it triggers whenever a value crosses the threshold from a lesser values side to a greater values side, and vice versa. We use the event types in an userspace low-memory killer: we get a notification when memory becomes low, so we start freeing memory by killing unneeded processes, and we get notification when memory hits the threshold from another side, so we know that we freed enough of memory. Signed-off-by: Anton Vorontsov --- On Thu, Apr 19, 2012 at 09:29:23AM -0700, Anton Vorontsov wrote: > > > Yep, with CONFIG_SWAP=n, and I had to a modify the test > > > since I saw the same thing, I believe. I'll try w/ the swap enabled, > > > and see how it goes. I think the vmevent-test.c needs some improvemnts > > > in general, but meanwhile... > > > > > > > Physical pages: 109858 > > > > read failed: Invalid argument > > > > > > Can you send me the .config file that you used? Might be that > > > you have CONFIG_SWAP=n too? > > > > No, I have CONFIG_SWAP=y. Here's the config I use. > > Thanks! It appears that there was just another hard-coded value for > the counter in vmevent-test.c, I changed it to config.counter and > now everything should be fine. [...] > + if ((lt || gt) && !one_shot) > return true; Noticed one small issue: the code doesn't check whether we actually asked to track lt or gt states, so it shoudl be (attr_lt && lt) || (attr_gt && gt). This is fixed now. include/linux/vmevent.h | 13 ++++++++++ mm/vmevent.c | 45 +++++++++++++++++++++++++++++----- tools/testing/vmevent/vmevent-test.c | 24 +++++++++++++----- 3 files changed, 70 insertions(+), 12 deletions(-) diff --git a/include/linux/vmevent.h b/include/linux/vmevent.h index 64357e4..ca97cf0 100644 --- a/include/linux/vmevent.h +++ b/include/linux/vmevent.h @@ -22,6 +22,19 @@ enum { * Sample value is less than user-specified value */ VMEVENT_ATTR_STATE_VALUE_LT = (1UL << 0), + /* + * Sample value is greater than user-specified value + */ + VMEVENT_ATTR_STATE_VALUE_GT = (1UL << 1), + /* + * One-shot mode. + */ + VMEVENT_ATTR_STATE_ONE_SHOT = (1UL << 2), + + /* Saved state, used internally by the kernel for one-shot mode. */ + __VMEVENT_ATTR_STATE_VALUE_WAS_LT = (1UL << 30), + /* Saved state, used internally by the kernel for one-shot mode. */ + __VMEVENT_ATTR_STATE_VALUE_WAS_GT = (1UL << 31), }; struct vmevent_attr { diff --git a/mm/vmevent.c b/mm/vmevent.c index 9ed6aca..47ed448 100644 --- a/mm/vmevent.c +++ b/mm/vmevent.c @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -83,16 +84,48 @@ static bool vmevent_match(struct vmevent_watch *watch) for (i = 0; i < config->counter; i++) { struct vmevent_attr *attr = &config->attrs[i]; - u64 value; + u32 state = attr->state; + bool attr_lt = state & VMEVENT_ATTR_STATE_VALUE_LT; + bool attr_gt = state & VMEVENT_ATTR_STATE_VALUE_GT; - if (!attr->state) + if (!state) continue; - value = vmevent_sample_attr(watch, attr); - - if (attr->state & VMEVENT_ATTR_STATE_VALUE_LT) { - if (value < attr->value) + if (attr_lt || attr_gt) { + bool one_shot = state & VMEVENT_ATTR_STATE_ONE_SHOT; + u32 was_lt_mask = __VMEVENT_ATTR_STATE_VALUE_WAS_LT; + u32 was_gt_mask = __VMEVENT_ATTR_STATE_VALUE_WAS_GT; + u64 value = vmevent_sample_attr(watch, attr); + bool lt = value < attr->value; + bool gt = value > attr->value; + bool was_lt = state & was_lt_mask; + bool was_gt = state & was_gt_mask; + bool ret = false; + + if (((attr_lt && lt) || (attr_gt && gt)) && !one_shot) return true; + + if (attr_lt && lt && was_lt) { + return false; + } else if (attr_gt && gt && was_gt) { + return false; + } else if (lt) { + state |= was_lt_mask; + state &= ~was_gt_mask; + if (attr_lt) + ret = true; + } else if (gt) { + state |= was_gt_mask; + state &= ~was_lt_mask; + if (attr_gt) + ret = true; + } else { + state &= ~was_lt_mask; + state &= ~was_gt_mask; + } + + attr->state = state; + return ret; } } diff --git a/tools/testing/vmevent/vmevent-test.c b/tools/testing/vmevent/vmevent-test.c index 534f827..fd9a174 100644 --- a/tools/testing/vmevent/vmevent-test.c +++ b/tools/testing/vmevent/vmevent-test.c @@ -33,20 +33,32 @@ int main(int argc, char *argv[]) config = (struct vmevent_config) { .sample_period_ns = 1000000000L, - .counter = 4, + .counter = 6, .attrs = { - [0] = { + { .type = VMEVENT_ATTR_NR_FREE_PAGES, .state = VMEVENT_ATTR_STATE_VALUE_LT, .value = phys_pages, }, - [1] = { + { + .type = VMEVENT_ATTR_NR_FREE_PAGES, + .state = VMEVENT_ATTR_STATE_VALUE_GT, + .value = phys_pages, + }, + { + .type = VMEVENT_ATTR_NR_FREE_PAGES, + .state = VMEVENT_ATTR_STATE_VALUE_LT | + VMEVENT_ATTR_STATE_VALUE_GT | + VMEVENT_ATTR_STATE_ONE_SHOT, + .value = phys_pages / 2, + }, + { .type = VMEVENT_ATTR_NR_AVAIL_PAGES, }, - [2] = { + { .type = VMEVENT_ATTR_NR_SWAP_PAGES, }, - [3] = { + { .type = 0xffff, /* invalid */ }, }, @@ -59,7 +71,7 @@ int main(int argc, char *argv[]) } for (i = 0; i < 10; i++) { - char buffer[sizeof(struct vmevent_event) + 4 * sizeof(struct vmevent_attr)]; + char buffer[sizeof(struct vmevent_event) + config.counter * sizeof(struct vmevent_attr)]; struct vmevent_event *event; int n = 0; int idx;