From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sean Christopherson Date: Thu, 2 Nov 2023 08:38:01 -0700 Subject: [PATCH v13 17/35] KVM: Add transparent hugepage support for dedicated guest memory In-Reply-To: References: <20231027182217.3615211-18-seanjc@google.com> <7c0844d8-6f97-4904-a140-abeabeb552c1@intel.com> <92ba7ddd-2bc8-4a8d-bd67-d6614b21914f@intel.com> <4ca2253d-276f-43c5-8e9f-0ded5d5b2779@redhat.com> Message-ID: List-Id: To: kvm-riscv@lists.infradead.org MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit On Thu, Nov 02, 2023, Paolo Bonzini wrote: > On Wed, Nov 1, 2023 at 11:35?PM Sean Christopherson wrote: > > > > On Wed, Nov 01, 2023, Paolo Bonzini wrote: > > > On 11/1/23 17:36, Sean Christopherson wrote: > > > > Can you post a fixup patch? It's not clear to me exactly what behavior you intend > > > > to end up with. > > > > > > Sure, just this: > > > > > > diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c > > > index 7d1a33c2ad42..34fd070e03d9 100644 > > > --- a/virt/kvm/guest_memfd.c > > > +++ b/virt/kvm/guest_memfd.c > > > @@ -430,10 +430,7 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) > > > { > > > loff_t size = args->size; > > > u64 flags = args->flags; > > > - u64 valid_flags = 0; > > > - > > > - if (IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE)) > > > - valid_flags |= KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > + u64 valid_flags = KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > if (flags & ~valid_flags) > > > return -EINVAL; > > > @@ -441,11 +438,9 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) > > > if (size < 0 || !PAGE_ALIGNED(size)) > > > return -EINVAL; > > > -#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > > if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && > > > !IS_ALIGNED(size, HPAGE_PMD_SIZE)) > > > return -EINVAL; > > > -#endif > > > > That won't work, HPAGE_PMD_SIZE is valid only for CONFIG_TRANSPARENT_HUGEPAGE=y. > > > > #else /* CONFIG_TRANSPARENT_HUGEPAGE */ > > #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_SIZE ({ BUILD_BUG(); 0; }) > > Would have caught it when actually testing it, I guess. :) It has to > be PMD_SIZE, possibly with > > #ifdef CONFIG_TRANSPARENT_HUGEPAGE > BUILD_BUG_ON(HPAGE_PMD_SIZE != PMD_SIZE); > #endif Yeah, that works for me. Actually, looking that this again, there's not actually a hard dependency on THP. A THP-enabled kernel _probably_ gives a higher probability of using hugepages, but mostly because THP selects COMPACTION, and I suppose because using THP for other allocations reduces overall fragmentation. So rather than honor KVM_GUEST_MEMFD_ALLOW_HUGEPAGE iff THP is enabled, I think we should do the below (I verified KVM can create hugepages with THP=n). We'll need another capability, but (a) we probably should have that anyways and (b) it provides a cleaner path to adding PUD-sized hugepage support in the future. And then adjust the tests like so: diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testing/selftests/kvm/guest_memfd_test.c index c15de9852316..c9f449718fce 100644 --- a/tools/testing/selftests/kvm/guest_memfd_test.c +++ b/tools/testing/selftests/kvm/guest_memfd_test.c @@ -201,6 +201,10 @@ int main(int argc, char *argv[]) TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD)); + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE) && thp_configured()) + TEST_ASSERT_EQ(get_trans_hugepagesz(), + kvm_check_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE)); + page_size = getpagesize(); total_size = page_size * 4; diff --git a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c index be311944e90a..245901587ed2 100644 --- a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c +++ b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c @@ -396,7 +396,7 @@ static void test_mem_conversions(enum vm_mem_backing_src_type src_type, uint32_t vm_enable_cap(vm, KVM_CAP_EXIT_HYPERCALL, (1 << KVM_HC_MAP_GPA_RANGE)); - if (backing_src_can_be_huge(src_type)) + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE)) memfd_flags = KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; else memfd_flags = 0; -- From: Sean Christopherson Date: Wed, 25 Oct 2023 16:26:41 -0700 Subject: [PATCH] KVM: Add best-effort hugepage support for dedicated guest memory Extend guest_memfd to allow backing guest memory with hugepages. For now, make hugepage utilization best-effort, i.e. fall back to non-huge mappings if a hugepage can't be allocated. Guaranteeing hugepages would require a dedicated memory pool and significantly more complexity and churn.. Require userspace to opt-in via a flag even though it's unlikely real use cases will ever want to use order-0 pages, e.g. to give userspace a safety valve in case hugepage support is buggy, and to allow for easier testing of both paths. Do not take a dependency on CONFIG_TRANSPARENT_HUGEPAGE, as THP enabling primarily deals with userspace page tables, which are explicitly not in play for guest_memfd. Selecting THP does make obtaining hugepages more likely, but only because THP selects CONFIG_COMPACTION. Don't select CONFIG_COMPACTION either, because again it's not a hard dependency. For simplicity, require the guest_memfd size to be a multiple of the hugepage size, e.g. so that KVM doesn't need to do bounds checking when deciding whether or not to allocate a huge folio. When reporting the max order when KVM gets a pfn from guest_memfd, force order-0 pages if the hugepage is not fully contained by the memslot binding, e.g. if userspace requested hugepages but punches a hole in the memslot bindings in order to emulate x86's VGA hole. Signed-off-by: Sean Christopherson --- Documentation/virt/kvm/api.rst | 17 +++++++++ include/uapi/linux/kvm.h | 3 ++ virt/kvm/guest_memfd.c | 69 +++++++++++++++++++++++++++++----- virt/kvm/kvm_main.c | 4 ++ 4 files changed, 84 insertions(+), 9 deletions(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index e82c69d5e755..ccdd5413920d 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -6176,6 +6176,8 @@ and cannot be resized (guest_memfd files do however support PUNCH_HOLE). __u64 reserved[6]; }; + #define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + Conceptually, the inode backing a guest_memfd file represents physical memory, i.e. is coupled to the virtual machine as a thing, not to a "struct kvm". The file itself, which is bound to a "struct kvm", is that instance's view of the @@ -6192,6 +6194,12 @@ most one mapping per page, i.e. binding multiple memory regions to a single guest_memfd range is not allowed (any number of memory regions can be bound to a single guest_memfd file, but the bound ranges must not overlap). +If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set in flags, KVM will attempt to allocate +and map PMD-size hugepages for the guest_memfd file. This is currently best +effort. If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set, size must be aligned to at +least the size reported by KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE (which also +enumerates support for KVM_GUEST_MEMFD_ALLOW_HUGEPAGE). + See KVM_SET_USER_MEMORY_REGION2 for additional details. 5. The kvm_run structure @@ -8639,6 +8647,15 @@ block sizes is exposed in KVM_CAP_ARM_SUPPORTED_BLOCK_SIZES as a 64-bit bitmap (each bit describing a block size). The default value is 0, to disable the eager page splitting. + +8.41 KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE +------------------------------------------ + +This is an information-only capability that returns guest_memfd's hugepage size +for PMD hugepages. Returns '0' if guest_memfd is not supported, or if KVM +doesn't support creating hugepages for guest_memfd. Note, guest_memfd doesn't +currently support PUD-sized hugepages. + 9. Known KVM API problems ========================= diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 25caee8d1a80..b78d0e3bf22a 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1217,6 +1217,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_MEMORY_FAULT_INFO 231 #define KVM_CAP_MEMORY_ATTRIBUTES 232 #define KVM_CAP_GUEST_MEMFD 233 +#define KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE 234 #ifdef KVM_CAP_IRQ_ROUTING @@ -2303,4 +2304,6 @@ struct kvm_create_guest_memfd { __u64 reserved[6]; }; +#define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + #endif /* __LINUX_KVM_H */ diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c index 98a12da80214..31b5e94d461a 100644 --- a/virt/kvm/guest_memfd.c +++ b/virt/kvm/guest_memfd.c @@ -13,14 +13,44 @@ struct kvm_gmem { struct list_head entry; }; +#define NR_PAGES_PER_PMD (1 << PMD_ORDER) + +static struct folio *kvm_gmem_get_huge_folio(struct inode *inode, pgoff_t index) +{ + unsigned long huge_index = round_down(index, NR_PAGES_PER_PMD); + unsigned long flags = (unsigned long)inode->i_private; + struct address_space *mapping = inode->i_mapping; + gfp_t gfp = mapping_gfp_mask(mapping); + struct folio *folio; + + if (!(flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE)) + return NULL; + + if (filemap_range_has_page(mapping, huge_index << PAGE_SHIFT, + (huge_index + NR_PAGES_PER_PMD - 1) << PAGE_SHIFT)) + return NULL; + + folio = filemap_alloc_folio(gfp, PMD_ORDER); + if (!folio) + return NULL; + + if (filemap_add_folio(mapping, folio, huge_index, gfp)) { + folio_put(folio); + return NULL; + } + return folio; +} + static struct folio *kvm_gmem_get_folio(struct inode *inode, pgoff_t index) { struct folio *folio; - /* TODO: Support huge pages. */ - folio = filemap_grab_folio(inode->i_mapping, index); - if (IS_ERR_OR_NULL(folio)) - return NULL; + folio = kvm_gmem_get_huge_folio(inode, index); + if (!folio) { + folio = filemap_grab_folio(inode->i_mapping, index); + if (IS_ERR_OR_NULL(folio)) + return NULL; + } /* * Use the up-to-date flag to track whether or not the memory has been @@ -373,6 +403,7 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t size, u64 flags) inode->i_mode |= S_IFREG; inode->i_size = size; mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); + mapping_set_large_folios(inode->i_mapping); mapping_set_unmovable(inode->i_mapping); /* Unmovable mappings are supposed to be marked unevictable as well. */ WARN_ON_ONCE(!mapping_unevictable(inode->i_mapping)); @@ -394,14 +425,18 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t size, u64 flags) int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) { + u64 valid_flags = KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; loff_t size = args->size; u64 flags = args->flags; - u64 valid_flags = 0; if (flags & ~valid_flags) return -EINVAL; - if (size < 0 || !PAGE_ALIGNED(size)) + if (size <= 0 || !PAGE_ALIGNED(size)) + return -EINVAL; + + if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && + !IS_ALIGNED(size, PMD_SIZE)) return -EINVAL; return __kvm_gmem_create(kvm, size, flags); @@ -501,7 +536,7 @@ void kvm_gmem_unbind(struct kvm_memory_slot *slot) int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, gfn_t gfn, kvm_pfn_t *pfn, int *max_order) { - pgoff_t index = gfn - slot->base_gfn + slot->gmem.pgoff; + pgoff_t index, huge_index; struct kvm_gmem *gmem; struct folio *folio; struct page *page; @@ -514,6 +549,7 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, gmem = file->private_data; + index = gfn - slot->base_gfn + slot->gmem.pgoff; if (WARN_ON_ONCE(xa_load(&gmem->bindings, index) != slot)) { r = -EIO; goto out_fput; @@ -533,9 +569,24 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, page = folio_file_page(folio, index); *pfn = page_to_pfn(page); - if (max_order) + if (!max_order) + goto success; + + *max_order = compound_order(compound_head(page)); + if (!*max_order) + goto success; + + /* + * The folio can be mapped with a hugepage if and only if the folio is + * fully contained by the range the memslot is bound to. Note, the + * caller is responsible for handling gfn alignment, this only deals + * with the file binding. + */ + huge_index = ALIGN(index, 1ull << *max_order); + if (huge_index < ALIGN(slot->gmem.pgoff, 1ull << *max_order) || + huge_index + (1ull << *max_order) > slot->gmem.pgoff + slot->npages) *max_order = 0; - +success: r = 0; out_unlock: diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 5d1a2f1b4e94..0711f2c75667 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -4888,6 +4888,10 @@ static int kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg) #ifdef CONFIG_KVM_PRIVATE_MEM case KVM_CAP_GUEST_MEMFD: return !kvm || kvm_arch_has_private_mem(kvm); + case KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE: + if (kvm && !kvm_arch_has_private_mem(kvm)) + return 0; + return PMD_SIZE; #endif default: break; base-commit: fcbef1e5e5d2a60dacac0d16c06ac00bedaefc0f -- From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-yb1-f201.google.com (mail-yb1-f201.google.com [209.85.219.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AE10879F0 for ; Thu, 2 Nov 2023 15:38:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--seanjc.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="fFhfunHo" Received: by mail-yb1-f201.google.com with SMTP id 3f1490d57ef6-da13698a6d3so1363788276.0 for ; Thu, 02 Nov 2023 08:38:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698939483; x=1699544283; darn=lists.linux.dev; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=fFhfunHouW7C+KYNODZAbVHr96rh3Uxqpaf8783JTPSJJ9y+22z/UYQI9FpsfArby8 Yh6vrXYfnyZKXMIgqunr9W2QOI2piFZhOIkcx1VtfhDC2QGmB47xiMo0RkKc+ImzHZls NEMDpOT9ayemGHPUwMP6FCdBk/PyqvGGek6Tg7v2cnxPOnz517CXEgu50crT25IqugBi TiYt8rnMScmIUfhmNMQXkaqjFFHV3wbbNTF3WpdiZyRj142u+5GEixCWI141a8ZnRqZt 6GaJkb2n5u/vY9vL2NntyJePZKbrD4EFyTFBRBA4aLj15CiY1RE4J4ZF4x9r3KOO5C0C ZMLQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698939483; x=1699544283; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=H5tsDTXT3g6//jRHNXUsMZsK/zi4m6OSF+aq/v8rZS/D/+sHLOouXcamDjd4ns8TMn 5KIg6kZUEOjeQ/RfdVBM5Rw1VTaq6C5B/LUEFQ5jr3AJLZC9f3TiyidNQjjhbwjI1y6A MOg63dreZowKGDWEjLkzxOUTkXtGnYBfhJJI0t4lu+WqMcYLc0dxr3BhSmxf367OgVvZ OVTlPRwecC9zery6Cpspmjci+eCQqwhpOLX2dl6Dk7KtQTrEc7MP8f4dvNgJ4jLmz3SD Fl8CjpcuOyfZ2HlcszO00nXafeGV4mpeR0uo892OIxfe4uG7fYDcN1UPCOHiZ/8s9hx3 lCDQ== X-Gm-Message-State: AOJu0YzGS8F5CF17b6jYG21/JscvZE+33HliY14+6Zt75vcq8Mq96URB UtP4iAvq5RYrayvAR47vT49zayACvjo= X-Google-Smtp-Source: AGHT+IEEyjIaBF20Z+W+qpNozhmx7pCgnMaB7hSicNkCqZ1DUoIMtGZcYN59XWhCRCiGJ/+gJuVvphWrNGQ= X-Received: from zagreus.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:5c37]) (user=seanjc job=sendgmr) by 2002:a25:cfca:0:b0:d9a:556d:5f8a with SMTP id f193-20020a25cfca000000b00d9a556d5f8amr360317ybg.12.1698939483567; Thu, 02 Nov 2023 08:38:03 -0700 (PDT) Date: Thu, 2 Nov 2023 08:38:01 -0700 In-Reply-To: Precedence: bulk X-Mailing-List: kvmarm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20231027182217.3615211-18-seanjc@google.com> <7c0844d8-6f97-4904-a140-abeabeb552c1@intel.com> <92ba7ddd-2bc8-4a8d-bd67-d6614b21914f@intel.com> <4ca2253d-276f-43c5-8e9f-0ded5d5b2779@redhat.com> Message-ID: Subject: Re: [PATCH v13 17/35] KVM: Add transparent hugepage support for dedicated guest memory From: Sean Christopherson To: Paolo Bonzini Cc: Xiaoyao Li , Marc Zyngier , Oliver Upton , Huacai Chen , Michael Ellerman , Anup Patel , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexander Viro , Christian Brauner , "Matthew Wilcox (Oracle)" , Andrew Morton , kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, kvm-riscv@lists.infradead.org, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, Xu Yilun , Chao Peng , Fuad Tabba , Jarkko Sakkinen , Anish Moorthy , David Matlack , Yu Zhang , Isaku Yamahata , "=?utf-8?Q?Micka=C3=ABl_Sala=C3=BCn?=" , Vlastimil Babka , Vishal Annapurve , Ackerley Tng , Maciej Szmigiero , David Hildenbrand , Quentin Perret , Michael Roth , Wang , Liam Merwick , Isaku Yamahata , "Kirill A . Shutemov" Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable On Thu, Nov 02, 2023, Paolo Bonzini wrote: > On Wed, Nov 1, 2023 at 11:35=E2=80=AFPM Sean Christopherson wrote: > > > > On Wed, Nov 01, 2023, Paolo Bonzini wrote: > > > On 11/1/23 17:36, Sean Christopherson wrote: > > > > Can you post a fixup patch? It's not clear to me exactly what beha= vior you intend > > > > to end up with. > > > > > > Sure, just this: > > > > > > diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c > > > index 7d1a33c2ad42..34fd070e03d9 100644 > > > --- a/virt/kvm/guest_memfd.c > > > +++ b/virt/kvm/guest_memfd.c > > > @@ -430,10 +430,7 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_= create_guest_memfd *args) > > > { > > > loff_t size =3D args->size; > > > u64 flags =3D args->flags; > > > - u64 valid_flags =3D 0; > > > - > > > - if (IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE)) > > > - valid_flags |=3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > + u64 valid_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > if (flags & ~valid_flags) > > > return -EINVAL; > > > @@ -441,11 +438,9 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_= create_guest_memfd *args) > > > if (size < 0 || !PAGE_ALIGNED(size)) > > > return -EINVAL; > > > -#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > > if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && > > > !IS_ALIGNED(size, HPAGE_PMD_SIZE)) > > > return -EINVAL; > > > -#endif > > > > That won't work, HPAGE_PMD_SIZE is valid only for CONFIG_TRANSPARENT_HU= GEPAGE=3Dy. > > > > #else /* CONFIG_TRANSPARENT_HUGEPAGE */ > > #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_SIZE ({ BUILD_BUG(); 0; }) >=20 > Would have caught it when actually testing it, I guess. :) It has to > be PMD_SIZE, possibly with >=20 > #ifdef CONFIG_TRANSPARENT_HUGEPAGE > BUILD_BUG_ON(HPAGE_PMD_SIZE !=3D PMD_SIZE); > #endif Yeah, that works for me. Actually, looking that this again, there's not actually a hard dependency o= n THP. A THP-enabled kernel _probably_ gives a higher probability of using hugepa= ges, but mostly because THP selects COMPACTION, and I suppose because using THP = for other allocations reduces overall fragmentation. So rather than honor KVM_GUEST_MEMFD_ALLOW_HUGEPAGE iff THP is enabled, I t= hink we should do the below (I verified KVM can create hugepages with THP=3Dn). = We'll need another capability, but (a) we probably should have that anyways and (= b) it provides a cleaner path to adding PUD-sized hugepage support in the future. And then adjust the tests like so: diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testing= /selftests/kvm/guest_memfd_test.c index c15de9852316..c9f449718fce 100644 --- a/tools/testing/selftests/kvm/guest_memfd_test.c +++ b/tools/testing/selftests/kvm/guest_memfd_test.c @@ -201,6 +201,10 @@ int main(int argc, char *argv[]) =20 TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD)); =20 + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE) && thp_confi= gured()) + TEST_ASSERT_EQ(get_trans_hugepagesz(), + kvm_check_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_P= MD_SIZE)); + page_size =3D getpagesize(); total_size =3D page_size * 4; =20 diff --git a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_tes= t.c b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c index be311944e90a..245901587ed2 100644 --- a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c +++ b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c @@ -396,7 +396,7 @@ static void test_mem_conversions(enum vm_mem_backing_sr= c_type src_type, uint32_t =20 vm_enable_cap(vm, KVM_CAP_EXIT_HYPERCALL, (1 << KVM_HC_MAP_GPA_RANG= E)); =20 - if (backing_src_can_be_huge(src_type)) + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE)) memfd_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; else memfd_flags =3D 0; -- From: Sean Christopherson Date: Wed, 25 Oct 2023 16:26:41 -0700 Subject: [PATCH] KVM: Add best-effort hugepage support for dedicated guest memory Extend guest_memfd to allow backing guest memory with hugepages. For now, make hugepage utilization best-effort, i.e. fall back to non-huge mappings if a hugepage can't be allocated. Guaranteeing hugepages would require a dedicated memory pool and significantly more complexity and churn.. Require userspace to opt-in via a flag even though it's unlikely real use cases will ever want to use order-0 pages, e.g. to give userspace a safety valve in case hugepage support is buggy, and to allow for easier testing of both paths. Do not take a dependency on CONFIG_TRANSPARENT_HUGEPAGE, as THP enabling primarily deals with userspace page tables, which are explicitly not in play for guest_memfd. Selecting THP does make obtaining hugepages more likely, but only because THP selects CONFIG_COMPACTION. Don't select CONFIG_COMPACTION either, because again it's not a hard dependency. For simplicity, require the guest_memfd size to be a multiple of the hugepage size, e.g. so that KVM doesn't need to do bounds checking when deciding whether or not to allocate a huge folio. When reporting the max order when KVM gets a pfn from guest_memfd, force order-0 pages if the hugepage is not fully contained by the memslot binding, e.g. if userspace requested hugepages but punches a hole in the memslot bindings in order to emulate x86's VGA hole. Signed-off-by: Sean Christopherson --- Documentation/virt/kvm/api.rst | 17 +++++++++ include/uapi/linux/kvm.h | 3 ++ virt/kvm/guest_memfd.c | 69 +++++++++++++++++++++++++++++----- virt/kvm/kvm_main.c | 4 ++ 4 files changed, 84 insertions(+), 9 deletions(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rs= t index e82c69d5e755..ccdd5413920d 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -6176,6 +6176,8 @@ and cannot be resized (guest_memfd files do however = support PUNCH_HOLE). __u64 reserved[6]; }; =20 + #define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + Conceptually, the inode backing a guest_memfd file represents physical mem= ory, i.e. is coupled to the virtual machine as a thing, not to a "struct kvm". = The file itself, which is bound to a "struct kvm", is that instance's view of = the @@ -6192,6 +6194,12 @@ most one mapping per page, i.e. binding multiple mem= ory regions to a single guest_memfd range is not allowed (any number of memory regions can be boun= d to a single guest_memfd file, but the bound ranges must not overlap). =20 +If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set in flags, KVM will attempt to all= ocate +and map PMD-size hugepages for the guest_memfd file. This is currently be= st +effort. If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set, size must be aligned to= at +least the size reported by KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE (which al= so +enumerates support for KVM_GUEST_MEMFD_ALLOW_HUGEPAGE). + See KVM_SET_USER_MEMORY_REGION2 for additional details. =20 5. The kvm_run structure @@ -8639,6 +8647,15 @@ block sizes is exposed in KVM_CAP_ARM_SUPPORTED_BLOC= K_SIZES as a 64-bit bitmap (each bit describing a block size). The default value is 0, to disable the eager page splitting. =20 + +8.41 KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE +------------------------------------------ + +This is an information-only capability that returns guest_memfd's hugepage= size +for PMD hugepages. Returns '0' if guest_memfd is not supported, or if KVM +doesn't support creating hugepages for guest_memfd. Note, guest_memfd doe= sn't +currently support PUD-sized hugepages. + 9. Known KVM API problems =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D =20 diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 25caee8d1a80..b78d0e3bf22a 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1217,6 +1217,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_MEMORY_FAULT_INFO 231 #define KVM_CAP_MEMORY_ATTRIBUTES 232 #define KVM_CAP_GUEST_MEMFD 233 +#define KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE 234 =20 #ifdef KVM_CAP_IRQ_ROUTING =20 @@ -2303,4 +2304,6 @@ struct kvm_create_guest_memfd { __u64 reserved[6]; }; =20 +#define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + #endif /* __LINUX_KVM_H */ diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c index 98a12da80214..31b5e94d461a 100644 --- a/virt/kvm/guest_memfd.c +++ b/virt/kvm/guest_memfd.c @@ -13,14 +13,44 @@ struct kvm_gmem { struct list_head entry; }; =20 +#define NR_PAGES_PER_PMD (1 << PMD_ORDER) + +static struct folio *kvm_gmem_get_huge_folio(struct inode *inode, pgoff_t = index) +{ + unsigned long huge_index =3D round_down(index, NR_PAGES_PER_PMD); + unsigned long flags =3D (unsigned long)inode->i_private; + struct address_space *mapping =3D inode->i_mapping; + gfp_t gfp =3D mapping_gfp_mask(mapping); + struct folio *folio; + + if (!(flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE)) + return NULL; + + if (filemap_range_has_page(mapping, huge_index << PAGE_SHIFT, + (huge_index + NR_PAGES_PER_PMD - 1) << PAGE_SHIFT)) + return NULL; + + folio =3D filemap_alloc_folio(gfp, PMD_ORDER); + if (!folio) + return NULL; + + if (filemap_add_folio(mapping, folio, huge_index, gfp)) { + folio_put(folio); + return NULL; + } + return folio; +} + static struct folio *kvm_gmem_get_folio(struct inode *inode, pgoff_t index= ) { struct folio *folio; =20 - /* TODO: Support huge pages. */ - folio =3D filemap_grab_folio(inode->i_mapping, index); - if (IS_ERR_OR_NULL(folio)) - return NULL; + folio =3D kvm_gmem_get_huge_folio(inode, index); + if (!folio) { + folio =3D filemap_grab_folio(inode->i_mapping, index); + if (IS_ERR_OR_NULL(folio)) + return NULL; + } =20 /* * Use the up-to-date flag to track whether or not the memory has been @@ -373,6 +403,7 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t si= ze, u64 flags) inode->i_mode |=3D S_IFREG; inode->i_size =3D size; mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); + mapping_set_large_folios(inode->i_mapping); mapping_set_unmovable(inode->i_mapping); /* Unmovable mappings are supposed to be marked unevictable as well. */ WARN_ON_ONCE(!mapping_unevictable(inode->i_mapping)); @@ -394,14 +425,18 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t = size, u64 flags) =20 int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) { + u64 valid_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; loff_t size =3D args->size; u64 flags =3D args->flags; - u64 valid_flags =3D 0; =20 if (flags & ~valid_flags) return -EINVAL; =20 - if (size < 0 || !PAGE_ALIGNED(size)) + if (size <=3D 0 || !PAGE_ALIGNED(size)) + return -EINVAL; + + if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && + !IS_ALIGNED(size, PMD_SIZE)) return -EINVAL; =20 return __kvm_gmem_create(kvm, size, flags); @@ -501,7 +536,7 @@ void kvm_gmem_unbind(struct kvm_memory_slot *slot) int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, gfn_t gfn, kvm_pfn_t *pfn, int *max_order) { - pgoff_t index =3D gfn - slot->base_gfn + slot->gmem.pgoff; + pgoff_t index, huge_index; struct kvm_gmem *gmem; struct folio *folio; struct page *page; @@ -514,6 +549,7 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory= _slot *slot, =20 gmem =3D file->private_data; =20 + index =3D gfn - slot->base_gfn + slot->gmem.pgoff; if (WARN_ON_ONCE(xa_load(&gmem->bindings, index) !=3D slot)) { r =3D -EIO; goto out_fput; @@ -533,9 +569,24 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memor= y_slot *slot, page =3D folio_file_page(folio, index); =20 *pfn =3D page_to_pfn(page); - if (max_order) + if (!max_order) + goto success; + + *max_order =3D compound_order(compound_head(page)); + if (!*max_order) + goto success; + + /* + * The folio can be mapped with a hugepage if and only if the folio is + * fully contained by the range the memslot is bound to. Note, the + * caller is responsible for handling gfn alignment, this only deals + * with the file binding. + */ + huge_index =3D ALIGN(index, 1ull << *max_order); + if (huge_index < ALIGN(slot->gmem.pgoff, 1ull << *max_order) || + huge_index + (1ull << *max_order) > slot->gmem.pgoff + slot->npages) *max_order =3D 0; - +success: r =3D 0; =20 out_unlock: diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 5d1a2f1b4e94..0711f2c75667 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -4888,6 +4888,10 @@ static int kvm_vm_ioctl_check_extension_generic(stru= ct kvm *kvm, long arg) #ifdef CONFIG_KVM_PRIVATE_MEM case KVM_CAP_GUEST_MEMFD: return !kvm || kvm_arch_has_private_mem(kvm); + case KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE: + if (kvm && !kvm_arch_has_private_mem(kvm)) + return 0; + return PMD_SIZE; #endif default: break; base-commit: fcbef1e5e5d2a60dacac0d16c06ac00bedaefc0f -- 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 3C928C4332F for ; Thu, 2 Nov 2023 15:38:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:Message-ID: References:Mime-Version:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=hsednWus7RNGVqhd/DwkejbEGNYoCMItul4dLWiW8jA=; b=BhGky7x5EI03bUuQceMM2H/SkU 4PoiIlgLTL8Q0n4ovamc5ci6PVigSJUjPZV/rdTzg6EtYOeQINZOthwXgxucDEEqMfkxtG9EOktzt Myh46rVYzCIA+FYz1onIuvSNJiGgr0N70ZORY4js6kwAneZIN5rccsEqT8Sqfnw37tNQDQua4eqDe NNIjHRIsVNwsNMGzklIyxgopEVHCqjPQPcNHhbjN0m6p6vkiq+UmmUiPCWYaUTpG45TYXQIwN3g8d GhImIEykw7GjXHZMvPHmX+xfnSJ1pVqYWK9qioDh37MV0iAsGGRf1TSNCAsLn3LeBnEiQt2yBtnId QB0mQ24g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qyZlq-009ldD-1Y; Thu, 02 Nov 2023 15:38:10 +0000 Received: from mail-yb1-xb49.google.com ([2607:f8b0:4864:20::b49]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qyZll-009lal-0r for linux-riscv@lists.infradead.org; Thu, 02 Nov 2023 15:38:09 +0000 Received: by mail-yb1-xb49.google.com with SMTP id 3f1490d57ef6-d9ab7badadeso1346030276.1 for ; Thu, 02 Nov 2023 08:38:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698939483; x=1699544283; darn=lists.infradead.org; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=yyvXyOflhlAuKgOkWVe9luHYUlMaQTNpIeI8zcJp+y47QUS5KzISilmYWN5RW/p1/1 6s30NUw7NS7JvTZVzujwLYLedRUuvLsbYxvZv/67LgLxlPB54YPgkBmdrc+ViDYKgMcg FTrhBTvip0q3kBzskfLIpIp2S8xkWd4snh2HeTtV9I3ZZHw/uEp8aJ9+ovecz24cTwjP vvCxpCjfDVQRMCsTXK96Gi/fSvOX/j6RF0dU2l4FzcBdAtgFfAjoJMEOOokpDmHWJWKy +zrjkzHMUtfx2SVUfSFhU4HoS+KZgHVRAZWDJmqImblZ4x7YRBBh8tRKvseR/aOo1x39 pVCg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698939483; x=1699544283; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=mN0r2i2cTt+DY0YxOqVkAuOe9gK4T5ZmA1GXAMMXM761hOKSHNOmNTPdrAPXfKrSqk mG7AB/8fM+rpc9a9aQ9d/K3eRb4OLm0Xg7tjmpEpm0lJrpY+IbZEIsaJ/o6+0VGz03sO kkS3CawzCdpkvJJ3V01Pm6YdRd933GKO1+sTJr7Kdxm/4MThwkTWhwBUfzp9wN7aNNEx jJ7LEkfbdUNDM7jVOVwqiaUyClwq5z+yfm3tGJdmNnoeghw0Dvb+YMWcNnduYF35y9Vh wPo+TAVnfpcegxYnUL5pV144wEVAVl21ucMqCToLkowa7d61rCfvY8STyXoi4ytjD1/S 9DZg== X-Gm-Message-State: AOJu0YzQcLbVC3WEvhkXRbsTfMtD5qmxkQrfgXihOXV1xOUn+MYxD0BY OGH6cwIyzIA8H4ie+592EwIV9/RH0SQ= X-Google-Smtp-Source: AGHT+IEEyjIaBF20Z+W+qpNozhmx7pCgnMaB7hSicNkCqZ1DUoIMtGZcYN59XWhCRCiGJ/+gJuVvphWrNGQ= X-Received: from zagreus.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:5c37]) (user=seanjc job=sendgmr) by 2002:a25:cfca:0:b0:d9a:556d:5f8a with SMTP id f193-20020a25cfca000000b00d9a556d5f8amr360317ybg.12.1698939483567; Thu, 02 Nov 2023 08:38:03 -0700 (PDT) Date: Thu, 2 Nov 2023 08:38:01 -0700 In-Reply-To: Mime-Version: 1.0 References: <20231027182217.3615211-18-seanjc@google.com> <7c0844d8-6f97-4904-a140-abeabeb552c1@intel.com> <92ba7ddd-2bc8-4a8d-bd67-d6614b21914f@intel.com> <4ca2253d-276f-43c5-8e9f-0ded5d5b2779@redhat.com> Message-ID: Subject: Re: [PATCH v13 17/35] KVM: Add transparent hugepage support for dedicated guest memory From: Sean Christopherson To: Paolo Bonzini Cc: Xiaoyao Li , Marc Zyngier , Oliver Upton , Huacai Chen , Michael Ellerman , Anup Patel , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexander Viro , Christian Brauner , "Matthew Wilcox (Oracle)" , Andrew Morton , kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, kvm-riscv@lists.infradead.org, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, Xu Yilun , Chao Peng , Fuad Tabba , Jarkko Sakkinen , Anish Moorthy , David Matlack , Yu Zhang , Isaku Yamahata , "=?utf-8?Q?Micka=C3=ABl_Sala=C3=BCn?=" , Vlastimil Babka , Vishal Annapurve , Ackerley Tng , Maciej Szmigiero , David Hildenbrand , Quentin Perret , Michael Roth , Wang , Liam Merwick , Isaku Yamahata , "Kirill A . Shutemov" X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231102_083805_330611_1ECDD251 X-CRM114-Status: GOOD ( 41.92 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gVGh1LCBOb3YgMDIsIDIwMjMsIFBhb2xvIEJvbnppbmkgd3JvdGU6Cj4gT24gV2VkLCBOb3Yg MSwgMjAyMyBhdCAxMTozNeKAr1BNIFNlYW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUu Y29tPiB3cm90ZToKPiA+Cj4gPiBPbiBXZWQsIE5vdiAwMSwgMjAyMywgUGFvbG8gQm9uemluaSB3 cm90ZToKPiA+ID4gT24gMTEvMS8yMyAxNzozNiwgU2VhbiBDaHJpc3RvcGhlcnNvbiB3cm90ZToK PiA+ID4gPiBDYW4geW91IHBvc3QgYSBmaXh1cCBwYXRjaD8gIEl0J3Mgbm90IGNsZWFyIHRvIG1l IGV4YWN0bHkgd2hhdCBiZWhhdmlvciB5b3UgaW50ZW5kCj4gPiA+ID4gdG8gZW5kIHVwIHdpdGgu Cj4gPiA+Cj4gPiA+IFN1cmUsIGp1c3QgdGhpczoKPiA+ID4KPiA+ID4gZGlmZiAtLWdpdCBhL3Zp cnQva3ZtL2d1ZXN0X21lbWZkLmMgYi92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCj4gPiA+IGluZGV4 IDdkMWEzM2MyYWQ0Mi4uMzRmZDA3MGUwM2Q5IDEwMDY0NAo+ID4gPiAtLS0gYS92aXJ0L2t2bS9n dWVzdF9tZW1mZC5jCj4gPiA+ICsrKyBiL3ZpcnQva3ZtL2d1ZXN0X21lbWZkLmMKPiA+ID4gQEAg LTQzMCwxMCArNDMwLDcgQEAgaW50IGt2bV9nbWVtX2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIHN0 cnVjdCBrdm1fY3JlYXRlX2d1ZXN0X21lbWZkICphcmdzKQo+ID4gPiAgewo+ID4gPiAgICAgICBs b2ZmX3Qgc2l6ZSA9IGFyZ3MtPnNpemU7Cj4gPiA+ICAgICAgIHU2NCBmbGFncyA9IGFyZ3MtPmZs YWdzOwo+ID4gPiAtICAgICB1NjQgdmFsaWRfZmxhZ3MgPSAwOwo+ID4gPiAtCj4gPiA+IC0gICAg IGlmIChJU19FTkFCTEVEKENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSkpCj4gPiA+IC0gICAg ICAgICAgICAgdmFsaWRfZmxhZ3MgfD0gS1ZNX0dVRVNUX01FTUZEX0FMTE9XX0hVR0VQQUdFOwo+ ID4gPiArICAgICB1NjQgdmFsaWRfZmxhZ3MgPSBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBB R0U7Cj4gPiA+ICAgICAgIGlmIChmbGFncyAmIH52YWxpZF9mbGFncykKPiA+ID4gICAgICAgICAg ICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ID4gQEAgLTQ0MSwxMSArNDM4LDkgQEAgaW50IGt2bV9n bWVtX2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIHN0cnVjdCBrdm1fY3JlYXRlX2d1ZXN0X21lbWZk ICphcmdzKQo+ID4gPiAgICAgICBpZiAoc2l6ZSA8IDAgfHwgIVBBR0VfQUxJR05FRChzaXplKSkK PiA+ID4gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ID4gLSNpZmRlZiBDT05GSUdf VFJBTlNQQVJFTlRfSFVHRVBBR0UKPiA+ID4gICAgICAgaWYgKChmbGFncyAmIEtWTV9HVUVTVF9N RU1GRF9BTExPV19IVUdFUEFHRSkgJiYKPiA+ID4gICAgICAgICAgICFJU19BTElHTkVEKHNpemUs IEhQQUdFX1BNRF9TSVpFKSkKPiA+ID4gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ ID4gLSNlbmRpZgo+ID4KPiA+IFRoYXQgd29uJ3Qgd29yaywgSFBBR0VfUE1EX1NJWkUgaXMgdmFs aWQgb25seSBmb3IgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFPXkuCj4gPgo+ID4gI2Vsc2Ug LyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCj4gPiAjZGVmaW5lIEhQQUdFX1BNRF9T SElGVCAoeyBCVUlMRF9CVUcoKTsgMDsgfSkKPiA+ICNkZWZpbmUgSFBBR0VfUE1EX01BU0sgKHsg QlVJTERfQlVHKCk7IDA7IH0pCj4gPiAjZGVmaW5lIEhQQUdFX1BNRF9TSVpFICh7IEJVSUxEX0JV RygpOyAwOyB9KQo+IAo+IFdvdWxkIGhhdmUgY2F1Z2h0IGl0IHdoZW4gYWN0dWFsbHkgdGVzdGlu ZyBpdCwgSSBndWVzcy4gOikgSXQgaGFzIHRvCj4gYmUgUE1EX1NJWkUsIHBvc3NpYmx5IHdpdGgK PiAKPiAjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCj4gQlVJTERfQlVHX09OKEhQ QUdFX1BNRF9TSVpFICE9IFBNRF9TSVpFKTsKPiAjZW5kaWYKClllYWgsIHRoYXQgd29ya3MgZm9y IG1lLgoKQWN0dWFsbHksIGxvb2tpbmcgdGhhdCB0aGlzIGFnYWluLCB0aGVyZSdzIG5vdCBhY3R1 YWxseSBhIGhhcmQgZGVwZW5kZW5jeSBvbiBUSFAuCkEgVEhQLWVuYWJsZWQga2VybmVsIF9wcm9i YWJseV8gIGdpdmVzIGEgaGlnaGVyIHByb2JhYmlsaXR5IG9mIHVzaW5nIGh1Z2VwYWdlcywKYnV0 IG1vc3RseSBiZWNhdXNlIFRIUCBzZWxlY3RzIENPTVBBQ1RJT04sIGFuZCBJIHN1cHBvc2UgYmVj YXVzZSB1c2luZyBUSFAgZm9yCm90aGVyIGFsbG9jYXRpb25zIHJlZHVjZXMgb3ZlcmFsbCBmcmFn bWVudGF0aW9uLgoKU28gcmF0aGVyIHRoYW4gaG9ub3IgS1ZNX0dVRVNUX01FTUZEX0FMTE9XX0hV R0VQQUdFIGlmZiBUSFAgaXMgZW5hYmxlZCwgSSB0aGluawp3ZSBzaG91bGQgZG8gdGhlIGJlbG93 IChJIHZlcmlmaWVkIEtWTSBjYW4gY3JlYXRlIGh1Z2VwYWdlcyB3aXRoIFRIUD1uKS4gIFdlJ2xs Cm5lZWQgYW5vdGhlciBjYXBhYmlsaXR5LCBidXQgKGEpIHdlIHByb2JhYmx5IHNob3VsZCBoYXZl IHRoYXQgYW55d2F5cyBhbmQgKGIpIGl0CnByb3ZpZGVzIGEgY2xlYW5lciBwYXRoIHRvIGFkZGlu ZyBQVUQtc2l6ZWQgaHVnZXBhZ2Ugc3VwcG9ydCBpbiB0aGUgZnV0dXJlLgoKQW5kIHRoZW4gYWRq dXN0IHRoZSB0ZXN0cyBsaWtlIHNvOgoKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRl c3RzL2t2bS9ndWVzdF9tZW1mZF90ZXN0LmMgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0v Z3Vlc3RfbWVtZmRfdGVzdC5jCmluZGV4IGMxNWRlOTg1MjMxNi4uYzlmNDQ5NzE4ZmNlIDEwMDY0 NAotLS0gYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0vZ3Vlc3RfbWVtZmRfdGVzdC5jCisr KyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS9ndWVzdF9tZW1mZF90ZXN0LmMKQEAgLTIw MSw2ICsyMDEsMTAgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIAogICAgICAg IFRFU1RfUkVRVUlSRShrdm1faGFzX2NhcChLVk1fQ0FQX0dVRVNUX01FTUZEKSk7CiAKKyAgICAg ICBpZiAoa3ZtX2hhc19jYXAoS1ZNX0NBUF9HVUVTVF9NRU1GRF9IVUdFUEFHRV9QTURfU0laRSkg JiYgdGhwX2NvbmZpZ3VyZWQoKSkKKyAgICAgICAgICAgICAgIFRFU1RfQVNTRVJUX0VRKGdldF90 cmFuc19odWdlcGFnZXN6KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrdm1fY2hl Y2tfY2FwKEtWTV9DQVBfR1VFU1RfTUVNRkRfSFVHRVBBR0VfUE1EX1NJWkUpKTsKKwogICAgICAg IHBhZ2Vfc2l6ZSA9IGdldHBhZ2VzaXplKCk7CiAgICAgICAgdG90YWxfc2l6ZSA9IHBhZ2Vfc2l6 ZSAqIDQ7CiAKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQv cHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMv a3ZtL3g4Nl82NC9wcml2YXRlX21lbV9jb252ZXJzaW9uc190ZXN0LmMKaW5kZXggYmUzMTE5NDRl OTBhLi4yNDU5MDE1ODdlZDIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2 bS94ODZfNjQvcHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jCisrKyBiL3Rvb2xzL3Rlc3Rp bmcvc2VsZnRlc3RzL2t2bS94ODZfNjQvcHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jCkBA IC0zOTYsNyArMzk2LDcgQEAgc3RhdGljIHZvaWQgdGVzdF9tZW1fY29udmVyc2lvbnMoZW51bSB2 bV9tZW1fYmFja2luZ19zcmNfdHlwZSBzcmNfdHlwZSwgdWludDMyX3QKIAogICAgICAgIHZtX2Vu YWJsZV9jYXAodm0sIEtWTV9DQVBfRVhJVF9IWVBFUkNBTEwsICgxIDw8IEtWTV9IQ19NQVBfR1BB X1JBTkdFKSk7CiAKLSAgICAgICBpZiAoYmFja2luZ19zcmNfY2FuX2JlX2h1Z2Uoc3JjX3R5cGUp KQorICAgICAgIGlmIChrdm1faGFzX2NhcChLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BN RF9TSVpFKSkKICAgICAgICAgICAgICAgIG1lbWZkX2ZsYWdzID0gS1ZNX0dVRVNUX01FTUZEX0FM TE9XX0hVR0VQQUdFOwogICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIG1lbWZkX2ZsYWdzID0g MDsKCi0tCkZyb206IFNlYW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUuY29tPgpEYXRl OiBXZWQsIDI1IE9jdCAyMDIzIDE2OjI2OjQxIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gS1ZNOiBB ZGQgYmVzdC1lZmZvcnQgaHVnZXBhZ2Ugc3VwcG9ydCBmb3IgZGVkaWNhdGVkIGd1ZXN0CiBtZW1v cnkKCkV4dGVuZCBndWVzdF9tZW1mZCB0byBhbGxvdyBiYWNraW5nIGd1ZXN0IG1lbW9yeSB3aXRo IGh1Z2VwYWdlcy4gIEZvciBub3csCm1ha2UgaHVnZXBhZ2UgdXRpbGl6YXRpb24gYmVzdC1lZmZv cnQsIGkuZS4gZmFsbCBiYWNrIHRvIG5vbi1odWdlIG1hcHBpbmdzCmlmIGEgaHVnZXBhZ2UgY2Fu J3QgYmUgYWxsb2NhdGVkLiAgR3VhcmFudGVlaW5nIGh1Z2VwYWdlcyB3b3VsZCByZXF1aXJlIGEK ZGVkaWNhdGVkIG1lbW9yeSBwb29sIGFuZCBzaWduaWZpY2FudGx5IG1vcmUgY29tcGxleGl0eSBh bmQgY2h1cm4uLgoKUmVxdWlyZSB1c2Vyc3BhY2UgdG8gb3B0LWluIHZpYSBhIGZsYWcgZXZlbiB0 aG91Z2ggaXQncyB1bmxpa2VseSByZWFsIHVzZQpjYXNlcyB3aWxsIGV2ZXIgd2FudCB0byB1c2Ug b3JkZXItMCBwYWdlcywgZS5nLiB0byBnaXZlIHVzZXJzcGFjZSBhIHNhZmV0eQp2YWx2ZSBpbiBj YXNlIGh1Z2VwYWdlIHN1cHBvcnQgaXMgYnVnZ3ksIGFuZCB0byBhbGxvdyBmb3IgZWFzaWVyIHRl c3RpbmcKb2YgYm90aCBwYXRocy4KCkRvIG5vdCB0YWtlIGEgZGVwZW5kZW5jeSBvbiBDT05GSUdf VFJBTlNQQVJFTlRfSFVHRVBBR0UsIGFzIFRIUCBlbmFibGluZwpwcmltYXJpbHkgZGVhbHMgd2l0 aCB1c2Vyc3BhY2UgcGFnZSB0YWJsZXMsIHdoaWNoIGFyZSBleHBsaWNpdGx5IG5vdCBpbgpwbGF5 IGZvciBndWVzdF9tZW1mZC4gIFNlbGVjdGluZyBUSFAgZG9lcyBtYWtlIG9idGFpbmluZyBodWdl cGFnZXMgbW9yZQpsaWtlbHksIGJ1dCBvbmx5IGJlY2F1c2UgVEhQIHNlbGVjdHMgQ09ORklHX0NP TVBBQ1RJT04uICBEb24ndCBzZWxlY3QKQ09ORklHX0NPTVBBQ1RJT04gZWl0aGVyLCBiZWNhdXNl IGFnYWluIGl0J3Mgbm90IGEgaGFyZCBkZXBlbmRlbmN5LgoKRm9yIHNpbXBsaWNpdHksIHJlcXVp cmUgdGhlIGd1ZXN0X21lbWZkIHNpemUgdG8gYmUgYSBtdWx0aXBsZSBvZiB0aGUKaHVnZXBhZ2Ug c2l6ZSwgZS5nLiBzbyB0aGF0IEtWTSBkb2Vzbid0IG5lZWQgdG8gZG8gYm91bmRzIGNoZWNraW5n IHdoZW4KZGVjaWRpbmcgd2hldGhlciBvciBub3QgdG8gYWxsb2NhdGUgYSBodWdlIGZvbGlvLgoK V2hlbiByZXBvcnRpbmcgdGhlIG1heCBvcmRlciB3aGVuIEtWTSBnZXRzIGEgcGZuIGZyb20gZ3Vl c3RfbWVtZmQsIGZvcmNlCm9yZGVyLTAgcGFnZXMgaWYgdGhlIGh1Z2VwYWdlIGlzIG5vdCBmdWxs eSBjb250YWluZWQgYnkgdGhlIG1lbXNsb3QKYmluZGluZywgZS5nLiBpZiB1c2Vyc3BhY2UgcmVx dWVzdGVkIGh1Z2VwYWdlcyBidXQgcHVuY2hlcyBhIGhvbGUgaW4gdGhlCm1lbXNsb3QgYmluZGlu Z3MgaW4gb3JkZXIgdG8gZW11bGF0ZSB4ODYncyBWR0EgaG9sZS4KClNpZ25lZC1vZmYtYnk6IFNl YW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUuY29tPgotLS0KIERvY3VtZW50YXRpb24v dmlydC9rdm0vYXBpLnJzdCB8IDE3ICsrKysrKysrKwogaW5jbHVkZS91YXBpL2xpbnV4L2t2bS5o ICAgICAgIHwgIDMgKysKIHZpcnQva3ZtL2d1ZXN0X21lbWZkLmMgICAgICAgICB8IDY5ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIHZpcnQva3ZtL2t2bV9tYWluLmMgICAgICAg ICAgICB8ICA0ICsrCiA0IGZpbGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDkgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0IGIvRG9j dW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0CmluZGV4IGU4MmM2OWQ1ZTc1NS4uY2NkZDU0MTM5 MjBkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2FwaS5yc3QKKysrIGIvRG9j dW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0CkBAIC02MTc2LDYgKzYxNzYsOCBAQCBhbmQgY2Fu bm90IGJlIHJlc2l6ZWQgIChndWVzdF9tZW1mZCBmaWxlcyBkbyBob3dldmVyIHN1cHBvcnQgUFVO Q0hfSE9MRSkuCiAJX191NjQgcmVzZXJ2ZWRbNl07CiAgIH07CiAKKyAgI2RlZmluZSBLVk1fR1VF U1RfTUVNRkRfQUxMT1dfSFVHRVBBR0UgICAgICAgICAoMVVMTCA8PCAwKQorCiBDb25jZXB0dWFs bHksIHRoZSBpbm9kZSBiYWNraW5nIGEgZ3Vlc3RfbWVtZmQgZmlsZSByZXByZXNlbnRzIHBoeXNp Y2FsIG1lbW9yeSwKIGkuZS4gaXMgY291cGxlZCB0byB0aGUgdmlydHVhbCBtYWNoaW5lIGFzIGEg dGhpbmcsIG5vdCB0byBhICJzdHJ1Y3Qga3ZtIi4gIFRoZQogZmlsZSBpdHNlbGYsIHdoaWNoIGlz IGJvdW5kIHRvIGEgInN0cnVjdCBrdm0iLCBpcyB0aGF0IGluc3RhbmNlJ3MgdmlldyBvZiB0aGUK QEAgLTYxOTIsNiArNjE5NCwxMiBAQCBtb3N0IG9uZSBtYXBwaW5nIHBlciBwYWdlLCBpLmUuIGJp bmRpbmcgbXVsdGlwbGUgbWVtb3J5IHJlZ2lvbnMgdG8gYSBzaW5nbGUKIGd1ZXN0X21lbWZkIHJh bmdlIGlzIG5vdCBhbGxvd2VkIChhbnkgbnVtYmVyIG9mIG1lbW9yeSByZWdpb25zIGNhbiBiZSBi b3VuZCB0bwogYSBzaW5nbGUgZ3Vlc3RfbWVtZmQgZmlsZSwgYnV0IHRoZSBib3VuZCByYW5nZXMg bXVzdCBub3Qgb3ZlcmxhcCkuCiAKK0lmIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSBp cyBzZXQgaW4gZmxhZ3MsIEtWTSB3aWxsIGF0dGVtcHQgdG8gYWxsb2NhdGUKK2FuZCBtYXAgUE1E LXNpemUgaHVnZXBhZ2VzIGZvciB0aGUgZ3Vlc3RfbWVtZmQgZmlsZS4gIFRoaXMgaXMgY3VycmVu dGx5IGJlc3QKK2VmZm9ydC4gIElmIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSBpcyBz ZXQsIHNpemUgbXVzdCBiZSBhbGlnbmVkIHRvIGF0CitsZWFzdCB0aGUgc2l6ZSByZXBvcnRlZCBi eSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9TSVpFICh3aGljaCBhbHNvCitlbnVt ZXJhdGVzIHN1cHBvcnQgZm9yIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSkuCisKIFNl ZSBLVk1fU0VUX1VTRVJfTUVNT1JZX1JFR0lPTjIgZm9yIGFkZGl0aW9uYWwgZGV0YWlscy4KIAog NS4gVGhlIGt2bV9ydW4gc3RydWN0dXJlCkBAIC04NjM5LDYgKzg2NDcsMTUgQEAgYmxvY2sgc2l6 ZXMgaXMgZXhwb3NlZCBpbiBLVk1fQ0FQX0FSTV9TVVBQT1JURURfQkxPQ0tfU0laRVMgYXMgYQog NjQtYml0IGJpdG1hcCAoZWFjaCBiaXQgZGVzY3JpYmluZyBhIGJsb2NrIHNpemUpLiBUaGUgZGVm YXVsdCB2YWx1ZSBpcwogMCwgdG8gZGlzYWJsZSB0aGUgZWFnZXIgcGFnZSBzcGxpdHRpbmcuCiAK KworOC40MSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9TSVpFCistLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVGhpcyBpcyBhbiBpbmZvcm1hdGlv bi1vbmx5IGNhcGFiaWxpdHkgdGhhdCByZXR1cm5zIGd1ZXN0X21lbWZkJ3MgaHVnZXBhZ2Ugc2l6 ZQorZm9yIFBNRCBodWdlcGFnZXMuICBSZXR1cm5zICcwJyBpZiBndWVzdF9tZW1mZCBpcyBub3Qg c3VwcG9ydGVkLCBvciBpZiBLVk0KK2RvZXNuJ3Qgc3VwcG9ydCBjcmVhdGluZyBodWdlcGFnZXMg Zm9yIGd1ZXN0X21lbWZkLiAgTm90ZSwgZ3Vlc3RfbWVtZmQgZG9lc24ndAorY3VycmVudGx5IHN1 cHBvcnQgUFVELXNpemVkIGh1Z2VwYWdlcy4KKwogOS4gS25vd24gS1ZNIEFQSSBwcm9ibGVtcwog PT09PT09PT09PT09PT09PT09PT09PT09PQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGlu dXgva3ZtLmggYi9pbmNsdWRlL3VhcGkvbGludXgva3ZtLmgKaW5kZXggMjVjYWVlOGQxYTgwLi5i NzhkMGUzYmYyMmEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9rdm0uaAorKysgYi9p bmNsdWRlL3VhcGkvbGludXgva3ZtLmgKQEAgLTEyMTcsNiArMTIxNyw3IEBAIHN0cnVjdCBrdm1f cHBjX3Jlc2l6ZV9ocHQgewogI2RlZmluZSBLVk1fQ0FQX01FTU9SWV9GQVVMVF9JTkZPIDIzMQog I2RlZmluZSBLVk1fQ0FQX01FTU9SWV9BVFRSSUJVVEVTIDIzMgogI2RlZmluZSBLVk1fQ0FQX0dV RVNUX01FTUZEIDIzMworI2RlZmluZSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9T SVpFIDIzNAogCiAjaWZkZWYgS1ZNX0NBUF9JUlFfUk9VVElORwogCkBAIC0yMzAzLDQgKzIzMDQs NiBAQCBzdHJ1Y3Qga3ZtX2NyZWF0ZV9ndWVzdF9tZW1mZCB7CiAJX191NjQgcmVzZXJ2ZWRbNl07 CiB9OwogCisjZGVmaW5lIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRQkJKDFVTEwgPDwg MCkKKwogI2VuZGlmIC8qIF9fTElOVVhfS1ZNX0ggKi8KZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2d1 ZXN0X21lbWZkLmMgYi92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCmluZGV4IDk4YTEyZGE4MDIxNC4u MzFiNWU5NGQ0NjFhIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCisrKyBiL3Zp cnQva3ZtL2d1ZXN0X21lbWZkLmMKQEAgLTEzLDE0ICsxMyw0NCBAQCBzdHJ1Y3Qga3ZtX2dtZW0g ewogCXN0cnVjdCBsaXN0X2hlYWQgZW50cnk7CiB9OwogCisjZGVmaW5lIE5SX1BBR0VTX1BFUl9Q TUQgKDEgPDwgUE1EX09SREVSKQorCitzdGF0aWMgc3RydWN0IGZvbGlvICprdm1fZ21lbV9nZXRf aHVnZV9mb2xpbyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBwZ29mZl90IGluZGV4KQoreworCXVuc2ln bmVkIGxvbmcgaHVnZV9pbmRleCA9IHJvdW5kX2Rvd24oaW5kZXgsIE5SX1BBR0VTX1BFUl9QTUQp OworCXVuc2lnbmVkIGxvbmcgZmxhZ3MgPSAodW5zaWduZWQgbG9uZylpbm9kZS0+aV9wcml2YXRl OworCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nICA9IGlub2RlLT5pX21hcHBpbmc7CisJ Z2ZwX3QgZ2ZwID0gbWFwcGluZ19nZnBfbWFzayhtYXBwaW5nKTsKKwlzdHJ1Y3QgZm9saW8gKmZv bGlvOworCisJaWYgKCEoZmxhZ3MgJiBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBBR0UpKQor CQlyZXR1cm4gTlVMTDsKKworCWlmIChmaWxlbWFwX3JhbmdlX2hhc19wYWdlKG1hcHBpbmcsIGh1 Z2VfaW5kZXggPDwgUEFHRV9TSElGVCwKKwkJCQkgICAoaHVnZV9pbmRleCArIE5SX1BBR0VTX1BF Ul9QTUQgLSAxKSA8PCBQQUdFX1NISUZUKSkKKwkJcmV0dXJuIE5VTEw7CisKKwlmb2xpbyA9IGZp bGVtYXBfYWxsb2NfZm9saW8oZ2ZwLCBQTURfT1JERVIpOworCWlmICghZm9saW8pCisJCXJldHVy biBOVUxMOworCisJaWYgKGZpbGVtYXBfYWRkX2ZvbGlvKG1hcHBpbmcsIGZvbGlvLCBodWdlX2lu ZGV4LCBnZnApKSB7CisJCWZvbGlvX3B1dChmb2xpbyk7CisJCXJldHVybiBOVUxMOworCX0KKwly ZXR1cm4gZm9saW87Cit9CisKIHN0YXRpYyBzdHJ1Y3QgZm9saW8gKmt2bV9nbWVtX2dldF9mb2xp byhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBwZ29mZl90IGluZGV4KQogewogCXN0cnVjdCBmb2xpbyAq Zm9saW87CiAKLQkvKiBUT0RPOiBTdXBwb3J0IGh1Z2UgcGFnZXMuICovCi0JZm9saW8gPSBmaWxl bWFwX2dyYWJfZm9saW8oaW5vZGUtPmlfbWFwcGluZywgaW5kZXgpOwotCWlmIChJU19FUlJfT1Jf TlVMTChmb2xpbykpCi0JCXJldHVybiBOVUxMOworCWZvbGlvID0ga3ZtX2dtZW1fZ2V0X2h1Z2Vf Zm9saW8oaW5vZGUsIGluZGV4KTsKKwlpZiAoIWZvbGlvKSB7CisJCWZvbGlvID0gZmlsZW1hcF9n cmFiX2ZvbGlvKGlub2RlLT5pX21hcHBpbmcsIGluZGV4KTsKKwkJaWYgKElTX0VSUl9PUl9OVUxM KGZvbGlvKSkKKwkJCXJldHVybiBOVUxMOworCX0KIAogCS8qCiAJICogVXNlIHRoZSB1cC10by1k YXRlIGZsYWcgdG8gdHJhY2sgd2hldGhlciBvciBub3QgdGhlIG1lbW9yeSBoYXMgYmVlbgpAQCAt MzczLDYgKzQwMyw3IEBAIHN0YXRpYyBpbnQgX19rdm1fZ21lbV9jcmVhdGUoc3RydWN0IGt2bSAq a3ZtLCBsb2ZmX3Qgc2l6ZSwgdTY0IGZsYWdzKQogCWlub2RlLT5pX21vZGUgfD0gU19JRlJFRzsK IAlpbm9kZS0+aV9zaXplID0gc2l6ZTsKIAltYXBwaW5nX3NldF9nZnBfbWFzayhpbm9kZS0+aV9t YXBwaW5nLCBHRlBfSElHSFVTRVIpOworCW1hcHBpbmdfc2V0X2xhcmdlX2ZvbGlvcyhpbm9kZS0+ aV9tYXBwaW5nKTsKIAltYXBwaW5nX3NldF91bm1vdmFibGUoaW5vZGUtPmlfbWFwcGluZyk7CiAJ LyogVW5tb3ZhYmxlIG1hcHBpbmdzIGFyZSBzdXBwb3NlZCB0byBiZSBtYXJrZWQgdW5ldmljdGFi bGUgYXMgd2VsbC4gKi8KIAlXQVJOX09OX09OQ0UoIW1hcHBpbmdfdW5ldmljdGFibGUoaW5vZGUt PmlfbWFwcGluZykpOwpAQCAtMzk0LDE0ICs0MjUsMTggQEAgc3RhdGljIGludCBfX2t2bV9nbWVt X2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIGxvZmZfdCBzaXplLCB1NjQgZmxhZ3MpCiAKIGludCBr dm1fZ21lbV9jcmVhdGUoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX2NyZWF0ZV9ndWVzdF9t ZW1mZCAqYXJncykKIHsKKwl1NjQgdmFsaWRfZmxhZ3MgPSBLVk1fR1VFU1RfTUVNRkRfQUxMT1df SFVHRVBBR0U7CiAJbG9mZl90IHNpemUgPSBhcmdzLT5zaXplOwogCXU2NCBmbGFncyA9IGFyZ3Mt PmZsYWdzOwotCXU2NCB2YWxpZF9mbGFncyA9IDA7CiAKIAlpZiAoZmxhZ3MgJiB+dmFsaWRfZmxh Z3MpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaWYgKHNpemUgPCAwIHx8ICFQQUdFX0FMSUdORUQo c2l6ZSkpCisJaWYgKHNpemUgPD0gMCB8fCAhUEFHRV9BTElHTkVEKHNpemUpKQorCQlyZXR1cm4g LUVJTlZBTDsKKworCWlmICgoZmxhZ3MgJiBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBBR0Up ICYmCisJICAgICFJU19BTElHTkVEKHNpemUsIFBNRF9TSVpFKSkKIAkJcmV0dXJuIC1FSU5WQUw7 CiAKIAlyZXR1cm4gX19rdm1fZ21lbV9jcmVhdGUoa3ZtLCBzaXplLCBmbGFncyk7CkBAIC01MDEs NyArNTM2LDcgQEAgdm9pZCBrdm1fZ21lbV91bmJpbmQoc3RydWN0IGt2bV9tZW1vcnlfc2xvdCAq c2xvdCkKIGludCBrdm1fZ21lbV9nZXRfcGZuKHN0cnVjdCBrdm0gKmt2bSwgc3RydWN0IGt2bV9t ZW1vcnlfc2xvdCAqc2xvdCwKIAkJICAgICBnZm5fdCBnZm4sIGt2bV9wZm5fdCAqcGZuLCBpbnQg Km1heF9vcmRlcikKIHsKLQlwZ29mZl90IGluZGV4ID0gZ2ZuIC0gc2xvdC0+YmFzZV9nZm4gKyBz bG90LT5nbWVtLnBnb2ZmOworCXBnb2ZmX3QgaW5kZXgsIGh1Z2VfaW5kZXg7CiAJc3RydWN0IGt2 bV9nbWVtICpnbWVtOwogCXN0cnVjdCBmb2xpbyAqZm9saW87CiAJc3RydWN0IHBhZ2UgKnBhZ2U7 CkBAIC01MTQsNiArNTQ5LDcgQEAgaW50IGt2bV9nbWVtX2dldF9wZm4oc3RydWN0IGt2bSAqa3Zt LCBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAogCiAJZ21lbSA9IGZpbGUtPnByaXZhdGVf ZGF0YTsKIAorCWluZGV4ID0gZ2ZuIC0gc2xvdC0+YmFzZV9nZm4gKyBzbG90LT5nbWVtLnBnb2Zm OwogCWlmIChXQVJOX09OX09OQ0UoeGFfbG9hZCgmZ21lbS0+YmluZGluZ3MsIGluZGV4KSAhPSBz bG90KSkgewogCQlyID0gLUVJTzsKIAkJZ290byBvdXRfZnB1dDsKQEAgLTUzMyw5ICs1NjksMjQg QEAgaW50IGt2bV9nbWVtX2dldF9wZm4oc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX21lbW9y eV9zbG90ICpzbG90LAogCXBhZ2UgPSBmb2xpb19maWxlX3BhZ2UoZm9saW8sIGluZGV4KTsKIAog CSpwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKLQlpZiAobWF4X29yZGVyKQorCWlmICghbWF4X29y ZGVyKQorCQlnb3RvIHN1Y2Nlc3M7CisKKwkqbWF4X29yZGVyID0gY29tcG91bmRfb3JkZXIoY29t cG91bmRfaGVhZChwYWdlKSk7CisJaWYgKCEqbWF4X29yZGVyKQorCQlnb3RvIHN1Y2Nlc3M7CisK KwkvKgorCSAqIFRoZSBmb2xpbyBjYW4gYmUgbWFwcGVkIHdpdGggYSBodWdlcGFnZSBpZiBhbmQg b25seSBpZiB0aGUgZm9saW8gaXMKKwkgKiBmdWxseSBjb250YWluZWQgYnkgdGhlIHJhbmdlIHRo ZSBtZW1zbG90IGlzIGJvdW5kIHRvLiAgTm90ZSwgdGhlCisJICogY2FsbGVyIGlzIHJlc3BvbnNp YmxlIGZvciBoYW5kbGluZyBnZm4gYWxpZ25tZW50LCB0aGlzIG9ubHkgZGVhbHMKKwkgKiB3aXRo IHRoZSBmaWxlIGJpbmRpbmcuCisJICovCisJaHVnZV9pbmRleCA9IEFMSUdOKGluZGV4LCAxdWxs IDw8ICptYXhfb3JkZXIpOworCWlmIChodWdlX2luZGV4IDwgQUxJR04oc2xvdC0+Z21lbS5wZ29m ZiwgMXVsbCA8PCAqbWF4X29yZGVyKSB8fAorCSAgICBodWdlX2luZGV4ICsgKDF1bGwgPDwgKm1h eF9vcmRlcikgPiBzbG90LT5nbWVtLnBnb2ZmICsgc2xvdC0+bnBhZ2VzKQogCQkqbWF4X29yZGVy ID0gMDsKLQorc3VjY2VzczoKIAlyID0gMDsKIAogb3V0X3VubG9jazoKZGlmZiAtLWdpdCBhL3Zp cnQva3ZtL2t2bV9tYWluLmMgYi92aXJ0L2t2bS9rdm1fbWFpbi5jCmluZGV4IDVkMWEyZjFiNGU5 NC4uMDcxMWYyYzc1NjY3IDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5jCisrKyBiL3Zp cnQva3ZtL2t2bV9tYWluLmMKQEAgLTQ4ODgsNiArNDg4OCwxMCBAQCBzdGF0aWMgaW50IGt2bV92 bV9pb2N0bF9jaGVja19leHRlbnNpb25fZ2VuZXJpYyhzdHJ1Y3Qga3ZtICprdm0sIGxvbmcgYXJn KQogI2lmZGVmIENPTkZJR19LVk1fUFJJVkFURV9NRU0KIAljYXNlIEtWTV9DQVBfR1VFU1RfTUVN RkQ6CiAJCXJldHVybiAha3ZtIHx8IGt2bV9hcmNoX2hhc19wcml2YXRlX21lbShrdm0pOworCWNh c2UgS1ZNX0NBUF9HVUVTVF9NRU1GRF9IVUdFUEFHRV9QTURfU0laRToKKwkJaWYgKGt2bSAmJiAh a3ZtX2FyY2hfaGFzX3ByaXZhdGVfbWVtKGt2bSkpCisJCQlyZXR1cm4gMDsKKwkJcmV0dXJuIFBN RF9TSVpFOwogI2VuZGlmCiAJZGVmYXVsdDoKIAkJYnJlYWs7CgpiYXNlLWNvbW1pdDogZmNiZWYx ZTVlNWQyYTYwZGFjYWMwZDE2YzA2YWMwMGJlZGFlZmMwZgotLQoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0Cmxp bnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo= 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 Received: from lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id C04DEC4332F for ; Thu, 2 Nov 2023 15:39:08 +0000 (UTC) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.a=rsa-sha256 header.s=20230601 header.b=JY9Ot+wc; dkim-atps=neutral Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4SLp2M0tSfz3ck3 for ; Fri, 3 Nov 2023 02:39:07 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.a=rsa-sha256 header.s=20230601 header.b=JY9Ot+wc; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=flex--seanjc.bounces.google.com (client-ip=2607:f8b0:4864:20::1149; helo=mail-yw1-x1149.google.com; envelope-from=3w8jdzqykdcaoa6jf8ckkcha.8kihejqtll8-9arheopo.kvh67o.knc@flex--seanjc.bounces.google.com; receiver=lists.ozlabs.org) Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4SLp1F6LD4z3cRH for ; Fri, 3 Nov 2023 02:38:07 +1100 (AEDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-5afa86b8d66so14595787b3.3 for ; Thu, 02 Nov 2023 08:38:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698939483; x=1699544283; darn=lists.ozlabs.org; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=JY9Ot+wclJkSxwRJrxDQe9NMoSyUSdkO1kIw8EhvChj1j5IwOHe3ngxoRuM6gZoUZP 9iHOJU7Rg9N4sEXEGZ2NkPqHJ1hm2MxaPbSit1aBE6tupFhgvzGiX4KLdkg6O18K6jig HP9JkO0ys/JauQLx5/vxIV9UZZ0Rr2FUpnoVz6Cpy/OXDM0n2cgsh7+BfH1ebXDNRciK NbXgQD/OkepjXxG7cuNoZ62mVyPh0a2He83f3IxDpDZqmAizSQjeATaVNFPvrQInTYeT b1KCAqRz6RWtPyi5EFg/TFQ5x+TDy1phMj0GbvB37P00W7z3Qtcgyjhyxh4qDe3pVNwc ioUQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698939483; x=1699544283; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=rYloFzOY7oGMF4Fu7pxi/EmVcsPuno5QN9s6+TYfxBZdwFJfgLCPpWemXiUMqg1N+o fqbXzPOw3La3m4K3gB11w0Ws5gmvdWSRrcdF0SPl2/ViHSWVYbgZKrRfjcxT3/okI6FM SObik1QHs64uLefqsVJDZxut/iRTmkU7Dv6RjZfpRgriLjZ2GsRwjTza6Zyt3s/jDjua Et0EnHi2QcReFTydCn+4DIsD4P8c45lNqOOjq1jb/2i2xo/GpsiVvybkhnkvRGii3Yty nDSUYlSKrUd9ufGfGGk+ztP0PhaG7PlYg4jRgORCKbVNJPTkAy/uG3GV3/XqAC9r5uz3 wG5w== X-Gm-Message-State: AOJu0YxowqPSv/lIYKegCjopbpNIp0lJcf4WWdAMSXiEPKFGs+xFOB7M xYdKm3EAl1i1kExI6pNabrctAInYIZM= X-Google-Smtp-Source: AGHT+IEEyjIaBF20Z+W+qpNozhmx7pCgnMaB7hSicNkCqZ1DUoIMtGZcYN59XWhCRCiGJ/+gJuVvphWrNGQ= X-Received: from zagreus.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:5c37]) (user=seanjc job=sendgmr) by 2002:a25:cfca:0:b0:d9a:556d:5f8a with SMTP id f193-20020a25cfca000000b00d9a556d5f8amr360317ybg.12.1698939483567; Thu, 02 Nov 2023 08:38:03 -0700 (PDT) Date: Thu, 2 Nov 2023 08:38:01 -0700 In-Reply-To: Mime-Version: 1.0 References: <20231027182217.3615211-18-seanjc@google.com> <7c0844d8-6f97-4904-a140-abeabeb552c1@intel.com> <92ba7ddd-2bc8-4a8d-bd67-d6614b21914f@intel.com> <4ca2253d-276f-43c5-8e9f-0ded5d5b2779@redhat.com> Message-ID: Subject: Re: [PATCH v13 17/35] KVM: Add transparent hugepage support for dedicated guest memory From: Sean Christopherson To: Paolo Bonzini Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kvm@vger.kernel.org, David Hildenbrand , linux-kernel@vger.kernel.org, linux-mm@kvack.org, Chao Peng , linux-riscv@lists.infradead.org, Isaku Yamahata , Marc Zyngier , Huacai Chen , Xiaoyao Li , "Matthew Wilcox \(Oracle\)" , Wang , Fuad Tabba , Yu Zhang , Maciej Szmigiero , Albert Ou , Vlastimil Babka , Michael Roth , Ackerley Tng , Alexander Viro , Paul Walmsley , kvmarm@lists.linux.dev, linux-arm-kernel@lists.infradead.org, =?utf-8?Q?Micka=C3=ABl_Sala=C3=BCn?= , Isaku Yamahata , Christian Brauner , Quentin Perret , A nup Patel , linux-mips@vger.kernel.org, Oliver Upton , David Matlack , Jarkko Sakkinen , Palmer Dabbelt , "Kirill A . Shutemov" , kvm-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org, Liam Merwick , Andrew Morton , Vishal Annapurve , linuxppc-dev@lists.ozlabs.org, Xu Yilun , Anish Moorthy Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" On Thu, Nov 02, 2023, Paolo Bonzini wrote: > On Wed, Nov 1, 2023 at 11:35=E2=80=AFPM Sean Christopherson wrote: > > > > On Wed, Nov 01, 2023, Paolo Bonzini wrote: > > > On 11/1/23 17:36, Sean Christopherson wrote: > > > > Can you post a fixup patch? It's not clear to me exactly what beha= vior you intend > > > > to end up with. > > > > > > Sure, just this: > > > > > > diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c > > > index 7d1a33c2ad42..34fd070e03d9 100644 > > > --- a/virt/kvm/guest_memfd.c > > > +++ b/virt/kvm/guest_memfd.c > > > @@ -430,10 +430,7 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_= create_guest_memfd *args) > > > { > > > loff_t size =3D args->size; > > > u64 flags =3D args->flags; > > > - u64 valid_flags =3D 0; > > > - > > > - if (IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE)) > > > - valid_flags |=3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > + u64 valid_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; > > > if (flags & ~valid_flags) > > > return -EINVAL; > > > @@ -441,11 +438,9 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_= create_guest_memfd *args) > > > if (size < 0 || !PAGE_ALIGNED(size)) > > > return -EINVAL; > > > -#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > > if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && > > > !IS_ALIGNED(size, HPAGE_PMD_SIZE)) > > > return -EINVAL; > > > -#endif > > > > That won't work, HPAGE_PMD_SIZE is valid only for CONFIG_TRANSPARENT_HU= GEPAGE=3Dy. > > > > #else /* CONFIG_TRANSPARENT_HUGEPAGE */ > > #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; }) > > #define HPAGE_PMD_SIZE ({ BUILD_BUG(); 0; }) >=20 > Would have caught it when actually testing it, I guess. :) It has to > be PMD_SIZE, possibly with >=20 > #ifdef CONFIG_TRANSPARENT_HUGEPAGE > BUILD_BUG_ON(HPAGE_PMD_SIZE !=3D PMD_SIZE); > #endif Yeah, that works for me. Actually, looking that this again, there's not actually a hard dependency o= n THP. A THP-enabled kernel _probably_ gives a higher probability of using hugepa= ges, but mostly because THP selects COMPACTION, and I suppose because using THP = for other allocations reduces overall fragmentation. So rather than honor KVM_GUEST_MEMFD_ALLOW_HUGEPAGE iff THP is enabled, I t= hink we should do the below (I verified KVM can create hugepages with THP=3Dn). = We'll need another capability, but (a) we probably should have that anyways and (= b) it provides a cleaner path to adding PUD-sized hugepage support in the future. And then adjust the tests like so: diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testing= /selftests/kvm/guest_memfd_test.c index c15de9852316..c9f449718fce 100644 --- a/tools/testing/selftests/kvm/guest_memfd_test.c +++ b/tools/testing/selftests/kvm/guest_memfd_test.c @@ -201,6 +201,10 @@ int main(int argc, char *argv[]) =20 TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD)); =20 + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE) && thp_confi= gured()) + TEST_ASSERT_EQ(get_trans_hugepagesz(), + kvm_check_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_P= MD_SIZE)); + page_size =3D getpagesize(); total_size =3D page_size * 4; =20 diff --git a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_tes= t.c b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c index be311944e90a..245901587ed2 100644 --- a/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c +++ b/tools/testing/selftests/kvm/x86_64/private_mem_conversions_test.c @@ -396,7 +396,7 @@ static void test_mem_conversions(enum vm_mem_backing_sr= c_type src_type, uint32_t =20 vm_enable_cap(vm, KVM_CAP_EXIT_HYPERCALL, (1 << KVM_HC_MAP_GPA_RANG= E)); =20 - if (backing_src_can_be_huge(src_type)) + if (kvm_has_cap(KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE)) memfd_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; else memfd_flags =3D 0; -- From: Sean Christopherson Date: Wed, 25 Oct 2023 16:26:41 -0700 Subject: [PATCH] KVM: Add best-effort hugepage support for dedicated guest memory Extend guest_memfd to allow backing guest memory with hugepages. For now, make hugepage utilization best-effort, i.e. fall back to non-huge mappings if a hugepage can't be allocated. Guaranteeing hugepages would require a dedicated memory pool and significantly more complexity and churn.. Require userspace to opt-in via a flag even though it's unlikely real use cases will ever want to use order-0 pages, e.g. to give userspace a safety valve in case hugepage support is buggy, and to allow for easier testing of both paths. Do not take a dependency on CONFIG_TRANSPARENT_HUGEPAGE, as THP enabling primarily deals with userspace page tables, which are explicitly not in play for guest_memfd. Selecting THP does make obtaining hugepages more likely, but only because THP selects CONFIG_COMPACTION. Don't select CONFIG_COMPACTION either, because again it's not a hard dependency. For simplicity, require the guest_memfd size to be a multiple of the hugepage size, e.g. so that KVM doesn't need to do bounds checking when deciding whether or not to allocate a huge folio. When reporting the max order when KVM gets a pfn from guest_memfd, force order-0 pages if the hugepage is not fully contained by the memslot binding, e.g. if userspace requested hugepages but punches a hole in the memslot bindings in order to emulate x86's VGA hole. Signed-off-by: Sean Christopherson --- Documentation/virt/kvm/api.rst | 17 +++++++++ include/uapi/linux/kvm.h | 3 ++ virt/kvm/guest_memfd.c | 69 +++++++++++++++++++++++++++++----- virt/kvm/kvm_main.c | 4 ++ 4 files changed, 84 insertions(+), 9 deletions(-) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rs= t index e82c69d5e755..ccdd5413920d 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -6176,6 +6176,8 @@ and cannot be resized (guest_memfd files do however = support PUNCH_HOLE). __u64 reserved[6]; }; =20 + #define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + Conceptually, the inode backing a guest_memfd file represents physical mem= ory, i.e. is coupled to the virtual machine as a thing, not to a "struct kvm". = The file itself, which is bound to a "struct kvm", is that instance's view of = the @@ -6192,6 +6194,12 @@ most one mapping per page, i.e. binding multiple mem= ory regions to a single guest_memfd range is not allowed (any number of memory regions can be boun= d to a single guest_memfd file, but the bound ranges must not overlap). =20 +If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set in flags, KVM will attempt to all= ocate +and map PMD-size hugepages for the guest_memfd file. This is currently be= st +effort. If KVM_GUEST_MEMFD_ALLOW_HUGEPAGE is set, size must be aligned to= at +least the size reported by KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE (which al= so +enumerates support for KVM_GUEST_MEMFD_ALLOW_HUGEPAGE). + See KVM_SET_USER_MEMORY_REGION2 for additional details. =20 5. The kvm_run structure @@ -8639,6 +8647,15 @@ block sizes is exposed in KVM_CAP_ARM_SUPPORTED_BLOC= K_SIZES as a 64-bit bitmap (each bit describing a block size). The default value is 0, to disable the eager page splitting. =20 + +8.41 KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE +------------------------------------------ + +This is an information-only capability that returns guest_memfd's hugepage= size +for PMD hugepages. Returns '0' if guest_memfd is not supported, or if KVM +doesn't support creating hugepages for guest_memfd. Note, guest_memfd doe= sn't +currently support PUD-sized hugepages. + 9. Known KVM API problems =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D =20 diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 25caee8d1a80..b78d0e3bf22a 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1217,6 +1217,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_MEMORY_FAULT_INFO 231 #define KVM_CAP_MEMORY_ATTRIBUTES 232 #define KVM_CAP_GUEST_MEMFD 233 +#define KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE 234 =20 #ifdef KVM_CAP_IRQ_ROUTING =20 @@ -2303,4 +2304,6 @@ struct kvm_create_guest_memfd { __u64 reserved[6]; }; =20 +#define KVM_GUEST_MEMFD_ALLOW_HUGEPAGE (1ULL << 0) + #endif /* __LINUX_KVM_H */ diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c index 98a12da80214..31b5e94d461a 100644 --- a/virt/kvm/guest_memfd.c +++ b/virt/kvm/guest_memfd.c @@ -13,14 +13,44 @@ struct kvm_gmem { struct list_head entry; }; =20 +#define NR_PAGES_PER_PMD (1 << PMD_ORDER) + +static struct folio *kvm_gmem_get_huge_folio(struct inode *inode, pgoff_t = index) +{ + unsigned long huge_index =3D round_down(index, NR_PAGES_PER_PMD); + unsigned long flags =3D (unsigned long)inode->i_private; + struct address_space *mapping =3D inode->i_mapping; + gfp_t gfp =3D mapping_gfp_mask(mapping); + struct folio *folio; + + if (!(flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE)) + return NULL; + + if (filemap_range_has_page(mapping, huge_index << PAGE_SHIFT, + (huge_index + NR_PAGES_PER_PMD - 1) << PAGE_SHIFT)) + return NULL; + + folio =3D filemap_alloc_folio(gfp, PMD_ORDER); + if (!folio) + return NULL; + + if (filemap_add_folio(mapping, folio, huge_index, gfp)) { + folio_put(folio); + return NULL; + } + return folio; +} + static struct folio *kvm_gmem_get_folio(struct inode *inode, pgoff_t index= ) { struct folio *folio; =20 - /* TODO: Support huge pages. */ - folio =3D filemap_grab_folio(inode->i_mapping, index); - if (IS_ERR_OR_NULL(folio)) - return NULL; + folio =3D kvm_gmem_get_huge_folio(inode, index); + if (!folio) { + folio =3D filemap_grab_folio(inode->i_mapping, index); + if (IS_ERR_OR_NULL(folio)) + return NULL; + } =20 /* * Use the up-to-date flag to track whether or not the memory has been @@ -373,6 +403,7 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t si= ze, u64 flags) inode->i_mode |=3D S_IFREG; inode->i_size =3D size; mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); + mapping_set_large_folios(inode->i_mapping); mapping_set_unmovable(inode->i_mapping); /* Unmovable mappings are supposed to be marked unevictable as well. */ WARN_ON_ONCE(!mapping_unevictable(inode->i_mapping)); @@ -394,14 +425,18 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t = size, u64 flags) =20 int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) { + u64 valid_flags =3D KVM_GUEST_MEMFD_ALLOW_HUGEPAGE; loff_t size =3D args->size; u64 flags =3D args->flags; - u64 valid_flags =3D 0; =20 if (flags & ~valid_flags) return -EINVAL; =20 - if (size < 0 || !PAGE_ALIGNED(size)) + if (size <=3D 0 || !PAGE_ALIGNED(size)) + return -EINVAL; + + if ((flags & KVM_GUEST_MEMFD_ALLOW_HUGEPAGE) && + !IS_ALIGNED(size, PMD_SIZE)) return -EINVAL; =20 return __kvm_gmem_create(kvm, size, flags); @@ -501,7 +536,7 @@ void kvm_gmem_unbind(struct kvm_memory_slot *slot) int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, gfn_t gfn, kvm_pfn_t *pfn, int *max_order) { - pgoff_t index =3D gfn - slot->base_gfn + slot->gmem.pgoff; + pgoff_t index, huge_index; struct kvm_gmem *gmem; struct folio *folio; struct page *page; @@ -514,6 +549,7 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory= _slot *slot, =20 gmem =3D file->private_data; =20 + index =3D gfn - slot->base_gfn + slot->gmem.pgoff; if (WARN_ON_ONCE(xa_load(&gmem->bindings, index) !=3D slot)) { r =3D -EIO; goto out_fput; @@ -533,9 +569,24 @@ int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memor= y_slot *slot, page =3D folio_file_page(folio, index); =20 *pfn =3D page_to_pfn(page); - if (max_order) + if (!max_order) + goto success; + + *max_order =3D compound_order(compound_head(page)); + if (!*max_order) + goto success; + + /* + * The folio can be mapped with a hugepage if and only if the folio is + * fully contained by the range the memslot is bound to. Note, the + * caller is responsible for handling gfn alignment, this only deals + * with the file binding. + */ + huge_index =3D ALIGN(index, 1ull << *max_order); + if (huge_index < ALIGN(slot->gmem.pgoff, 1ull << *max_order) || + huge_index + (1ull << *max_order) > slot->gmem.pgoff + slot->npages) *max_order =3D 0; - +success: r =3D 0; =20 out_unlock: diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 5d1a2f1b4e94..0711f2c75667 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -4888,6 +4888,10 @@ static int kvm_vm_ioctl_check_extension_generic(stru= ct kvm *kvm, long arg) #ifdef CONFIG_KVM_PRIVATE_MEM case KVM_CAP_GUEST_MEMFD: return !kvm || kvm_arch_has_private_mem(kvm); + case KVM_CAP_GUEST_MEMFD_HUGEPAGE_PMD_SIZE: + if (kvm && !kvm_arch_has_private_mem(kvm)) + return 0; + return PMD_SIZE; #endif default: break; base-commit: fcbef1e5e5d2a60dacac0d16c06ac00bedaefc0f -- 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id F317FC4332F for ; Thu, 2 Nov 2023 15:38:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:Message-ID: References:Mime-Version:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=lypzLZ/7A4hU/C77FJWFbUcvJ+DM9eltnCIqUZcoybE=; b=FZYifItSIGd+ULirVm9/rFn9sH 5e5wgJRL2to/zDV1L32AoZqP7J1g5jHnlzk9uGK/50rbCdJpLWFgw49X/gqJIRMl27Vs5FiHbRnE+ LFoxukQlPxzV4Evm7j63y7s3x6XJrUAzGZWIBsxH6r1Vpj/Rwadtdh2kY2K193Acg9WKVRE97OeiO MM49DCEXtPRIq+HzeiPa6jdCRDGVxh7TyYaJdEZuL5BqfqZKuWLVoPqFUZx1E6F4OENQ0fYVCkwFo kip4r3KXly/YgfUVt6ynwy4VJh3KaMnwL3At1cjT2TODnzIAI6q01uVg4o3gqj+RsGuaDUrM0B/M1 cowscskw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qyZlo-009lc8-1z; Thu, 02 Nov 2023 15:38:08 +0000 Received: from mail-yb1-xb49.google.com ([2607:f8b0:4864:20::b49]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qyZll-009lak-0E for linux-arm-kernel@lists.infradead.org; Thu, 02 Nov 2023 15:38:07 +0000 Received: by mail-yb1-xb49.google.com with SMTP id 3f1490d57ef6-da2b87dd614so1331292276.2 for ; Thu, 02 Nov 2023 08:38:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1698939483; x=1699544283; darn=lists.infradead.org; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=yyvXyOflhlAuKgOkWVe9luHYUlMaQTNpIeI8zcJp+y47QUS5KzISilmYWN5RW/p1/1 6s30NUw7NS7JvTZVzujwLYLedRUuvLsbYxvZv/67LgLxlPB54YPgkBmdrc+ViDYKgMcg FTrhBTvip0q3kBzskfLIpIp2S8xkWd4snh2HeTtV9I3ZZHw/uEp8aJ9+ovecz24cTwjP vvCxpCjfDVQRMCsTXK96Gi/fSvOX/j6RF0dU2l4FzcBdAtgFfAjoJMEOOokpDmHWJWKy +zrjkzHMUtfx2SVUfSFhU4HoS+KZgHVRAZWDJmqImblZ4x7YRBBh8tRKvseR/aOo1x39 pVCg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698939483; x=1699544283; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=Djt9nhoFwnRVHKi/ktNpcOC5s8Lv9feOIxZ1Y9JKJMU=; b=vXWAV2NYdeQzLAwyZ5uQ0tsw2rU607phUzlboEYfovCzwtGfbuNOMZvLGJCEJWYYbe lJXcz5lJpNEL0MeF4pVk2qAA+uI53HOwjR24798XqvxugEVXcPM3ZDp8NcpH/uT87SMv +aD6XySkJnBmghHUSXp20GadFPtD8wFQhv6SeL+kqMgJzSLTg3+yiPu0JLHl/zZbyjrv ns+04ZFOq8eC4kbBJtikV8SPnDmiji6Slxo+OTv0wTQ6NiEMZPzCrAbLiu1rA27JJrBy P7hELXW4lc40a2gkdG+1BxP6QL+8rcbDpKQxRg2KNKYUNkgaTiWVecamBUq2pySA8DvV 6Irg== X-Gm-Message-State: AOJu0Yxi0/Uueneug46nwKSk+6C4G4FGTgqRCgfHzGpUyKTb0A0m+i6H xDFVhL+erIuFTbQ+1sCTCsigQUAxgD0= X-Google-Smtp-Source: AGHT+IEEyjIaBF20Z+W+qpNozhmx7pCgnMaB7hSicNkCqZ1DUoIMtGZcYN59XWhCRCiGJ/+gJuVvphWrNGQ= X-Received: from zagreus.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:5c37]) (user=seanjc job=sendgmr) by 2002:a25:cfca:0:b0:d9a:556d:5f8a with SMTP id f193-20020a25cfca000000b00d9a556d5f8amr360317ybg.12.1698939483567; Thu, 02 Nov 2023 08:38:03 -0700 (PDT) Date: Thu, 2 Nov 2023 08:38:01 -0700 In-Reply-To: Mime-Version: 1.0 References: <20231027182217.3615211-18-seanjc@google.com> <7c0844d8-6f97-4904-a140-abeabeb552c1@intel.com> <92ba7ddd-2bc8-4a8d-bd67-d6614b21914f@intel.com> <4ca2253d-276f-43c5-8e9f-0ded5d5b2779@redhat.com> Message-ID: Subject: Re: [PATCH v13 17/35] KVM: Add transparent hugepage support for dedicated guest memory From: Sean Christopherson To: Paolo Bonzini Cc: Xiaoyao Li , Marc Zyngier , Oliver Upton , Huacai Chen , Michael Ellerman , Anup Patel , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexander Viro , Christian Brauner , "Matthew Wilcox (Oracle)" , Andrew Morton , kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, kvm-riscv@lists.infradead.org, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, Xu Yilun , Chao Peng , Fuad Tabba , Jarkko Sakkinen , Anish Moorthy , David Matlack , Yu Zhang , Isaku Yamahata , "=?utf-8?Q?Micka=C3=ABl_Sala=C3=BCn?=" , Vlastimil Babka , Vishal Annapurve , Ackerley Tng , Maciej Szmigiero , David Hildenbrand , Quentin Perret , Michael Roth , Wang , Liam Merwick , Isaku Yamahata , "Kirill A . Shutemov" X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231102_083805_157330_0C6941B6 X-CRM114-Status: GOOD ( 43.42 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gVGh1LCBOb3YgMDIsIDIwMjMsIFBhb2xvIEJvbnppbmkgd3JvdGU6Cj4gT24gV2VkLCBOb3Yg MSwgMjAyMyBhdCAxMTozNeKAr1BNIFNlYW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUu Y29tPiB3cm90ZToKPiA+Cj4gPiBPbiBXZWQsIE5vdiAwMSwgMjAyMywgUGFvbG8gQm9uemluaSB3 cm90ZToKPiA+ID4gT24gMTEvMS8yMyAxNzozNiwgU2VhbiBDaHJpc3RvcGhlcnNvbiB3cm90ZToK PiA+ID4gPiBDYW4geW91IHBvc3QgYSBmaXh1cCBwYXRjaD8gIEl0J3Mgbm90IGNsZWFyIHRvIG1l IGV4YWN0bHkgd2hhdCBiZWhhdmlvciB5b3UgaW50ZW5kCj4gPiA+ID4gdG8gZW5kIHVwIHdpdGgu Cj4gPiA+Cj4gPiA+IFN1cmUsIGp1c3QgdGhpczoKPiA+ID4KPiA+ID4gZGlmZiAtLWdpdCBhL3Zp cnQva3ZtL2d1ZXN0X21lbWZkLmMgYi92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCj4gPiA+IGluZGV4 IDdkMWEzM2MyYWQ0Mi4uMzRmZDA3MGUwM2Q5IDEwMDY0NAo+ID4gPiAtLS0gYS92aXJ0L2t2bS9n dWVzdF9tZW1mZC5jCj4gPiA+ICsrKyBiL3ZpcnQva3ZtL2d1ZXN0X21lbWZkLmMKPiA+ID4gQEAg LTQzMCwxMCArNDMwLDcgQEAgaW50IGt2bV9nbWVtX2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIHN0 cnVjdCBrdm1fY3JlYXRlX2d1ZXN0X21lbWZkICphcmdzKQo+ID4gPiAgewo+ID4gPiAgICAgICBs b2ZmX3Qgc2l6ZSA9IGFyZ3MtPnNpemU7Cj4gPiA+ICAgICAgIHU2NCBmbGFncyA9IGFyZ3MtPmZs YWdzOwo+ID4gPiAtICAgICB1NjQgdmFsaWRfZmxhZ3MgPSAwOwo+ID4gPiAtCj4gPiA+IC0gICAg IGlmIChJU19FTkFCTEVEKENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSkpCj4gPiA+IC0gICAg ICAgICAgICAgdmFsaWRfZmxhZ3MgfD0gS1ZNX0dVRVNUX01FTUZEX0FMTE9XX0hVR0VQQUdFOwo+ ID4gPiArICAgICB1NjQgdmFsaWRfZmxhZ3MgPSBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBB R0U7Cj4gPiA+ICAgICAgIGlmIChmbGFncyAmIH52YWxpZF9mbGFncykKPiA+ID4gICAgICAgICAg ICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ID4gQEAgLTQ0MSwxMSArNDM4LDkgQEAgaW50IGt2bV9n bWVtX2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIHN0cnVjdCBrdm1fY3JlYXRlX2d1ZXN0X21lbWZk ICphcmdzKQo+ID4gPiAgICAgICBpZiAoc2l6ZSA8IDAgfHwgIVBBR0VfQUxJR05FRChzaXplKSkK PiA+ID4gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ID4gLSNpZmRlZiBDT05GSUdf VFJBTlNQQVJFTlRfSFVHRVBBR0UKPiA+ID4gICAgICAgaWYgKChmbGFncyAmIEtWTV9HVUVTVF9N RU1GRF9BTExPV19IVUdFUEFHRSkgJiYKPiA+ID4gICAgICAgICAgICFJU19BTElHTkVEKHNpemUs IEhQQUdFX1BNRF9TSVpFKSkKPiA+ID4gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+ ID4gLSNlbmRpZgo+ID4KPiA+IFRoYXQgd29uJ3Qgd29yaywgSFBBR0VfUE1EX1NJWkUgaXMgdmFs aWQgb25seSBmb3IgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFPXkuCj4gPgo+ID4gI2Vsc2Ug LyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCj4gPiAjZGVmaW5lIEhQQUdFX1BNRF9T SElGVCAoeyBCVUlMRF9CVUcoKTsgMDsgfSkKPiA+ICNkZWZpbmUgSFBBR0VfUE1EX01BU0sgKHsg QlVJTERfQlVHKCk7IDA7IH0pCj4gPiAjZGVmaW5lIEhQQUdFX1BNRF9TSVpFICh7IEJVSUxEX0JV RygpOyAwOyB9KQo+IAo+IFdvdWxkIGhhdmUgY2F1Z2h0IGl0IHdoZW4gYWN0dWFsbHkgdGVzdGlu ZyBpdCwgSSBndWVzcy4gOikgSXQgaGFzIHRvCj4gYmUgUE1EX1NJWkUsIHBvc3NpYmx5IHdpdGgK PiAKPiAjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCj4gQlVJTERfQlVHX09OKEhQ QUdFX1BNRF9TSVpFICE9IFBNRF9TSVpFKTsKPiAjZW5kaWYKClllYWgsIHRoYXQgd29ya3MgZm9y IG1lLgoKQWN0dWFsbHksIGxvb2tpbmcgdGhhdCB0aGlzIGFnYWluLCB0aGVyZSdzIG5vdCBhY3R1 YWxseSBhIGhhcmQgZGVwZW5kZW5jeSBvbiBUSFAuCkEgVEhQLWVuYWJsZWQga2VybmVsIF9wcm9i YWJseV8gIGdpdmVzIGEgaGlnaGVyIHByb2JhYmlsaXR5IG9mIHVzaW5nIGh1Z2VwYWdlcywKYnV0 IG1vc3RseSBiZWNhdXNlIFRIUCBzZWxlY3RzIENPTVBBQ1RJT04sIGFuZCBJIHN1cHBvc2UgYmVj YXVzZSB1c2luZyBUSFAgZm9yCm90aGVyIGFsbG9jYXRpb25zIHJlZHVjZXMgb3ZlcmFsbCBmcmFn bWVudGF0aW9uLgoKU28gcmF0aGVyIHRoYW4gaG9ub3IgS1ZNX0dVRVNUX01FTUZEX0FMTE9XX0hV R0VQQUdFIGlmZiBUSFAgaXMgZW5hYmxlZCwgSSB0aGluawp3ZSBzaG91bGQgZG8gdGhlIGJlbG93 IChJIHZlcmlmaWVkIEtWTSBjYW4gY3JlYXRlIGh1Z2VwYWdlcyB3aXRoIFRIUD1uKS4gIFdlJ2xs Cm5lZWQgYW5vdGhlciBjYXBhYmlsaXR5LCBidXQgKGEpIHdlIHByb2JhYmx5IHNob3VsZCBoYXZl IHRoYXQgYW55d2F5cyBhbmQgKGIpIGl0CnByb3ZpZGVzIGEgY2xlYW5lciBwYXRoIHRvIGFkZGlu ZyBQVUQtc2l6ZWQgaHVnZXBhZ2Ugc3VwcG9ydCBpbiB0aGUgZnV0dXJlLgoKQW5kIHRoZW4gYWRq dXN0IHRoZSB0ZXN0cyBsaWtlIHNvOgoKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRl c3RzL2t2bS9ndWVzdF9tZW1mZF90ZXN0LmMgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0v Z3Vlc3RfbWVtZmRfdGVzdC5jCmluZGV4IGMxNWRlOTg1MjMxNi4uYzlmNDQ5NzE4ZmNlIDEwMDY0 NAotLS0gYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0vZ3Vlc3RfbWVtZmRfdGVzdC5jCisr KyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS9ndWVzdF9tZW1mZF90ZXN0LmMKQEAgLTIw MSw2ICsyMDEsMTAgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIAogICAgICAg IFRFU1RfUkVRVUlSRShrdm1faGFzX2NhcChLVk1fQ0FQX0dVRVNUX01FTUZEKSk7CiAKKyAgICAg ICBpZiAoa3ZtX2hhc19jYXAoS1ZNX0NBUF9HVUVTVF9NRU1GRF9IVUdFUEFHRV9QTURfU0laRSkg JiYgdGhwX2NvbmZpZ3VyZWQoKSkKKyAgICAgICAgICAgICAgIFRFU1RfQVNTRVJUX0VRKGdldF90 cmFuc19odWdlcGFnZXN6KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrdm1fY2hl Y2tfY2FwKEtWTV9DQVBfR1VFU1RfTUVNRkRfSFVHRVBBR0VfUE1EX1NJWkUpKTsKKwogICAgICAg IHBhZ2Vfc2l6ZSA9IGdldHBhZ2VzaXplKCk7CiAgICAgICAgdG90YWxfc2l6ZSA9IHBhZ2Vfc2l6 ZSAqIDQ7CiAKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQv cHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMv a3ZtL3g4Nl82NC9wcml2YXRlX21lbV9jb252ZXJzaW9uc190ZXN0LmMKaW5kZXggYmUzMTE5NDRl OTBhLi4yNDU5MDE1ODdlZDIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2 bS94ODZfNjQvcHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jCisrKyBiL3Rvb2xzL3Rlc3Rp bmcvc2VsZnRlc3RzL2t2bS94ODZfNjQvcHJpdmF0ZV9tZW1fY29udmVyc2lvbnNfdGVzdC5jCkBA IC0zOTYsNyArMzk2LDcgQEAgc3RhdGljIHZvaWQgdGVzdF9tZW1fY29udmVyc2lvbnMoZW51bSB2 bV9tZW1fYmFja2luZ19zcmNfdHlwZSBzcmNfdHlwZSwgdWludDMyX3QKIAogICAgICAgIHZtX2Vu YWJsZV9jYXAodm0sIEtWTV9DQVBfRVhJVF9IWVBFUkNBTEwsICgxIDw8IEtWTV9IQ19NQVBfR1BB X1JBTkdFKSk7CiAKLSAgICAgICBpZiAoYmFja2luZ19zcmNfY2FuX2JlX2h1Z2Uoc3JjX3R5cGUp KQorICAgICAgIGlmIChrdm1faGFzX2NhcChLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BN RF9TSVpFKSkKICAgICAgICAgICAgICAgIG1lbWZkX2ZsYWdzID0gS1ZNX0dVRVNUX01FTUZEX0FM TE9XX0hVR0VQQUdFOwogICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIG1lbWZkX2ZsYWdzID0g MDsKCi0tCkZyb206IFNlYW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUuY29tPgpEYXRl OiBXZWQsIDI1IE9jdCAyMDIzIDE2OjI2OjQxIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gS1ZNOiBB ZGQgYmVzdC1lZmZvcnQgaHVnZXBhZ2Ugc3VwcG9ydCBmb3IgZGVkaWNhdGVkIGd1ZXN0CiBtZW1v cnkKCkV4dGVuZCBndWVzdF9tZW1mZCB0byBhbGxvdyBiYWNraW5nIGd1ZXN0IG1lbW9yeSB3aXRo IGh1Z2VwYWdlcy4gIEZvciBub3csCm1ha2UgaHVnZXBhZ2UgdXRpbGl6YXRpb24gYmVzdC1lZmZv cnQsIGkuZS4gZmFsbCBiYWNrIHRvIG5vbi1odWdlIG1hcHBpbmdzCmlmIGEgaHVnZXBhZ2UgY2Fu J3QgYmUgYWxsb2NhdGVkLiAgR3VhcmFudGVlaW5nIGh1Z2VwYWdlcyB3b3VsZCByZXF1aXJlIGEK ZGVkaWNhdGVkIG1lbW9yeSBwb29sIGFuZCBzaWduaWZpY2FudGx5IG1vcmUgY29tcGxleGl0eSBh bmQgY2h1cm4uLgoKUmVxdWlyZSB1c2Vyc3BhY2UgdG8gb3B0LWluIHZpYSBhIGZsYWcgZXZlbiB0 aG91Z2ggaXQncyB1bmxpa2VseSByZWFsIHVzZQpjYXNlcyB3aWxsIGV2ZXIgd2FudCB0byB1c2Ug b3JkZXItMCBwYWdlcywgZS5nLiB0byBnaXZlIHVzZXJzcGFjZSBhIHNhZmV0eQp2YWx2ZSBpbiBj YXNlIGh1Z2VwYWdlIHN1cHBvcnQgaXMgYnVnZ3ksIGFuZCB0byBhbGxvdyBmb3IgZWFzaWVyIHRl c3RpbmcKb2YgYm90aCBwYXRocy4KCkRvIG5vdCB0YWtlIGEgZGVwZW5kZW5jeSBvbiBDT05GSUdf VFJBTlNQQVJFTlRfSFVHRVBBR0UsIGFzIFRIUCBlbmFibGluZwpwcmltYXJpbHkgZGVhbHMgd2l0 aCB1c2Vyc3BhY2UgcGFnZSB0YWJsZXMsIHdoaWNoIGFyZSBleHBsaWNpdGx5IG5vdCBpbgpwbGF5 IGZvciBndWVzdF9tZW1mZC4gIFNlbGVjdGluZyBUSFAgZG9lcyBtYWtlIG9idGFpbmluZyBodWdl cGFnZXMgbW9yZQpsaWtlbHksIGJ1dCBvbmx5IGJlY2F1c2UgVEhQIHNlbGVjdHMgQ09ORklHX0NP TVBBQ1RJT04uICBEb24ndCBzZWxlY3QKQ09ORklHX0NPTVBBQ1RJT04gZWl0aGVyLCBiZWNhdXNl IGFnYWluIGl0J3Mgbm90IGEgaGFyZCBkZXBlbmRlbmN5LgoKRm9yIHNpbXBsaWNpdHksIHJlcXVp cmUgdGhlIGd1ZXN0X21lbWZkIHNpemUgdG8gYmUgYSBtdWx0aXBsZSBvZiB0aGUKaHVnZXBhZ2Ug c2l6ZSwgZS5nLiBzbyB0aGF0IEtWTSBkb2Vzbid0IG5lZWQgdG8gZG8gYm91bmRzIGNoZWNraW5n IHdoZW4KZGVjaWRpbmcgd2hldGhlciBvciBub3QgdG8gYWxsb2NhdGUgYSBodWdlIGZvbGlvLgoK V2hlbiByZXBvcnRpbmcgdGhlIG1heCBvcmRlciB3aGVuIEtWTSBnZXRzIGEgcGZuIGZyb20gZ3Vl c3RfbWVtZmQsIGZvcmNlCm9yZGVyLTAgcGFnZXMgaWYgdGhlIGh1Z2VwYWdlIGlzIG5vdCBmdWxs eSBjb250YWluZWQgYnkgdGhlIG1lbXNsb3QKYmluZGluZywgZS5nLiBpZiB1c2Vyc3BhY2UgcmVx dWVzdGVkIGh1Z2VwYWdlcyBidXQgcHVuY2hlcyBhIGhvbGUgaW4gdGhlCm1lbXNsb3QgYmluZGlu Z3MgaW4gb3JkZXIgdG8gZW11bGF0ZSB4ODYncyBWR0EgaG9sZS4KClNpZ25lZC1vZmYtYnk6IFNl YW4gQ2hyaXN0b3BoZXJzb24gPHNlYW5qY0Bnb29nbGUuY29tPgotLS0KIERvY3VtZW50YXRpb24v dmlydC9rdm0vYXBpLnJzdCB8IDE3ICsrKysrKysrKwogaW5jbHVkZS91YXBpL2xpbnV4L2t2bS5o ICAgICAgIHwgIDMgKysKIHZpcnQva3ZtL2d1ZXN0X21lbWZkLmMgICAgICAgICB8IDY5ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIHZpcnQva3ZtL2t2bV9tYWluLmMgICAgICAg ICAgICB8ICA0ICsrCiA0IGZpbGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDkgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0IGIvRG9j dW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0CmluZGV4IGU4MmM2OWQ1ZTc1NS4uY2NkZDU0MTM5 MjBkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2FwaS5yc3QKKysrIGIvRG9j dW1lbnRhdGlvbi92aXJ0L2t2bS9hcGkucnN0CkBAIC02MTc2LDYgKzYxNzYsOCBAQCBhbmQgY2Fu bm90IGJlIHJlc2l6ZWQgIChndWVzdF9tZW1mZCBmaWxlcyBkbyBob3dldmVyIHN1cHBvcnQgUFVO Q0hfSE9MRSkuCiAJX191NjQgcmVzZXJ2ZWRbNl07CiAgIH07CiAKKyAgI2RlZmluZSBLVk1fR1VF U1RfTUVNRkRfQUxMT1dfSFVHRVBBR0UgICAgICAgICAoMVVMTCA8PCAwKQorCiBDb25jZXB0dWFs bHksIHRoZSBpbm9kZSBiYWNraW5nIGEgZ3Vlc3RfbWVtZmQgZmlsZSByZXByZXNlbnRzIHBoeXNp Y2FsIG1lbW9yeSwKIGkuZS4gaXMgY291cGxlZCB0byB0aGUgdmlydHVhbCBtYWNoaW5lIGFzIGEg dGhpbmcsIG5vdCB0byBhICJzdHJ1Y3Qga3ZtIi4gIFRoZQogZmlsZSBpdHNlbGYsIHdoaWNoIGlz IGJvdW5kIHRvIGEgInN0cnVjdCBrdm0iLCBpcyB0aGF0IGluc3RhbmNlJ3MgdmlldyBvZiB0aGUK QEAgLTYxOTIsNiArNjE5NCwxMiBAQCBtb3N0IG9uZSBtYXBwaW5nIHBlciBwYWdlLCBpLmUuIGJp bmRpbmcgbXVsdGlwbGUgbWVtb3J5IHJlZ2lvbnMgdG8gYSBzaW5nbGUKIGd1ZXN0X21lbWZkIHJh bmdlIGlzIG5vdCBhbGxvd2VkIChhbnkgbnVtYmVyIG9mIG1lbW9yeSByZWdpb25zIGNhbiBiZSBi b3VuZCB0bwogYSBzaW5nbGUgZ3Vlc3RfbWVtZmQgZmlsZSwgYnV0IHRoZSBib3VuZCByYW5nZXMg bXVzdCBub3Qgb3ZlcmxhcCkuCiAKK0lmIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSBp cyBzZXQgaW4gZmxhZ3MsIEtWTSB3aWxsIGF0dGVtcHQgdG8gYWxsb2NhdGUKK2FuZCBtYXAgUE1E LXNpemUgaHVnZXBhZ2VzIGZvciB0aGUgZ3Vlc3RfbWVtZmQgZmlsZS4gIFRoaXMgaXMgY3VycmVu dGx5IGJlc3QKK2VmZm9ydC4gIElmIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSBpcyBz ZXQsIHNpemUgbXVzdCBiZSBhbGlnbmVkIHRvIGF0CitsZWFzdCB0aGUgc2l6ZSByZXBvcnRlZCBi eSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9TSVpFICh3aGljaCBhbHNvCitlbnVt ZXJhdGVzIHN1cHBvcnQgZm9yIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRSkuCisKIFNl ZSBLVk1fU0VUX1VTRVJfTUVNT1JZX1JFR0lPTjIgZm9yIGFkZGl0aW9uYWwgZGV0YWlscy4KIAog NS4gVGhlIGt2bV9ydW4gc3RydWN0dXJlCkBAIC04NjM5LDYgKzg2NDcsMTUgQEAgYmxvY2sgc2l6 ZXMgaXMgZXhwb3NlZCBpbiBLVk1fQ0FQX0FSTV9TVVBQT1JURURfQkxPQ0tfU0laRVMgYXMgYQog NjQtYml0IGJpdG1hcCAoZWFjaCBiaXQgZGVzY3JpYmluZyBhIGJsb2NrIHNpemUpLiBUaGUgZGVm YXVsdCB2YWx1ZSBpcwogMCwgdG8gZGlzYWJsZSB0aGUgZWFnZXIgcGFnZSBzcGxpdHRpbmcuCiAK KworOC40MSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9TSVpFCistLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVGhpcyBpcyBhbiBpbmZvcm1hdGlv bi1vbmx5IGNhcGFiaWxpdHkgdGhhdCByZXR1cm5zIGd1ZXN0X21lbWZkJ3MgaHVnZXBhZ2Ugc2l6 ZQorZm9yIFBNRCBodWdlcGFnZXMuICBSZXR1cm5zICcwJyBpZiBndWVzdF9tZW1mZCBpcyBub3Qg c3VwcG9ydGVkLCBvciBpZiBLVk0KK2RvZXNuJ3Qgc3VwcG9ydCBjcmVhdGluZyBodWdlcGFnZXMg Zm9yIGd1ZXN0X21lbWZkLiAgTm90ZSwgZ3Vlc3RfbWVtZmQgZG9lc24ndAorY3VycmVudGx5IHN1 cHBvcnQgUFVELXNpemVkIGh1Z2VwYWdlcy4KKwogOS4gS25vd24gS1ZNIEFQSSBwcm9ibGVtcwog PT09PT09PT09PT09PT09PT09PT09PT09PQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGlu dXgva3ZtLmggYi9pbmNsdWRlL3VhcGkvbGludXgva3ZtLmgKaW5kZXggMjVjYWVlOGQxYTgwLi5i NzhkMGUzYmYyMmEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9rdm0uaAorKysgYi9p bmNsdWRlL3VhcGkvbGludXgva3ZtLmgKQEAgLTEyMTcsNiArMTIxNyw3IEBAIHN0cnVjdCBrdm1f cHBjX3Jlc2l6ZV9ocHQgewogI2RlZmluZSBLVk1fQ0FQX01FTU9SWV9GQVVMVF9JTkZPIDIzMQog I2RlZmluZSBLVk1fQ0FQX01FTU9SWV9BVFRSSUJVVEVTIDIzMgogI2RlZmluZSBLVk1fQ0FQX0dV RVNUX01FTUZEIDIzMworI2RlZmluZSBLVk1fQ0FQX0dVRVNUX01FTUZEX0hVR0VQQUdFX1BNRF9T SVpFIDIzNAogCiAjaWZkZWYgS1ZNX0NBUF9JUlFfUk9VVElORwogCkBAIC0yMzAzLDQgKzIzMDQs NiBAQCBzdHJ1Y3Qga3ZtX2NyZWF0ZV9ndWVzdF9tZW1mZCB7CiAJX191NjQgcmVzZXJ2ZWRbNl07 CiB9OwogCisjZGVmaW5lIEtWTV9HVUVTVF9NRU1GRF9BTExPV19IVUdFUEFHRQkJKDFVTEwgPDwg MCkKKwogI2VuZGlmIC8qIF9fTElOVVhfS1ZNX0ggKi8KZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2d1 ZXN0X21lbWZkLmMgYi92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCmluZGV4IDk4YTEyZGE4MDIxNC4u MzFiNWU5NGQ0NjFhIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9ndWVzdF9tZW1mZC5jCisrKyBiL3Zp cnQva3ZtL2d1ZXN0X21lbWZkLmMKQEAgLTEzLDE0ICsxMyw0NCBAQCBzdHJ1Y3Qga3ZtX2dtZW0g ewogCXN0cnVjdCBsaXN0X2hlYWQgZW50cnk7CiB9OwogCisjZGVmaW5lIE5SX1BBR0VTX1BFUl9Q TUQgKDEgPDwgUE1EX09SREVSKQorCitzdGF0aWMgc3RydWN0IGZvbGlvICprdm1fZ21lbV9nZXRf aHVnZV9mb2xpbyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBwZ29mZl90IGluZGV4KQoreworCXVuc2ln bmVkIGxvbmcgaHVnZV9pbmRleCA9IHJvdW5kX2Rvd24oaW5kZXgsIE5SX1BBR0VTX1BFUl9QTUQp OworCXVuc2lnbmVkIGxvbmcgZmxhZ3MgPSAodW5zaWduZWQgbG9uZylpbm9kZS0+aV9wcml2YXRl OworCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nICA9IGlub2RlLT5pX21hcHBpbmc7CisJ Z2ZwX3QgZ2ZwID0gbWFwcGluZ19nZnBfbWFzayhtYXBwaW5nKTsKKwlzdHJ1Y3QgZm9saW8gKmZv bGlvOworCisJaWYgKCEoZmxhZ3MgJiBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBBR0UpKQor CQlyZXR1cm4gTlVMTDsKKworCWlmIChmaWxlbWFwX3JhbmdlX2hhc19wYWdlKG1hcHBpbmcsIGh1 Z2VfaW5kZXggPDwgUEFHRV9TSElGVCwKKwkJCQkgICAoaHVnZV9pbmRleCArIE5SX1BBR0VTX1BF Ul9QTUQgLSAxKSA8PCBQQUdFX1NISUZUKSkKKwkJcmV0dXJuIE5VTEw7CisKKwlmb2xpbyA9IGZp bGVtYXBfYWxsb2NfZm9saW8oZ2ZwLCBQTURfT1JERVIpOworCWlmICghZm9saW8pCisJCXJldHVy biBOVUxMOworCisJaWYgKGZpbGVtYXBfYWRkX2ZvbGlvKG1hcHBpbmcsIGZvbGlvLCBodWdlX2lu ZGV4LCBnZnApKSB7CisJCWZvbGlvX3B1dChmb2xpbyk7CisJCXJldHVybiBOVUxMOworCX0KKwly ZXR1cm4gZm9saW87Cit9CisKIHN0YXRpYyBzdHJ1Y3QgZm9saW8gKmt2bV9nbWVtX2dldF9mb2xp byhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBwZ29mZl90IGluZGV4KQogewogCXN0cnVjdCBmb2xpbyAq Zm9saW87CiAKLQkvKiBUT0RPOiBTdXBwb3J0IGh1Z2UgcGFnZXMuICovCi0JZm9saW8gPSBmaWxl bWFwX2dyYWJfZm9saW8oaW5vZGUtPmlfbWFwcGluZywgaW5kZXgpOwotCWlmIChJU19FUlJfT1Jf TlVMTChmb2xpbykpCi0JCXJldHVybiBOVUxMOworCWZvbGlvID0ga3ZtX2dtZW1fZ2V0X2h1Z2Vf Zm9saW8oaW5vZGUsIGluZGV4KTsKKwlpZiAoIWZvbGlvKSB7CisJCWZvbGlvID0gZmlsZW1hcF9n cmFiX2ZvbGlvKGlub2RlLT5pX21hcHBpbmcsIGluZGV4KTsKKwkJaWYgKElTX0VSUl9PUl9OVUxM KGZvbGlvKSkKKwkJCXJldHVybiBOVUxMOworCX0KIAogCS8qCiAJICogVXNlIHRoZSB1cC10by1k YXRlIGZsYWcgdG8gdHJhY2sgd2hldGhlciBvciBub3QgdGhlIG1lbW9yeSBoYXMgYmVlbgpAQCAt MzczLDYgKzQwMyw3IEBAIHN0YXRpYyBpbnQgX19rdm1fZ21lbV9jcmVhdGUoc3RydWN0IGt2bSAq a3ZtLCBsb2ZmX3Qgc2l6ZSwgdTY0IGZsYWdzKQogCWlub2RlLT5pX21vZGUgfD0gU19JRlJFRzsK IAlpbm9kZS0+aV9zaXplID0gc2l6ZTsKIAltYXBwaW5nX3NldF9nZnBfbWFzayhpbm9kZS0+aV9t YXBwaW5nLCBHRlBfSElHSFVTRVIpOworCW1hcHBpbmdfc2V0X2xhcmdlX2ZvbGlvcyhpbm9kZS0+ aV9tYXBwaW5nKTsKIAltYXBwaW5nX3NldF91bm1vdmFibGUoaW5vZGUtPmlfbWFwcGluZyk7CiAJ LyogVW5tb3ZhYmxlIG1hcHBpbmdzIGFyZSBzdXBwb3NlZCB0byBiZSBtYXJrZWQgdW5ldmljdGFi bGUgYXMgd2VsbC4gKi8KIAlXQVJOX09OX09OQ0UoIW1hcHBpbmdfdW5ldmljdGFibGUoaW5vZGUt PmlfbWFwcGluZykpOwpAQCAtMzk0LDE0ICs0MjUsMTggQEAgc3RhdGljIGludCBfX2t2bV9nbWVt X2NyZWF0ZShzdHJ1Y3Qga3ZtICprdm0sIGxvZmZfdCBzaXplLCB1NjQgZmxhZ3MpCiAKIGludCBr dm1fZ21lbV9jcmVhdGUoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX2NyZWF0ZV9ndWVzdF9t ZW1mZCAqYXJncykKIHsKKwl1NjQgdmFsaWRfZmxhZ3MgPSBLVk1fR1VFU1RfTUVNRkRfQUxMT1df SFVHRVBBR0U7CiAJbG9mZl90IHNpemUgPSBhcmdzLT5zaXplOwogCXU2NCBmbGFncyA9IGFyZ3Mt PmZsYWdzOwotCXU2NCB2YWxpZF9mbGFncyA9IDA7CiAKIAlpZiAoZmxhZ3MgJiB+dmFsaWRfZmxh Z3MpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaWYgKHNpemUgPCAwIHx8ICFQQUdFX0FMSUdORUQo c2l6ZSkpCisJaWYgKHNpemUgPD0gMCB8fCAhUEFHRV9BTElHTkVEKHNpemUpKQorCQlyZXR1cm4g LUVJTlZBTDsKKworCWlmICgoZmxhZ3MgJiBLVk1fR1VFU1RfTUVNRkRfQUxMT1dfSFVHRVBBR0Up ICYmCisJICAgICFJU19BTElHTkVEKHNpemUsIFBNRF9TSVpFKSkKIAkJcmV0dXJuIC1FSU5WQUw7 CiAKIAlyZXR1cm4gX19rdm1fZ21lbV9jcmVhdGUoa3ZtLCBzaXplLCBmbGFncyk7CkBAIC01MDEs NyArNTM2LDcgQEAgdm9pZCBrdm1fZ21lbV91bmJpbmQoc3RydWN0IGt2bV9tZW1vcnlfc2xvdCAq c2xvdCkKIGludCBrdm1fZ21lbV9nZXRfcGZuKHN0cnVjdCBrdm0gKmt2bSwgc3RydWN0IGt2bV9t ZW1vcnlfc2xvdCAqc2xvdCwKIAkJICAgICBnZm5fdCBnZm4sIGt2bV9wZm5fdCAqcGZuLCBpbnQg Km1heF9vcmRlcikKIHsKLQlwZ29mZl90IGluZGV4ID0gZ2ZuIC0gc2xvdC0+YmFzZV9nZm4gKyBz bG90LT5nbWVtLnBnb2ZmOworCXBnb2ZmX3QgaW5kZXgsIGh1Z2VfaW5kZXg7CiAJc3RydWN0IGt2 bV9nbWVtICpnbWVtOwogCXN0cnVjdCBmb2xpbyAqZm9saW87CiAJc3RydWN0IHBhZ2UgKnBhZ2U7 CkBAIC01MTQsNiArNTQ5LDcgQEAgaW50IGt2bV9nbWVtX2dldF9wZm4oc3RydWN0IGt2bSAqa3Zt LCBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAogCiAJZ21lbSA9IGZpbGUtPnByaXZhdGVf ZGF0YTsKIAorCWluZGV4ID0gZ2ZuIC0gc2xvdC0+YmFzZV9nZm4gKyBzbG90LT5nbWVtLnBnb2Zm OwogCWlmIChXQVJOX09OX09OQ0UoeGFfbG9hZCgmZ21lbS0+YmluZGluZ3MsIGluZGV4KSAhPSBz bG90KSkgewogCQlyID0gLUVJTzsKIAkJZ290byBvdXRfZnB1dDsKQEAgLTUzMyw5ICs1NjksMjQg QEAgaW50IGt2bV9nbWVtX2dldF9wZm4oc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX21lbW9y eV9zbG90ICpzbG90LAogCXBhZ2UgPSBmb2xpb19maWxlX3BhZ2UoZm9saW8sIGluZGV4KTsKIAog CSpwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKLQlpZiAobWF4X29yZGVyKQorCWlmICghbWF4X29y ZGVyKQorCQlnb3RvIHN1Y2Nlc3M7CisKKwkqbWF4X29yZGVyID0gY29tcG91bmRfb3JkZXIoY29t cG91bmRfaGVhZChwYWdlKSk7CisJaWYgKCEqbWF4X29yZGVyKQorCQlnb3RvIHN1Y2Nlc3M7CisK KwkvKgorCSAqIFRoZSBmb2xpbyBjYW4gYmUgbWFwcGVkIHdpdGggYSBodWdlcGFnZSBpZiBhbmQg b25seSBpZiB0aGUgZm9saW8gaXMKKwkgKiBmdWxseSBjb250YWluZWQgYnkgdGhlIHJhbmdlIHRo ZSBtZW1zbG90IGlzIGJvdW5kIHRvLiAgTm90ZSwgdGhlCisJICogY2FsbGVyIGlzIHJlc3BvbnNp YmxlIGZvciBoYW5kbGluZyBnZm4gYWxpZ25tZW50LCB0aGlzIG9ubHkgZGVhbHMKKwkgKiB3aXRo IHRoZSBmaWxlIGJpbmRpbmcuCisJICovCisJaHVnZV9pbmRleCA9IEFMSUdOKGluZGV4LCAxdWxs IDw8ICptYXhfb3JkZXIpOworCWlmIChodWdlX2luZGV4IDwgQUxJR04oc2xvdC0+Z21lbS5wZ29m ZiwgMXVsbCA8PCAqbWF4X29yZGVyKSB8fAorCSAgICBodWdlX2luZGV4ICsgKDF1bGwgPDwgKm1h eF9vcmRlcikgPiBzbG90LT5nbWVtLnBnb2ZmICsgc2xvdC0+bnBhZ2VzKQogCQkqbWF4X29yZGVy ID0gMDsKLQorc3VjY2VzczoKIAlyID0gMDsKIAogb3V0X3VubG9jazoKZGlmZiAtLWdpdCBhL3Zp cnQva3ZtL2t2bV9tYWluLmMgYi92aXJ0L2t2bS9rdm1fbWFpbi5jCmluZGV4IDVkMWEyZjFiNGU5 NC4uMDcxMWYyYzc1NjY3IDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5jCisrKyBiL3Zp cnQva3ZtL2t2bV9tYWluLmMKQEAgLTQ4ODgsNiArNDg4OCwxMCBAQCBzdGF0aWMgaW50IGt2bV92 bV9pb2N0bF9jaGVja19leHRlbnNpb25fZ2VuZXJpYyhzdHJ1Y3Qga3ZtICprdm0sIGxvbmcgYXJn KQogI2lmZGVmIENPTkZJR19LVk1fUFJJVkFURV9NRU0KIAljYXNlIEtWTV9DQVBfR1VFU1RfTUVN RkQ6CiAJCXJldHVybiAha3ZtIHx8IGt2bV9hcmNoX2hhc19wcml2YXRlX21lbShrdm0pOworCWNh c2UgS1ZNX0NBUF9HVUVTVF9NRU1GRF9IVUdFUEFHRV9QTURfU0laRToKKwkJaWYgKGt2bSAmJiAh a3ZtX2FyY2hfaGFzX3ByaXZhdGVfbWVtKGt2bSkpCisJCQlyZXR1cm4gMDsKKwkJcmV0dXJuIFBN RF9TSVpFOwogI2VuZGlmCiAJZGVmYXVsdDoKIAkJYnJlYWs7CgpiYXNlLWNvbW1pdDogZmNiZWYx ZTVlNWQyYTYwZGFjYWMwZDE2YzA2YWMwMGJlZGFlZmMwZgotLQoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxp c3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZy YWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=