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=-9.9 required=3.0 tests=BAYES_00,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=unavailable 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 523B7C2D0F6 for ; Tue, 8 Sep 2020 20:11:18 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1CEE920936 for ; Tue, 8 Sep 2020 20:11:18 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="fmJwwx/y" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732068AbgIHULQ (ORCPT ); Tue, 8 Sep 2020 16:11:16 -0400 Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120]:28544 "EHLO us-smtp-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1730931AbgIHULN (ORCPT ); Tue, 8 Sep 2020 16:11:13 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1599595871; 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=XWGa3qSfN9Odfx6sHlIPwO9T/8fSKtz1FdQi3pBhRQ0=; b=fmJwwx/yLiiDaUw2tz0cH2djPZWOd+UwB8ClaG1Np5FgNH+2tb/EQ0iWHsA7/KCicJuQQP dYlWRgt0RtIHuBcd7pZ44DNLhCMqNz6q4QyOm/1F026N2OFG59n8eMBQCnwfilGycJExm5 IugipTAEMIM2vc6wsut1Myf7OpYpoQY= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-217-ugEopWE8Oy6O8LRJQsXXwg-1; Tue, 08 Sep 2020 16:11:07 -0400 X-MC-Unique: ugEopWE8Oy6O8LRJQsXXwg-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 4701F1007465; Tue, 8 Sep 2020 20:11:04 +0000 (UTC) Received: from t480s.redhat.com (ovpn-115-46.ams2.redhat.com [10.36.115.46]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E9B75D9E8; Tue, 8 Sep 2020 20:10:56 +0000 (UTC) From: David Hildenbrand To: linux-kernel@vger.kernel.org Cc: virtualization@lists.linux-foundation.org, linux-mm@kvack.org, linux-hyperv@vger.kernel.org, xen-devel@lists.xenproject.org, linux-acpi@vger.kernel.org, linux-nvdimm@lists.01.org, linux-s390@vger.kernel.org, Andrew Morton , David Hildenbrand , Michal Hocko , Dan Williams , Jason Gunthorpe , Kees Cook , Ard Biesheuvel , Thomas Gleixner , "K. Y. Srinivasan" , Haiyang Zhang , Stephen Hemminger , Wei Liu , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= , Julien Grall , Pankaj Gupta , Baoquan He , Wei Yang Subject: [PATCH v2 4/7] mm/memory_hotplug: MEMHP_MERGE_RESOURCE to specify merging of System RAM resources Date: Tue, 8 Sep 2020 22:10:09 +0200 Message-Id: <20200908201012.44168-5-david@redhat.com> In-Reply-To: <20200908201012.44168-1-david@redhat.com> References: <20200908201012.44168-1-david@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 Sender: linux-acpi-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-acpi@vger.kernel.org Some add_memory*() users add memory in small, contiguous memory blocks. Examples include virtio-mem, hyper-v balloon, and the XEN balloon. This can quickly result in a lot of memory resources, whereby the actual resource boundaries are not of interest (e.g., it might be relevant for DIMMs, exposed via /proc/iomem to user space). We really want to merge added resources in this scenario where possible. Let's provide a flag (MEMHP_MERGE_RESOURCE) to specify that a resource either created within add_memory*() or passed via add_memory_resource() shall be marked mergeable and merged with applicable siblings. To implement that, we need a kernel/resource interface to mark selected System RAM resources mergeable (IORESOURCE_SYSRAM_MERGEABLE) and trigger merging. Note: We really want to merge after the whole operation succeeded, not directly when adding a resource to the resource tree (it would break add_memory_resource() and require splitting resources again when the operation failed - e.g., due to -ENOMEM). Cc: Andrew Morton Cc: Michal Hocko Cc: Dan Williams Cc: Jason Gunthorpe Cc: Kees Cook Cc: Ard Biesheuvel Cc: Thomas Gleixner Cc: "K. Y. Srinivasan" Cc: Haiyang Zhang Cc: Stephen Hemminger Cc: Wei Liu Cc: Boris Ostrovsky Cc: Juergen Gross Cc: Stefano Stabellini Cc: Roger Pau Monné Cc: Julien Grall Cc: Pankaj Gupta Cc: Baoquan He Cc: Wei Yang Signed-off-by: David Hildenbrand --- include/linux/ioport.h | 4 +++ include/linux/memory_hotplug.h | 9 +++++ kernel/resource.c | 60 ++++++++++++++++++++++++++++++++++ mm/memory_hotplug.c | 7 ++++ 4 files changed, 80 insertions(+) diff --git a/include/linux/ioport.h b/include/linux/ioport.h index d7620d7c941a0..7e61389dcb017 100644 --- a/include/linux/ioport.h +++ b/include/linux/ioport.h @@ -60,6 +60,7 @@ struct resource { /* IORESOURCE_SYSRAM specific bits. */ #define IORESOURCE_SYSRAM_DRIVER_MANAGED 0x02000000 /* Always detected via a driver. */ +#define IORESOURCE_SYSRAM_MERGEABLE 0x04000000 /* Resource can be merged. */ #define IORESOURCE_EXCLUSIVE 0x08000000 /* Userland may not map this resource */ @@ -253,6 +254,9 @@ extern void __release_region(struct resource *, resource_size_t, extern void release_mem_region_adjustable(struct resource *, resource_size_t, resource_size_t); #endif +#ifdef CONFIG_MEMORY_HOTPLUG +extern void merge_system_ram_resource(struct resource *res); +#endif /* Wrappers for managed devices */ struct device; diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h index 5cd48332ce119..feb4aac03f2eb 100644 --- a/include/linux/memory_hotplug.h +++ b/include/linux/memory_hotplug.h @@ -68,6 +68,15 @@ struct mhp_params { pgprot_t pgprot; }; +/* Flags used for add_memory() and friends. */ + +/* + * Allow merging of the added System RAM resource with adjacent, mergeable + * resources. After a successful call to add_memory_resource() with this flag + * set, the resource pointer must no longer be used as it might be stale. + */ +#define MEMHP_MERGE_RESOURCE 1 + /* * Zone resizing functions * diff --git a/kernel/resource.c b/kernel/resource.c index 36b3552210120..7a91b935f4c20 100644 --- a/kernel/resource.c +++ b/kernel/resource.c @@ -1363,6 +1363,66 @@ void release_mem_region_adjustable(struct resource *parent, } #endif /* CONFIG_MEMORY_HOTREMOVE */ +#ifdef CONFIG_MEMORY_HOTPLUG +static bool system_ram_resources_mergeable(struct resource *r1, + struct resource *r2) +{ + /* We assume either r1 or r2 is IORESOURCE_SYSRAM_MERGEABLE. */ + return r1->flags == r2->flags && r1->end + 1 == r2->start && + r1->name == r2->name && r1->desc == r2->desc && + !r1->child && !r2->child; +} + +/* + * merge_system_ram_resource - mark the System RAM resource mergeable and try to + * merge it with adjacent, mergeable resources + * @res: resource descriptor + * + * This interface is intended for memory hotplug, whereby lots of contiguous + * system ram resources are added (e.g., via add_memory*()) by a driver, and + * the actual resource boundaries are not of interest (e.g., it might be + * relevant for DIMMs). Only resources that are marked mergeable, that have the + * same parent, and that don't have any children are considered. All mergeable + * resources must be immutable during the request. + * + * Note: + * - The caller has to make sure that no pointers to resources that are + * marked mergeable are used anymore after this call - the resource might + * be freed and the pointer might be stale! + * - release_mem_region_adjustable() will split on demand on memory hotunplug + */ +void merge_system_ram_resource(struct resource *res) +{ + const unsigned long flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; + struct resource *cur; + + if (WARN_ON_ONCE((res->flags & flags) != flags)) + return; + + write_lock(&resource_lock); + res->flags |= IORESOURCE_SYSRAM_MERGEABLE; + + /* Try to merge with next item in the list. */ + cur = res->sibling; + if (cur && system_ram_resources_mergeable(res, cur)) { + res->end = cur->end; + res->sibling = cur->sibling; + free_resource(cur); + } + + /* Try to merge with previous item in the list. */ + cur = res->parent->child; + while (cur && cur->sibling != res) + cur = cur->sibling; + if (cur && system_ram_resources_mergeable(cur, res)) { + cur->end = res->end; + cur->sibling = res->sibling; + free_resource(res); + } + write_unlock(&resource_lock); +} +#endif /* CONFIG_MEMORY_HOTPLUG */ + /* * Managed region resource */ diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c index 64b07f006bc10..f62c2a46df8b1 100644 --- a/mm/memory_hotplug.c +++ b/mm/memory_hotplug.c @@ -1103,6 +1103,13 @@ int __ref add_memory_resource(int nid, struct resource *res, /* device_online() will take the lock when calling online_pages() */ mem_hotplug_done(); + /* + * In case we're allowed to merge the resource, flag it and trigger + * merging now that adding succeeded. + */ + if (flags & MEMHP_MERGE_RESOURCE) + merge_system_ram_resource(res); + /* online pages if requested */ if (memhp_default_online_type != MMOP_OFFLINE) walk_memory_blocks(start, size, NULL, online_memory_block); -- 2.26.2 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=-9.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,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 C9794C2D0E2 for ; Tue, 8 Sep 2020 20:11:14 +0000 (UTC) Received: from ml01.01.org (ml01.01.org [198.145.21.10]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 890DB2166E for ; Tue, 8 Sep 2020 20:11:14 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="fmJwwx/y" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 890DB2166E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvdimm-bounces@lists.01.org Received: from ml01.vlan13.01.org (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id 6DF9F13C4BD13; Tue, 8 Sep 2020 13:11:14 -0700 (PDT) Received-SPF: Pass (mailfrom) identity=mailfrom; client-ip=207.211.31.120; helo=us-smtp-1.mimecast.com; envelope-from=david@redhat.com; receiver= Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 7943113C4BD04 for ; Tue, 8 Sep 2020 13:11:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1599595871; 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=XWGa3qSfN9Odfx6sHlIPwO9T/8fSKtz1FdQi3pBhRQ0=; b=fmJwwx/yLiiDaUw2tz0cH2djPZWOd+UwB8ClaG1Np5FgNH+2tb/EQ0iWHsA7/KCicJuQQP dYlWRgt0RtIHuBcd7pZ44DNLhCMqNz6q4QyOm/1F026N2OFG59n8eMBQCnwfilGycJExm5 IugipTAEMIM2vc6wsut1Myf7OpYpoQY= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-217-ugEopWE8Oy6O8LRJQsXXwg-1; Tue, 08 Sep 2020 16:11:07 -0400 X-MC-Unique: ugEopWE8Oy6O8LRJQsXXwg-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 4701F1007465; Tue, 8 Sep 2020 20:11:04 +0000 (UTC) Received: from t480s.redhat.com (ovpn-115-46.ams2.redhat.com [10.36.115.46]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E9B75D9E8; Tue, 8 Sep 2020 20:10:56 +0000 (UTC) From: David Hildenbrand To: linux-kernel@vger.kernel.org Subject: [PATCH v2 4/7] mm/memory_hotplug: MEMHP_MERGE_RESOURCE to specify merging of System RAM resources Date: Tue, 8 Sep 2020 22:10:09 +0200 Message-Id: <20200908201012.44168-5-david@redhat.com> In-Reply-To: <20200908201012.44168-1-david@redhat.com> References: <20200908201012.44168-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 Message-ID-Hash: TCSPSBEJYYPJNHKPC6XGOM33LVXWXUBA X-Message-ID-Hash: TCSPSBEJYYPJNHKPC6XGOM33LVXWXUBA X-MailFrom: david@redhat.com X-Mailman-Rule-Hits: nonmember-moderation X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; emergency; loop; banned-address; member-moderation CC: virtualization@lists.linux-foundation.org, linux-mm@kvack.org, linux-hyperv@vger.kernel.org, xen-devel@lists.xenproject.org, linux-acpi@vger.kernel.org, linux-nvdimm@lists.01.org, linux-s390@vger.kernel.org, Andrew Morton , David Hildenbrand , Michal Hocko , Jason Gunthorpe , Kees Cook , Ard Biesheuvel , Thomas Gleixner , "K. Y. Srinivasan" , Haiyang Zhang , Stephen Hemminger , Wei Liu , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= , Julien Grall , Pankaj Gupta , Baoquan He X-Mailman-Version: 3.1.1 Precedence: list List-Id: "Linux-nvdimm developer list." Archived-At: List-Archive: List-Help: List-Post: List-Subscribe: List-Unsubscribe: Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 U29tZSBhZGRfbWVtb3J5KigpIHVzZXJzIGFkZCBtZW1vcnkgaW4gc21hbGwsIGNvbnRpZ3VvdXMg bWVtb3J5IGJsb2Nrcy4NCkV4YW1wbGVzIGluY2x1ZGUgdmlydGlvLW1lbSwgaHlwZXItdiBiYWxs b29uLCBhbmQgdGhlIFhFTiBiYWxsb29uLg0KDQpUaGlzIGNhbiBxdWlja2x5IHJlc3VsdCBpbiBh IGxvdCBvZiBtZW1vcnkgcmVzb3VyY2VzLCB3aGVyZWJ5IHRoZSBhY3R1YWwNCnJlc291cmNlIGJv dW5kYXJpZXMgYXJlIG5vdCBvZiBpbnRlcmVzdCAoZS5nLiwgaXQgbWlnaHQgYmUgcmVsZXZhbnQg Zm9yDQpESU1NcywgZXhwb3NlZCB2aWEgL3Byb2MvaW9tZW0gdG8gdXNlciBzcGFjZSkuIFdlIHJl YWxseSB3YW50IHRvIG1lcmdlDQphZGRlZCByZXNvdXJjZXMgaW4gdGhpcyBzY2VuYXJpbyB3aGVy ZSBwb3NzaWJsZS4NCg0KTGV0J3MgcHJvdmlkZSBhIGZsYWcgKE1FTUhQX01FUkdFX1JFU09VUkNF KSB0byBzcGVjaWZ5IHRoYXQgYSByZXNvdXJjZQ0KZWl0aGVyIGNyZWF0ZWQgd2l0aGluIGFkZF9t ZW1vcnkqKCkgb3IgcGFzc2VkIHZpYSBhZGRfbWVtb3J5X3Jlc291cmNlKCkNCnNoYWxsIGJlIG1h cmtlZCBtZXJnZWFibGUgYW5kIG1lcmdlZCB3aXRoIGFwcGxpY2FibGUgc2libGluZ3MuDQoNClRv IGltcGxlbWVudCB0aGF0LCB3ZSBuZWVkIGEga2VybmVsL3Jlc291cmNlIGludGVyZmFjZSB0byBt YXJrIHNlbGVjdGVkDQpTeXN0ZW0gUkFNIHJlc291cmNlcyBtZXJnZWFibGUgKElPUkVTT1VSQ0Vf U1lTUkFNX01FUkdFQUJMRSkgYW5kIHRyaWdnZXINCm1lcmdpbmcuDQoNCk5vdGU6IFdlIHJlYWxs eSB3YW50IHRvIG1lcmdlIGFmdGVyIHRoZSB3aG9sZSBvcGVyYXRpb24gc3VjY2VlZGVkLCBub3QN CmRpcmVjdGx5IHdoZW4gYWRkaW5nIGEgcmVzb3VyY2UgdG8gdGhlIHJlc291cmNlIHRyZWUgKGl0 IHdvdWxkIGJyZWFrDQphZGRfbWVtb3J5X3Jlc291cmNlKCkgYW5kIHJlcXVpcmUgc3BsaXR0aW5n IHJlc291cmNlcyBhZ2FpbiB3aGVuIHRoZQ0Kb3BlcmF0aW9uIGZhaWxlZCAtIGUuZy4sIGR1ZSB0 byAtRU5PTUVNKS4NCg0KQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRhdGlvbi5v cmc+DQpDYzogTWljaGFsIEhvY2tvIDxtaG9ja29Ac3VzZS5jb20+DQpDYzogRGFuIFdpbGxpYW1z IDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQpDYzogSmFzb24gR3VudGhvcnBlIDxqZ2dAemll cGUuY2E+DQpDYzogS2VlcyBDb29rIDxrZWVzY29va0BjaHJvbWl1bS5vcmc+DQpDYzogQXJkIEJp ZXNoZXV2ZWwgPGFyZGJAa2VybmVsLm9yZz4NCkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGlu dXRyb25peC5kZT4NCkNjOiAiSy4gWS4gU3Jpbml2YXNhbiIgPGt5c0BtaWNyb3NvZnQuY29tPg0K Q2M6IEhhaXlhbmcgWmhhbmcgPGhhaXlhbmd6QG1pY3Jvc29mdC5jb20+DQpDYzogU3RlcGhlbiBI ZW1taW5nZXIgPHN0aGVtbWluQG1pY3Jvc29mdC5jb20+DQpDYzogV2VpIExpdSA8d2VpLmxpdUBr ZXJuZWwub3JnPg0KQ2M6IEJvcmlzIE9zdHJvdnNreSA8Ym9yaXMub3N0cm92c2t5QG9yYWNsZS5j b20+DQpDYzogSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPg0KQ2M6IFN0ZWZhbm8gU3Rh YmVsbGluaSA8c3N0YWJlbGxpbmlAa2VybmVsLm9yZz4NCkNjOiBSb2dlciBQYXUgTW9ubsOpIDxy b2dlci5wYXVAY2l0cml4LmNvbT4NCkNjOiBKdWxpZW4gR3JhbGwgPGp1bGllbkB4ZW4ub3JnPg0K Q2M6IFBhbmthaiBHdXB0YSA8cGFua2FqLmd1cHRhLmxpbnV4QGdtYWlsLmNvbT4NCkNjOiBCYW9x dWFuIEhlIDxiaGVAcmVkaGF0LmNvbT4NCkNjOiBXZWkgWWFuZyA8cmljaGFyZHcueWFuZ0BsaW51 eC5pbnRlbC5jb20+DQpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBIaWxkZW5icmFuZCA8ZGF2aWRAcmVk aGF0LmNvbT4NCi0tLQ0KIGluY2x1ZGUvbGludXgvaW9wb3J0LmggICAgICAgICB8ICA0ICsrKw0K IGluY2x1ZGUvbGludXgvbWVtb3J5X2hvdHBsdWcuaCB8ICA5ICsrKysrDQoga2VybmVsL3Jlc291 cmNlLmMgICAgICAgICAgICAgIHwgNjAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Kw0KIG1tL21lbW9yeV9ob3RwbHVnLmMgICAgICAgICAgICB8ICA3ICsrKysNCiA0IGZpbGVzIGNo YW5nZWQsIDgwIGluc2VydGlvbnMoKykNCg0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW9w b3J0LmggYi9pbmNsdWRlL2xpbnV4L2lvcG9ydC5oDQppbmRleCBkNzYyMGQ3Yzk0MWEwLi43ZTYx Mzg5ZGNiMDE3IDEwMDY0NA0KLS0tIGEvaW5jbHVkZS9saW51eC9pb3BvcnQuaA0KKysrIGIvaW5j bHVkZS9saW51eC9pb3BvcnQuaA0KQEAgLTYwLDYgKzYwLDcgQEAgc3RydWN0IHJlc291cmNlIHsN CiANCiAvKiBJT1JFU09VUkNFX1NZU1JBTSBzcGVjaWZpYyBiaXRzLiAqLw0KICNkZWZpbmUgSU9S RVNPVVJDRV9TWVNSQU1fRFJJVkVSX01BTkFHRUQJMHgwMjAwMDAwMCAvKiBBbHdheXMgZGV0ZWN0 ZWQgdmlhIGEgZHJpdmVyLiAqLw0KKyNkZWZpbmUgSU9SRVNPVVJDRV9TWVNSQU1fTUVSR0VBQkxF CQkweDA0MDAwMDAwIC8qIFJlc291cmNlIGNhbiBiZSBtZXJnZWQuICovDQogDQogI2RlZmluZSBJ T1JFU09VUkNFX0VYQ0xVU0lWRQkweDA4MDAwMDAwCS8qIFVzZXJsYW5kIG1heSBub3QgbWFwIHRo aXMgcmVzb3VyY2UgKi8NCiANCkBAIC0yNTMsNiArMjU0LDkgQEAgZXh0ZXJuIHZvaWQgX19yZWxl YXNlX3JlZ2lvbihzdHJ1Y3QgcmVzb3VyY2UgKiwgcmVzb3VyY2Vfc2l6ZV90LA0KIGV4dGVybiB2 b2lkIHJlbGVhc2VfbWVtX3JlZ2lvbl9hZGp1c3RhYmxlKHN0cnVjdCByZXNvdXJjZSAqLCByZXNv dXJjZV9zaXplX3QsDQogCQkJCQkgIHJlc291cmNlX3NpemVfdCk7DQogI2VuZGlmDQorI2lmZGVm IENPTkZJR19NRU1PUllfSE9UUExVRw0KK2V4dGVybiB2b2lkIG1lcmdlX3N5c3RlbV9yYW1fcmVz b3VyY2Uoc3RydWN0IHJlc291cmNlICpyZXMpOw0KKyNlbmRpZg0KIA0KIC8qIFdyYXBwZXJzIGZv ciBtYW5hZ2VkIGRldmljZXMgKi8NCiBzdHJ1Y3QgZGV2aWNlOw0KZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvbWVtb3J5X2hvdHBsdWcuaCBiL2luY2x1ZGUvbGludXgvbWVtb3J5X2hvdHBsdWcu aA0KaW5kZXggNWNkNDgzMzJjZTExOS4uZmViNGFhYzAzZjJlYiAxMDA2NDQNCi0tLSBhL2luY2x1 ZGUvbGludXgvbWVtb3J5X2hvdHBsdWcuaA0KKysrIGIvaW5jbHVkZS9saW51eC9tZW1vcnlfaG90 cGx1Zy5oDQpAQCAtNjgsNiArNjgsMTUgQEAgc3RydWN0IG1ocF9wYXJhbXMgew0KIAlwZ3Byb3Rf dCBwZ3Byb3Q7DQogfTsNCiANCisvKiBGbGFncyB1c2VkIGZvciBhZGRfbWVtb3J5KCkgYW5kIGZy aWVuZHMuICovDQorDQorLyoNCisgKiBBbGxvdyBtZXJnaW5nIG9mIHRoZSBhZGRlZCBTeXN0ZW0g UkFNIHJlc291cmNlIHdpdGggYWRqYWNlbnQsIG1lcmdlYWJsZQ0KKyAqIHJlc291cmNlcy4gQWZ0 ZXIgYSBzdWNjZXNzZnVsIGNhbGwgdG8gYWRkX21lbW9yeV9yZXNvdXJjZSgpIHdpdGggdGhpcyBm bGFnDQorICogc2V0LCB0aGUgcmVzb3VyY2UgcG9pbnRlciBtdXN0IG5vIGxvbmdlciBiZSB1c2Vk IGFzIGl0IG1pZ2h0IGJlIHN0YWxlLg0KKyAqLw0KKyNkZWZpbmUgTUVNSFBfTUVSR0VfUkVTT1VS Q0UJCTENCisNCiAvKg0KICAqIFpvbmUgcmVzaXppbmcgZnVuY3Rpb25zDQogICoNCmRpZmYgLS1n aXQgYS9rZXJuZWwvcmVzb3VyY2UuYyBiL2tlcm5lbC9yZXNvdXJjZS5jDQppbmRleCAzNmIzNTUy MjEwMTIwLi43YTkxYjkzNWY0YzIwIDEwMDY0NA0KLS0tIGEva2VybmVsL3Jlc291cmNlLmMNCisr KyBiL2tlcm5lbC9yZXNvdXJjZS5jDQpAQCAtMTM2Myw2ICsxMzYzLDY2IEBAIHZvaWQgcmVsZWFz ZV9tZW1fcmVnaW9uX2FkanVzdGFibGUoc3RydWN0IHJlc291cmNlICpwYXJlbnQsDQogfQ0KICNl bmRpZgkvKiBDT05GSUdfTUVNT1JZX0hPVFJFTU9WRSAqLw0KIA0KKyNpZmRlZiBDT05GSUdfTUVN T1JZX0hPVFBMVUcNCitzdGF0aWMgYm9vbCBzeXN0ZW1fcmFtX3Jlc291cmNlc19tZXJnZWFibGUo c3RydWN0IHJlc291cmNlICpyMSwNCisJCQkJCSAgIHN0cnVjdCByZXNvdXJjZSAqcjIpDQorew0K KwkvKiBXZSBhc3N1bWUgZWl0aGVyIHIxIG9yIHIyIGlzIElPUkVTT1VSQ0VfU1lTUkFNX01FUkdF QUJMRS4gKi8NCisJcmV0dXJuIHIxLT5mbGFncyA9PSByMi0+ZmxhZ3MgJiYgcjEtPmVuZCArIDEg PT0gcjItPnN0YXJ0ICYmDQorCSAgICAgICByMS0+bmFtZSA9PSByMi0+bmFtZSAmJiByMS0+ZGVz YyA9PSByMi0+ZGVzYyAmJg0KKwkgICAgICAgIXIxLT5jaGlsZCAmJiAhcjItPmNoaWxkOw0KK30N CisNCisvKg0KKyAqIG1lcmdlX3N5c3RlbV9yYW1fcmVzb3VyY2UgLSBtYXJrIHRoZSBTeXN0ZW0g UkFNIHJlc291cmNlIG1lcmdlYWJsZSBhbmQgdHJ5IHRvDQorICogbWVyZ2UgaXQgd2l0aCBhZGph Y2VudCwgbWVyZ2VhYmxlIHJlc291cmNlcw0KKyAqIEByZXM6IHJlc291cmNlIGRlc2NyaXB0b3IN CisgKg0KKyAqIFRoaXMgaW50ZXJmYWNlIGlzIGludGVuZGVkIGZvciBtZW1vcnkgaG90cGx1Zywg d2hlcmVieSBsb3RzIG9mIGNvbnRpZ3VvdXMNCisgKiBzeXN0ZW0gcmFtIHJlc291cmNlcyBhcmUg YWRkZWQgKGUuZy4sIHZpYSBhZGRfbWVtb3J5KigpKSBieSBhIGRyaXZlciwgYW5kDQorICogdGhl IGFjdHVhbCByZXNvdXJjZSBib3VuZGFyaWVzIGFyZSBub3Qgb2YgaW50ZXJlc3QgKGUuZy4sIGl0 IG1pZ2h0IGJlDQorICogcmVsZXZhbnQgZm9yIERJTU1zKS4gT25seSByZXNvdXJjZXMgdGhhdCBh cmUgbWFya2VkIG1lcmdlYWJsZSwgdGhhdCBoYXZlIHRoZQ0KKyAqIHNhbWUgcGFyZW50LCBhbmQg dGhhdCBkb24ndCBoYXZlIGFueSBjaGlsZHJlbiBhcmUgY29uc2lkZXJlZC4gQWxsIG1lcmdlYWJs ZQ0KKyAqIHJlc291cmNlcyBtdXN0IGJlIGltbXV0YWJsZSBkdXJpbmcgdGhlIHJlcXVlc3QuDQor ICoNCisgKiBOb3RlOg0KKyAqIC0gVGhlIGNhbGxlciBoYXMgdG8gbWFrZSBzdXJlIHRoYXQgbm8g cG9pbnRlcnMgdG8gcmVzb3VyY2VzIHRoYXQgYXJlDQorICogICBtYXJrZWQgbWVyZ2VhYmxlIGFy ZSB1c2VkIGFueW1vcmUgYWZ0ZXIgdGhpcyBjYWxsIC0gdGhlIHJlc291cmNlIG1pZ2h0DQorICog ICBiZSBmcmVlZCBhbmQgdGhlIHBvaW50ZXIgbWlnaHQgYmUgc3RhbGUhDQorICogLSByZWxlYXNl X21lbV9yZWdpb25fYWRqdXN0YWJsZSgpIHdpbGwgc3BsaXQgb24gZGVtYW5kIG9uIG1lbW9yeSBo b3R1bnBsdWcNCisgKi8NCit2b2lkIG1lcmdlX3N5c3RlbV9yYW1fcmVzb3VyY2Uoc3RydWN0IHJl c291cmNlICpyZXMpDQorew0KKwljb25zdCB1bnNpZ25lZCBsb25nIGZsYWdzID0gSU9SRVNPVVJD RV9TWVNURU1fUkFNIHwgSU9SRVNPVVJDRV9CVVNZOw0KKwlzdHJ1Y3QgcmVzb3VyY2UgKmN1cjsN CisNCisJaWYgKFdBUk5fT05fT05DRSgocmVzLT5mbGFncyAmIGZsYWdzKSAhPSBmbGFncykpDQor CQlyZXR1cm47DQorDQorCXdyaXRlX2xvY2soJnJlc291cmNlX2xvY2spOw0KKwlyZXMtPmZsYWdz IHw9IElPUkVTT1VSQ0VfU1lTUkFNX01FUkdFQUJMRTsNCisNCisJLyogVHJ5IHRvIG1lcmdlIHdp dGggbmV4dCBpdGVtIGluIHRoZSBsaXN0LiAqLw0KKwljdXIgPSByZXMtPnNpYmxpbmc7DQorCWlm IChjdXIgJiYgc3lzdGVtX3JhbV9yZXNvdXJjZXNfbWVyZ2VhYmxlKHJlcywgY3VyKSkgew0KKwkJ cmVzLT5lbmQgPSBjdXItPmVuZDsNCisJCXJlcy0+c2libGluZyA9IGN1ci0+c2libGluZzsNCisJ CWZyZWVfcmVzb3VyY2UoY3VyKTsNCisJfQ0KKw0KKwkvKiBUcnkgdG8gbWVyZ2Ugd2l0aCBwcmV2 aW91cyBpdGVtIGluIHRoZSBsaXN0LiAqLw0KKwljdXIgPSByZXMtPnBhcmVudC0+Y2hpbGQ7DQor CXdoaWxlIChjdXIgJiYgY3VyLT5zaWJsaW5nICE9IHJlcykNCisJCWN1ciA9IGN1ci0+c2libGlu ZzsNCisJaWYgKGN1ciAmJiBzeXN0ZW1fcmFtX3Jlc291cmNlc19tZXJnZWFibGUoY3VyLCByZXMp KSB7DQorCQljdXItPmVuZCA9IHJlcy0+ZW5kOw0KKwkJY3VyLT5zaWJsaW5nID0gcmVzLT5zaWJs aW5nOw0KKwkJZnJlZV9yZXNvdXJjZShyZXMpOw0KKwl9DQorCXdyaXRlX3VubG9jaygmcmVzb3Vy Y2VfbG9jayk7DQorfQ0KKyNlbmRpZgkvKiBDT05GSUdfTUVNT1JZX0hPVFBMVUcgKi8NCisNCiAv Kg0KICAqIE1hbmFnZWQgcmVnaW9uIHJlc291cmNlDQogICovDQpkaWZmIC0tZ2l0IGEvbW0vbWVt b3J5X2hvdHBsdWcuYyBiL21tL21lbW9yeV9ob3RwbHVnLmMNCmluZGV4IDY0YjA3ZjAwNmJjMTAu LmY2MmMyYTQ2ZGY4YjEgMTAwNjQ0DQotLS0gYS9tbS9tZW1vcnlfaG90cGx1Zy5jDQorKysgYi9t bS9tZW1vcnlfaG90cGx1Zy5jDQpAQCAtMTEwMyw2ICsxMTAzLDEzIEBAIGludCBfX3JlZiBhZGRf bWVtb3J5X3Jlc291cmNlKGludCBuaWQsIHN0cnVjdCByZXNvdXJjZSAqcmVzLA0KIAkvKiBkZXZp Y2Vfb25saW5lKCkgd2lsbCB0YWtlIHRoZSBsb2NrIHdoZW4gY2FsbGluZyBvbmxpbmVfcGFnZXMo KSAqLw0KIAltZW1faG90cGx1Z19kb25lKCk7DQogDQorCS8qDQorCSAqIEluIGNhc2Ugd2UncmUg YWxsb3dlZCB0byBtZXJnZSB0aGUgcmVzb3VyY2UsIGZsYWcgaXQgYW5kIHRyaWdnZXINCisJICog bWVyZ2luZyBub3cgdGhhdCBhZGRpbmcgc3VjY2VlZGVkLg0KKwkgKi8NCisJaWYgKGZsYWdzICYg TUVNSFBfTUVSR0VfUkVTT1VSQ0UpDQorCQltZXJnZV9zeXN0ZW1fcmFtX3Jlc291cmNlKHJlcyk7 DQorDQogCS8qIG9ubGluZSBwYWdlcyBpZiByZXF1ZXN0ZWQgKi8NCiAJaWYgKG1lbWhwX2RlZmF1 bHRfb25saW5lX3R5cGUgIT0gTU1PUF9PRkZMSU5FKQ0KIAkJd2Fsa19tZW1vcnlfYmxvY2tzKHN0 YXJ0LCBzaXplLCBOVUxMLCBvbmxpbmVfbWVtb3J5X2Jsb2NrKTsNCi0tIA0KMi4yNi4yDQpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1udmRpbW0g bWFpbGluZyBsaXN0IC0tIGxpbnV4LW52ZGltbUBsaXN0cy4wMS5vcmcKVG8gdW5zdWJzY3JpYmUg c2VuZCBhbiBlbWFpbCB0byBsaW51eC1udmRpbW0tbGVhdmVAbGlzdHMuMDEub3JnCg== 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=-9.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,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 D307DC433E2 for ; Tue, 8 Sep 2020 20:11:21 +0000 (UTC) Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 6C3D6208FE for ; Tue, 8 Sep 2020 20:11:21 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="fmJwwx/y" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6C3D6208FE Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=virtualization-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 09E0086CE0; Tue, 8 Sep 2020 20:11:21 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id Ere5zEGvMZ0a; Tue, 8 Sep 2020 20:11:19 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by whitealder.osuosl.org (Postfix) with ESMTP id 1004B86EBB; Tue, 8 Sep 2020 20:11:19 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 0810CC0859; Tue, 8 Sep 2020 20:11:19 +0000 (UTC) Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id D494BC0051 for ; Tue, 8 Sep 2020 20:11:17 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id B033A27A6E for ; Tue, 8 Sep 2020 20:11:17 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id clGDk7jVgEPt for ; Tue, 8 Sep 2020 20:11:12 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) by silver.osuosl.org (Postfix) with ESMTPS id A6F262150A for ; Tue, 8 Sep 2020 20:11:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1599595871; 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=XWGa3qSfN9Odfx6sHlIPwO9T/8fSKtz1FdQi3pBhRQ0=; b=fmJwwx/yLiiDaUw2tz0cH2djPZWOd+UwB8ClaG1Np5FgNH+2tb/EQ0iWHsA7/KCicJuQQP dYlWRgt0RtIHuBcd7pZ44DNLhCMqNz6q4QyOm/1F026N2OFG59n8eMBQCnwfilGycJExm5 IugipTAEMIM2vc6wsut1Myf7OpYpoQY= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-217-ugEopWE8Oy6O8LRJQsXXwg-1; Tue, 08 Sep 2020 16:11:07 -0400 X-MC-Unique: ugEopWE8Oy6O8LRJQsXXwg-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 4701F1007465; Tue, 8 Sep 2020 20:11:04 +0000 (UTC) Received: from t480s.redhat.com (ovpn-115-46.ams2.redhat.com [10.36.115.46]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4E9B75D9E8; Tue, 8 Sep 2020 20:10:56 +0000 (UTC) From: David Hildenbrand To: linux-kernel@vger.kernel.org Subject: [PATCH v2 4/7] mm/memory_hotplug: MEMHP_MERGE_RESOURCE to specify merging of System RAM resources Date: Tue, 8 Sep 2020 22:10:09 +0200 Message-Id: <20200908201012.44168-5-david@redhat.com> In-Reply-To: <20200908201012.44168-1-david@redhat.com> References: <20200908201012.44168-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 Cc: linux-hyperv@vger.kernel.org, Michal Hocko , virtualization@lists.linux-foundation.org, linux-mm@kvack.org, Thomas Gleixner , linux-s390@vger.kernel.org, Wei Liu , Stefano Stabellini , Stephen Hemminger , Baoquan He , linux-nvdimm@lists.01.org, Jason Gunthorpe , Ard Biesheuvel , linux-acpi@vger.kernel.org, xen-devel@lists.xenproject.org, Julien Grall , Kees Cook , Haiyang Zhang , Dan Williams , Boris Ostrovsky , Juergen Gross , Pankaj Gupta , Wei Yang , Andrew Morton , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" U29tZSBhZGRfbWVtb3J5KigpIHVzZXJzIGFkZCBtZW1vcnkgaW4gc21hbGwsIGNvbnRpZ3VvdXMg bWVtb3J5IGJsb2Nrcy4KRXhhbXBsZXMgaW5jbHVkZSB2aXJ0aW8tbWVtLCBoeXBlci12IGJhbGxv b24sIGFuZCB0aGUgWEVOIGJhbGxvb24uCgpUaGlzIGNhbiBxdWlja2x5IHJlc3VsdCBpbiBhIGxv dCBvZiBtZW1vcnkgcmVzb3VyY2VzLCB3aGVyZWJ5IHRoZSBhY3R1YWwKcmVzb3VyY2UgYm91bmRh cmllcyBhcmUgbm90IG9mIGludGVyZXN0IChlLmcuLCBpdCBtaWdodCBiZSByZWxldmFudCBmb3IK RElNTXMsIGV4cG9zZWQgdmlhIC9wcm9jL2lvbWVtIHRvIHVzZXIgc3BhY2UpLiBXZSByZWFsbHkg d2FudCB0byBtZXJnZQphZGRlZCByZXNvdXJjZXMgaW4gdGhpcyBzY2VuYXJpbyB3aGVyZSBwb3Nz aWJsZS4KCkxldCdzIHByb3ZpZGUgYSBmbGFnIChNRU1IUF9NRVJHRV9SRVNPVVJDRSkgdG8gc3Bl Y2lmeSB0aGF0IGEgcmVzb3VyY2UKZWl0aGVyIGNyZWF0ZWQgd2l0aGluIGFkZF9tZW1vcnkqKCkg b3IgcGFzc2VkIHZpYSBhZGRfbWVtb3J5X3Jlc291cmNlKCkKc2hhbGwgYmUgbWFya2VkIG1lcmdl YWJsZSBhbmQgbWVyZ2VkIHdpdGggYXBwbGljYWJsZSBzaWJsaW5ncy4KClRvIGltcGxlbWVudCB0 aGF0LCB3ZSBuZWVkIGEga2VybmVsL3Jlc291cmNlIGludGVyZmFjZSB0byBtYXJrIHNlbGVjdGVk ClN5c3RlbSBSQU0gcmVzb3VyY2VzIG1lcmdlYWJsZSAoSU9SRVNPVVJDRV9TWVNSQU1fTUVSR0VB QkxFKSBhbmQgdHJpZ2dlcgptZXJnaW5nLgoKTm90ZTogV2UgcmVhbGx5IHdhbnQgdG8gbWVyZ2Ug YWZ0ZXIgdGhlIHdob2xlIG9wZXJhdGlvbiBzdWNjZWVkZWQsIG5vdApkaXJlY3RseSB3aGVuIGFk ZGluZyBhIHJlc291cmNlIHRvIHRoZSByZXNvdXJjZSB0cmVlIChpdCB3b3VsZCBicmVhawphZGRf bWVtb3J5X3Jlc291cmNlKCkgYW5kIHJlcXVpcmUgc3BsaXR0aW5nIHJlc291cmNlcyBhZ2FpbiB3 aGVuIHRoZQpvcGVyYXRpb24gZmFpbGVkIC0gZS5nLiwgZHVlIHRvIC1FTk9NRU0pLgoKQ2M6IEFu ZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRhdGlvbi5vcmc+CkNjOiBNaWNoYWwgSG9ja28g PG1ob2Nrb0BzdXNlLmNvbT4KQ2M6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwu Y29tPgpDYzogSmFzb24gR3VudGhvcnBlIDxqZ2dAemllcGUuY2E+CkNjOiBLZWVzIENvb2sgPGtl ZXNjb29rQGNocm9taXVtLm9yZz4KQ2M6IEFyZCBCaWVzaGV1dmVsIDxhcmRiQGtlcm5lbC5vcmc+ CkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KQ2M6ICJLLiBZLiBTcmlu aXZhc2FuIiA8a3lzQG1pY3Jvc29mdC5jb20+CkNjOiBIYWl5YW5nIFpoYW5nIDxoYWl5YW5nekBt aWNyb3NvZnQuY29tPgpDYzogU3RlcGhlbiBIZW1taW5nZXIgPHN0aGVtbWluQG1pY3Jvc29mdC5j b20+CkNjOiBXZWkgTGl1IDx3ZWkubGl1QGtlcm5lbC5vcmc+CkNjOiBCb3JpcyBPc3Ryb3Zza3kg PGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29tPgpDYzogSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1 c2UuY29tPgpDYzogU3RlZmFubyBTdGFiZWxsaW5pIDxzc3RhYmVsbGluaUBrZXJuZWwub3JnPgpD YzogUm9nZXIgUGF1IE1vbm7DqSA8cm9nZXIucGF1QGNpdHJpeC5jb20+CkNjOiBKdWxpZW4gR3Jh bGwgPGp1bGllbkB4ZW4ub3JnPgpDYzogUGFua2FqIEd1cHRhIDxwYW5rYWouZ3VwdGEubGludXhA Z21haWwuY29tPgpDYzogQmFvcXVhbiBIZSA8YmhlQHJlZGhhdC5jb20+CkNjOiBXZWkgWWFuZyA8 cmljaGFyZHcueWFuZ0BsaW51eC5pbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlkIEhpbGRl bmJyYW5kIDxkYXZpZEByZWRoYXQuY29tPgotLS0KIGluY2x1ZGUvbGludXgvaW9wb3J0LmggICAg ICAgICB8ICA0ICsrKwogaW5jbHVkZS9saW51eC9tZW1vcnlfaG90cGx1Zy5oIHwgIDkgKysrKysK IGtlcm5lbC9yZXNvdXJjZS5jICAgICAgICAgICAgICB8IDYwICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysKIG1tL21lbW9yeV9ob3RwbHVnLmMgICAgICAgICAgICB8ICA3ICsrKysK IDQgZmlsZXMgY2hhbmdlZCwgODAgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvaW9wb3J0LmggYi9pbmNsdWRlL2xpbnV4L2lvcG9ydC5oCmluZGV4IGQ3NjIwZDdjOTQx YTAuLjdlNjEzODlkY2IwMTcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaW9wb3J0LmgKKysr IGIvaW5jbHVkZS9saW51eC9pb3BvcnQuaApAQCAtNjAsNiArNjAsNyBAQCBzdHJ1Y3QgcmVzb3Vy Y2UgewogCiAvKiBJT1JFU09VUkNFX1NZU1JBTSBzcGVjaWZpYyBiaXRzLiAqLwogI2RlZmluZSBJ T1JFU09VUkNFX1NZU1JBTV9EUklWRVJfTUFOQUdFRAkweDAyMDAwMDAwIC8qIEFsd2F5cyBkZXRl Y3RlZCB2aWEgYSBkcml2ZXIuICovCisjZGVmaW5lIElPUkVTT1VSQ0VfU1lTUkFNX01FUkdFQUJM RQkJMHgwNDAwMDAwMCAvKiBSZXNvdXJjZSBjYW4gYmUgbWVyZ2VkLiAqLwogCiAjZGVmaW5lIElP UkVTT1VSQ0VfRVhDTFVTSVZFCTB4MDgwMDAwMDAJLyogVXNlcmxhbmQgbWF5IG5vdCBtYXAgdGhp cyByZXNvdXJjZSAqLwogCkBAIC0yNTMsNiArMjU0LDkgQEAgZXh0ZXJuIHZvaWQgX19yZWxlYXNl X3JlZ2lvbihzdHJ1Y3QgcmVzb3VyY2UgKiwgcmVzb3VyY2Vfc2l6ZV90LAogZXh0ZXJuIHZvaWQg cmVsZWFzZV9tZW1fcmVnaW9uX2FkanVzdGFibGUoc3RydWN0IHJlc291cmNlICosIHJlc291cmNl X3NpemVfdCwKIAkJCQkJICByZXNvdXJjZV9zaXplX3QpOwogI2VuZGlmCisjaWZkZWYgQ09ORklH X01FTU9SWV9IT1RQTFVHCitleHRlcm4gdm9pZCBtZXJnZV9zeXN0ZW1fcmFtX3Jlc291cmNlKHN0 cnVjdCByZXNvdXJjZSAqcmVzKTsKKyNlbmRpZgogCiAvKiBXcmFwcGVycyBmb3IgbWFuYWdlZCBk ZXZpY2VzICovCiBzdHJ1Y3QgZGV2aWNlOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZW1v cnlfaG90cGx1Zy5oIGIvaW5jbHVkZS9saW51eC9tZW1vcnlfaG90cGx1Zy5oCmluZGV4IDVjZDQ4 MzMyY2UxMTkuLmZlYjRhYWMwM2YyZWIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWVtb3J5 X2hvdHBsdWcuaAorKysgYi9pbmNsdWRlL2xpbnV4L21lbW9yeV9ob3RwbHVnLmgKQEAgLTY4LDYg KzY4LDE1IEBAIHN0cnVjdCBtaHBfcGFyYW1zIHsKIAlwZ3Byb3RfdCBwZ3Byb3Q7CiB9OwogCisv KiBGbGFncyB1c2VkIGZvciBhZGRfbWVtb3J5KCkgYW5kIGZyaWVuZHMuICovCisKKy8qCisgKiBB bGxvdyBtZXJnaW5nIG9mIHRoZSBhZGRlZCBTeXN0ZW0gUkFNIHJlc291cmNlIHdpdGggYWRqYWNl bnQsIG1lcmdlYWJsZQorICogcmVzb3VyY2VzLiBBZnRlciBhIHN1Y2Nlc3NmdWwgY2FsbCB0byBh ZGRfbWVtb3J5X3Jlc291cmNlKCkgd2l0aCB0aGlzIGZsYWcKKyAqIHNldCwgdGhlIHJlc291cmNl IHBvaW50ZXIgbXVzdCBubyBsb25nZXIgYmUgdXNlZCBhcyBpdCBtaWdodCBiZSBzdGFsZS4KKyAq LworI2RlZmluZSBNRU1IUF9NRVJHRV9SRVNPVVJDRQkJMQorCiAvKgogICogWm9uZSByZXNpemlu ZyBmdW5jdGlvbnMKICAqCmRpZmYgLS1naXQgYS9rZXJuZWwvcmVzb3VyY2UuYyBiL2tlcm5lbC9y ZXNvdXJjZS5jCmluZGV4IDM2YjM1NTIyMTAxMjAuLjdhOTFiOTM1ZjRjMjAgMTAwNjQ0Ci0tLSBh L2tlcm5lbC9yZXNvdXJjZS5jCisrKyBiL2tlcm5lbC9yZXNvdXJjZS5jCkBAIC0xMzYzLDYgKzEz NjMsNjYgQEAgdm9pZCByZWxlYXNlX21lbV9yZWdpb25fYWRqdXN0YWJsZShzdHJ1Y3QgcmVzb3Vy Y2UgKnBhcmVudCwKIH0KICNlbmRpZgkvKiBDT05GSUdfTUVNT1JZX0hPVFJFTU9WRSAqLwogCisj aWZkZWYgQ09ORklHX01FTU9SWV9IT1RQTFVHCitzdGF0aWMgYm9vbCBzeXN0ZW1fcmFtX3Jlc291 cmNlc19tZXJnZWFibGUoc3RydWN0IHJlc291cmNlICpyMSwKKwkJCQkJICAgc3RydWN0IHJlc291 cmNlICpyMikKK3sKKwkvKiBXZSBhc3N1bWUgZWl0aGVyIHIxIG9yIHIyIGlzIElPUkVTT1VSQ0Vf U1lTUkFNX01FUkdFQUJMRS4gKi8KKwlyZXR1cm4gcjEtPmZsYWdzID09IHIyLT5mbGFncyAmJiBy MS0+ZW5kICsgMSA9PSByMi0+c3RhcnQgJiYKKwkgICAgICAgcjEtPm5hbWUgPT0gcjItPm5hbWUg JiYgcjEtPmRlc2MgPT0gcjItPmRlc2MgJiYKKwkgICAgICAgIXIxLT5jaGlsZCAmJiAhcjItPmNo aWxkOworfQorCisvKgorICogbWVyZ2Vfc3lzdGVtX3JhbV9yZXNvdXJjZSAtIG1hcmsgdGhlIFN5 c3RlbSBSQU0gcmVzb3VyY2UgbWVyZ2VhYmxlIGFuZCB0cnkgdG8KKyAqIG1lcmdlIGl0IHdpdGgg YWRqYWNlbnQsIG1lcmdlYWJsZSByZXNvdXJjZXMKKyAqIEByZXM6IHJlc291cmNlIGRlc2NyaXB0 b3IKKyAqCisgKiBUaGlzIGludGVyZmFjZSBpcyBpbnRlbmRlZCBmb3IgbWVtb3J5IGhvdHBsdWcs IHdoZXJlYnkgbG90cyBvZiBjb250aWd1b3VzCisgKiBzeXN0ZW0gcmFtIHJlc291cmNlcyBhcmUg YWRkZWQgKGUuZy4sIHZpYSBhZGRfbWVtb3J5KigpKSBieSBhIGRyaXZlciwgYW5kCisgKiB0aGUg YWN0dWFsIHJlc291cmNlIGJvdW5kYXJpZXMgYXJlIG5vdCBvZiBpbnRlcmVzdCAoZS5nLiwgaXQg bWlnaHQgYmUKKyAqIHJlbGV2YW50IGZvciBESU1NcykuIE9ubHkgcmVzb3VyY2VzIHRoYXQgYXJl IG1hcmtlZCBtZXJnZWFibGUsIHRoYXQgaGF2ZSB0aGUKKyAqIHNhbWUgcGFyZW50LCBhbmQgdGhh dCBkb24ndCBoYXZlIGFueSBjaGlsZHJlbiBhcmUgY29uc2lkZXJlZC4gQWxsIG1lcmdlYWJsZQor ICogcmVzb3VyY2VzIG11c3QgYmUgaW1tdXRhYmxlIGR1cmluZyB0aGUgcmVxdWVzdC4KKyAqCisg KiBOb3RlOgorICogLSBUaGUgY2FsbGVyIGhhcyB0byBtYWtlIHN1cmUgdGhhdCBubyBwb2ludGVy cyB0byByZXNvdXJjZXMgdGhhdCBhcmUKKyAqICAgbWFya2VkIG1lcmdlYWJsZSBhcmUgdXNlZCBh bnltb3JlIGFmdGVyIHRoaXMgY2FsbCAtIHRoZSByZXNvdXJjZSBtaWdodAorICogICBiZSBmcmVl ZCBhbmQgdGhlIHBvaW50ZXIgbWlnaHQgYmUgc3RhbGUhCisgKiAtIHJlbGVhc2VfbWVtX3JlZ2lv bl9hZGp1c3RhYmxlKCkgd2lsbCBzcGxpdCBvbiBkZW1hbmQgb24gbWVtb3J5IGhvdHVucGx1Zwor ICovCit2b2lkIG1lcmdlX3N5c3RlbV9yYW1fcmVzb3VyY2Uoc3RydWN0IHJlc291cmNlICpyZXMp Cit7CisJY29uc3QgdW5zaWduZWQgbG9uZyBmbGFncyA9IElPUkVTT1VSQ0VfU1lTVEVNX1JBTSB8 IElPUkVTT1VSQ0VfQlVTWTsKKwlzdHJ1Y3QgcmVzb3VyY2UgKmN1cjsKKworCWlmIChXQVJOX09O X09OQ0UoKHJlcy0+ZmxhZ3MgJiBmbGFncykgIT0gZmxhZ3MpKQorCQlyZXR1cm47CisKKwl3cml0 ZV9sb2NrKCZyZXNvdXJjZV9sb2NrKTsKKwlyZXMtPmZsYWdzIHw9IElPUkVTT1VSQ0VfU1lTUkFN X01FUkdFQUJMRTsKKworCS8qIFRyeSB0byBtZXJnZSB3aXRoIG5leHQgaXRlbSBpbiB0aGUgbGlz dC4gKi8KKwljdXIgPSByZXMtPnNpYmxpbmc7CisJaWYgKGN1ciAmJiBzeXN0ZW1fcmFtX3Jlc291 cmNlc19tZXJnZWFibGUocmVzLCBjdXIpKSB7CisJCXJlcy0+ZW5kID0gY3VyLT5lbmQ7CisJCXJl cy0+c2libGluZyA9IGN1ci0+c2libGluZzsKKwkJZnJlZV9yZXNvdXJjZShjdXIpOworCX0KKwor CS8qIFRyeSB0byBtZXJnZSB3aXRoIHByZXZpb3VzIGl0ZW0gaW4gdGhlIGxpc3QuICovCisJY3Vy ID0gcmVzLT5wYXJlbnQtPmNoaWxkOworCXdoaWxlIChjdXIgJiYgY3VyLT5zaWJsaW5nICE9IHJl cykKKwkJY3VyID0gY3VyLT5zaWJsaW5nOworCWlmIChjdXIgJiYgc3lzdGVtX3JhbV9yZXNvdXJj ZXNfbWVyZ2VhYmxlKGN1ciwgcmVzKSkgeworCQljdXItPmVuZCA9IHJlcy0+ZW5kOworCQljdXIt PnNpYmxpbmcgPSByZXMtPnNpYmxpbmc7CisJCWZyZWVfcmVzb3VyY2UocmVzKTsKKwl9CisJd3Jp dGVfdW5sb2NrKCZyZXNvdXJjZV9sb2NrKTsKK30KKyNlbmRpZgkvKiBDT05GSUdfTUVNT1JZX0hP VFBMVUcgKi8KKwogLyoKICAqIE1hbmFnZWQgcmVnaW9uIHJlc291cmNlCiAgKi8KZGlmZiAtLWdp dCBhL21tL21lbW9yeV9ob3RwbHVnLmMgYi9tbS9tZW1vcnlfaG90cGx1Zy5jCmluZGV4IDY0YjA3 ZjAwNmJjMTAuLmY2MmMyYTQ2ZGY4YjEgMTAwNjQ0Ci0tLSBhL21tL21lbW9yeV9ob3RwbHVnLmMK KysrIGIvbW0vbWVtb3J5X2hvdHBsdWcuYwpAQCAtMTEwMyw2ICsxMTAzLDEzIEBAIGludCBfX3Jl ZiBhZGRfbWVtb3J5X3Jlc291cmNlKGludCBuaWQsIHN0cnVjdCByZXNvdXJjZSAqcmVzLAogCS8q IGRldmljZV9vbmxpbmUoKSB3aWxsIHRha2UgdGhlIGxvY2sgd2hlbiBjYWxsaW5nIG9ubGluZV9w YWdlcygpICovCiAJbWVtX2hvdHBsdWdfZG9uZSgpOwogCisJLyoKKwkgKiBJbiBjYXNlIHdlJ3Jl IGFsbG93ZWQgdG8gbWVyZ2UgdGhlIHJlc291cmNlLCBmbGFnIGl0IGFuZCB0cmlnZ2VyCisJICog bWVyZ2luZyBub3cgdGhhdCBhZGRpbmcgc3VjY2VlZGVkLgorCSAqLworCWlmIChmbGFncyAmIE1F TUhQX01FUkdFX1JFU09VUkNFKQorCQltZXJnZV9zeXN0ZW1fcmFtX3Jlc291cmNlKHJlcyk7CisK IAkvKiBvbmxpbmUgcGFnZXMgaWYgcmVxdWVzdGVkICovCiAJaWYgKG1lbWhwX2RlZmF1bHRfb25s aW5lX3R5cGUgIT0gTU1PUF9PRkZMSU5FKQogCQl3YWxrX21lbW9yeV9ibG9ja3Moc3RhcnQsIHNp emUsIE5VTEwsIG9ubGluZV9tZW1vcnlfYmxvY2spOwotLSAKMi4yNi4yCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXphdGlvbiBtYWlsaW5n IGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9s aXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmlydHVhbGl6YXRpb24=