From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S966662AbeEYPdw (ORCPT ); Fri, 25 May 2018 11:33:52 -0400 Received: from mail-wr0-f195.google.com ([209.85.128.195]:40090 "EHLO mail-wr0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S964823AbeEYPdr (ORCPT ); Fri, 25 May 2018 11:33:47 -0400 X-Google-Smtp-Source: ADUXVKIvISQGo6VG3E/0b5xPnLHk3b+vj+WFS7EG9M7kX0LO41XWloa4lyMHAWNGYPqR65GdtaYF4A== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: daniel.vetter@intel.com, andr2000@gmail.com, dongwon.kim@intel.com, matthew.d.roper@intel.com, Oleksandr Andrushchenko Subject: [PATCH 2/8] xen/balloon: Move common memory reservation routines to a module Date: Fri, 25 May 2018 18:33:25 +0300 Message-Id: <20180525153331.31188-3-andr2000@gmail.com> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Memory {increase|decrease}_reservation and VA mappings update/reset code used in balloon driver can be made common, so other drivers can also re-use the same functionality without open-coding. Create a dedicated module for the shared code and export corresponding symbols for other kernel modules. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/Makefile | 1 + drivers/xen/balloon.c | 71 ++---------------- drivers/xen/mem-reservation.c | 134 ++++++++++++++++++++++++++++++++++ include/xen/mem_reservation.h | 29 ++++++++ 4 files changed, 170 insertions(+), 65 deletions(-) create mode 100644 drivers/xen/mem-reservation.c create mode 100644 include/xen/mem_reservation.h diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index 451e833f5931..3c87b0c3aca6 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -2,6 +2,7 @@ obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o obj-$(CONFIG_X86) += fallback.o obj-y += grant-table.o features.o balloon.o manage.o preempt.o time.o +obj-y += mem-reservation.o obj-y += events/ obj-y += xenbus/ diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index 065f0b607373..57b482d67a3a 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -71,6 +71,7 @@ #include #include #include +#include static int xen_hotplug_unpopulated; @@ -157,13 +158,6 @@ static DECLARE_DELAYED_WORK(balloon_worker, balloon_process); #define GFP_BALLOON \ (GFP_HIGHUSER | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC) -static void scrub_page(struct page *page) -{ -#ifdef CONFIG_XEN_SCRUB_PAGES - clear_highpage(page); -#endif -} - /* balloon_append: add the given page to the balloon. */ static void __balloon_append(struct page *page) { @@ -463,11 +457,6 @@ static enum bp_state increase_reservation(unsigned long nr_pages) int rc; unsigned long i; struct page *page; - struct xen_memory_reservation reservation = { - .address_bits = 0, - .extent_order = EXTENT_ORDER, - .domid = DOMID_SELF - }; if (nr_pages > ARRAY_SIZE(frame_list)) nr_pages = ARRAY_SIZE(frame_list); @@ -486,9 +475,7 @@ static enum bp_state increase_reservation(unsigned long nr_pages) page = balloon_next_page(page); } - set_xen_guest_handle(reservation.extent_start, frame_list); - reservation.nr_extents = nr_pages; - rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); + rc = xenmem_reservation_increase(nr_pages, frame_list); if (rc <= 0) return BP_EAGAIN; @@ -496,29 +483,7 @@ static enum bp_state increase_reservation(unsigned long nr_pages) page = balloon_retrieve(false); BUG_ON(page == NULL); -#ifdef CONFIG_XEN_HAVE_PVMMU - /* - * We don't support PV MMU when Linux and Xen is using - * different page granularity. - */ - BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); - - if (!xen_feature(XENFEAT_auto_translated_physmap)) { - unsigned long pfn = page_to_pfn(page); - - set_phys_to_machine(pfn, frame_list[i]); - - /* Link back into the page tables if not highmem. */ - if (!PageHighMem(page)) { - int ret; - ret = HYPERVISOR_update_va_mapping( - (unsigned long)__va(pfn << PAGE_SHIFT), - mfn_pte(frame_list[i], PAGE_KERNEL), - 0); - BUG_ON(ret); - } - } -#endif + xenmem_reservation_va_mapping_update(1, &page, &frame_list[i]); /* Relinquish the page back to the allocator. */ free_reserved_page(page); @@ -535,11 +500,6 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) unsigned long i; struct page *page, *tmp; int ret; - struct xen_memory_reservation reservation = { - .address_bits = 0, - .extent_order = EXTENT_ORDER, - .domid = DOMID_SELF - }; LIST_HEAD(pages); if (nr_pages > ARRAY_SIZE(frame_list)) @@ -553,7 +513,7 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) break; } adjust_managed_page_count(page, -1); - scrub_page(page); + xenmem_reservation_scrub_page(page); list_add(&page->lru, &pages); } @@ -575,25 +535,8 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) /* XENMEM_decrease_reservation requires a GFN */ frame_list[i++] = xen_page_to_gfn(page); -#ifdef CONFIG_XEN_HAVE_PVMMU - /* - * We don't support PV MMU when Linux and Xen is using - * different page granularity. - */ - BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); - - if (!xen_feature(XENFEAT_auto_translated_physmap)) { - unsigned long pfn = page_to_pfn(page); + xenmem_reservation_va_mapping_reset(1, &page); - if (!PageHighMem(page)) { - ret = HYPERVISOR_update_va_mapping( - (unsigned long)__va(pfn << PAGE_SHIFT), - __pte_ma(0), 0); - BUG_ON(ret); - } - __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); - } -#endif list_del(&page->lru); balloon_append(page); @@ -601,9 +544,7 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) flush_tlb_all(); - set_xen_guest_handle(reservation.extent_start, frame_list); - reservation.nr_extents = nr_pages; - ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation); + ret = xenmem_reservation_decrease(nr_pages, frame_list); BUG_ON(ret != nr_pages); balloon_stats.current_pages -= nr_pages; diff --git a/drivers/xen/mem-reservation.c b/drivers/xen/mem-reservation.c new file mode 100644 index 000000000000..29882e4324f5 --- /dev/null +++ b/drivers/xen/mem-reservation.c @@ -0,0 +1,134 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/****************************************************************************** + * Xen memory reservation utilities. + * + * Copyright (c) 2003, B Dragovic + * Copyright (c) 2003-2004, M Williamson, K Fraser + * Copyright (c) 2005 Dan M. Smith, IBM Corporation + * Copyright (c) 2010 Daniel Kiper + * Copyright (c) 2018, Oleksandr Andrushchenko, EPAM Systems Inc. + */ + +#include +#include + +#include +#include + +#include +#include + +/* + * Use one extent per PAGE_SIZE to avoid to break down the page into + * multiple frame. + */ +#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1) + +void xenmem_reservation_scrub_page(struct page *page) +{ +#ifdef CONFIG_XEN_SCRUB_PAGES + clear_highpage(page); +#endif +} +EXPORT_SYMBOL(xenmem_reservation_scrub_page); + +void xenmem_reservation_va_mapping_update(unsigned long count, + struct page **pages, + xen_pfn_t *frames) +{ +#ifdef CONFIG_XEN_HAVE_PVMMU + int i; + + for (i = 0; i < count; i++) { + struct page *page; + + page = pages[i]; + BUG_ON(page == NULL); + + /* + * We don't support PV MMU when Linux and Xen is using + * different page granularity. + */ + BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); + + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + unsigned long pfn = page_to_pfn(page); + + set_phys_to_machine(pfn, frames[i]); + + /* Link back into the page tables if not highmem. */ + if (!PageHighMem(page)) { + int ret; + + ret = HYPERVISOR_update_va_mapping( + (unsigned long)__va(pfn << PAGE_SHIFT), + mfn_pte(frames[i], PAGE_KERNEL), + 0); + BUG_ON(ret); + } + } + } +#endif +} +EXPORT_SYMBOL(xenmem_reservation_va_mapping_update); + +void xenmem_reservation_va_mapping_reset(unsigned long count, + struct page **pages) +{ +#ifdef CONFIG_XEN_HAVE_PVMMU + int i; + + for (i = 0; i < count; i++) { + /* + * We don't support PV MMU when Linux and Xen is using + * different page granularity. + */ + BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); + + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + struct page *page = pages[i]; + unsigned long pfn = page_to_pfn(page); + + if (!PageHighMem(page)) { + int ret; + + ret = HYPERVISOR_update_va_mapping( + (unsigned long)__va(pfn << PAGE_SHIFT), + __pte_ma(0), 0); + BUG_ON(ret); + } + __set_phys_to_machine(pfn, INVALID_P2M_ENTRY); + } + } +#endif +} +EXPORT_SYMBOL(xenmem_reservation_va_mapping_reset); + +int xenmem_reservation_increase(int count, xen_pfn_t *frames) +{ + struct xen_memory_reservation reservation = { + .address_bits = 0, + .extent_order = EXTENT_ORDER, + .domid = DOMID_SELF + }; + + set_xen_guest_handle(reservation.extent_start, frames); + reservation.nr_extents = count; + return HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation); +} +EXPORT_SYMBOL(xenmem_reservation_increase); + +int xenmem_reservation_decrease(int count, xen_pfn_t *frames) +{ + struct xen_memory_reservation reservation = { + .address_bits = 0, + .extent_order = EXTENT_ORDER, + .domid = DOMID_SELF + }; + + set_xen_guest_handle(reservation.extent_start, frames); + reservation.nr_extents = count; + return HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation); +} +EXPORT_SYMBOL(xenmem_reservation_decrease); diff --git a/include/xen/mem_reservation.h b/include/xen/mem_reservation.h new file mode 100644 index 000000000000..9306d9b8743c --- /dev/null +++ b/include/xen/mem_reservation.h @@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ + +/* + * Xen memory reservation utilities. + * + * Copyright (c) 2003, B Dragovic + * Copyright (c) 2003-2004, M Williamson, K Fraser + * Copyright (c) 2005 Dan M. Smith, IBM Corporation + * Copyright (c) 2010 Daniel Kiper + * Copyright (c) 2018, Oleksandr Andrushchenko, EPAM Systems Inc. + */ + +#ifndef _XENMEM_RESERVATION_H +#define _XENMEM_RESERVATION_H + +void xenmem_reservation_scrub_page(struct page *page); + +void xenmem_reservation_va_mapping_update(unsigned long count, + struct page **pages, + xen_pfn_t *frames); + +void xenmem_reservation_va_mapping_reset(unsigned long count, + struct page **pages); + +int xenmem_reservation_increase(int count, xen_pfn_t *frames); + +int xenmem_reservation_decrease(int count, xen_pfn_t *frames); + +#endif -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 2/8] xen/balloon: Move common memory reservation routines to a module Date: Fri, 25 May 2018 18:33:25 +0300 Message-ID: <20180525153331.31188-3-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wr0-x243.google.com (mail-wr0-x243.google.com [IPv6:2a00:1450:400c:c0c::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id 60B1B6E950 for ; Fri, 25 May 2018 15:33:47 +0000 (UTC) Received: by mail-wr0-x243.google.com with SMTP id j1-v6so9955981wrm.1 for ; Fri, 25 May 2018 08:33:47 -0700 (PDT) In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, daniel.vetter@intel.com, dongwon.kim@intel.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKTWVtb3J5IHtpbmNyZWFzZXxkZWNyZWFzZX1fcmVzZXJ2YXRpb24gYW5kIFZBIG1h cHBpbmdzIHVwZGF0ZS9yZXNldApjb2RlIHVzZWQgaW4gYmFsbG9vbiBkcml2ZXIgY2FuIGJlIG1h ZGUgY29tbW9uLCBzbyBvdGhlciBkcml2ZXJzIGNhbgphbHNvIHJlLXVzZSB0aGUgc2FtZSBmdW5j dGlvbmFsaXR5IHdpdGhvdXQgb3Blbi1jb2RpbmcuCkNyZWF0ZSBhIGRlZGljYXRlZCBtb2R1bGUg Zm9yIHRoZSBzaGFyZWQgY29kZSBhbmQgZXhwb3J0IGNvcnJlc3BvbmRpbmcKc3ltYm9scyBmb3Ig b3RoZXIga2VybmVsIG1vZHVsZXMuCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNo ZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogZHJpdmVycy94ZW4v TWFrZWZpbGUgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy94ZW4vYmFsbG9vbi5jICAgICAgICAg fCAgNzEgKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9tZW0tcmVzZXJ2YXRpb24uYyB8 IDEzNCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3hlbi9tZW1f cmVzZXJ2YXRpb24uaCB8ICAyOSArKysrKysrKwogNCBmaWxlcyBjaGFuZ2VkLCAxNzAgaW5zZXJ0 aW9ucygrKSwgNjUgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy94ZW4v bWVtLXJlc2VydmF0aW9uLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3hlbi9tZW1fcmVz ZXJ2YXRpb24uaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL01ha2VmaWxlIGIvZHJpdmVycy94 ZW4vTWFrZWZpbGUKaW5kZXggNDUxZTgzM2Y1OTMxLi4zYzg3YjBjM2FjYTYgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMveGVuL01ha2VmaWxlCisrKyBiL2RyaXZlcnMveGVuL01ha2VmaWxlCkBAIC0yLDYg KzIsNyBAQAogb2JqLSQoQ09ORklHX0hPVFBMVUdfQ1BVKQkJKz0gY3B1X2hvdHBsdWcubwogb2Jq LSQoQ09ORklHX1g4NikJCQkrPSBmYWxsYmFjay5vCiBvYmoteQkrPSBncmFudC10YWJsZS5vIGZl YXR1cmVzLm8gYmFsbG9vbi5vIG1hbmFnZS5vIHByZWVtcHQubyB0aW1lLm8KK29iai15CSs9IG1l bS1yZXNlcnZhdGlvbi5vCiBvYmoteQkrPSBldmVudHMvCiBvYmoteQkrPSB4ZW5idXMvCiAKZGlm ZiAtLWdpdCBhL2RyaXZlcnMveGVuL2JhbGxvb24uYyBiL2RyaXZlcnMveGVuL2JhbGxvb24uYwpp bmRleCAwNjVmMGI2MDczNzMuLjU3YjQ4MmQ2N2EzYSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4v YmFsbG9vbi5jCisrKyBiL2RyaXZlcnMveGVuL2JhbGxvb24uYwpAQCAtNzEsNiArNzEsNyBAQAog I2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CiAjaW5jbHVkZSA8eGVuL2ZlYXR1cmVzLmg+CiAjaW5j bHVkZSA8eGVuL3BhZ2UuaD4KKyNpbmNsdWRlIDx4ZW4vbWVtX3Jlc2VydmF0aW9uLmg+CiAKIHN0 YXRpYyBpbnQgeGVuX2hvdHBsdWdfdW5wb3B1bGF0ZWQ7CiAKQEAgLTE1NywxMyArMTU4LDYgQEAg c3RhdGljIERFQ0xBUkVfREVMQVlFRF9XT1JLKGJhbGxvb25fd29ya2VyLCBiYWxsb29uX3Byb2Nl c3MpOwogI2RlZmluZSBHRlBfQkFMTE9PTiBcCiAJKEdGUF9ISUdIVVNFUiB8IF9fR0ZQX05PV0FS TiB8IF9fR0ZQX05PUkVUUlkgfCBfX0dGUF9OT01FTUFMTE9DKQogCi1zdGF0aWMgdm9pZCBzY3J1 Yl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQotewotI2lmZGVmIENPTkZJR19YRU5fU0NSVUJfUEFH RVMKLQljbGVhcl9oaWdocGFnZShwYWdlKTsKLSNlbmRpZgotfQotCiAvKiBiYWxsb29uX2FwcGVu ZDogYWRkIHRoZSBnaXZlbiBwYWdlIHRvIHRoZSBiYWxsb29uLiAqLwogc3RhdGljIHZvaWQgX19i YWxsb29uX2FwcGVuZChzdHJ1Y3QgcGFnZSAqcGFnZSkKIHsKQEAgLTQ2MywxMSArNDU3LDYgQEAg c3RhdGljIGVudW0gYnBfc3RhdGUgaW5jcmVhc2VfcmVzZXJ2YXRpb24odW5zaWduZWQgbG9uZyBu cl9wYWdlcykKIAlpbnQgcmM7CiAJdW5zaWduZWQgbG9uZyBpOwogCXN0cnVjdCBwYWdlICAgKnBh Z2U7Ci0Jc3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24gcmVzZXJ2YXRpb24gPSB7Ci0JCS5h ZGRyZXNzX2JpdHMgPSAwLAotCQkuZXh0ZW50X29yZGVyID0gRVhURU5UX09SREVSLAotCQkuZG9t aWQgICAgICAgID0gRE9NSURfU0VMRgotCX07CiAKIAlpZiAobnJfcGFnZXMgPiBBUlJBWV9TSVpF KGZyYW1lX2xpc3QpKQogCQlucl9wYWdlcyA9IEFSUkFZX1NJWkUoZnJhbWVfbGlzdCk7CkBAIC00 ODYsOSArNDc1LDcgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgaW5jcmVhc2VfcmVzZXJ2YXRpb24o dW5zaWduZWQgbG9uZyBucl9wYWdlcykKIAkJcGFnZSA9IGJhbGxvb25fbmV4dF9wYWdlKHBhZ2Up OwogCX0KIAotCXNldF94ZW5fZ3Vlc3RfaGFuZGxlKHJlc2VydmF0aW9uLmV4dGVudF9zdGFydCwg ZnJhbWVfbGlzdCk7Ci0JcmVzZXJ2YXRpb24ubnJfZXh0ZW50cyA9IG5yX3BhZ2VzOwotCXJjID0g SFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVNX3BvcHVsYXRlX3BoeXNtYXAsICZyZXNlcnZhdGlv bik7CisJcmMgPSB4ZW5tZW1fcmVzZXJ2YXRpb25faW5jcmVhc2UobnJfcGFnZXMsIGZyYW1lX2xp c3QpOwogCWlmIChyYyA8PSAwKQogCQlyZXR1cm4gQlBfRUFHQUlOOwogCkBAIC00OTYsMjkgKzQ4 Myw3IEBAIHN0YXRpYyBlbnVtIGJwX3N0YXRlIGluY3JlYXNlX3Jlc2VydmF0aW9uKHVuc2lnbmVk IGxvbmcgbnJfcGFnZXMpCiAJCXBhZ2UgPSBiYWxsb29uX3JldHJpZXZlKGZhbHNlKTsKIAkJQlVH X09OKHBhZ2UgPT0gTlVMTCk7CiAKLSNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZNTVUKLQkJLyoK LQkJICogV2UgZG9uJ3Qgc3VwcG9ydCBQViBNTVUgd2hlbiBMaW51eCBhbmQgWGVuIGlzIHVzaW5n Ci0JCSAqIGRpZmZlcmVudCBwYWdlIGdyYW51bGFyaXR5LgotCQkgKi8KLQkJQlVJTERfQlVHX09O KFhFTl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKTsKLQotCQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZF QVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSB7Ci0JCQl1bnNpZ25lZCBsb25nIHBmbiA9IHBh Z2VfdG9fcGZuKHBhZ2UpOwotCi0JCQlzZXRfcGh5c190b19tYWNoaW5lKHBmbiwgZnJhbWVfbGlz dFtpXSk7Ci0KLQkJCS8qIExpbmsgYmFjayBpbnRvIHRoZSBwYWdlIHRhYmxlcyBpZiBub3QgaGln aG1lbS4gKi8KLQkJCWlmICghUGFnZUhpZ2hNZW0ocGFnZSkpIHsKLQkJCQlpbnQgcmV0OwotCQkJ CXJldCA9IEhZUEVSVklTT1JfdXBkYXRlX3ZhX21hcHBpbmcoCi0JCQkJCQkodW5zaWduZWQgbG9u ZylfX3ZhKHBmbiA8PCBQQUdFX1NISUZUKSwKLQkJCQkJCW1mbl9wdGUoZnJhbWVfbGlzdFtpXSwg UEFHRV9LRVJORUwpLAotCQkJCQkJMCk7Ci0JCQkJQlVHX09OKHJldCk7Ci0JCQl9Ci0JCX0KLSNl bmRpZgorCQl4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUoMSwgJnBhZ2UsICZm cmFtZV9saXN0W2ldKTsKIAogCQkvKiBSZWxpbnF1aXNoIHRoZSBwYWdlIGJhY2sgdG8gdGhlIGFs bG9jYXRvci4gKi8KIAkJZnJlZV9yZXNlcnZlZF9wYWdlKHBhZ2UpOwpAQCAtNTM1LDExICs1MDAs NiBAQCBzdGF0aWMgZW51bSBicF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlvbih1bnNpZ25lZCBs b25nIG5yX3BhZ2VzLCBnZnBfdCBnZnApCiAJdW5zaWduZWQgbG9uZyBpOwogCXN0cnVjdCBwYWdl ICpwYWdlLCAqdG1wOwogCWludCByZXQ7Ci0Jc3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24g cmVzZXJ2YXRpb24gPSB7Ci0JCS5hZGRyZXNzX2JpdHMgPSAwLAotCQkuZXh0ZW50X29yZGVyID0g RVhURU5UX09SREVSLAotCQkuZG9taWQgICAgICAgID0gRE9NSURfU0VMRgotCX07CiAJTElTVF9I RUFEKHBhZ2VzKTsKIAogCWlmIChucl9wYWdlcyA+IEFSUkFZX1NJWkUoZnJhbWVfbGlzdCkpCkBA IC01NTMsNyArNTEzLDcgQEAgc3RhdGljIGVudW0gYnBfc3RhdGUgZGVjcmVhc2VfcmVzZXJ2YXRp b24odW5zaWduZWQgbG9uZyBucl9wYWdlcywgZ2ZwX3QgZ2ZwKQogCQkJYnJlYWs7CiAJCX0KIAkJ YWRqdXN0X21hbmFnZWRfcGFnZV9jb3VudChwYWdlLCAtMSk7Ci0JCXNjcnViX3BhZ2UocGFnZSk7 CisJCXhlbm1lbV9yZXNlcnZhdGlvbl9zY3J1Yl9wYWdlKHBhZ2UpOwogCQlsaXN0X2FkZCgmcGFn ZS0+bHJ1LCAmcGFnZXMpOwogCX0KIApAQCAtNTc1LDI1ICs1MzUsOCBAQCBzdGF0aWMgZW51bSBi cF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlvbih1bnNpZ25lZCBsb25nIG5yX3BhZ2VzLCBnZnBf dCBnZnApCiAJCS8qIFhFTk1FTV9kZWNyZWFzZV9yZXNlcnZhdGlvbiByZXF1aXJlcyBhIEdGTiAq LwogCQlmcmFtZV9saXN0W2krK10gPSB4ZW5fcGFnZV90b19nZm4ocGFnZSk7CiAKLSNpZmRlZiBD T05GSUdfWEVOX0hBVkVfUFZNTVUKLQkJLyoKLQkJICogV2UgZG9uJ3Qgc3VwcG9ydCBQViBNTVUg d2hlbiBMaW51eCBhbmQgWGVuIGlzIHVzaW5nCi0JCSAqIGRpZmZlcmVudCBwYWdlIGdyYW51bGFy aXR5LgotCQkgKi8KLQkJQlVJTERfQlVHX09OKFhFTl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKTsK LQotCQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSB7 Ci0JCQl1bnNpZ25lZCBsb25nIHBmbiA9IHBhZ2VfdG9fcGZuKHBhZ2UpOworCQl4ZW5tZW1fcmVz ZXJ2YXRpb25fdmFfbWFwcGluZ19yZXNldCgxLCAmcGFnZSk7CiAKLQkJCWlmICghUGFnZUhpZ2hN ZW0ocGFnZSkpIHsKLQkJCQlyZXQgPSBIWVBFUlZJU09SX3VwZGF0ZV92YV9tYXBwaW5nKAotCQkJ CQkJKHVuc2lnbmVkIGxvbmcpX192YShwZm4gPDwgUEFHRV9TSElGVCksCi0JCQkJCQlfX3B0ZV9t YSgwKSwgMCk7Ci0JCQkJQlVHX09OKHJldCk7Ci0JCQl9Ci0JCQlfX3NldF9waHlzX3RvX21hY2hp bmUocGZuLCBJTlZBTElEX1AyTV9FTlRSWSk7Ci0JCX0KLSNlbmRpZgogCQlsaXN0X2RlbCgmcGFn ZS0+bHJ1KTsKIAogCQliYWxsb29uX2FwcGVuZChwYWdlKTsKQEAgLTYwMSw5ICs1NDQsNyBAQCBz dGF0aWMgZW51bSBicF9zdGF0ZSBkZWNyZWFzZV9yZXNlcnZhdGlvbih1bnNpZ25lZCBsb25nIG5y X3BhZ2VzLCBnZnBfdCBnZnApCiAKIAlmbHVzaF90bGJfYWxsKCk7CiAKLQlzZXRfeGVuX2d1ZXN0 X2hhbmRsZShyZXNlcnZhdGlvbi5leHRlbnRfc3RhcnQsIGZyYW1lX2xpc3QpOwotCXJlc2VydmF0 aW9uLm5yX2V4dGVudHMgICA9IG5yX3BhZ2VzOwotCXJldCA9IEhZUEVSVklTT1JfbWVtb3J5X29w KFhFTk1FTV9kZWNyZWFzZV9yZXNlcnZhdGlvbiwgJnJlc2VydmF0aW9uKTsKKwlyZXQgPSB4ZW5t ZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UobnJfcGFnZXMsIGZyYW1lX2xpc3QpOwogCUJVR19PTihy ZXQgIT0gbnJfcGFnZXMpOwogCiAJYmFsbG9vbl9zdGF0cy5jdXJyZW50X3BhZ2VzIC09IG5yX3Bh Z2VzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vbWVtLXJlc2VydmF0aW9uLmMgYi9kcml2ZXJz L3hlbi9tZW0tcmVzZXJ2YXRpb24uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLjI5ODgyZTQzMjRmNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMveGVuL21lbS1y ZXNlcnZhdGlvbi5jCkBAIC0wLDAgKzEsMTM0IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMCBPUiBNSVQKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogWGVuIG1lbW9y eSByZXNlcnZhdGlvbiB1dGlsaXRpZXMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAzLCBCIERy YWdvdmljCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwNCwgTSBXaWxsaWFtc29uLCBLIEZyYXNl cgorICogQ29weXJpZ2h0IChjKSAyMDA1IERhbiBNLiBTbWl0aCwgSUJNIENvcnBvcmF0aW9uCisg KiBDb3B5cmlnaHQgKGMpIDIwMTAgRGFuaWVsIEtpcGVyCisgKiBDb3B5cmlnaHQgKGMpIDIwMTgs IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvLCBFUEFNIFN5c3RlbXMgSW5jLgorICovCisKKyNpbmNs dWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisKKyNpbmNsdWRl IDxhc20vdGxiLmg+CisjaW5jbHVkZSA8YXNtL3hlbi9oeXBlcmNhbGwuaD4KKworI2luY2x1ZGUg PHhlbi9pbnRlcmZhY2UvbWVtb3J5Lmg+CisjaW5jbHVkZSA8eGVuL3BhZ2UuaD4KKworLyoKKyAq IFVzZSBvbmUgZXh0ZW50IHBlciBQQUdFX1NJWkUgdG8gYXZvaWQgdG8gYnJlYWsgZG93biB0aGUg cGFnZSBpbnRvCisgKiBtdWx0aXBsZSBmcmFtZS4KKyAqLworI2RlZmluZSBFWFRFTlRfT1JERVIg KGZscyhYRU5fUEZOX1BFUl9QQUdFKSAtIDEpCisKK3ZvaWQgeGVubWVtX3Jlc2VydmF0aW9uX3Nj cnViX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisjaWZkZWYgQ09ORklHX1hFTl9TQ1JVQl9Q QUdFUworCWNsZWFyX2hpZ2hwYWdlKHBhZ2UpOworI2VuZGlmCit9CitFWFBPUlRfU1lNQk9MKHhl bm1lbV9yZXNlcnZhdGlvbl9zY3J1Yl9wYWdlKTsKKwordm9pZCB4ZW5tZW1fcmVzZXJ2YXRpb25f dmFfbWFwcGluZ191cGRhdGUodW5zaWduZWQgbG9uZyBjb3VudCwKKwkJCQkJICBzdHJ1Y3QgcGFn ZSAqKnBhZ2VzLAorCQkJCQkgIHhlbl9wZm5fdCAqZnJhbWVzKQoreworI2lmZGVmIENPTkZJR19Y RU5fSEFWRV9QVk1NVQorCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsK KwkJc3RydWN0IHBhZ2UgKnBhZ2U7CisKKwkJcGFnZSA9IHBhZ2VzW2ldOworCQlCVUdfT04ocGFn ZSA9PSBOVUxMKTsKKworCQkvKgorCQkgKiBXZSBkb24ndCBzdXBwb3J0IFBWIE1NVSB3aGVuIExp bnV4IGFuZCBYZW4gaXMgdXNpbmcKKwkJICogZGlmZmVyZW50IHBhZ2UgZ3JhbnVsYXJpdHkuCisJ CSAqLworCQlCVUlMRF9CVUdfT04oWEVOX1BBR0VfU0laRSAhPSBQQUdFX1NJWkUpOworCisJCWlm ICgheGVuX2ZlYXR1cmUoWEVORkVBVF9hdXRvX3RyYW5zbGF0ZWRfcGh5c21hcCkpIHsKKwkJCXVu c2lnbmVkIGxvbmcgcGZuID0gcGFnZV90b19wZm4ocGFnZSk7CisKKwkJCXNldF9waHlzX3RvX21h Y2hpbmUocGZuLCBmcmFtZXNbaV0pOworCisJCQkvKiBMaW5rIGJhY2sgaW50byB0aGUgcGFnZSB0 YWJsZXMgaWYgbm90IGhpZ2htZW0uICovCisJCQlpZiAoIVBhZ2VIaWdoTWVtKHBhZ2UpKSB7CisJ CQkJaW50IHJldDsKKworCQkJCXJldCA9IEhZUEVSVklTT1JfdXBkYXRlX3ZhX21hcHBpbmcoCisJ CQkJCQkodW5zaWduZWQgbG9uZylfX3ZhKHBmbiA8PCBQQUdFX1NISUZUKSwKKwkJCQkJCW1mbl9w dGUoZnJhbWVzW2ldLCBQQUdFX0tFUk5FTCksCisJCQkJCQkwKTsKKwkJCQlCVUdfT04ocmV0KTsK KwkJCX0KKwkJfQorCX0KKyNlbmRpZgorfQorRVhQT1JUX1NZTUJPTCh4ZW5tZW1fcmVzZXJ2YXRp b25fdmFfbWFwcGluZ191cGRhdGUpOworCit2b2lkIHhlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBw aW5nX3Jlc2V0KHVuc2lnbmVkIGxvbmcgY291bnQsCisJCQkJCSBzdHJ1Y3QgcGFnZSAqKnBhZ2Vz KQoreworI2lmZGVmIENPTkZJR19YRU5fSEFWRV9QVk1NVQorCWludCBpOworCisJZm9yIChpID0g MDsgaSA8IGNvdW50OyBpKyspIHsKKwkJLyoKKwkJICogV2UgZG9uJ3Qgc3VwcG9ydCBQViBNTVUg d2hlbiBMaW51eCBhbmQgWGVuIGlzIHVzaW5nCisJCSAqIGRpZmZlcmVudCBwYWdlIGdyYW51bGFy aXR5LgorCQkgKi8KKwkJQlVJTERfQlVHX09OKFhFTl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKTsK KworCQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSB7 CisJCQlzdHJ1Y3QgcGFnZSAqcGFnZSA9IHBhZ2VzW2ldOworCQkJdW5zaWduZWQgbG9uZyBwZm4g PSBwYWdlX3RvX3BmbihwYWdlKTsKKworCQkJaWYgKCFQYWdlSGlnaE1lbShwYWdlKSkgeworCQkJ CWludCByZXQ7CisKKwkJCQlyZXQgPSBIWVBFUlZJU09SX3VwZGF0ZV92YV9tYXBwaW5nKAorCQkJ CQkJKHVuc2lnbmVkIGxvbmcpX192YShwZm4gPDwgUEFHRV9TSElGVCksCisJCQkJCQlfX3B0ZV9t YSgwKSwgMCk7CisJCQkJQlVHX09OKHJldCk7CisJCQl9CisJCQlfX3NldF9waHlzX3RvX21hY2hp bmUocGZuLCBJTlZBTElEX1AyTV9FTlRSWSk7CisJCX0KKwl9CisjZW5kaWYKK30KK0VYUE9SVF9T WU1CT0woeGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfcmVzZXQpOworCitpbnQgeGVubWVt X3Jlc2VydmF0aW9uX2luY3JlYXNlKGludCBjb3VudCwgeGVuX3Bmbl90ICpmcmFtZXMpCit7CisJ c3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24gcmVzZXJ2YXRpb24gPSB7CisJCS5hZGRyZXNz X2JpdHMgPSAwLAorCQkuZXh0ZW50X29yZGVyID0gRVhURU5UX09SREVSLAorCQkuZG9taWQgICAg ICAgID0gRE9NSURfU0VMRgorCX07CisKKwlzZXRfeGVuX2d1ZXN0X2hhbmRsZShyZXNlcnZhdGlv bi5leHRlbnRfc3RhcnQsIGZyYW1lcyk7CisJcmVzZXJ2YXRpb24ubnJfZXh0ZW50cyA9IGNvdW50 OworCXJldHVybiBIWVBFUlZJU09SX21lbW9yeV9vcChYRU5NRU1fcG9wdWxhdGVfcGh5c21hcCwg JnJlc2VydmF0aW9uKTsKK30KK0VYUE9SVF9TWU1CT0woeGVubWVtX3Jlc2VydmF0aW9uX2luY3Jl YXNlKTsKKworaW50IHhlbm1lbV9yZXNlcnZhdGlvbl9kZWNyZWFzZShpbnQgY291bnQsIHhlbl9w Zm5fdCAqZnJhbWVzKQoreworCXN0cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIHJlc2VydmF0 aW9uID0geworCQkuYWRkcmVzc19iaXRzID0gMCwKKwkJLmV4dGVudF9vcmRlciA9IEVYVEVOVF9P UkRFUiwKKwkJLmRvbWlkICAgICAgICA9IERPTUlEX1NFTEYKKwl9OworCisJc2V0X3hlbl9ndWVz dF9oYW5kbGUocmVzZXJ2YXRpb24uZXh0ZW50X3N0YXJ0LCBmcmFtZXMpOworCXJlc2VydmF0aW9u Lm5yX2V4dGVudHMgPSBjb3VudDsKKwlyZXR1cm4gSFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVN X2RlY3JlYXNlX3Jlc2VydmF0aW9uLCAmcmVzZXJ2YXRpb24pOworfQorRVhQT1JUX1NZTUJPTCh4 ZW5tZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vbWVt X3Jlc2VydmF0aW9uLmggYi9pbmNsdWRlL3hlbi9tZW1fcmVzZXJ2YXRpb24uaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjkzMDZkOWI4NzQzYwotLS0gL2Rldi9udWxs CisrKyBiL2luY2x1ZGUveGVuL21lbV9yZXNlcnZhdGlvbi5oCkBAIC0wLDAgKzEsMjkgQEAKKy8q IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogWGVu IG1lbW9yeSByZXNlcnZhdGlvbiB1dGlsaXRpZXMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAz LCBCIERyYWdvdmljCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwNCwgTSBXaWxsaWFtc29uLCBL IEZyYXNlcgorICogQ29weXJpZ2h0IChjKSAyMDA1IERhbiBNLiBTbWl0aCwgSUJNIENvcnBvcmF0 aW9uCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgRGFuaWVsIEtpcGVyCisgKiBDb3B5cmlnaHQgKGMp IDIwMTgsIE9sZWtzYW5kciBBbmRydXNoY2hlbmtvLCBFUEFNIFN5c3RlbXMgSW5jLgorICovCisK KyNpZm5kZWYgX1hFTk1FTV9SRVNFUlZBVElPTl9ICisjZGVmaW5lIF9YRU5NRU1fUkVTRVJWQVRJ T05fSAorCit2b2lkIHhlbm1lbV9yZXNlcnZhdGlvbl9zY3J1Yl9wYWdlKHN0cnVjdCBwYWdlICpw YWdlKTsKKwordm9pZCB4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUodW5zaWdu ZWQgbG9uZyBjb3VudCwKKwkJCQkJICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAorCQkJCQkgIHhlbl9w Zm5fdCAqZnJhbWVzKTsKKwordm9pZCB4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ19yZXNl dCh1bnNpZ25lZCBsb25nIGNvdW50LAorCQkJCQkgc3RydWN0IHBhZ2UgKipwYWdlcyk7CisKK2lu dCB4ZW5tZW1fcmVzZXJ2YXRpb25faW5jcmVhc2UoaW50IGNvdW50LCB4ZW5fcGZuX3QgKmZyYW1l cyk7CisKK2ludCB4ZW5tZW1fcmVzZXJ2YXRpb25fZGVjcmVhc2UoaW50IGNvdW50LCB4ZW5fcGZu X3QgKmZyYW1lcyk7CisKKyNlbmRpZgotLSAKMi4xNy4wCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK