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 71E94C7115C for ; Wed, 25 Jun 2025 09:50:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type:In-Reply-To:From:References:Cc:To:Subject:MIME-Version:Date: Message-ID:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=c9eJXWiLkEHbzhuAnPgypPWcb3z11lz3Pujb6AiAmuc=; b=Et1J552ZZp0p3fo0ZpfVWv90ev cI4yQmrX1/ZjL0HEhEGuvBii+0BvsRwztndk/WfQTaRAwc5jaCaZG1+m7/dlAGNfZ3vMX3UKSlBv5 2UzTQrvBgk3J4c/OP+EODp35JpyCteaYSu6g2G9A/G2qLjUtCgcxgnuhH5KBX5qeixBPl/vyEUgmS lsxCRaLUKIkeTXKjqdLOzQPKvvV3dpkmc4ckgiEfmJgk9VXe5OTTICA1M2EBv1FE5CL9/Zes8BCoo QSXiOrNvMi0MlZRxXh71a8W16+yvUGT7jOwkdMLa8w01kpshUE07GlI1by5wR5yGaVGMP452j5m5o NnnzSmTg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uUMlm-00000008BeM-3qz6; Wed, 25 Jun 2025 09:50:18 +0000 Received: from desiato.infradead.org ([2001:8b0:10b:1:d65d:64ff:fe57:4e05]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1uULkz-000000080kf-3aFp for linux-arm-kernel@bombadil.infradead.org; Wed, 25 Jun 2025 08:45:26 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=Content-Transfer-Encoding:Content-Type :In-Reply-To:From:References:Cc:To:Subject:MIME-Version:Date:Message-ID: Sender:Reply-To:Content-ID:Content-Description; bh=c9eJXWiLkEHbzhuAnPgypPWcb3z11lz3Pujb6AiAmuc=; b=ZG4tglZDosaNHNAqucjoarx37Z 9bHTOfYvgoYQg3bOrejPMd/rCgKegIj0854B8c7GbxBgFRzo5phW4Iz80oBmwDPHRWjmcYCoChXrj hD5bwO5Q2VW5AH0mym2EyPO5JU5OAGUvXJz26Vf912+zV0jGUMYR1C04w3P3wHSubzEHKD5LPv2r5 ET8vqPwkjyVh83dQUehWYTsjjbAUurXeS+WfmAL1bQhP2VPWj/CeBANXix9LOYdpnGgo0W0B/tTRR 7quNa1hIryu1I7wNDR91THvTHhEr58VUA8JxHVeS3AiR5WR3IGHWCsJET7Zn3eGsq+is4nG4HI8HW NoDOTTiw==; Received: from out-183.mta0.migadu.com ([91.218.175.183]) by desiato.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1uULkw-00000005hPh-0TVy for linux-arm-kernel@lists.infradead.org; Wed, 25 Jun 2025 08:45:24 +0000 Message-ID: DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1750841102; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=c9eJXWiLkEHbzhuAnPgypPWcb3z11lz3Pujb6AiAmuc=; b=G4CAHzSj6ghduZghtJvd0SSnHNyQgbjvNmbKL8+wxYzsjj++dTHT9bjPssGm42SDZYXT4m fFuuOiQUmw9TdQ9A4K1i4Z1XZY1qhpB07s/HL0NajUB1FdmvfYUf1l9v0vG+M2F6U8Cvr0 LiDZ6A36AoDyGYUoU4WVXGpL1ELKOyI= Date: Wed, 25 Jun 2025 16:44:47 +0800 MIME-Version: 1.0 Subject: Re: [PATCH v4 3/4] mm: Support batched unmap for lazyfree large folios during reclamation Content-Language: en-US To: David Hildenbrand Cc: 21cnbao@gmail.com, akpm@linux-foundation.org, baolin.wang@linux.alibaba.com, chrisl@kernel.org, kasong@tencent.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-riscv@lists.infradead.org, lorenzo.stoakes@oracle.com, ryan.roberts@arm.com, v-songbaohua@oppo.com, x86@kernel.org, ying.huang@intel.com, zhengtangquan@oppo.com, Lance Yang References: <20250624152654.38145-1-ioworker0@gmail.com> <2c19a6cf-0b42-477b-a672-ed8c1edd4267@redhat.com> X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. From: Lance Yang In-Reply-To: <2c19a6cf-0b42-477b-a672-ed8c1edd4267@redhat.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250625_094522_595818_E0C99F9E X-CRM114-Status: GOOD ( 30.62 ) 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: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On 2025/6/24 23:34, David Hildenbrand wrote: > On 24.06.25 17:26, Lance Yang wrote: >> On 2025/6/24 20:55, David Hildenbrand wrote: >>> On 14.02.25 10:30, Barry Song wrote: >>>> From: Barry Song >> [...] >>>> diff --git a/mm/rmap.c b/mm/rmap.c >>>> index 89e51a7a9509..8786704bd466 100644 >>>> --- a/mm/rmap.c >>>> +++ b/mm/rmap.c >>>> @@ -1781,6 +1781,25 @@ void folio_remove_rmap_pud(struct folio *folio, >>>> struct page *page, >>>>    #endif >>>>    } >>>> +/* We support batch unmapping of PTEs for lazyfree large folios */ >>>> +static inline bool can_batch_unmap_folio_ptes(unsigned long addr, >>>> +            struct folio *folio, pte_t *ptep) >>>> +{ >>>> +    const fpb_t fpb_flags = FPB_IGNORE_DIRTY | FPB_IGNORE_SOFT_DIRTY; >>>> +    int max_nr = folio_nr_pages(folio); >>> >>> Let's assume we have the first page of a folio mapped at the last page >>> table entry in our page table. >> >> Good point. I'm curious if it is something we've seen in practice ;) > > I challenge you to write a reproducer :P I assume it might be doable > through simple mremap(). Yes! The scenario is indeed reproducible from userspace ;p First, I get a 64KB folio by allocating a large anonymous mapping and advising the kernel with madvise(MADV_HUGEPAGE). After faulting in the pages, /proc/self/pagemap confirms the PFNs are contiguous. Then, the key is to use mremap() with MREMAP_FIXED to move the folio to a virtual address that crosses a PMD boundary. Doing so ensures the physically contiguous folio is mapped by PTEs from two different page tables. The C reproducer is attached. It was tested on a system with 64KB mTHP enabled (in madvise mode). Please correct me if I'm wrong ;) ``` #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #define PAGE_SIZE ((size_t)sysconf(_SC_PAGESIZE)) #define FOLIO_SIZE (64 * 1024) #define NUM_PAGES_IN_FOLIO (FOLIO_SIZE / PAGE_SIZE) #define PMD_SIZE (2 * 1024 * 1024) int get_pagemap_entry(uint64_t *entry, int pagemap_fd, uintptr_t vaddr) { size_t offset = (vaddr / PAGE_SIZE) * sizeof(uint64_t); if (pread(pagemap_fd, entry, sizeof(uint64_t), offset) != sizeof(uint64_t)) { perror("pread pagemap"); return -1; } return 0; } int is_page_present(uint64_t entry) { return (entry >> 63) & 1; } uint64_t get_pfn(uint64_t entry) { return entry & ((1ULL << 55) - 1); } bool verify_contiguity(int pagemap_fd, uintptr_t vaddr, size_t size, const char *label) { printf("\n--- Verifying Contiguity for: %s at 0x%lx ---\n", label, vaddr); printf("Page | Virtual Address | Present | PFN (Physical) | Contiguous?\n"); printf("-----+---------------------------+---------+--------------------+-------------\n"); uint64_t first_pfn = 0; bool is_contiguous = true; int num_pages = size / PAGE_SIZE; for (int i = 0; i < num_pages; ++i) { uintptr_t current_vaddr = vaddr + i * PAGE_SIZE; uint64_t pagemap_entry; if (get_pagemap_entry(&pagemap_entry, pagemap_fd, current_vaddr) != 0) { is_contiguous = false; break; } if (!is_page_present(pagemap_entry)) { printf(" %2d | 0x%016lx | No | N/A | Error\n", i, current_vaddr); is_contiguous = false; continue; } uint64_t pfn = get_pfn(pagemap_entry); char contiguous_str[4] = "Yes"; if (i == 0) { first_pfn = pfn; } else { if (pfn != first_pfn + i) { strcpy(contiguous_str, "No!"); is_contiguous = false; } } printf(" %2d | 0x%016lx | Yes | 0x%-16lx | %s\n", i, current_vaddr, pfn, contiguous_str); } if (is_contiguous) { printf("Verification PASSED: PFNs are contiguous for %s.\n", label); } else { printf("Verification FAILED: PFNs are NOT contiguous for %s.\n", label); } return is_contiguous; } int main(void) { printf("--- Folio-across-PMD-boundary reproducer ---\n"); printf("Page size: %zu KB, Folio size: %zu KB, PMD coverage: %zu MB\n", PAGE_SIZE / 1024, FOLIO_SIZE / 1024, PMD_SIZE / (1024 * 1024)); size_t source_size = 4 * 1024 * 1024; void *source_addr = mmap(NULL, source_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if (source_addr == MAP_FAILED) { perror("mmap source"); exit(EXIT_FAILURE); } printf("\n1. Source memory mapped at: %p\n", source_addr); if (madvise(source_addr, source_size, MADV_HUGEPAGE) != 0) { perror("madvise MADV_HUGEPAGE"); } printf("2. Advised kernel to use large folios (MADV_HUGEPAGE).\n"); memset(source_addr, 'A', source_size); printf("3. Faulted in source pages.\n"); int pagemap_fd = open("/proc/self/pagemap", O_RDONLY); if (pagemap_fd < 0) { perror("open /proc/self/pagemap"); exit(EXIT_FAILURE); } if (!verify_contiguity(pagemap_fd, (uintptr_t)source_addr, FOLIO_SIZE, "Source Address (pre-mremap)")) { fprintf(stderr, "\nInitial folio allocation failed. Cannot proceed.\n"); close(pagemap_fd); munmap(source_addr, source_size); exit(EXIT_FAILURE); } uintptr_t search_base = 0x10000000000UL; uintptr_t pmd_boundary = (search_base + PMD_SIZE) & ~(PMD_SIZE - 1); uintptr_t target_vaddr = pmd_boundary - PAGE_SIZE; printf("\n5. Calculated target address to be 0x%lx\n", target_vaddr); munmap((void *)target_vaddr, FOLIO_SIZE); void *new_addr = mremap(source_addr, FOLIO_SIZE, FOLIO_SIZE, MREMAP_MAYMOVE | MREMAP_FIXED, (void *)target_vaddr); if (new_addr == MAP_FAILED) { perror("mremap"); close(pagemap_fd); exit(EXIT_FAILURE); } printf("6. Successfully mremap'd %zu KB to 0x%lx.\n", FOLIO_SIZE / 1024, (uintptr_t)new_addr); bool final_success = verify_contiguity(pagemap_fd, (uintptr_t)new_addr, FOLIO_SIZE, "Target Address (post-mremap)"); printf("\n--- Final Conclusion ---\n"); if (final_success) { printf("✅ SUCCESS: The folio's pages remained physically contiguous after remapping to a PMD-crossing virtual address.\n"); printf(" The reproducer successfully created the desired edge-case memory layout.\n"); } else { printf("❌ UNEXPECTED FAILURE: The pages were not contiguous after mremap.\n"); } close(pagemap_fd); munmap(new_addr, FOLIO_SIZE); return 0; } ``` $ a.out ``` --- Folio-across-PMD-boundary reproducer --- Page size: 4 KB, Folio size: 64 KB, PMD coverage: 2 MB 1. Source memory mapped at: 0x7f2e41200000 2. Advised kernel to use large folios (MADV_HUGEPAGE). 3. Faulted in source pages. --- Verifying Contiguity for: Source Address (pre-mremap) at 0x7f2e41200000 --- Page | Virtual Address | Present | PFN (Physical) | Contiguous? -----+---------------------------+---------+--------------------+------------- 0 | 0x00007f2e41200000 | Yes | 0x113aa0 | Yes 1 | 0x00007f2e41201000 | Yes | 0x113aa1 | Yes 2 | 0x00007f2e41202000 | Yes | 0x113aa2 | Yes 3 | 0x00007f2e41203000 | Yes | 0x113aa3 | Yes 4 | 0x00007f2e41204000 | Yes | 0x113aa4 | Yes 5 | 0x00007f2e41205000 | Yes | 0x113aa5 | Yes 6 | 0x00007f2e41206000 | Yes | 0x113aa6 | Yes 7 | 0x00007f2e41207000 | Yes | 0x113aa7 | Yes 8 | 0x00007f2e41208000 | Yes | 0x113aa8 | Yes 9 | 0x00007f2e41209000 | Yes | 0x113aa9 | Yes 10 | 0x00007f2e4120a000 | Yes | 0x113aaa | Yes 11 | 0x00007f2e4120b000 | Yes | 0x113aab | Yes 12 | 0x00007f2e4120c000 | Yes | 0x113aac | Yes 13 | 0x00007f2e4120d000 | Yes | 0x113aad | Yes 14 | 0x00007f2e4120e000 | Yes | 0x113aae | Yes 15 | 0x00007f2e4120f000 | Yes | 0x113aaf | Yes Verification PASSED: PFNs are contiguous for Source Address (pre-mremap). 5. Calculated target address to be 0x100001ff000 6. Successfully mremap'd 64 KB to 0x100001ff000. --- Verifying Contiguity for: Target Address (post-mremap) at 0x100001ff000 --- Page | Virtual Address | Present | PFN (Physical) | Contiguous? -----+---------------------------+---------+--------------------+------------- 0 | 0x00000100001ff000 | Yes | 0x113aa0 | Yes 1 | 0x0000010000200000 | Yes | 0x113aa1 | Yes 2 | 0x0000010000201000 | Yes | 0x113aa2 | Yes 3 | 0x0000010000202000 | Yes | 0x113aa3 | Yes 4 | 0x0000010000203000 | Yes | 0x113aa4 | Yes 5 | 0x0000010000204000 | Yes | 0x113aa5 | Yes 6 | 0x0000010000205000 | Yes | 0x113aa6 | Yes 7 | 0x0000010000206000 | Yes | 0x113aa7 | Yes 8 | 0x0000010000207000 | Yes | 0x113aa8 | Yes 9 | 0x0000010000208000 | Yes | 0x113aa9 | Yes 10 | 0x0000010000209000 | Yes | 0x113aaa | Yes 11 | 0x000001000020a000 | Yes | 0x113aab | Yes 12 | 0x000001000020b000 | Yes | 0x113aac | Yes 13 | 0x000001000020c000 | Yes | 0x113aad | Yes 14 | 0x000001000020d000 | Yes | 0x113aae | Yes 15 | 0x000001000020e000 | Yes | 0x113aaf | Yes Verification PASSED: PFNs are contiguous for Target Address (post-mremap). --- Final Conclusion --- ✅ SUCCESS: The folio's pages remained physically contiguous after remapping to a PMD-crossing virtual address. The reproducer successfully created the desired edge-case memory layout. ``` Thanks, Lance > >> >>> >>> What prevents folio_pte_batch() from reading outside the page table? >> >> Assuming such a scenario is possible, to prevent any chance of an >> out-of-bounds read, how about this change: >> >> diff --git a/mm/rmap.c b/mm/rmap.c >> index fb63d9256f09..9aeae811a38b 100644 >> --- a/mm/rmap.c >> +++ b/mm/rmap.c >> @@ -1852,6 +1852,25 @@ static inline bool >> can_batch_unmap_folio_ptes(unsigned long addr, >>       const fpb_t fpb_flags = FPB_IGNORE_DIRTY | FPB_IGNORE_SOFT_DIRTY; >>       int max_nr = folio_nr_pages(folio); >>       pte_t pte = ptep_get(ptep); >> +    unsigned long end_addr; >> + >> +    /* >> +     * To batch unmap, the entire folio's PTEs must be contiguous >> +     * and mapped within the same PTE page table, which corresponds to >> +     * a single PMD entry. Before calling folio_pte_batch(), which does >> +     * not perform boundary checks itself, we must verify that the >> +     * address range covered by the folio does not cross a PMD boundary. >> +     */ >> +    end_addr = addr + (max_nr * PAGE_SIZE) - 1; >> + >> +    /* >> +     * A fast way to check for a PMD boundary cross is to align both >> +     * the start and end addresses to the PMD boundary and see if they >> +     * are different. If they are, the range spans across at least two >> +     * different PMD-managed regions. >> +     */ >> +    if ((addr & PMD_MASK) != (end_addr & PMD_MASK)) >> +        return false; > > You should not be messing with max_nr = folio_nr_pages(folio) here at > all. folio_pte_batch() takes care of that. > > Also, way too many comments ;) > > You may only batch within a single VMA and within a single page table. > > So simply align the addr up to the next PMD, and make sure it does not > exceed the vma end. > > ALIGN and friends can help avoiding excessive comments. > 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 6E543C7EE32 for ; Wed, 25 Jun 2025 09:50:26 +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-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:Cc:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=VtW06UXxS9oNAWK8u5vlfgkz6j3QAOk8A/nNquUwriQ=; b=QRJwMNN2grcNOs +hGE1gJAK4Zl3B66Gblu1/3oVN5Hqb0pbi77V9nzVELfcN4RMflox41QzFssNFiJZXJOf1XuZMixz sC8ABDM4qextll7DnkH1xu3S2UmTqYRb8b7RnBLnpPoGxKMsv55gl79NKzZUMcAMVZZwwnut/H10y vB1XkP/8C6Xa6aJER1oRqmzRbNQWAUViZ50YzDmN2zdmXrauNBzHobvFYhTXrGN+LwIBqJj+MJhRr DFWIv+1d4EOKEZFpWWNcnpEved0+5CW8JEuuZV+ylTeICfksK/ggR6lL2AtnTZEqgqMYSBURamJu3 zqDb96CDpBFNq58XPUpg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uUMll-00000008Bcl-0pnz; Wed, 25 Jun 2025 09:50:17 +0000 Received: from out-171.mta0.migadu.com ([2001:41d0:1004:224b::ab]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1uULki-000000080ex-39Gf for linux-riscv@lists.infradead.org; Wed, 25 Jun 2025 08:45:10 +0000 Message-ID: DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1750841102; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=c9eJXWiLkEHbzhuAnPgypPWcb3z11lz3Pujb6AiAmuc=; b=G4CAHzSj6ghduZghtJvd0SSnHNyQgbjvNmbKL8+wxYzsjj++dTHT9bjPssGm42SDZYXT4m fFuuOiQUmw9TdQ9A4K1i4Z1XZY1qhpB07s/HL0NajUB1FdmvfYUf1l9v0vG+M2F6U8Cvr0 LiDZ6A36AoDyGYUoU4WVXGpL1ELKOyI= Date: Wed, 25 Jun 2025 16:44:47 +0800 MIME-Version: 1.0 Subject: Re: [PATCH v4 3/4] mm: Support batched unmap for lazyfree large folios during reclamation Content-Language: en-US To: David Hildenbrand Cc: 21cnbao@gmail.com, akpm@linux-foundation.org, baolin.wang@linux.alibaba.com, chrisl@kernel.org, kasong@tencent.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-riscv@lists.infradead.org, lorenzo.stoakes@oracle.com, ryan.roberts@arm.com, v-songbaohua@oppo.com, x86@kernel.org, ying.huang@intel.com, zhengtangquan@oppo.com, Lance Yang References: <20250624152654.38145-1-ioworker0@gmail.com> <2c19a6cf-0b42-477b-a672-ed8c1edd4267@redhat.com> X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. From: Lance Yang In-Reply-To: <2c19a6cf-0b42-477b-a672-ed8c1edd4267@redhat.com> X-Migadu-Flow: FLOW_OUT X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250625_014509_081794_B66F65A0 X-CRM114-Status: GOOD ( 29.65 ) 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org CgpPbiAyMDI1LzYvMjQgMjM6MzQsIERhdmlkIEhpbGRlbmJyYW5kIHdyb3RlOgo+IE9uIDI0LjA2 LjI1IDE3OjI2LCBMYW5jZSBZYW5nIHdyb3RlOgo+PiBPbiAyMDI1LzYvMjQgMjA6NTUsIERhdmlk IEhpbGRlbmJyYW5kIHdyb3RlOgo+Pj4gT24gMTQuMDIuMjUgMTA6MzAsIEJhcnJ5IFNvbmcgd3Jv dGU6Cj4+Pj4gRnJvbTogQmFycnkgU29uZyA8di1zb25nYmFvaHVhQG9wcG8uY29tPgo+PiBbLi4u XQo+Pj4+IGRpZmYgLS1naXQgYS9tbS9ybWFwLmMgYi9tbS9ybWFwLmMKPj4+PiBpbmRleCA4OWU1 MWE3YTk1MDkuLjg3ODY3MDRiZDQ2NiAxMDA2NDQKPj4+PiAtLS0gYS9tbS9ybWFwLmMKPj4+PiAr KysgYi9tbS9ybWFwLmMKPj4+PiBAQCAtMTc4MSw2ICsxNzgxLDI1IEBAIHZvaWQgZm9saW9fcmVt b3ZlX3JtYXBfcHVkKHN0cnVjdCBmb2xpbyAqZm9saW8sCj4+Pj4gc3RydWN0IHBhZ2UgKnBhZ2Us Cj4+Pj4gwqDCoCAjZW5kaWYKPj4+PiDCoMKgIH0KPj4+PiArLyogV2Ugc3VwcG9ydCBiYXRjaCB1 bm1hcHBpbmcgb2YgUFRFcyBmb3IgbGF6eWZyZWUgbGFyZ2UgZm9saW9zICovCj4+Pj4gK3N0YXRp YyBpbmxpbmUgYm9vbCBjYW5fYmF0Y2hfdW5tYXBfZm9saW9fcHRlcyh1bnNpZ25lZCBsb25nIGFk ZHIsCj4+Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IGZvbGlvICpmb2xpbywgcHRl X3QgKnB0ZXApCj4+Pj4gK3sKPj4+PiArwqDCoMKgIGNvbnN0IGZwYl90IGZwYl9mbGFncyA9IEZQ Ql9JR05PUkVfRElSVFkgfCBGUEJfSUdOT1JFX1NPRlRfRElSVFk7Cj4+Pj4gK8KgwqDCoCBpbnQg bWF4X25yID0gZm9saW9fbnJfcGFnZXMoZm9saW8pOwo+Pj4KPj4+IExldCdzIGFzc3VtZSB3ZSBo YXZlIHRoZSBmaXJzdCBwYWdlIG9mIGEgZm9saW8gbWFwcGVkIGF0IHRoZSBsYXN0IHBhZ2UKPj4+ IHRhYmxlIGVudHJ5IGluIG91ciBwYWdlIHRhYmxlLgo+Pgo+PiBHb29kIHBvaW50LiBJJ20gY3Vy aW91cyBpZiBpdCBpcyBzb21ldGhpbmcgd2UndmUgc2VlbiBpbiBwcmFjdGljZSA7KQo+IAo+IEkg Y2hhbGxlbmdlIHlvdSB0byB3cml0ZSBhIHJlcHJvZHVjZXIgOlAgSSBhc3N1bWUgaXQgbWlnaHQg YmUgZG9hYmxlIAo+IHRocm91Z2ggc2ltcGxlIG1yZW1hcCgpLgoKWWVzISBUaGUgc2NlbmFyaW8g aXMgaW5kZWVkIHJlcHJvZHVjaWJsZSBmcm9tIHVzZXJzcGFjZSA7cAoKRmlyc3QsIEkgZ2V0IGEg NjRLQiBmb2xpbyBieSBhbGxvY2F0aW5nIGEgbGFyZ2UgYW5vbnltb3VzIG1hcHBpbmcgYW5kCmFk dmlzaW5nIHRoZSBrZXJuZWwgd2l0aCBtYWR2aXNlKE1BRFZfSFVHRVBBR0UpLiBBZnRlciBmYXVs dGluZyBpbiB0aGUKcGFnZXMsIC9wcm9jL3NlbGYvcGFnZW1hcCBjb25maXJtcyB0aGUgUEZOcyBh cmUgY29udGlndW91cy4KClRoZW4sIHRoZSBrZXkgaXMgdG8gdXNlIG1yZW1hcCgpIHdpdGggTVJF TUFQX0ZJWEVEIHRvIG1vdmUgdGhlIGZvbGlvIHRvCmEgdmlydHVhbCBhZGRyZXNzIHRoYXQgY3Jv c3NlcyBhIFBNRCBib3VuZGFyeS4gRG9pbmcgc28gZW5zdXJlcyB0aGUKcGh5c2ljYWxseSBjb250 aWd1b3VzIGZvbGlvIGlzIG1hcHBlZCBieSBQVEVzIGZyb20gdHdvIGRpZmZlcmVudCBwYWdlCnRh Ymxlcy4KClRoZSBDIHJlcHJvZHVjZXIgaXMgYXR0YWNoZWQuIEl0IHdhcyB0ZXN0ZWQgb24gYSBz eXN0ZW0gd2l0aCA2NEtCIG1USFAKZW5hYmxlZCAoaW4gbWFkdmlzZSBtb2RlKS4gUGxlYXNlIGNv cnJlY3QgbWUgaWYgSSdtIHdyb25nIDspCgoKYGBgCiNkZWZpbmUgX0dOVV9TT1VSQ0UKI2luY2x1 ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdGRsaWIuaD4KI2luY2x1ZGUgPHN0cmluZy5oPgojaW5j bHVkZSA8c3RkaW50Lmg+CiNpbmNsdWRlIDx1bmlzdGQuaD4KI2luY2x1ZGUgPGZjbnRsLmg+CiNp bmNsdWRlIDxlcnJuby5oPgojaW5jbHVkZSA8c3lzL21tYW4uaD4KI2luY2x1ZGUgPHN0ZGJvb2wu aD4KCiNkZWZpbmUgUEFHRV9TSVpFICgoc2l6ZV90KXN5c2NvbmYoX1NDX1BBR0VTSVpFKSkKI2Rl ZmluZSBGT0xJT19TSVpFICg2NCAqIDEwMjQpCiNkZWZpbmUgTlVNX1BBR0VTX0lOX0ZPTElPIChG T0xJT19TSVpFIC8gUEFHRV9TSVpFKQojZGVmaW5lIFBNRF9TSVpFICgyICogMTAyNCAqIDEwMjQp CgppbnQgZ2V0X3BhZ2VtYXBfZW50cnkodWludDY0X3QgKmVudHJ5LCBpbnQgcGFnZW1hcF9mZCwg dWludHB0cl90IHZhZGRyKSB7CiAgICAgc2l6ZV90IG9mZnNldCA9ICh2YWRkciAvIFBBR0VfU0la RSkgKiBzaXplb2YodWludDY0X3QpOwogICAgIGlmIChwcmVhZChwYWdlbWFwX2ZkLCBlbnRyeSwg c2l6ZW9mKHVpbnQ2NF90KSwgb2Zmc2V0KSAhPSAKc2l6ZW9mKHVpbnQ2NF90KSkgewogICAgICAg ICBwZXJyb3IoInByZWFkIHBhZ2VtYXAiKTsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KICAg ICByZXR1cm4gMDsKfQoKaW50IGlzX3BhZ2VfcHJlc2VudCh1aW50NjRfdCBlbnRyeSkgeyByZXR1 cm4gKGVudHJ5ID4+IDYzKSAmIDE7IH0KdWludDY0X3QgZ2V0X3Bmbih1aW50NjRfdCBlbnRyeSkg eyByZXR1cm4gZW50cnkgJiAoKDFVTEwgPDwgNTUpIC0gMSk7IH0KCmJvb2wgdmVyaWZ5X2NvbnRp Z3VpdHkoaW50IHBhZ2VtYXBfZmQsIHVpbnRwdHJfdCB2YWRkciwgc2l6ZV90IHNpemUsIApjb25z dCBjaGFyICpsYWJlbCkgewogICAgIHByaW50ZigiXG4tLS0gVmVyaWZ5aW5nIENvbnRpZ3VpdHkg Zm9yOiAlcyBhdCAweCVseCAtLS1cbiIsIGxhYmVsLCAKdmFkZHIpOwogICAgIHByaW50ZigiUGFn ZSB8ICAgICAgVmlydHVhbCBBZGRyZXNzICAgICAgfCBQcmVzZW50IHwgICBQRk4gCihQaHlzaWNh bCkgICB8IENvbnRpZ3VvdXM/XG4iKTsKICAKcHJpbnRmKCItLS0tLSstLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS1c biIpOwoKICAgICB1aW50NjRfdCBmaXJzdF9wZm4gPSAwOwogICAgIGJvb2wgaXNfY29udGlndW91 cyA9IHRydWU7CiAgICAgaW50IG51bV9wYWdlcyA9IHNpemUgLyBQQUdFX1NJWkU7CgogICAgIGZv ciAoaW50IGkgPSAwOyBpIDwgbnVtX3BhZ2VzOyArK2kpIHsKICAgICAgICAgdWludHB0cl90IGN1 cnJlbnRfdmFkZHIgPSB2YWRkciArIGkgKiBQQUdFX1NJWkU7CiAgICAgICAgIHVpbnQ2NF90IHBh Z2VtYXBfZW50cnk7CgogICAgICAgICBpZiAoZ2V0X3BhZ2VtYXBfZW50cnkoJnBhZ2VtYXBfZW50 cnksIHBhZ2VtYXBfZmQsIApjdXJyZW50X3ZhZGRyKSAhPSAwKSB7CiAgICAgICAgICAgICBpc19j b250aWd1b3VzID0gZmFsc2U7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQoKICAgICAg ICAgaWYgKCFpc19wYWdlX3ByZXNlbnQocGFnZW1hcF9lbnRyeSkpIHsKICAgICAgICAgICAgIHBy aW50ZigiICUyZCAgfCAweCUwMTZseCB8ICAgIE5vICAgfCAgICAgICAgTi9BICAgICAgICAgfCAK RXJyb3JcbiIsIGksIGN1cnJlbnRfdmFkZHIpOwogICAgICAgICAgICAgaXNfY29udGlndW91cyA9 IGZhbHNlOwogICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgIH0KCiAgICAgICAgIHVpbnQ2 NF90IHBmbiA9IGdldF9wZm4ocGFnZW1hcF9lbnRyeSk7CiAgICAgICAgIGNoYXIgY29udGlndW91 c19zdHJbNF0gPSAiWWVzIjsKCiAgICAgICAgIGlmIChpID09IDApIHsKICAgICAgICAgICAgIGZp cnN0X3BmbiA9IHBmbjsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIGlmIChwZm4gIT0g Zmlyc3RfcGZuICsgaSkgewogICAgICAgICAgICAgICAgIHN0cmNweShjb250aWd1b3VzX3N0ciwg Ik5vISIpOwogICAgICAgICAgICAgICAgIGlzX2NvbnRpZ3VvdXMgPSBmYWxzZTsKICAgICAgICAg ICAgIH0KICAgICAgICAgfQoKICAgICAgICAgcHJpbnRmKCIgJTJkICB8IDB4JTAxNmx4IHwgICBZ ZXMgICB8IDB4JS0xNmx4IHwgICAgICVzXG4iLCBpLCAKY3VycmVudF92YWRkciwgcGZuLCBjb250 aWd1b3VzX3N0cik7CiAgICAgfQoKICAgICBpZiAoaXNfY29udGlndW91cykgewogICAgICAgICBw cmludGYoIlZlcmlmaWNhdGlvbiBQQVNTRUQ6IFBGTnMgYXJlIGNvbnRpZ3VvdXMgZm9yICVzLlxu IiwgCmxhYmVsKTsKICAgICB9IGVsc2UgewogICAgICAgICBwcmludGYoIlZlcmlmaWNhdGlvbiBG QUlMRUQ6IFBGTnMgYXJlIE5PVCBjb250aWd1b3VzIGZvciAKJXMuXG4iLCBsYWJlbCk7CiAgICAg fQogICAgIHJldHVybiBpc19jb250aWd1b3VzOwp9CgoKaW50IG1haW4odm9pZCkgewogICAgIHBy aW50ZigiLS0tIEZvbGlvLWFjcm9zcy1QTUQtYm91bmRhcnkgcmVwcm9kdWNlciAtLS1cbiIpOwog ICAgIHByaW50ZigiUGFnZSBzaXplOiAlenUgS0IsIEZvbGlvIHNpemU6ICV6dSBLQiwgUE1EIGNv dmVyYWdlOiAlenUgTUJcbiIsCiAgICAgICAgICAgIFBBR0VfU0laRSAvIDEwMjQsIEZPTElPX1NJ WkUgLyAxMDI0LCBQTURfU0laRSAvICgxMDI0ICogMTAyNCkpOwoKICAgICBzaXplX3Qgc291cmNl X3NpemUgPSA0ICogMTAyNCAqIDEwMjQ7CiAgICAgdm9pZCAqc291cmNlX2FkZHIgPSBtbWFwKE5V TEwsIHNvdXJjZV9zaXplLCBQUk9UX1JFQUQgfCBQUk9UX1dSSVRFLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBNQVBfUFJJVkFURSB8IE1BUF9BTk9OWU1PVVMsIC0xLCAwKTsKICAgICBp ZiAoc291cmNlX2FkZHIgPT0gTUFQX0ZBSUxFRCkgewogICAgICAgICBwZXJyb3IoIm1tYXAgc291 cmNlIik7IGV4aXQoRVhJVF9GQUlMVVJFKTsKICAgICB9CiAgICAgcHJpbnRmKCJcbjEuIFNvdXJj ZSBtZW1vcnkgbWFwcGVkIGF0OiAlcFxuIiwgc291cmNlX2FkZHIpOwoKICAgICBpZiAobWFkdmlz ZShzb3VyY2VfYWRkciwgc291cmNlX3NpemUsIE1BRFZfSFVHRVBBR0UpICE9IDApIHsKICAgICAg ICAgcGVycm9yKCJtYWR2aXNlIE1BRFZfSFVHRVBBR0UiKTsKICAgICB9CiAgICAgcHJpbnRmKCIy LiBBZHZpc2VkIGtlcm5lbCB0byB1c2UgbGFyZ2UgZm9saW9zIChNQURWX0hVR0VQQUdFKS5cbiIp OwoKICAgICBtZW1zZXQoc291cmNlX2FkZHIsICdBJywgc291cmNlX3NpemUpOwogICAgIHByaW50 ZigiMy4gRmF1bHRlZCBpbiBzb3VyY2UgcGFnZXMuXG4iKTsKCiAgICAgaW50IHBhZ2VtYXBfZmQg PSBvcGVuKCIvcHJvYy9zZWxmL3BhZ2VtYXAiLCBPX1JET05MWSk7CiAgICAgaWYgKHBhZ2VtYXBf ZmQgPCAwKSB7CiAgICAgICAgIHBlcnJvcigib3BlbiAvcHJvYy9zZWxmL3BhZ2VtYXAiKTsKICAg ICAgICAgZXhpdChFWElUX0ZBSUxVUkUpOwogICAgIH0KCiAgICAgaWYgKCF2ZXJpZnlfY29udGln dWl0eShwYWdlbWFwX2ZkLCAodWludHB0cl90KXNvdXJjZV9hZGRyLCAKRk9MSU9fU0laRSwgIlNv dXJjZSBBZGRyZXNzIChwcmUtbXJlbWFwKSIpKSB7CiAgICAgICAgIGZwcmludGYoc3RkZXJyLCAi XG5Jbml0aWFsIGZvbGlvIGFsbG9jYXRpb24gZmFpbGVkLiBDYW5ub3QgCnByb2NlZWQuXG4iKTsK ICAgICAgICAgY2xvc2UocGFnZW1hcF9mZCk7CiAgICAgICAgIG11bm1hcChzb3VyY2VfYWRkciwg c291cmNlX3NpemUpOwogICAgICAgICBleGl0KEVYSVRfRkFJTFVSRSk7CiAgICAgfQoKICAgICB1 aW50cHRyX3Qgc2VhcmNoX2Jhc2UgPSAweDEwMDAwMDAwMDAwVUw7CiAgICAgdWludHB0cl90IHBt ZF9ib3VuZGFyeSA9IChzZWFyY2hfYmFzZSArIFBNRF9TSVpFKSAmIH4oUE1EX1NJWkUgLSAxKTsK ICAgICB1aW50cHRyX3QgdGFyZ2V0X3ZhZGRyID0gcG1kX2JvdW5kYXJ5IC0gUEFHRV9TSVpFOwog ICAgIHByaW50ZigiXG41LiBDYWxjdWxhdGVkIHRhcmdldCBhZGRyZXNzIHRvIGJlIDB4JWx4XG4i LCB0YXJnZXRfdmFkZHIpOwoKICAgICBtdW5tYXAoKHZvaWQgKil0YXJnZXRfdmFkZHIsIEZPTElP X1NJWkUpOwogICAgIHZvaWQgKm5ld19hZGRyID0gbXJlbWFwKHNvdXJjZV9hZGRyLCBGT0xJT19T SVpFLCBGT0xJT19TSVpFLCAKTVJFTUFQX01BWU1PVkUgfCBNUkVNQVBfRklYRUQsICh2b2lkICop dGFyZ2V0X3ZhZGRyKTsKICAgICBpZiAobmV3X2FkZHIgPT0gTUFQX0ZBSUxFRCkgewogICAgICAg ICBwZXJyb3IoIm1yZW1hcCIpOwogICAgICAgICBjbG9zZShwYWdlbWFwX2ZkKTsKICAgICAgICAg ZXhpdChFWElUX0ZBSUxVUkUpOwogICAgIH0KICAgICBwcmludGYoIjYuIFN1Y2Nlc3NmdWxseSBt cmVtYXAnZCAlenUgS0IgdG8gMHglbHguXG4iLCBGT0xJT19TSVpFIC8gCjEwMjQsICh1aW50cHRy X3QpbmV3X2FkZHIpOwoKICAgICBib29sIGZpbmFsX3N1Y2Nlc3MgPSB2ZXJpZnlfY29udGlndWl0 eShwYWdlbWFwX2ZkLCAKKHVpbnRwdHJfdCluZXdfYWRkciwgRk9MSU9fU0laRSwgIlRhcmdldCBB ZGRyZXNzIChwb3N0LW1yZW1hcCkiKTsKCiAgICAgcHJpbnRmKCJcbi0tLSBGaW5hbCBDb25jbHVz aW9uIC0tLVxuIik7CiAgICAgaWYgKGZpbmFsX3N1Y2Nlc3MpIHsKICAgICAgICAgcHJpbnRmKCLi nIUgU1VDQ0VTUzogVGhlIGZvbGlvJ3MgcGFnZXMgcmVtYWluZWQgcGh5c2ljYWxseSAKY29udGln dW91cyBhZnRlciByZW1hcHBpbmcgdG8gYSBQTUQtY3Jvc3NpbmcgdmlydHVhbCBhZGRyZXNzLlxu Iik7CiAgICAgICAgIHByaW50ZigiICAgVGhlIHJlcHJvZHVjZXIgc3VjY2Vzc2Z1bGx5IGNyZWF0 ZWQgdGhlIGRlc2lyZWQgCmVkZ2UtY2FzZSBtZW1vcnkgbGF5b3V0LlxuIik7CiAgICAgfSBlbHNl IHsKICAgICAgICAgcHJpbnRmKCLinYwgVU5FWFBFQ1RFRCBGQUlMVVJFOiBUaGUgcGFnZXMgd2Vy ZSBub3QgY29udGlndW91cyAKYWZ0ZXIgbXJlbWFwLlxuIik7CiAgICAgfQoKICAgICBjbG9zZShw YWdlbWFwX2ZkKTsKICAgICBtdW5tYXAobmV3X2FkZHIsIEZPTElPX1NJWkUpOwoKICAgICByZXR1 cm4gMDsKfQpgYGAKCiQgYS5vdXQKCmBgYAotLS0gRm9saW8tYWNyb3NzLVBNRC1ib3VuZGFyeSBy ZXByb2R1Y2VyIC0tLQpQYWdlIHNpemU6IDQgS0IsIEZvbGlvIHNpemU6IDY0IEtCLCBQTUQgY292 ZXJhZ2U6IDIgTUIKCjEuIFNvdXJjZSBtZW1vcnkgbWFwcGVkIGF0OiAweDdmMmU0MTIwMDAwMAoy LiBBZHZpc2VkIGtlcm5lbCB0byB1c2UgbGFyZ2UgZm9saW9zIChNQURWX0hVR0VQQUdFKS4KMy4g RmF1bHRlZCBpbiBzb3VyY2UgcGFnZXMuCgotLS0gVmVyaWZ5aW5nIENvbnRpZ3VpdHkgZm9yOiBT b3VyY2UgQWRkcmVzcyAocHJlLW1yZW1hcCkgYXQgCjB4N2YyZTQxMjAwMDAwIC0tLQpQYWdlIHwg ICAgICBWaXJ0dWFsIEFkZHJlc3MgICAgICB8IFByZXNlbnQgfCAgIFBGTiAoUGh5c2ljYWwpICAg fCAKQ29udGlndW91cz8KLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0t LSstLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tCiAgIDAgIHwgMHgwMDAwN2YyZTQx MjAwMDAwIHwgICBZZXMgICB8IDB4MTEzYWEwICAgICAgICAgICB8ICAgICBZZXMKICAgMSAgfCAw eDAwMDA3ZjJlNDEyMDEwMDAgfCAgIFllcyAgIHwgMHgxMTNhYTEgICAgICAgICAgIHwgICAgIFll cwogICAyICB8IDB4MDAwMDdmMmU0MTIwMjAwMCB8ICAgWWVzICAgfCAweDExM2FhMiAgICAgICAg ICAgfCAgICAgWWVzCiAgIDMgIHwgMHgwMDAwN2YyZTQxMjAzMDAwIHwgICBZZXMgICB8IDB4MTEz YWEzICAgICAgICAgICB8ICAgICBZZXMKICAgNCAgfCAweDAwMDA3ZjJlNDEyMDQwMDAgfCAgIFll cyAgIHwgMHgxMTNhYTQgICAgICAgICAgIHwgICAgIFllcwogICA1ICB8IDB4MDAwMDdmMmU0MTIw NTAwMCB8ICAgWWVzICAgfCAweDExM2FhNSAgICAgICAgICAgfCAgICAgWWVzCiAgIDYgIHwgMHgw MDAwN2YyZTQxMjA2MDAwIHwgICBZZXMgICB8IDB4MTEzYWE2ICAgICAgICAgICB8ICAgICBZZXMK ICAgNyAgfCAweDAwMDA3ZjJlNDEyMDcwMDAgfCAgIFllcyAgIHwgMHgxMTNhYTcgICAgICAgICAg IHwgICAgIFllcwogICA4ICB8IDB4MDAwMDdmMmU0MTIwODAwMCB8ICAgWWVzICAgfCAweDExM2Fh OCAgICAgICAgICAgfCAgICAgWWVzCiAgIDkgIHwgMHgwMDAwN2YyZTQxMjA5MDAwIHwgICBZZXMg ICB8IDB4MTEzYWE5ICAgICAgICAgICB8ICAgICBZZXMKICAxMCAgfCAweDAwMDA3ZjJlNDEyMGEw MDAgfCAgIFllcyAgIHwgMHgxMTNhYWEgICAgICAgICAgIHwgICAgIFllcwogIDExICB8IDB4MDAw MDdmMmU0MTIwYjAwMCB8ICAgWWVzICAgfCAweDExM2FhYiAgICAgICAgICAgfCAgICAgWWVzCiAg MTIgIHwgMHgwMDAwN2YyZTQxMjBjMDAwIHwgICBZZXMgICB8IDB4MTEzYWFjICAgICAgICAgICB8 ICAgICBZZXMKICAxMyAgfCAweDAwMDA3ZjJlNDEyMGQwMDAgfCAgIFllcyAgIHwgMHgxMTNhYWQg ICAgICAgICAgIHwgICAgIFllcwogIDE0ICB8IDB4MDAwMDdmMmU0MTIwZTAwMCB8ICAgWWVzICAg fCAweDExM2FhZSAgICAgICAgICAgfCAgICAgWWVzCiAgMTUgIHwgMHgwMDAwN2YyZTQxMjBmMDAw IHwgICBZZXMgICB8IDB4MTEzYWFmICAgICAgICAgICB8ICAgICBZZXMKVmVyaWZpY2F0aW9uIFBB U1NFRDogUEZOcyBhcmUgY29udGlndW91cyBmb3IgU291cmNlIEFkZHJlc3MgKHByZS1tcmVtYXAp LgoKNS4gQ2FsY3VsYXRlZCB0YXJnZXQgYWRkcmVzcyB0byBiZSAweDEwMDAwMWZmMDAwCjYuIFN1 Y2Nlc3NmdWxseSBtcmVtYXAnZCA2NCBLQiB0byAweDEwMDAwMWZmMDAwLgoKLS0tIFZlcmlmeWlu ZyBDb250aWd1aXR5IGZvcjogVGFyZ2V0IEFkZHJlc3MgKHBvc3QtbXJlbWFwKSBhdCAKMHgxMDAw MDFmZjAwMCAtLS0KUGFnZSB8ICAgICAgVmlydHVhbCBBZGRyZXNzICAgICAgfCBQcmVzZW50IHwg ICBQRk4gKFBoeXNpY2FsKSAgIHwgCkNvbnRpZ3VvdXM/Ci0tLS0tKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLQog ICAwICB8IDB4MDAwMDAxMDAwMDFmZjAwMCB8ICAgWWVzICAgfCAweDExM2FhMCAgICAgICAgICAg fCAgICAgWWVzCiAgIDEgIHwgMHgwMDAwMDEwMDAwMjAwMDAwIHwgICBZZXMgICB8IDB4MTEzYWEx ICAgICAgICAgICB8ICAgICBZZXMKICAgMiAgfCAweDAwMDAwMTAwMDAyMDEwMDAgfCAgIFllcyAg IHwgMHgxMTNhYTIgICAgICAgICAgIHwgICAgIFllcwogICAzICB8IDB4MDAwMDAxMDAwMDIwMjAw MCB8ICAgWWVzICAgfCAweDExM2FhMyAgICAgICAgICAgfCAgICAgWWVzCiAgIDQgIHwgMHgwMDAw MDEwMDAwMjAzMDAwIHwgICBZZXMgICB8IDB4MTEzYWE0ICAgICAgICAgICB8ICAgICBZZXMKICAg NSAgfCAweDAwMDAwMTAwMDAyMDQwMDAgfCAgIFllcyAgIHwgMHgxMTNhYTUgICAgICAgICAgIHwg ICAgIFllcwogICA2ICB8IDB4MDAwMDAxMDAwMDIwNTAwMCB8ICAgWWVzICAgfCAweDExM2FhNiAg ICAgICAgICAgfCAgICAgWWVzCiAgIDcgIHwgMHgwMDAwMDEwMDAwMjA2MDAwIHwgICBZZXMgICB8 IDB4MTEzYWE3ICAgICAgICAgICB8ICAgICBZZXMKICAgOCAgfCAweDAwMDAwMTAwMDAyMDcwMDAg fCAgIFllcyAgIHwgMHgxMTNhYTggICAgICAgICAgIHwgICAgIFllcwogICA5ICB8IDB4MDAwMDAx MDAwMDIwODAwMCB8ICAgWWVzICAgfCAweDExM2FhOSAgICAgICAgICAgfCAgICAgWWVzCiAgMTAg IHwgMHgwMDAwMDEwMDAwMjA5MDAwIHwgICBZZXMgICB8IDB4MTEzYWFhICAgICAgICAgICB8ICAg ICBZZXMKICAxMSAgfCAweDAwMDAwMTAwMDAyMGEwMDAgfCAgIFllcyAgIHwgMHgxMTNhYWIgICAg ICAgICAgIHwgICAgIFllcwogIDEyICB8IDB4MDAwMDAxMDAwMDIwYjAwMCB8ICAgWWVzICAgfCAw eDExM2FhYyAgICAgICAgICAgfCAgICAgWWVzCiAgMTMgIHwgMHgwMDAwMDEwMDAwMjBjMDAwIHwg ICBZZXMgICB8IDB4MTEzYWFkICAgICAgICAgICB8ICAgICBZZXMKICAxNCAgfCAweDAwMDAwMTAw MDAyMGQwMDAgfCAgIFllcyAgIHwgMHgxMTNhYWUgICAgICAgICAgIHwgICAgIFllcwogIDE1ICB8 IDB4MDAwMDAxMDAwMDIwZTAwMCB8ICAgWWVzICAgfCAweDExM2FhZiAgICAgICAgICAgfCAgICAg WWVzClZlcmlmaWNhdGlvbiBQQVNTRUQ6IFBGTnMgYXJlIGNvbnRpZ3VvdXMgZm9yIFRhcmdldCBB ZGRyZXNzIChwb3N0LW1yZW1hcCkuCgotLS0gRmluYWwgQ29uY2x1c2lvbiAtLS0K4pyFIFNVQ0NF U1M6IFRoZSBmb2xpbydzIHBhZ2VzIHJlbWFpbmVkIHBoeXNpY2FsbHkgY29udGlndW91cyBhZnRl ciAKcmVtYXBwaW5nIHRvIGEgUE1ELWNyb3NzaW5nIHZpcnR1YWwgYWRkcmVzcy4KICAgIFRoZSBy ZXByb2R1Y2VyIHN1Y2Nlc3NmdWxseSBjcmVhdGVkIHRoZSBkZXNpcmVkIGVkZ2UtY2FzZSBtZW1v cnkgbGF5b3V0LgpgYGAKVGhhbmtzLApMYW5jZQoKPiAKPj4KPj4+Cj4+PiBXaGF0IHByZXZlbnRz IGZvbGlvX3B0ZV9iYXRjaCgpIGZyb20gcmVhZGluZyBvdXRzaWRlIHRoZSBwYWdlIHRhYmxlPwo+ Pgo+PiBBc3N1bWluZyBzdWNoIGEgc2NlbmFyaW8gaXMgcG9zc2libGUsIHRvIHByZXZlbnQgYW55 IGNoYW5jZSBvZiBhbgo+PiBvdXQtb2YtYm91bmRzIHJlYWQsIGhvdyBhYm91dCB0aGlzIGNoYW5n ZToKPj4KPj4gZGlmZiAtLWdpdCBhL21tL3JtYXAuYyBiL21tL3JtYXAuYwo+PiBpbmRleCBmYjYz ZDkyNTZmMDkuLjlhZWFlODExYTM4YiAxMDA2NDQKPj4gLS0tIGEvbW0vcm1hcC5jCj4+ICsrKyBi L21tL3JtYXAuYwo+PiBAQCAtMTg1Miw2ICsxODUyLDI1IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCAK Pj4gY2FuX2JhdGNoX3VubWFwX2ZvbGlvX3B0ZXModW5zaWduZWQgbG9uZyBhZGRyLAo+PiDCoMKg wqDCoMKgIGNvbnN0IGZwYl90IGZwYl9mbGFncyA9IEZQQl9JR05PUkVfRElSVFkgfCBGUEJfSUdO T1JFX1NPRlRfRElSVFk7Cj4+IMKgwqDCoMKgwqAgaW50IG1heF9uciA9IGZvbGlvX25yX3BhZ2Vz KGZvbGlvKTsKPj4gwqDCoMKgwqDCoCBwdGVfdCBwdGUgPSBwdGVwX2dldChwdGVwKTsKPj4gK8Kg wqDCoCB1bnNpZ25lZCBsb25nIGVuZF9hZGRyOwo+PiArCj4+ICvCoMKgwqAgLyoKPj4gK8KgwqDC oMKgICogVG8gYmF0Y2ggdW5tYXAsIHRoZSBlbnRpcmUgZm9saW8ncyBQVEVzIG11c3QgYmUgY29u dGlndW91cwo+PiArwqDCoMKgwqAgKiBhbmQgbWFwcGVkIHdpdGhpbiB0aGUgc2FtZSBQVEUgcGFn ZSB0YWJsZSwgd2hpY2ggY29ycmVzcG9uZHMgdG8KPj4gK8KgwqDCoMKgICogYSBzaW5nbGUgUE1E IGVudHJ5LiBCZWZvcmUgY2FsbGluZyBmb2xpb19wdGVfYmF0Y2goKSwgd2hpY2ggZG9lcwo+PiAr wqDCoMKgwqAgKiBub3QgcGVyZm9ybSBib3VuZGFyeSBjaGVja3MgaXRzZWxmLCB3ZSBtdXN0IHZl cmlmeSB0aGF0IHRoZQo+PiArwqDCoMKgwqAgKiBhZGRyZXNzIHJhbmdlIGNvdmVyZWQgYnkgdGhl IGZvbGlvIGRvZXMgbm90IGNyb3NzIGEgUE1EIGJvdW5kYXJ5Lgo+PiArwqDCoMKgwqAgKi8KPj4g K8KgwqDCoCBlbmRfYWRkciA9IGFkZHIgKyAobWF4X25yICogUEFHRV9TSVpFKSAtIDE7Cj4+ICsK Pj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBBIGZhc3Qgd2F5IHRvIGNoZWNrIGZvciBhIFBN RCBib3VuZGFyeSBjcm9zcyBpcyB0byBhbGlnbiBib3RoCj4+ICvCoMKgwqDCoCAqIHRoZSBzdGFy dCBhbmQgZW5kIGFkZHJlc3NlcyB0byB0aGUgUE1EIGJvdW5kYXJ5IGFuZCBzZWUgaWYgdGhleQo+ PiArwqDCoMKgwqAgKiBhcmUgZGlmZmVyZW50LiBJZiB0aGV5IGFyZSwgdGhlIHJhbmdlIHNwYW5z IGFjcm9zcyBhdCBsZWFzdCB0d28KPj4gK8KgwqDCoMKgICogZGlmZmVyZW50IFBNRC1tYW5hZ2Vk IHJlZ2lvbnMuCj4+ICvCoMKgwqDCoCAqLwo+PiArwqDCoMKgIGlmICgoYWRkciAmIFBNRF9NQVNL KSAhPSAoZW5kX2FkZHIgJiBQTURfTUFTSykpCj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gZmFs c2U7Cj4gCj4gWW91IHNob3VsZCBub3QgYmUgbWVzc2luZyB3aXRoIG1heF9uciA9IGZvbGlvX25y X3BhZ2VzKGZvbGlvKSBoZXJlIGF0IAo+IGFsbC4gZm9saW9fcHRlX2JhdGNoKCkgdGFrZXMgY2Fy ZSBvZiB0aGF0Lgo+IAo+IEFsc28sIHdheSB0b28gbWFueSBjb21tZW50cyA7KQo+IAo+IFlvdSBt YXkgb25seSBiYXRjaCB3aXRoaW4gYSBzaW5nbGUgVk1BIGFuZCB3aXRoaW4gYSBzaW5nbGUgcGFn ZSB0YWJsZS4KPiAKPiBTbyBzaW1wbHkgYWxpZ24gdGhlIGFkZHIgdXAgdG8gdGhlIG5leHQgUE1E LCBhbmQgbWFrZSBzdXJlIGl0IGRvZXMgbm90IAo+IGV4Y2VlZCB0aGUgdm1hIGVuZC4KPiAKPiBB TElHTiBhbmQgZnJpZW5kcyBjYW4gaGVscCBhdm9pZGluZyBleGNlc3NpdmUgY29tbWVudHMuCj4g CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt cmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=