From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DA93CC2BA19 for ; Tue, 14 Apr 2020 16:34:40 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 8229B2063A for ; Tue, 14 Apr 2020 16:34:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="ZA3qmBuh" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8229B2063A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 069EA8E000B; Tue, 14 Apr 2020 12:34:40 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 01A338E0001; Tue, 14 Apr 2020 12:34:39 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E4CEB8E000B; Tue, 14 Apr 2020 12:34:39 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0042.hostedemail.com [216.40.44.42]) by kanga.kvack.org (Postfix) with ESMTP id CEC168E0001 for ; Tue, 14 Apr 2020 12:34:39 -0400 (EDT) Received: from smtpin30.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with ESMTP id 95AC53CF6 for ; Tue, 14 Apr 2020 16:34:39 +0000 (UTC) X-FDA: 76707009078.30.plate08_b82975d19363 X-HE-Tag: plate08_b82975d19363 X-Filterd-Recvd-Size: 14798 Received: from us-smtp-delivery-1.mimecast.com (us-smtp-1.mimecast.com [205.139.110.61]) by imf33.hostedemail.com (Postfix) with ESMTP for ; Tue, 14 Apr 2020 16:34:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1586882078; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=sGpz4hU8G6goVCY8AIDdS7RweapKqJG0FarAOG5cOQ0=; b=ZA3qmBuhIVt5AjeuGFVF9obEvJMCRa8OCOI+8s/7ynmiaSJfPInV3BZP5kPvaZE4UnPac3 GwHUcVfiQCuH3axZPmwKegQUj6J5MzugJ1g66RPuem/Bb8psF8SL5g4a94BIfyp5Ln0/UP pMNdsOeHNiasUgL9EAqlfDcJ+QEqNOU= Received: from mail-qk1-f197.google.com (mail-qk1-f197.google.com [209.85.222.197]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-408-1ycOHlY6NqqZu0M-zYfIrw-1; Tue, 14 Apr 2020 12:34:34 -0400 X-MC-Unique: 1ycOHlY6NqqZu0M-zYfIrw-1 Received: by mail-qk1-f197.google.com with SMTP id r129so6196201qkd.19 for ; Tue, 14 Apr 2020 09:34:34 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:in-reply-to; bh=mxMk4OjYqz6WaLMP6SDDXA6S1CwQy1WHx7MZAFhC3P4=; b=eTCmiBXoscLITpS9vi2HSeYygL0gweXG4EfUa+8NAu0fB3/DtX2nPbDXhX/oxW1XbJ VRCVRcD7d7IAd55DSKu4eqx7pGeDtumT6EXgtvJ27E6Themle/fRsmgrNFn3RDuHZfpT fS/VU/Yv0/V2+joKLtfUUW4oOYHOU0dMqrlcrMTNlcGa/YNIAGvpmEfbt5LuyIesAYiv /O/9dS3QJnjZnxYjHS4+7NEor1+6n0LV583GRRYIMxEOwYw/LOA1Tt3+9e9yIj1lB5rW FNVHO/Ouv09iuX5Z7qBO4h908UetiIRpWmqsMWX8FTQssfAc+ondHyZfmYKXPsJAuGY3 fLgA== X-Gm-Message-State: AGi0PuaMXAgn2pgQRZCqiz1PMut29wGF+c13T3UjSbjE1r2MzWkJ2DRm ROc/ZGL6PI523SVWifVqePID/xri/p1uT9ZDJg5HdKsOId+QGf+EHqFMhgbqq9v+6whKNd87Q7V diQPLoivkezU= X-Received: by 2002:a37:4852:: with SMTP id v79mr21337197qka.459.1586882074311; Tue, 14 Apr 2020 09:34:34 -0700 (PDT) X-Google-Smtp-Source: APiQypIxDlWSPYHz24Em/CyqTvLeDJZn3kuTqc3zQvK9MuWirtAiyJlkACPViYqM2NQN7iOQBdFYOg== X-Received: by 2002:a37:4852:: with SMTP id v79mr21337161qka.459.1586882073931; Tue, 14 Apr 2020 09:34:33 -0700 (PDT) Received: from redhat.com (bzq-79-183-51-3.red.bezeqint.net. [79.183.51.3]) by smtp.gmail.com with ESMTPSA id y9sm10550413qkb.41.2020.04.14.09.34.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 14 Apr 2020 09:34:32 -0700 (PDT) Date: Tue, 14 Apr 2020 12:34:26 -0400 From: "Michael S. Tsirkin" To: David Hildenbrand Cc: linux-kernel@vger.kernel.org, linux-mm@kvack.org, virtio-dev@lists.oasis-open.org, virtualization@lists.linux-foundation.org, kvm@vger.kernel.org, Michal Hocko , Andrew Morton , Alexander Duyck , Michal Hocko , Juergen Gross , Konrad Rzeszutek Wilk , Pavel Tatashin , Vlastimil Babka , Johannes Weiner , Anthony Yznaga , Oscar Salvador , Mel Gorman , Mike Rapoport , Dan Williams , Anshuman Khandual , Qian Cai , Pingfan Liu Subject: Re: [PATCH v2 05/10] mm: Allow to offline unmovable PageOffline() pages via MEM_GOING_OFFLINE Message-ID: <20200414123334-mutt-send-email-mst@kernel.org> References: <20200311171422.10484-1-david@redhat.com> <20200311171422.10484-6-david@redhat.com> MIME-Version: 1.0 In-Reply-To: <20200311171422.10484-6-david@redhat.com> X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: quoted-printable Content-Disposition: inline X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: On Wed, Mar 11, 2020 at 06:14:17PM +0100, David Hildenbrand wrote: > virtio-mem wants to allow to offline memory blocks of which some parts > were unplugged (allocated via alloc_contig_range()), especially, to later > offline and remove completely unplugged memory blocks. The important part > is that PageOffline() has to remain set until the section is offline, so > these pages will never get accessed (e.g., when dumping). The pages shoul= d > not be handed back to the buddy (which would require clearing PageOffline= () > and result in issues if offlining fails and the pages are suddenly in the > buddy). >=20 > Let's allow to do that by allowing to isolate any PageOffline() page > when offlining. This way, we can reach the memory hotplug notifier > MEM_GOING_OFFLINE, where the driver can signal that he is fine with > offlining this page by dropping its reference count. PageOffline() pages > with a reference count of 0 can then be skipped when offlining the > pages (like if they were free, however they are not in the buddy). >=20 > Anybody who uses PageOffline() pages and does not agree to offline them > (e.g., Hyper-V balloon, XEN balloon, VMWare balloon for 2MB pages) will n= ot > decrement the reference count and make offlining fail when trying to > migrate such an unmovable page. So there should be no observable change. > Same applies to balloon compaction users (movable PageOffline() pages), t= he > pages will simply be migrated. >=20 > Note 1: If offlining fails, a driver has to increment the reference > =09count again in MEM_CANCEL_OFFLINE. >=20 > Note 2: A driver that makes use of this has to be aware that re-onlining > =09the memory block has to be handled by hooking into onlining code > =09(online_page_callback_t), resetting the page PageOffline() and > =09not giving them to the buddy. >=20 > Reviewed-by: Alexander Duyck > Acked-by: Michal Hocko > Cc: Andrew Morton > Cc: Juergen Gross > Cc: Konrad Rzeszutek Wilk > Cc: Pavel Tatashin > Cc: Alexander Duyck > Cc: Vlastimil Babka > Cc: Johannes Weiner > Cc: Anthony Yznaga > Cc: Michal Hocko > Cc: Oscar Salvador > Cc: Mel Gorman > Cc: Mike Rapoport > Cc: Dan Williams > Cc: Anshuman Khandual > Cc: Qian Cai > Cc: Pingfan Liu > Signed-off-by: David Hildenbrand Andrew, could you please ack merging this through the vhost tree together with the rest of the patches? > --- > include/linux/page-flags.h | 10 +++++++++ > mm/memory_hotplug.c | 44 +++++++++++++++++++++++++++++--------- > mm/page_alloc.c | 24 +++++++++++++++++++++ > mm/page_isolation.c | 9 ++++++++ > 4 files changed, 77 insertions(+), 10 deletions(-) >=20 > diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h > index 49c2697046b9..fd6d4670ccc3 100644 > --- a/include/linux/page-flags.h > +++ b/include/linux/page-flags.h > @@ -772,6 +772,16 @@ PAGE_TYPE_OPS(Buddy, buddy) > * not onlined when onlining the section). > * The content of these pages is effectively stale. Such pages should no= t > * be touched (read/write/dump/save) except by their owner. > + * > + * If a driver wants to allow to offline unmovable PageOffline() pages w= ithout > + * putting them back to the buddy, it can do so via the memory notifier = by > + * decrementing the reference count in MEM_GOING_OFFLINE and incrementin= g the > + * reference count in MEM_CANCEL_OFFLINE. When offlining, the PageOfflin= e() > + * pages (now with a reference count of zero) are treated like free page= s, > + * allowing the containing memory block to get offlined. A driver that > + * relies on this feature is aware that re-onlining the memory block wil= l > + * require to re-set the pages PageOffline() and not giving them to the > + * buddy via online_page_callback_t. > */ > PAGE_TYPE_OPS(Offline, offline) > =20 > diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c > index 1a00b5a37ef6..ab1c31e67fd1 100644 > --- a/mm/memory_hotplug.c > +++ b/mm/memory_hotplug.c > @@ -1221,11 +1221,17 @@ struct zone *test_pages_in_a_zone(unsigned long s= tart_pfn, > =20 > /* > * Scan pfn range [start,end) to find movable/migratable pages (LRU page= s, > - * non-lru movable pages and hugepages). We scan pfn because it's much > - * easier than scanning over linked list. This function returns the pfn > - * of the first found movable page if it's found, otherwise 0. > + * non-lru movable pages and hugepages). Will skip over most unmovable > + * pages (esp., pages that can be skipped when offlining), but bail out = on > + * definitely unmovable pages. > + * > + * Returns: > + *=090 in case a movable page is found and movable_pfn was updated. > + *=09-ENOENT in case no movable page was found. > + *=09-EBUSY in case a definitely unmovable page was found. > */ > -static unsigned long scan_movable_pages(unsigned long start, unsigned lo= ng end) > +static int scan_movable_pages(unsigned long start, unsigned long end, > +=09=09=09 unsigned long *movable_pfn) > { > =09unsigned long pfn; > =20 > @@ -1237,18 +1243,30 @@ static unsigned long scan_movable_pages(unsigned = long start, unsigned long end) > =09=09=09continue; > =09=09page =3D pfn_to_page(pfn); > =09=09if (PageLRU(page)) > -=09=09=09return pfn; > +=09=09=09goto found; > =09=09if (__PageMovable(page)) > -=09=09=09return pfn; > +=09=09=09goto found; > + > +=09=09/* > +=09=09 * PageOffline() pages that are not marked __PageMovable() and > +=09=09 * have a reference count > 0 (after MEM_GOING_OFFLINE) are > +=09=09 * definitely unmovable. If their reference count would be 0, > +=09=09 * they could at least be skipped when offlining memory. > +=09=09 */ > +=09=09if (PageOffline(page) && page_count(page)) > +=09=09=09return -EBUSY; > =20 > =09=09if (!PageHuge(page)) > =09=09=09continue; > =09=09head =3D compound_head(page); > =09=09if (page_huge_active(head)) > -=09=09=09return pfn; > +=09=09=09goto found; > =09=09skip =3D compound_nr(head) - (page - head); > =09=09pfn +=3D skip - 1; > =09} > +=09return -ENOENT; > +found: > +=09*movable_pfn =3D pfn; > =09return 0; > } > =20 > @@ -1515,7 +1533,8 @@ static int __ref __offline_pages(unsigned long star= t_pfn, > =09} > =20 > =09do { > -=09=09for (pfn =3D start_pfn; pfn;) { > +=09=09pfn =3D start_pfn; > +=09=09do { > =09=09=09if (signal_pending(current)) { > =09=09=09=09ret =3D -EINTR; > =09=09=09=09reason =3D "signal backoff"; > @@ -1525,14 +1544,19 @@ static int __ref __offline_pages(unsigned long st= art_pfn, > =09=09=09cond_resched(); > =09=09=09lru_add_drain_all(); > =20 > -=09=09=09pfn =3D scan_movable_pages(pfn, end_pfn); > -=09=09=09if (pfn) { > +=09=09=09ret =3D scan_movable_pages(pfn, end_pfn, &pfn); > +=09=09=09if (!ret) { > =09=09=09=09/* > =09=09=09=09 * TODO: fatal migration failures should bail > =09=09=09=09 * out > =09=09=09=09 */ > =09=09=09=09do_migrate_range(pfn, end_pfn); > =09=09=09} > +=09=09} while (!ret); > + > +=09=09if (ret !=3D -ENOENT) { > +=09=09=09reason =3D "unmovable page"; > +=09=09=09goto failed_removal_isolated; > =09=09} > =20 > =09=09/* > diff --git a/mm/page_alloc.c b/mm/page_alloc.c > index 8d7be3f33e26..baa60222215f 100644 > --- a/mm/page_alloc.c > +++ b/mm/page_alloc.c > @@ -8366,6 +8366,19 @@ struct page *has_unmovable_pages(struct zone *zone= , struct page *page, > =09=09if ((flags & MEMORY_OFFLINE) && PageHWPoison(page)) > =09=09=09continue; > =20 > +=09=09/* > +=09=09 * We treat all PageOffline() pages as movable when offlining > +=09=09 * to give drivers a chance to decrement their reference count > +=09=09 * in MEM_GOING_OFFLINE in order to indicate that these pages > +=09=09 * can be offlined as there are no direct references anymore. > +=09=09 * For actually unmovable PageOffline() where the driver does > +=09=09 * not support this, we will fail later when trying to actually > +=09=09 * move these pages that still have a reference count > 0. > +=09=09 * (false negatives in this function only) > +=09=09 */ > +=09=09if ((flags & MEMORY_OFFLINE) && PageOffline(page)) > +=09=09=09continue; > + > =09=09if (__PageMovable(page) || PageLRU(page)) > =09=09=09continue; > =20 > @@ -8786,6 +8799,17 @@ __offline_isolated_pages(unsigned long start_pfn, = unsigned long end_pfn) > =09=09=09offlined_pages++; > =09=09=09continue; > =09=09} > +=09=09/* > +=09=09 * At this point all remaining PageOffline() pages have a > +=09=09 * reference count of 0 and can simply be skipped. > +=09=09 */ > +=09=09if (PageOffline(page)) { > +=09=09=09BUG_ON(page_count(page)); > +=09=09=09BUG_ON(PageBuddy(page)); > +=09=09=09pfn++; > +=09=09=09offlined_pages++; > +=09=09=09continue; > +=09=09} > =20 > =09=09BUG_ON(page_count(page)); > =09=09BUG_ON(!PageBuddy(page)); > diff --git a/mm/page_isolation.c b/mm/page_isolation.c > index 2c11a38d6e87..f6d07c5f0d34 100644 > --- a/mm/page_isolation.c > +++ b/mm/page_isolation.c > @@ -151,6 +151,7 @@ __first_valid_page(unsigned long pfn, unsigned long n= r_pages) > *=09=09=09a bit mask) > *=09=09=09MEMORY_OFFLINE - isolate to offline (!allocate) memory > *=09=09=09=09=09 e.g., skip over PageHWPoison() pages > + *=09=09=09=09=09 and PageOffline() pages. > *=09=09=09REPORT_FAILURE - report details about the failure to > *=09=09=09isolate the range > * > @@ -259,6 +260,14 @@ __test_page_isolated_in_pageblock(unsigned long pfn,= unsigned long end_pfn, > =09=09else if ((flags & MEMORY_OFFLINE) && PageHWPoison(page)) > =09=09=09/* A HWPoisoned page cannot be also PageBuddy */ > =09=09=09pfn++; > +=09=09else if ((flags & MEMORY_OFFLINE) && PageOffline(page) && > +=09=09=09 !page_count(page)) > +=09=09=09/* > +=09=09=09 * The responsible driver agreed to skip PageOffline() > +=09=09=09 * pages when offlining memory by dropping its > +=09=09=09 * reference in MEM_GOING_OFFLINE. > +=09=09=09 */ > +=09=09=09pfn++; > =09=09else > =09=09=09break; > =09} > --=20 > 2.24.1