From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.6 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 09E50C47420 for ; Mon, 28 Sep 2020 21:36:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AC6F12083B for ; Mon, 28 Sep 2020 21:36:50 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="H5aghNuG" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727030AbgI1Vgt (ORCPT ); Mon, 28 Sep 2020 17:36:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49586 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727000AbgI1Vgr (ORCPT ); Mon, 28 Sep 2020 17:36:47 -0400 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A1D3FC061755; Mon, 28 Sep 2020 14:36:45 -0700 (PDT) Received: by mail-pj1-x102c.google.com with SMTP id fa1so1502439pjb.0; Mon, 28 Sep 2020 14:36:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=J0/zGQOdwo86NI5oEJNGeFe4pfrLpCIegm6D313BOXw=; b=H5aghNuGOFPNIBCnHfgg3qX3ftXgF1sBxruvFwj6/2VOfiuG/1eQNzdWf2+FrkV2zh bG6U0zsQvxw2ubbOjrDAGs7DKyJ7aGNakjT89pMG8dVgj+fOqqZbiU8RPata1h0jJwRl LMwKVOKC8jljlinmqavNml2EhedXVoxbwwF7BJCv+Y0TZISBfflEokZOtSSBMM+Llfnd 9BhX/tGqaOYuuhs/liU6DpAxc/x/Am2xma0a19dNY/d9kE1tzo1uYJXR5f5ZIh54wvjt zEKtEjYpYJnpzgUsjTNQdXcUFvwG+ZVyNyhG0TWAx+l/svUTlxSvIc5IaAroZQeosaMb 8gvQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=J0/zGQOdwo86NI5oEJNGeFe4pfrLpCIegm6D313BOXw=; b=oIfRCbvoeF0gAburVgNfsLmwLYplHQBmw6SzHc+EMcZ+m2Dgv2RTvAkbAlhMiZtDew m1xgQvbcK36zED0j6mUnPCwxmVjS964W8oMDlIrE7FudGfZPOmxWeU6yzmI8uLhRg1Pk fQx19yQZtdDxWwQ1gHwN12qiSYIpgmFr/ObeFZP+uXhm6EPtr42yG+ZOI+UZspBJLBmi O9vPL4nePoi34tHyDg49Gw1Pl70Hea941gPtqPCgXVNwK+XzxaI/Cj+3ZCNpvcR7oyAf IX4qWoap+qZKzjdushP/QSqGkElropS91RNn+ExLaiOphb/9k3GdCvFUY1Rwzg4udp4r lQOg== X-Gm-Message-State: AOAM530ji21tvNt4uO6RLFbGIQ8wB+8ae6iREhpz2OyOMZgg0tQPhbIg S7wq6/n1WCFEUJ3S/0kTtSs= X-Google-Smtp-Source: ABdhPJzVbo/wfcgVl4Cx3dMFlPxGAgLybP96ORsRkq6xsTmHOQQCY0Xw+FvtB1t0tkjoXijvQ+xMEA== X-Received: by 2002:a17:90b:108e:: with SMTP id gj14mr1048193pjb.225.1601329005039; Mon, 28 Sep 2020 14:36:45 -0700 (PDT) Received: from jacob-builder.jf.intel.com (jfdmzpr04-ext.jf.intel.com. [134.134.137.73]) by smtp.gmail.com with ESMTPSA id l11sm2220864pjf.17.2020.09.28.14.36.43 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Sep 2020 14:36:44 -0700 (PDT) From: Jacob Pan X-Google-Original-From: Jacob Pan To: iommu@lists.linux-foundation.org, LKML , Joerg Roedel , Alex Williamson , "Lu Baolu" , David Woodhouse , Jonathan Corbet Cc: linux-api@vger.kernel.org, Jean-Philippe Brucker , Eric Auger , Jacob Pan , Yi Liu , "Tian, Kevin" , Raj Ashok , Wu Hao , Yi Sun , Dave Jiang , Randy Dunlap , linux-doc@vger.kernel.org Subject: [PATCH v3 01/14] docs: Document IO Address Space ID (IOASID) APIs Date: Mon, 28 Sep 2020 14:38:28 -0700 Message-Id: <1601329121-36979-2-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1601329121-36979-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1601329121-36979-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org IOASID is used to identify address spaces that can be targeted by device DMA. It is a system-wide resource that is essential to its many users. This document is an attempt to help developers from all vendors navigate the APIs. At this time, ARM SMMU and Intel’s Scalable IO Virtualization (SIOV) enabled platforms are the primary users of IOASID. Examples of how SIOV components interact with IOASID APIs are provided in that many APIs are driven by the requirements from SIOV. Cc: Jonathan Corbet Cc: linux-doc@vger.kernel.org Cc: Randy Dunlap Signed-off-by: Liu Yi L Signed-off-by: Wu Hao Signed-off-by: Jacob Pan --- Documentation/driver-api/ioasid.rst | 648 ++++++++++++++++++++++++++++++++++++ 1 file changed, 648 insertions(+) create mode 100644 Documentation/driver-api/ioasid.rst diff --git a/Documentation/driver-api/ioasid.rst b/Documentation/driver-api/ioasid.rst new file mode 100644 index 000000000000..7f8e702997ab --- /dev/null +++ b/Documentation/driver-api/ioasid.rst @@ -0,0 +1,648 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. ioasid: + +=================== +IO Address Space ID +=================== + +IOASID is a generic name for PCIe Process Address ID (PASID) or ARM +SMMU SubstreamID. An IOASID identifies an address space that DMA +requests can target. + +The primary use cases for IOASID are Shared Virtual Address (SVA) and +multiple IOVA spaces per device. However, the requirements for IOASID +management can vary among hardware architectures. + +For baremetal IOVA, IOASID #0 is used for DMA request without +PASID. Even though some architectures such as VT-d also offers +the flexibility of using any PASIDs for DMA request without PASID. +PASID #0 is reserved and not allocated from any ioasid_set. + +Multiple IOVA spaces per device are mapped to auxiliary domains which +can be used for mediated device assignment with and without a virtual +IOMMU (vIOMMU). An IOASID is allocated for each auxiliary domain as default +PASID. Without vIOMMU, default IOASID is used for DMA map/unmap +APIs. With vIOMMU, default IOASID is used for guest IOVA where DMA +request with PASID is required for the device. The reason is that +there is only one PASID #0 per device, e.g. VT-d, RID_PASID is per PCI +device. + +This document covers the generic features supported by IOASID +APIs. Vendor-specific use cases are also illustrated with Intel's VT-d +based platforms as the first example. + +.. contents:: :local: + +Glossary +======== +PASID - Process Address Space ID + +IOASID - IO Address Space ID (generic term for PCIe PASID and +SubstreamID in SMMU) + +SVA/SVM - Shared Virtual Addressing/Memory + +ENQCMD - Intel X86 ISA for efficient workqueue submission [1] +!!!TODO: Link to Spec at the bottom + +DSA - Intel Data Streaming Accelerator [2] + +VDCM - Virtual Device Composition Module [3] + +SIOV - Intel Scalable IO Virtualization + + +Key Concepts +============ + +IOASID Set +----------- +An IOASID set is a group of IOASIDs allocated from the system-wide +IOASID pool. Refer to IOASID set APIs for more details. + +IOASID set is particularly useful for guest SVA where each guest could +have its own IOASID set for security and efficiency reasons. + +IOASID Set Private ID (SPID) +---------------------------- +Each IOASID set has a private namespace of SPIDs. An SPID maps to a +single system-wide IOASID. Conversely, each IOASID may be associated +with an alias ID, local to the IOASID set, named SPID. +SPIDs can be used as guest IOASIDs where each guest could do +IOASID allocation from its own pool and map them to host physical +IOASIDs. SPIDs are particularly useful for supporting live migration +where decoupling guest and host physical resources are necessary. + +For example, two VMs can both allocate guest PASID/SPID #101 but map to +different host PASIDs #201 and #202 respectively as shown in the +diagram below. +:: + + .------------------. .------------------. + | VM 1 | | VM 2 | + | | | | + |------------------| |------------------| + | GPASID/SPID 101 | | GPASID/SPID 101 | + '------------------' -------------------' Guest + __________|______________________|____________________ + | | Host + v v + .------------------. .------------------. + | Host IOASID 201 | | Host IOASID 202 | + '------------------' '------------------' + | IOASID set 1 | | IOASID set 2 | + '------------------' '------------------' + +Guest PASID is treated as IOASID set private ID (SPID) within an +IOASID set, mappings between guest and host IOASIDs are stored in the +set for inquiry. + +IOASID APIs +=========== +To get the IOASID APIs, users must #include . These APIs +serve the following functionalities: + + - IOASID allocation/Free + - Group management in the form of ioasid_set + - Private data storage and lookup + - Reference counting + - Event notification in case of a state change + +IOASID Set Level APIs +-------------------------- +For use cases such as guest SVA it is necessary to manage IOASIDs at +ioasid_set level. For example, VMs may allocate multiple IOASIDs for +guest process address sharing (vSVA). It is imperative to enforce +VM-IOASID ownership such that a malicious guest cannot target DMA +traffic outside its own IOASIDs, or free an active IOASID that belongs +to another VM. + +The IOASID set APIs serve the following purposes: + + - Ownership/permission enforcement + - Take collective actions, e.g. free an entire set + - Event notifications within a set + - Look up a set based on token + - Quota enforcement + +Each IOASID set is created with a token, which can be one of the +following token types: + + - IOASID_SET_TYPE_NULL (Arbitrary u64 value) + - IOASID_SET_TYPE_MM (Set token is a mm_struct) + +The explicit MM token type is useful when multiple users of an IOASID +set under the same process need to communicate about their shared IOASIDs. +E.g. An IOASID set created by VFIO for one guest can be associated +with the KVM instance for the same guest since they share a common mm_struct. +A token must be unique within its type. + +:: + + struct ioasid_set *ioasid_alloc_set(void *token, ioasid_t quota, u32 type) + + int ioasid_adjust_set(struct ioasid_set *set, int quota); + + void ioasid_set_get(struct ioasid_set *set) + + void ioasid_set_put(struct ioasid_set *set) + + void ioasid_set_get_locked(struct ioasid_set *set) + + void ioasid_set_put_locked(struct ioasid_set *set) + + int ioasid_set_for_each_ioasid(struct ioasid_set *set, + void (*fn)(ioasid_t id, void *data), + void *data) + + +Individual IOASID APIs +---------------------- +Once an ioasid_set is created, IOASIDs can be allocated from the set. +Within the IOASID set namespace, set private ID (SPID) is supported. In +the VM use case, SPID can be used for storing guest PASID. + +:: + + ioasid_t ioasid_alloc(struct ioasid_set *set, ioasid_t min, ioasid_t max, + void *private); + + int ioasid_get(struct ioasid_set *set, ioasid_t ioasid); + + void ioasid_put(struct ioasid_set *set, ioasid_t ioasid); + + int ioasid_get_locked(struct ioasid_set *set, ioasid_t ioasid); + + void ioasid_put_locked(struct ioasid_set *set, ioasid_t ioasid); + + void *ioasid_find(struct ioasid_set *set, ioasid_t ioasid, + bool (*getter)(void *)); + + ioasid_t ioasid_find_by_spid(struct ioasid_set *set, ioasid_t spid) + + int ioasid_attach_data(struct ioasid_set *set, ioasid_t ioasid, + void *data); + int ioasid_attach_spid(struct ioasid_set *set, ioasid_t ioasid, + ioasid_t spid); + + +Notifications +------------- +An IOASID may have multiple users, each user may have hardware context +associated with an IOASID. When the status of an IOASID changes, +e.g. an IOASID is being freed, users need to be notified such that the +associated hardware context can be cleared, flushed, and drained. + +:: + + int ioasid_register_notifier(struct ioasid_set *set, struct + notifier_block *nb) + + void ioasid_unregister_notifier(struct ioasid_set *set, + struct notifier_block *nb) + + int ioasid_register_notifier_mm(struct mm_struct *mm, struct + notifier_block *nb) + + void ioasid_unregister_notifier_mm(struct mm_struct *mm, struct + notifier_block *nb) + + int ioasid_notify(ioasid_t ioasid, enum ioasid_notify_val cmd, + unsigned int flags) + +"_mm" flavor of the ioasid_register_notifier() APIs are used when +an IOASID user need to listen to the IOASID events belong to a +process but without the knowledge of the associated ioasid_set. + +Events +~~~~~~ +Notification events are pertinent to individual IOASIDs, they can be +one of the following: + + - ALLOC + - FREE + - BIND + - UNBIND + +Ordering +~~~~~~~~ +Ordering is supported by IOASID notification priorities as the +following (in ascending order): + +:: + + enum ioasid_notifier_prios { + IOASID_PRIO_LAST, + IOASID_PRIO_IOMMU, + IOASID_PRIO_DEVICE, + IOASID_PRIO_CPU, + }; + +When registered, notifiers are assigned a priority that affect the +call order. For example, notifiers with CPU priority get called before +notifiers with device priority and so on. + +The typical use case is when an IOASID is freed due to an exception, DMA +source should be quiesced before tearing down other hardware contexts +in the system. This will reduce the churn in handling faults. DMA work +submission is performed by the CPU which is granted higher priority than +devices. + +Level Sensitivity +~~~~~~~~~~~~~~~~~ +For each IOASID state transition, IOASID core ensures that there is +only one notification sent. This resembles level triggered interrupt +where a single interrupt is raised during a state transition. +For example, if ioasid_free() is called twice by a user before the +IOASID is reclaimed, IOASID core will only send out a single +IOASID_NOTIFY_FREE event. Similarly, for IOASID_NOTIFY_BIND/UNBIND +events, which is only sent out once when a SPID is attached/detached. + +IOASID notifications cannot be sent directly by IOASID users, they are +sent out by the IOASID core as a by-product of the following APIs: +- ioasid_alloc/free(), emit IOASID_NOTIFY_ALLOC/FREE +- ioasid_attach/detach_spid() emit IOASID_NOTIFY_BIND/UNBIND + +Scopes +~~~~~~ +There are two types of notifiers in IOASID core: system-wide and +ioasid_set-wide. + +System-wide notifier is catering for users that need to handle all the +IOASIDs in the system. E.g. The IOMMU driver. + +Per ioasid_set notifier can be used by VM specific components such as +KVM. After all, each KVM instance only cares about IOASIDs within its +own set/guest. + + +Atomicity +~~~~~~~~~ +IOASID notifiers are atomic due to spinlocks used inside the IOASID +core. For tasks that cannot be completed in the notifier handler, +async work can be submitted to complete the work later as long as +there is no ordering requirement. + +Reference counting +------------------ +IOASID lifecycle management is based on reference counting. Users of +IOASID who intend to align lifecycle with the IOASID need to hold +a reference of the IOASID. The IOASID will not be returned to the pool +for allocation until all references are dropped. Calling ioasid_free() +will mark the IOASID as FREE_PENDING if the IOASID has outstanding +references. No new references can be taken by ioasid_get() once an +IOASID is in the FREE_PENDING state. ioasid_free() can be called +multiple times without an error until all refs are dropped. + +ioasid_put() decrements and tests refcount of the IOASID. If refcount +is 0, ioasid will be freed. Deleted from the system-wide xarray as +well as per set xarray. The IOASID will be returned to the pool and +available for new allocations. + +Event notifications are used to inform users of IOASID status change. +IOASID_FREE event prompts users to drop their references after +clearing its context. + +For example, on VT-d platform when an IOASID is freed, teardown +actions are performed on KVM, device driver (VDCM), and the IOMMU +driver. To quiesce VCPU for work submission, KVM notifier handler must +be called before VDCM handler. Therefore, KVM and VDCM shall use +notification priority IOASID_PRIO_CPU andIOASID_PRIO_DEVICE +respectively. + +For both KVM and VDCM, notifier blocks shall be registered on the +IOASID set such that *only* events from the matching VM are received. + +If KVM attempts to register a notifier block before the IOASID set is +created using the MM token, the notifier block will be placed on a +pending list inside IOASID core. Once the token matching IOASID set +is created, IOASID will register the notifier block automatically. +IOASID core does not replay events for the existing IOASIDs in the +set. For IOASID set of MM type, notification blocks can be registered +on empty sets only. This is to avoid lost events. + +IOMMU driver shall register notifier block on global chain:: + + static struct notifier_block pasid_nb_vtd = { + .notifier_call = pasid_status_change_vtd, + .priority = IOASID_PRIO_IOMMU, + }; + +Custom allocator APIs +--------------------- + +:: + + int ioasid_register_allocator(struct ioasid_allocator_ops *allocator); + + void ioasid_unregister_allocator(struct ioasid_allocator_ops *allocator); + +Allocator Choices +~~~~~~~~~~~~~~~~~ +IOASIDs are allocated for both host and guest SVA/IOVA usage. However, +allocators can be different. For example, on VT-d guest PASID +allocation must be performed via a virtual command interface which is +emulated by VMM. + +IOASID core has the notion of "custom allocator" such that guest can +register virtual command allocator that precedes the default one. + +Namespaces +~~~~~~~~~~ +IOASIDs are limited system resources that default to 20 bits in +size. Each device can have its own PASID table for security reasons. +Theoretically the namespace can be per device also. + +However IOASID namespace is system-wide for two reasons: +- Simplicity +- Sharing resources of a single device to multiple VMs. + +Take VT-d as an example, VT-d supports shared workqueue and ENQCMD[1] +where one IOASID could be used to submit work on multiple devices that +are shared with other VMs. This requires IOASID to be +system-wide. This is also the reason why guests must use an +emulated virtual command interface to allocate IOASID from the host. + +Life cycle +========== +This section covers IOASID life cycle management for both bare-metal +and guest usages. In bare-metal SVA, MMU notifier is directly hooked +up with IOMMU driver, therefore the IOASID life cycle matches the +process address space (MM) life cycle. + +However, guest MMU notifier is not available to host IOMMU driver, +when guest MM terminates unexpectedly, the events have to go through +VFIO and IOMMU UAPI to reach host IOMMU driver. There are also more +parties involved in guest SVA, e.g. on Intel VT-d platform, IOASIDs +are used by IOMMU driver, KVM, VDCM, and VFIO. + +Native IOASID Life Cycle (VT-d Example) +--------------------------------------- + +The normal flow of native SVA code with Intel Data Streaming +Accelerator(DSA) [2] as example: + +1. Host user opens accelerator FD, e.g. DSA driver, or uacce; +2. DSA driver allocate WQ, do sva_bind_device(); +3. IOMMU driver calls ioasid_alloc(), then bind PASID with device, + mmu_notifier_get() +4. DMA starts by DSA driver userspace +5. DSA userspace close FD +6. DSA/uacce kernel driver handles FD.close() +7. DSA driver stops DMA +8. DSA driver calls sva_unbind_device(); +9. IOMMU driver does unbind, clears PASID context in IOMMU, flush + TLBs. mmu_notifier_put() called. +10. mmu_notifier.release() called, IOMMU SVA code calls ioasid_free()* +11. The IOASID is returned to the pool, reclaimed. + +:: + + * With ENQCMD, PASID used on VT-d is not released in mmu_notifier() but + mmdrop(). mmdrop comes after FD close which does not make a difference. + +During the normal teardown, the following three key steps would happen in +order: (7), (9), (11). + +Exception happens when process terminates *before* device driver stops +DMA and call IOMMU driver to unbind. The detailed flow of process +exits are as follows: + +:: + + do_exit() { + exit_mm() { + mm_put(); + exit_mmap() { + intel_invalidate_range() //mmu notifier + tlb_finish_mmu() + mmu_notifier_release(mm) { + intel_mm_release() { + (9) intel_iommu_teardown_pasid(); + intel_iommu_flush_tlbs(); + } + // tlb_invalidate_range cb removed + } + unmap_vmas(); + free_pgtables(); // IOMMU cannot walk PGT after this + }; + } + exit_files(tsk) { + close_files() { + dsa_close(); + (7) dsa_stop_dma(); + intel_svm_unbind_pasid(); //nothing to do + } + } + } + + mmdrop() /* some random time later, lazy mm user */ { + mm_free_pgd(); + destroy_context(mm); { + (11) ioasid_free(); + } + } + +As shown in the list above, step #2 could happen before +#1. Unrecoverable(UR) faults could happen between #2 and #1. +Fault processing is disabled by the IOMMU driver in #2, therefore the UR +fault never reaches the driver. + + +Also notice that TLB invalidation occurs at mmu_notifier +invalidate_range callback as well as the release callback. The reason +is that release callback will delete IOMMU driver from the notifier +chain which may skip invalidate_range() calls during the exit path. + +To avoid unnecessary reporting of UR fault, IOMMU driver shall disable +fault reporting after free and before unbind. + +Guest IOASID Life Cycle (VT-d Example) +-------------------------------------- +Guest IOASID life cycle starts with guest driver open(), this could be +uacce or individual accelerator driver such as DSA. At FD open, +sva_bind_device() is called which triggers a series of actions. + +The example below is an illustration of *normal* operations that +involves *all* the SW components in VT-d. The flow can be simpler if +no ENQCMD is supported. + +:: + + VFIO IOMMU KVM VDCM IOASID Ref + .................................................................. + 1 ioasid_register_notifier/_mm() + 2 ioasid_alloc() 1 + 3 bind_gpasid() + 4 iommu_bind()->ioasid_get() 2 + 5 ioasid_notify(BIND) + 6 -> ioasid_get() 3 + 7 -> vmcs_update_atomic() + 8 mdev_write(gpasid) + 9 hpasid= + 10 find_by_spid(gpasid) 4 + 11 vdev_write(hpasid) + 12 -------- GUEST STARTS DMA -------------------------- + 13 -------- GUEST STOPS DMA -------------------------- + 14 mdev_clear(gpasid) + 15 vdev_clear(hpasid) + 16 ioasid_put() 3 + 17 unbind_gpasid() + 18 iommu_ubind() + 19 ioasid_notify(UNBIND) + 20 -> vmcs_update_atomic() + 21 -> ioasid_put() 2 + 22 ioasid_free() 1 + 23 ioasid_put() 0 + 24 Reclaimed + -------------- New Life Cycle Begin ---------------------------- + 1 ioasid_alloc() -> 1 + + Note: IOASID Notification Events: FREE, BIND, UNBIND + +Exception cases arise when a guest crashes or a malicious guest +attempts to cause disruption on the host system. The fault handling +rules are: + +1. IOASID free must *always* succeed. +2. An inactive period may be required before the freed IOASID is + reclaimed. During this period, consumers of IOASID perform cleanup. +3. Malfunction is limited to the guest owned resources for all + programming errors. + +The primary source of exception is when the following are out of +order: + +1. Start/Stop of DMA activity + (Guest device driver, mdev via VFIO) +2. Setup/Teardown of IOMMU PASID context, IOTLB, DevTLB flushes + (Host IOMMU driver bind/unbind) +3. Setup/Teardown of VMCS PASID translation table entries (KVM) in + case of ENQCMD +4. Programming/Clearing host PASID in VDCM (Host VDCM driver) +5. IOASID alloc/free (Host IOASID) + +VFIO is the *only* user-kernel interface, which is ultimately +responsible for exception handling. + +#1 is processed the same way as the assigned device today based on +device file descriptors and events. There is no special handling. + +#3 is based on bind/unbind events emitted by #2. + +#4 is naturally aligned with IOASID life cycle in that an illegal +guest PASID programming would fail in obtaining reference of the +matching host IOASID. + +#5 is similar to #4. The fault will be reported to the user if PASID +used in the ENQCMD is not set up in VMCS PASID translation table. + +Therefore, the remaining out of order problem is between #2 and +#5. I.e. unbind vs. free. More specifically, free before unbind. + +IOASID notifier and refcounting are used to ensure order. Following +a publisher-subscriber pattern where: + +- Publishers: VFIO & IOMMU +- Subscribers: KVM, VDCM, IOMMU + +IOASID reference must be acquired before receiving the FREE event. The +reference must be dropped at the end of the processing in order to +return the IOASID to the pool. + +Let's examine the IOASID life cycle again when free happens *before* +unbind. This could be a result of misbehaving guests or crash. Assuming +VFIO cannot enforce unbind->free order. Notice that the setup part up +until step #12 is identical to the normal case, the flow below starts +with step 13. + +:: + + VFIO IOMMU KVM VDCM IOASID Ref + .................................................................. + 13 -------- GUEST STARTS DMA -------------------------- + 14 -------- *GUEST MISBEHAVES!!!* ---------------- + 15 ioasid_free() + 16 ioasid_notify(FREE) + 17 mark_free_pending (1) + 18 kvm_nb_handler(FREE) + 19 vmcs_update_atomic() + 20 ioasid_put_locked() -> 3 + 21 vdcm_nb_handler(FREE) + 22 iomm_nb_handler(FREE) + 23 ioasid_free() returns(2) schedule_work() 2 + 24 schedule_work() vdev_clear_wk(hpasid) + 25 teardown_pasid_wk() + 26 ioasid_put() -> 1 + 27 ioasid_put() 0 + 28 Reclaimed + 29 unbind_gpasid() + 30 iommu_unbind()->ioasid_find() Fails(3) + -------------- New Life Cycle Begin ---------------------------- + +Note: + +1. By marking IOASID FREE_PENDING at step #17, no new references can be + held. ioasid_get/find() will return -ENOENT; +2. After step #23, all events can go out of order. Shall not affect + the outcome. +3. IOMMU driver fails to find private data for unbinding. If unbind is + called after the same IOASID is allocated for the same guest again, + this is a programming error. The damage is limited to the guest + itself since unbind performs permission checking based on the + IOASID set associated with the guest process. +4. Workqueues are used by VDCM and IOMMU driver for processing that + requires thread context. + + +KVM PASID Translation Table Updates +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Per VM PASID translation table is maintained by KVM in order to +support ENQCMD in the guest. The table contains host-guest PASID +translations to be consumed by CPU ucode. The synchronization of the +PASID states depends on VFIO/IOMMU driver, where IOCTL and atomic +notifiers are used. KVM must register IOASID notifier per VM instance +during launch time. The following events are handled: + +1. BIND/UNBIND +2. FREE + +Rules: + +1. Multiple devices can bind with the same PASID, this can be different PCI + devices or mdevs within the same PCI device. However, only the + *first* BIND and *last* UNBIND emit notifications. +2. IOASID code is responsible for ensuring the correctness of H-G + PASID mapping. There is no need for KVM to validate the + notification data. +3. When UNBIND happens *after* FREE, KVM will see error in + ioasid_get() even when the reclaim is not done. IOMMU driver will + also avoid sending UNBIND if the PASID is already FREE. +4. When KVM terminates *before* FREE & UNBIND, references will be + dropped for all host PASIDs. + +VDCM PASID Programming +~~~~~~~~~~~~~~~~~~~~~~ +VDCM composes virtual devices and exposes them to the guests. When +the guest allocates a PASID then program it to the virtual device, VDCM +intercepts the programming attempt then programs the matching host +PASID on to the hardware. +Conversely, when a device is going away, VDCM must be informed such +that PASID context on the hardware can be cleared. There could be +multiple mdevs assigned to different guests in the same VDCM. Since +the PASID table is shared at PCI device level, lazy clearing is not +secure. A malicious guest can attack by using newly freed PASIDs that +are allocated by another guest. + +By holding a reference of the PASID until VDCM cleans up the HW context, +it is guaranteed that PASID life cycles do not cross within the same +device. + + +Reference +==================================================== +1. https://software.intel.com/sites/default/files/managed/c5/15/architecture-instruction-set-extensions-programming-reference.pdf + +2. https://01.org/blogs/2019/introducing-intel-data-streaming-accelerator + +3. https://software.intel.com/en-us/download/intel-data-streaming-accelerator-preliminary-architecture-specification -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.3 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 574F2C4741F for ; Mon, 28 Sep 2020 21:36:54 +0000 (UTC) Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id F08192100A for ; Mon, 28 Sep 2020 21:36:53 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="H5aghNuG" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F08192100A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 9BD9386663; Mon, 28 Sep 2020 21:36:53 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id bdckEfV5wro2; Mon, 28 Sep 2020 21:36:49 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by whitealder.osuosl.org (Postfix) with ESMTP id EED2186654; Mon, 28 Sep 2020 21:36:48 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id D41E9C1AD6; Mon, 28 Sep 2020 21:36:48 +0000 (UTC) Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id EFDCAC0051 for ; Mon, 28 Sep 2020 21:36:47 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id DDD3785A82 for ; Mon, 28 Sep 2020 21:36:47 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id WEfKk70zE8qA for ; Mon, 28 Sep 2020 21:36:46 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-pj1-f51.google.com (mail-pj1-f51.google.com [209.85.216.51]) by hemlock.osuosl.org (Postfix) with ESMTPS id F327B86CE0 for ; Mon, 28 Sep 2020 21:36:45 +0000 (UTC) Received: by mail-pj1-f51.google.com with SMTP id j19so328654pjl.4 for ; Mon, 28 Sep 2020 14:36:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=J0/zGQOdwo86NI5oEJNGeFe4pfrLpCIegm6D313BOXw=; b=H5aghNuGOFPNIBCnHfgg3qX3ftXgF1sBxruvFwj6/2VOfiuG/1eQNzdWf2+FrkV2zh bG6U0zsQvxw2ubbOjrDAGs7DKyJ7aGNakjT89pMG8dVgj+fOqqZbiU8RPata1h0jJwRl LMwKVOKC8jljlinmqavNml2EhedXVoxbwwF7BJCv+Y0TZISBfflEokZOtSSBMM+Llfnd 9BhX/tGqaOYuuhs/liU6DpAxc/x/Am2xma0a19dNY/d9kE1tzo1uYJXR5f5ZIh54wvjt zEKtEjYpYJnpzgUsjTNQdXcUFvwG+ZVyNyhG0TWAx+l/svUTlxSvIc5IaAroZQeosaMb 8gvQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=J0/zGQOdwo86NI5oEJNGeFe4pfrLpCIegm6D313BOXw=; b=LRhJrKWqdwimiAyxbJC2bxzPEkIcEpDNg1cGooW4EqQSRdhLVEhQEM2uwLRbCe2L7H YXiP+rCo3em8PJcX9LI2jhHDq5tH8175Y7a60INWPtkVf3O6+m3ZM9sIijX+L2xhXwcb FKTin0IbWpwkSQ6yqvb4k0mD25QtH8CH9PvgU8TIYZj7VloJ444gayEfdN/fjIY21hbQ KZiVJ5CDy2o4r1RTUm42/8W848fw9HNZ0JqHvf97XelPgcqzJAZ77weE+QBNi3xrHpbc kX0hFZhc0fsfq4uIe2r9ysAIbUO60/YW22LnqBDbue71WO5FGutAj4nlD5SGShzrEPbD ZYUA== X-Gm-Message-State: AOAM532di9OfzX2b1ioPp5Z/1fsuIppnNe3ikwBHN8206x7Z638MhCpK w474eHOlkD9DpxCZ5xCOmjLloojjN10= X-Google-Smtp-Source: ABdhPJzVbo/wfcgVl4Cx3dMFlPxGAgLybP96ORsRkq6xsTmHOQQCY0Xw+FvtB1t0tkjoXijvQ+xMEA== X-Received: by 2002:a17:90b:108e:: with SMTP id gj14mr1048193pjb.225.1601329005039; Mon, 28 Sep 2020 14:36:45 -0700 (PDT) Received: from jacob-builder.jf.intel.com (jfdmzpr04-ext.jf.intel.com. [134.134.137.73]) by smtp.gmail.com with ESMTPSA id l11sm2220864pjf.17.2020.09.28.14.36.43 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Sep 2020 14:36:44 -0700 (PDT) From: Jacob Pan X-Google-Original-From: Jacob Pan To: iommu@lists.linux-foundation.org, LKML , Joerg Roedel , Alex Williamson , "Lu Baolu" , David Woodhouse , Jonathan Corbet Subject: [PATCH v3 01/14] docs: Document IO Address Space ID (IOASID) APIs Date: Mon, 28 Sep 2020 14:38:28 -0700 Message-Id: <1601329121-36979-2-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1601329121-36979-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1601329121-36979-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Cc: "Tian, Kevin" , Dave Jiang , Raj Ashok , linux-doc@vger.kernel.org, linux-api@vger.kernel.org, Randy Dunlap , Yi Sun , Jean-Philippe Brucker , Wu Hao X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" SU9BU0lEIGlzIHVzZWQgdG8gaWRlbnRpZnkgYWRkcmVzcyBzcGFjZXMgdGhhdCBjYW4gYmUgdGFy Z2V0ZWQgYnkgZGV2aWNlCkRNQS4gSXQgaXMgYSBzeXN0ZW0td2lkZSByZXNvdXJjZSB0aGF0IGlz IGVzc2VudGlhbCB0byBpdHMgbWFueSB1c2Vycy4KVGhpcyBkb2N1bWVudCBpcyBhbiBhdHRlbXB0 IHRvIGhlbHAgZGV2ZWxvcGVycyBmcm9tIGFsbCB2ZW5kb3JzIG5hdmlnYXRlCnRoZSBBUElzLiBB dCB0aGlzIHRpbWUsIEFSTSBTTU1VIGFuZCBJbnRlbOKAmXMgU2NhbGFibGUgSU8gVmlydHVhbGl6 YXRpb24KKFNJT1YpIGVuYWJsZWQgcGxhdGZvcm1zIGFyZSB0aGUgcHJpbWFyeSB1c2VycyBvZiBJ T0FTSUQuIEV4YW1wbGVzIG9mCmhvdyBTSU9WIGNvbXBvbmVudHMgaW50ZXJhY3Qgd2l0aCBJT0FT SUQgQVBJcyBhcmUgcHJvdmlkZWQgaW4gdGhhdCBtYW55CkFQSXMgYXJlIGRyaXZlbiBieSB0aGUg cmVxdWlyZW1lbnRzIGZyb20gU0lPVi4KCkNjOiBKb25hdGhhbiBDb3JiZXQgPGNvcmJldEBsd24u bmV0PgpDYzogbGludXgtZG9jQHZnZXIua2VybmVsLm9yZwpDYzogUmFuZHkgRHVubGFwIDxyZHVu bGFwQGluZnJhZGVhZC5vcmc+ClNpZ25lZC1vZmYtYnk6IExpdSBZaSBMIDx5aS5sLmxpdUBpbnRl bC5jb20+ClNpZ25lZC1vZmYtYnk6IFd1IEhhbyA8aGFvLnd1QGludGVsLmNvbT4KU2lnbmVkLW9m Zi1ieTogSmFjb2IgUGFuIDxqYWNvYi5qdW4ucGFuQGxpbnV4LmludGVsLmNvbT4KLS0tCiBEb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJzdCB8IDY0OCArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA2NDggaW5zZXJ0aW9ucygrKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9pb2FzaWQucnN0CgpkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2lvYXNpZC5yc3QgYi9Eb2N1bWVudGF0 aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAuLjdmOGU3MDI5OTdhYgotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24v ZHJpdmVyLWFwaS9pb2FzaWQucnN0CkBAIC0wLDAgKzEsNjQ4IEBACisuLiBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMAorLi4gaW9hc2lkOgorCis9PT09PT09PT09PT09PT09PT09CitJ TyBBZGRyZXNzIFNwYWNlIElECis9PT09PT09PT09PT09PT09PT09CisKK0lPQVNJRCBpcyBhIGdl bmVyaWMgbmFtZSBmb3IgUENJZSBQcm9jZXNzIEFkZHJlc3MgSUQgKFBBU0lEKSBvciBBUk0KK1NN TVUgU3Vic3RyZWFtSUQuIEFuIElPQVNJRCBpZGVudGlmaWVzIGFuIGFkZHJlc3Mgc3BhY2UgdGhh dCBETUEKK3JlcXVlc3RzIGNhbiB0YXJnZXQuCisKK1RoZSBwcmltYXJ5IHVzZSBjYXNlcyBmb3Ig SU9BU0lEIGFyZSBTaGFyZWQgVmlydHVhbCBBZGRyZXNzIChTVkEpIGFuZAorbXVsdGlwbGUgSU9W QSBzcGFjZXMgcGVyIGRldmljZS4gSG93ZXZlciwgdGhlIHJlcXVpcmVtZW50cyBmb3IgSU9BU0lE CittYW5hZ2VtZW50IGNhbiB2YXJ5IGFtb25nIGhhcmR3YXJlIGFyY2hpdGVjdHVyZXMuCisKK0Zv ciBiYXJlbWV0YWwgSU9WQSwgSU9BU0lEICMwIGlzIHVzZWQgZm9yIERNQSByZXF1ZXN0IHdpdGhv dXQKK1BBU0lELiBFdmVuIHRob3VnaCBzb21lIGFyY2hpdGVjdHVyZXMgc3VjaCBhcyBWVC1kIGFs c28gb2ZmZXJzCit0aGUgZmxleGliaWxpdHkgb2YgdXNpbmcgYW55IFBBU0lEcyBmb3IgRE1BIHJl cXVlc3Qgd2l0aG91dCBQQVNJRC4KK1BBU0lEICMwIGlzIHJlc2VydmVkIGFuZCBub3QgYWxsb2Nh dGVkIGZyb20gYW55IGlvYXNpZF9zZXQuCisKK011bHRpcGxlIElPVkEgc3BhY2VzIHBlciBkZXZp Y2UgYXJlIG1hcHBlZCB0byBhdXhpbGlhcnkgZG9tYWlucyB3aGljaAorY2FuIGJlIHVzZWQgZm9y IG1lZGlhdGVkIGRldmljZSBhc3NpZ25tZW50IHdpdGggYW5kIHdpdGhvdXQgYSB2aXJ0dWFsCitJ T01NVSAodklPTU1VKS4gQW4gSU9BU0lEIGlzIGFsbG9jYXRlZCBmb3IgZWFjaCBhdXhpbGlhcnkg ZG9tYWluIGFzIGRlZmF1bHQKK1BBU0lELiBXaXRob3V0IHZJT01NVSwgZGVmYXVsdCBJT0FTSUQg aXMgdXNlZCBmb3IgRE1BIG1hcC91bm1hcAorQVBJcy4gV2l0aCB2SU9NTVUsIGRlZmF1bHQgSU9B U0lEIGlzIHVzZWQgZm9yIGd1ZXN0IElPVkEgd2hlcmUgRE1BCityZXF1ZXN0IHdpdGggUEFTSUQg aXMgcmVxdWlyZWQgZm9yIHRoZSBkZXZpY2UuIFRoZSByZWFzb24gaXMgdGhhdAordGhlcmUgaXMg b25seSBvbmUgUEFTSUQgIzAgcGVyIGRldmljZSwgZS5nLiBWVC1kLCBSSURfUEFTSUQgaXMgcGVy IFBDSQorZGV2aWNlLgorCitUaGlzIGRvY3VtZW50IGNvdmVycyB0aGUgZ2VuZXJpYyBmZWF0dXJl cyBzdXBwb3J0ZWQgYnkgSU9BU0lECitBUElzLiBWZW5kb3Itc3BlY2lmaWMgdXNlIGNhc2VzIGFy ZSBhbHNvIGlsbHVzdHJhdGVkIHdpdGggSW50ZWwncyBWVC1kCitiYXNlZCBwbGF0Zm9ybXMgYXMg dGhlIGZpcnN0IGV4YW1wbGUuCisKKy4uIGNvbnRlbnRzOjogOmxvY2FsOgorCitHbG9zc2FyeQor PT09PT09PT0KK1BBU0lEIC0gUHJvY2VzcyBBZGRyZXNzIFNwYWNlIElECisKK0lPQVNJRCAtIElP IEFkZHJlc3MgU3BhY2UgSUQgKGdlbmVyaWMgdGVybSBmb3IgUENJZSBQQVNJRCBhbmQKK1N1YnN0 cmVhbUlEIGluIFNNTVUpCisKK1NWQS9TVk0gLSBTaGFyZWQgVmlydHVhbCBBZGRyZXNzaW5nL01l bW9yeQorCitFTlFDTUQgLSBJbnRlbCBYODYgSVNBIGZvciBlZmZpY2llbnQgd29ya3F1ZXVlIHN1 Ym1pc3Npb24gWzFdCishISFUT0RPOiBMaW5rIHRvIFNwZWMgYXQgdGhlIGJvdHRvbQorCitEU0Eg LSBJbnRlbCBEYXRhIFN0cmVhbWluZyBBY2NlbGVyYXRvciBbMl0KKworVkRDTSAtIFZpcnR1YWwg RGV2aWNlIENvbXBvc2l0aW9uIE1vZHVsZSBbM10KKworU0lPViAtIEludGVsIFNjYWxhYmxlIElP IFZpcnR1YWxpemF0aW9uCisKKworS2V5IENvbmNlcHRzCis9PT09PT09PT09PT0KKworSU9BU0lE IFNldAorLS0tLS0tLS0tLS0KK0FuIElPQVNJRCBzZXQgaXMgYSBncm91cCBvZiBJT0FTSURzIGFs bG9jYXRlZCBmcm9tIHRoZSBzeXN0ZW0td2lkZQorSU9BU0lEIHBvb2wuIFJlZmVyIHRvIElPQVNJ RCBzZXQgQVBJcyBmb3IgbW9yZSBkZXRhaWxzLgorCitJT0FTSUQgc2V0IGlzIHBhcnRpY3VsYXJs eSB1c2VmdWwgZm9yIGd1ZXN0IFNWQSB3aGVyZSBlYWNoIGd1ZXN0IGNvdWxkCitoYXZlIGl0cyBv d24gSU9BU0lEIHNldCBmb3Igc2VjdXJpdHkgYW5kIGVmZmljaWVuY3kgcmVhc29ucy4KKworSU9B U0lEIFNldCBQcml2YXRlIElEIChTUElEKQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQor RWFjaCBJT0FTSUQgc2V0IGhhcyBhIHByaXZhdGUgbmFtZXNwYWNlIG9mIFNQSURzLiBBbiBTUElE IG1hcHMgdG8gYQorc2luZ2xlIHN5c3RlbS13aWRlIElPQVNJRC4gQ29udmVyc2VseSwgZWFjaCBJ T0FTSUQgbWF5IGJlIGFzc29jaWF0ZWQKK3dpdGggYW4gYWxpYXMgSUQsIGxvY2FsIHRvIHRoZSBJ T0FTSUQgc2V0LCBuYW1lZCBTUElELgorU1BJRHMgY2FuIGJlIHVzZWQgYXMgZ3Vlc3QgSU9BU0lE cyB3aGVyZSBlYWNoIGd1ZXN0IGNvdWxkIGRvCitJT0FTSUQgYWxsb2NhdGlvbiBmcm9tIGl0cyBv d24gcG9vbCBhbmQgbWFwIHRoZW0gdG8gaG9zdCBwaHlzaWNhbAorSU9BU0lEcy4gU1BJRHMgYXJl IHBhcnRpY3VsYXJseSB1c2VmdWwgZm9yIHN1cHBvcnRpbmcgbGl2ZSBtaWdyYXRpb24KK3doZXJl IGRlY291cGxpbmcgZ3Vlc3QgYW5kIGhvc3QgcGh5c2ljYWwgcmVzb3VyY2VzIGFyZSBuZWNlc3Nh cnkuCisKK0ZvciBleGFtcGxlLCB0d28gVk1zIGNhbiBib3RoIGFsbG9jYXRlIGd1ZXN0IFBBU0lE L1NQSUQgIzEwMSBidXQgbWFwIHRvCitkaWZmZXJlbnQgaG9zdCBQQVNJRHMgIzIwMSBhbmQgIzIw MiByZXNwZWN0aXZlbHkgYXMgc2hvd24gaW4gdGhlCitkaWFncmFtIGJlbG93LgorOjoKKworIC4t LS0tLS0tLS0tLS0tLS0tLS0uICAgIC4tLS0tLS0tLS0tLS0tLS0tLS0uCisgfCAgIFZNIDEgICAg ICAgICAgIHwgICAgfCAgIFZNIDIgICAgICAgICAgIHwKKyB8ICAgICAgICAgICAgICAgICAgfCAg ICB8ICAgICAgICAgICAgICAgICAgfAorIHwtLS0tLS0tLS0tLS0tLS0tLS18ICAgIHwtLS0tLS0t LS0tLS0tLS0tLS18CisgfCBHUEFTSUQvU1BJRCAxMDEgIHwgICAgfCBHUEFTSUQvU1BJRCAxMDEg IHwKKyAnLS0tLS0tLS0tLS0tLS0tLS0tJyAgICAtLS0tLS0tLS0tLS0tLS0tLS0tJyAgICAgR3Vl c3QKKyBfX19fX19fX19ffF9fX19fX19fX19fX19fX19fX19fX198X19fX19fX19fX19fX19fX19f X18KKyAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICB8ICAgICAgICAgICAgICAgSG9z dAorICAgICAgICAgICB2ICAgICAgICAgICAgICAgICAgICAgIHYKKyAuLS0tLS0tLS0tLS0tLS0t LS0tLiAgICAuLS0tLS0tLS0tLS0tLS0tLS0tLgorIHwgSG9zdCBJT0FTSUQgMjAxICB8ICAgIHwg SG9zdCBJT0FTSUQgMjAyICB8CisgJy0tLS0tLS0tLS0tLS0tLS0tLScgICAgJy0tLS0tLS0tLS0t LS0tLS0tLScKKyB8ICAgSU9BU0lEIHNldCAxICAgfCAgICB8ICAgSU9BU0lEIHNldCAyICAgfAor ICctLS0tLS0tLS0tLS0tLS0tLS0nICAgICctLS0tLS0tLS0tLS0tLS0tLS0nCisKK0d1ZXN0IFBB U0lEIGlzIHRyZWF0ZWQgYXMgSU9BU0lEIHNldCBwcml2YXRlIElEIChTUElEKSB3aXRoaW4gYW4K K0lPQVNJRCBzZXQsIG1hcHBpbmdzIGJldHdlZW4gZ3Vlc3QgYW5kIGhvc3QgSU9BU0lEcyBhcmUg c3RvcmVkIGluIHRoZQorc2V0IGZvciBpbnF1aXJ5LgorCitJT0FTSUQgQVBJcworPT09PT09PT09 PT0KK1RvIGdldCB0aGUgSU9BU0lEIEFQSXMsIHVzZXJzIG11c3QgI2luY2x1ZGUgPGxpbnV4L2lv YXNpZC5oPi4gVGhlc2UgQVBJcworc2VydmUgdGhlIGZvbGxvd2luZyBmdW5jdGlvbmFsaXRpZXM6 CisKKyAgLSBJT0FTSUQgYWxsb2NhdGlvbi9GcmVlCisgIC0gR3JvdXAgbWFuYWdlbWVudCBpbiB0 aGUgZm9ybSBvZiBpb2FzaWRfc2V0CisgIC0gUHJpdmF0ZSBkYXRhIHN0b3JhZ2UgYW5kIGxvb2t1 cAorICAtIFJlZmVyZW5jZSBjb3VudGluZworICAtIEV2ZW50IG5vdGlmaWNhdGlvbiBpbiBjYXNl IG9mIGEgc3RhdGUgY2hhbmdlCisKK0lPQVNJRCBTZXQgTGV2ZWwgQVBJcworLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KK0ZvciB1c2UgY2FzZXMgc3VjaCBhcyBndWVzdCBTVkEgaXQgaXMgbmVj ZXNzYXJ5IHRvIG1hbmFnZSBJT0FTSURzIGF0Citpb2FzaWRfc2V0IGxldmVsLiBGb3IgZXhhbXBs ZSwgVk1zIG1heSBhbGxvY2F0ZSBtdWx0aXBsZSBJT0FTSURzIGZvcgorZ3Vlc3QgcHJvY2VzcyBh ZGRyZXNzIHNoYXJpbmcgKHZTVkEpLiBJdCBpcyBpbXBlcmF0aXZlIHRvIGVuZm9yY2UKK1ZNLUlP QVNJRCBvd25lcnNoaXAgc3VjaCB0aGF0IGEgbWFsaWNpb3VzIGd1ZXN0IGNhbm5vdCB0YXJnZXQg RE1BCit0cmFmZmljIG91dHNpZGUgaXRzIG93biBJT0FTSURzLCBvciBmcmVlIGFuIGFjdGl2ZSBJ T0FTSUQgdGhhdCBiZWxvbmdzCit0byBhbm90aGVyIFZNLgorCitUaGUgSU9BU0lEIHNldCBBUElz IHNlcnZlIHRoZSBmb2xsb3dpbmcgcHVycG9zZXM6CisKKyAtIE93bmVyc2hpcC9wZXJtaXNzaW9u IGVuZm9yY2VtZW50CisgLSBUYWtlIGNvbGxlY3RpdmUgYWN0aW9ucywgZS5nLiBmcmVlIGFuIGVu dGlyZSBzZXQKKyAtIEV2ZW50IG5vdGlmaWNhdGlvbnMgd2l0aGluIGEgc2V0CisgLSBMb29rIHVw IGEgc2V0IGJhc2VkIG9uIHRva2VuCisgLSBRdW90YSBlbmZvcmNlbWVudAorCitFYWNoIElPQVNJ RCBzZXQgaXMgY3JlYXRlZCB3aXRoIGEgdG9rZW4sIHdoaWNoIGNhbiBiZSBvbmUgb2YgdGhlCitm b2xsb3dpbmcgdG9rZW4gdHlwZXM6CisKKyAtIElPQVNJRF9TRVRfVFlQRV9OVUxMIChBcmJpdHJh cnkgdTY0IHZhbHVlKQorIC0gSU9BU0lEX1NFVF9UWVBFX01NIChTZXQgdG9rZW4gaXMgYSBtbV9z dHJ1Y3QpCisKK1RoZSBleHBsaWNpdCBNTSB0b2tlbiB0eXBlIGlzIHVzZWZ1bCB3aGVuIG11bHRp cGxlIHVzZXJzIG9mIGFuIElPQVNJRAorc2V0IHVuZGVyIHRoZSBzYW1lIHByb2Nlc3MgbmVlZCB0 byBjb21tdW5pY2F0ZSBhYm91dCB0aGVpciBzaGFyZWQgSU9BU0lEcy4KK0UuZy4gQW4gSU9BU0lE IHNldCBjcmVhdGVkIGJ5IFZGSU8gZm9yIG9uZSBndWVzdCBjYW4gYmUgYXNzb2NpYXRlZAord2l0 aCB0aGUgS1ZNIGluc3RhbmNlIGZvciB0aGUgc2FtZSBndWVzdCBzaW5jZSB0aGV5IHNoYXJlIGEg Y29tbW9uIG1tX3N0cnVjdC4KK0EgdG9rZW4gbXVzdCBiZSB1bmlxdWUgd2l0aGluIGl0cyB0eXBl LgorCis6OgorCisgc3RydWN0IGlvYXNpZF9zZXQgKmlvYXNpZF9hbGxvY19zZXQodm9pZCAqdG9r ZW4sIGlvYXNpZF90IHF1b3RhLCB1MzIgdHlwZSkKKworIGludCBpb2FzaWRfYWRqdXN0X3NldChz dHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpbnQgcXVvdGEpOworCisgdm9pZCBpb2FzaWRfc2V0X2dl dChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0KQorCisgdm9pZCBpb2FzaWRfc2V0X3B1dChzdHJ1Y3Qg aW9hc2lkX3NldCAqc2V0KQorCisgdm9pZCBpb2FzaWRfc2V0X2dldF9sb2NrZWQoc3RydWN0IGlv YXNpZF9zZXQgKnNldCkKKworIHZvaWQgaW9hc2lkX3NldF9wdXRfbG9ja2VkKHN0cnVjdCBpb2Fz aWRfc2V0ICpzZXQpCisKKyBpbnQgaW9hc2lkX3NldF9mb3JfZWFjaF9pb2FzaWQoc3RydWN0IGlv YXNpZF9zZXQgKnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAoKmZu KShpb2FzaWRfdCBpZCwgdm9pZCAqZGF0YSksCisJCQkJdm9pZCAqZGF0YSkKKworCitJbmRpdmlk dWFsIElPQVNJRCBBUElzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitPbmNlIGFuIGlvYXNpZF9z ZXQgaXMgY3JlYXRlZCwgSU9BU0lEcyBjYW4gYmUgYWxsb2NhdGVkIGZyb20gdGhlIHNldC4KK1dp dGhpbiB0aGUgSU9BU0lEIHNldCBuYW1lc3BhY2UsIHNldCBwcml2YXRlIElEIChTUElEKSBpcyBz dXBwb3J0ZWQuIEluCit0aGUgVk0gdXNlIGNhc2UsIFNQSUQgY2FuIGJlIHVzZWQgZm9yIHN0b3Jp bmcgZ3Vlc3QgUEFTSUQuCisKKzo6CisKKyBpb2FzaWRfdCBpb2FzaWRfYWxsb2Moc3RydWN0IGlv YXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgbWluLCBpb2FzaWRfdCBtYXgsCisgICAgICAgICAgICAg ICAgICAgICAgIHZvaWQgKnByaXZhdGUpOworCisgaW50IGlvYXNpZF9nZXQoc3RydWN0IGlvYXNp ZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkKTsKKworIHZvaWQgaW9hc2lkX3B1dChzdHJ1Y3Qg aW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQpOworCisgaW50IGlvYXNpZF9nZXRfbG9j a2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCk7CisKKyB2b2lkIGlv YXNpZF9wdXRfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCk7 CisKKyB2b2lkICppb2FzaWRfZmluZChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBp b2FzaWQsCisgICAgICAgICAgICAgICAgICAgYm9vbCAoKmdldHRlcikodm9pZCAqKSk7CisKKyBp b2FzaWRfdCBpb2FzaWRfZmluZF9ieV9zcGlkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNp ZF90IHNwaWQpCisKKyBpbnQgaW9hc2lkX2F0dGFjaF9kYXRhKHN0cnVjdCBpb2FzaWRfc2V0ICpz ZXQsIGlvYXNpZF90IGlvYXNpZCwKKyAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKmRhdGEp OworIGludCBpb2FzaWRfYXR0YWNoX3NwaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lk X3QgaW9hc2lkLAorICAgICAgICAgICAgICAgICAgICAgICAgaW9hc2lkX3Qgc3BpZCk7CisKKwor Tm90aWZpY2F0aW9ucworLS0tLS0tLS0tLS0tLQorQW4gSU9BU0lEIG1heSBoYXZlIG11bHRpcGxl IHVzZXJzLCBlYWNoIHVzZXIgbWF5IGhhdmUgaGFyZHdhcmUgY29udGV4dAorYXNzb2NpYXRlZCB3 aXRoIGFuIElPQVNJRC4gV2hlbiB0aGUgc3RhdHVzIG9mIGFuIElPQVNJRCBjaGFuZ2VzLAorZS5n LiBhbiBJT0FTSUQgaXMgYmVpbmcgZnJlZWQsIHVzZXJzIG5lZWQgdG8gYmUgbm90aWZpZWQgc3Vj aCB0aGF0IHRoZQorYXNzb2NpYXRlZCBoYXJkd2FyZSBjb250ZXh0IGNhbiBiZSBjbGVhcmVkLCBm bHVzaGVkLCBhbmQgZHJhaW5lZC4KKworOjoKKworIGludCBpb2FzaWRfcmVnaXN0ZXJfbm90aWZp ZXIoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgc3RydWN0CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBub3RpZmllcl9ibG9jayAqbmIpCisKKyB2b2lkIGlvYXNpZF91bnJlZ2lzdGVyX25v dGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKQorCisgaW50IGlvYXNpZF9yZWdpc3Rl cl9ub3RpZmllcl9tbShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBub3RpZmllcl9ibG9jayAqbmIpCisKKyB2b2lkIGlvYXNpZF91 bnJlZ2lzdGVyX25vdGlmaWVyX21tKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKKworIGlu dCBpb2FzaWRfbm90aWZ5KGlvYXNpZF90IGlvYXNpZCwgZW51bSBpb2FzaWRfbm90aWZ5X3ZhbCBj bWQsCisgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IGZsYWdzKQorCisiX21tIiBmbGF2 b3Igb2YgdGhlIGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcigpIEFQSXMgYXJlIHVzZWQgd2hlbgor YW4gSU9BU0lEIHVzZXIgbmVlZCB0byBsaXN0ZW4gdG8gdGhlIElPQVNJRCBldmVudHMgYmVsb25n IHRvIGEKK3Byb2Nlc3MgYnV0IHdpdGhvdXQgdGhlIGtub3dsZWRnZSBvZiB0aGUgYXNzb2NpYXRl ZCBpb2FzaWRfc2V0LgorCitFdmVudHMKK35+fn5+fgorTm90aWZpY2F0aW9uIGV2ZW50cyBhcmUg cGVydGluZW50IHRvIGluZGl2aWR1YWwgSU9BU0lEcywgdGhleSBjYW4gYmUKK29uZSBvZiB0aGUg Zm9sbG93aW5nOgorCisgLSBBTExPQworIC0gRlJFRQorIC0gQklORAorIC0gVU5CSU5ECisKK09y ZGVyaW5nCit+fn5+fn5+fgorT3JkZXJpbmcgaXMgc3VwcG9ydGVkIGJ5IElPQVNJRCBub3RpZmlj YXRpb24gcHJpb3JpdGllcyBhcyB0aGUKK2ZvbGxvd2luZyAoaW4gYXNjZW5kaW5nIG9yZGVyKToK KworOjoKKworIGVudW0gaW9hc2lkX25vdGlmaWVyX3ByaW9zIHsKKwlJT0FTSURfUFJJT19MQVNU LAorCUlPQVNJRF9QUklPX0lPTU1VLAorCUlPQVNJRF9QUklPX0RFVklDRSwKKwlJT0FTSURfUFJJ T19DUFUsCisgfTsKKworV2hlbiByZWdpc3RlcmVkLCBub3RpZmllcnMgYXJlIGFzc2lnbmVkIGEg cHJpb3JpdHkgdGhhdCBhZmZlY3QgdGhlCitjYWxsIG9yZGVyLiBGb3IgZXhhbXBsZSwgbm90aWZp ZXJzIHdpdGggQ1BVIHByaW9yaXR5IGdldCBjYWxsZWQgYmVmb3JlCitub3RpZmllcnMgd2l0aCBk ZXZpY2UgcHJpb3JpdHkgYW5kIHNvIG9uLgorCitUaGUgdHlwaWNhbCB1c2UgY2FzZSBpcyB3aGVu IGFuIElPQVNJRCBpcyBmcmVlZCBkdWUgdG8gYW4gZXhjZXB0aW9uLCBETUEKK3NvdXJjZSBzaG91 bGQgYmUgcXVpZXNjZWQgYmVmb3JlIHRlYXJpbmcgZG93biBvdGhlciBoYXJkd2FyZSBjb250ZXh0 cworaW4gdGhlIHN5c3RlbS4gVGhpcyB3aWxsIHJlZHVjZSB0aGUgY2h1cm4gaW4gaGFuZGxpbmcg ZmF1bHRzLiBETUEgd29yaworc3VibWlzc2lvbiBpcyBwZXJmb3JtZWQgYnkgdGhlIENQVSB3aGlj aCBpcyBncmFudGVkIGhpZ2hlciBwcmlvcml0eSB0aGFuCitkZXZpY2VzLgorCitMZXZlbCBTZW5z aXRpdml0eQorfn5+fn5+fn5+fn5+fn5+fn4KK0ZvciBlYWNoIElPQVNJRCBzdGF0ZSB0cmFuc2l0 aW9uLCBJT0FTSUQgY29yZSBlbnN1cmVzIHRoYXQgdGhlcmUgaXMKK29ubHkgb25lIG5vdGlmaWNh dGlvbiBzZW50LiBUaGlzIHJlc2VtYmxlcyBsZXZlbCB0cmlnZ2VyZWQgaW50ZXJydXB0Cit3aGVy ZSBhIHNpbmdsZSBpbnRlcnJ1cHQgaXMgcmFpc2VkIGR1cmluZyBhIHN0YXRlIHRyYW5zaXRpb24u CitGb3IgZXhhbXBsZSwgaWYgaW9hc2lkX2ZyZWUoKSBpcyBjYWxsZWQgdHdpY2UgYnkgYSB1c2Vy IGJlZm9yZSB0aGUKK0lPQVNJRCBpcyByZWNsYWltZWQsIElPQVNJRCBjb3JlIHdpbGwgb25seSBz ZW5kIG91dCBhIHNpbmdsZQorSU9BU0lEX05PVElGWV9GUkVFIGV2ZW50LiBTaW1pbGFybHksIGZv ciBJT0FTSURfTk9USUZZX0JJTkQvVU5CSU5ECitldmVudHMsIHdoaWNoIGlzIG9ubHkgc2VudCBv dXQgb25jZSB3aGVuIGEgU1BJRCBpcyBhdHRhY2hlZC9kZXRhY2hlZC4KKworSU9BU0lEIG5vdGlm aWNhdGlvbnMgY2Fubm90IGJlIHNlbnQgZGlyZWN0bHkgYnkgSU9BU0lEIHVzZXJzLCB0aGV5IGFy ZQorc2VudCBvdXQgYnkgdGhlIElPQVNJRCBjb3JlIGFzIGEgYnktcHJvZHVjdCBvZiB0aGUgZm9s bG93aW5nIEFQSXM6CistIGlvYXNpZF9hbGxvYy9mcmVlKCksIGVtaXQgSU9BU0lEX05PVElGWV9B TExPQy9GUkVFCistIGlvYXNpZF9hdHRhY2gvZGV0YWNoX3NwaWQoKSBlbWl0IElPQVNJRF9OT1RJ RllfQklORC9VTkJJTkQKKworU2NvcGVzCit+fn5+fn4KK1RoZXJlIGFyZSB0d28gdHlwZXMgb2Yg bm90aWZpZXJzIGluIElPQVNJRCBjb3JlOiBzeXN0ZW0td2lkZSBhbmQKK2lvYXNpZF9zZXQtd2lk ZS4KKworU3lzdGVtLXdpZGUgbm90aWZpZXIgaXMgY2F0ZXJpbmcgZm9yIHVzZXJzIHRoYXQgbmVl ZCB0byBoYW5kbGUgYWxsIHRoZQorSU9BU0lEcyBpbiB0aGUgc3lzdGVtLiBFLmcuIFRoZSBJT01N VSBkcml2ZXIuCisKK1BlciBpb2FzaWRfc2V0IG5vdGlmaWVyIGNhbiBiZSB1c2VkIGJ5IFZNIHNw ZWNpZmljIGNvbXBvbmVudHMgc3VjaCBhcworS1ZNLiBBZnRlciBhbGwsIGVhY2ggS1ZNIGluc3Rh bmNlIG9ubHkgY2FyZXMgYWJvdXQgSU9BU0lEcyB3aXRoaW4gaXRzCitvd24gc2V0L2d1ZXN0Lgor CisKK0F0b21pY2l0eQorfn5+fn5+fn5+CitJT0FTSUQgbm90aWZpZXJzIGFyZSBhdG9taWMgZHVl IHRvIHNwaW5sb2NrcyB1c2VkIGluc2lkZSB0aGUgSU9BU0lECitjb3JlLiBGb3IgdGFza3MgdGhh dCBjYW5ub3QgYmUgY29tcGxldGVkIGluIHRoZSBub3RpZmllciBoYW5kbGVyLAorYXN5bmMgd29y ayBjYW4gYmUgc3VibWl0dGVkIHRvIGNvbXBsZXRlIHRoZSB3b3JrIGxhdGVyIGFzIGxvbmcgYXMK K3RoZXJlIGlzIG5vIG9yZGVyaW5nIHJlcXVpcmVtZW50LgorCitSZWZlcmVuY2UgY291bnRpbmcK Ky0tLS0tLS0tLS0tLS0tLS0tLQorSU9BU0lEIGxpZmVjeWNsZSBtYW5hZ2VtZW50IGlzIGJhc2Vk IG9uIHJlZmVyZW5jZSBjb3VudGluZy4gVXNlcnMgb2YKK0lPQVNJRCB3aG8gaW50ZW5kIHRvIGFs aWduIGxpZmVjeWNsZSB3aXRoIHRoZSBJT0FTSUQgbmVlZCB0byBob2xkCithIHJlZmVyZW5jZSBv ZiB0aGUgSU9BU0lELiBUaGUgSU9BU0lEIHdpbGwgbm90IGJlIHJldHVybmVkIHRvIHRoZSBwb29s Citmb3IgYWxsb2NhdGlvbiB1bnRpbCBhbGwgcmVmZXJlbmNlcyBhcmUgZHJvcHBlZC4gQ2FsbGlu ZyBpb2FzaWRfZnJlZSgpCit3aWxsIG1hcmsgdGhlIElPQVNJRCBhcyBGUkVFX1BFTkRJTkcgaWYg dGhlIElPQVNJRCBoYXMgb3V0c3RhbmRpbmcKK3JlZmVyZW5jZXMuIE5vIG5ldyByZWZlcmVuY2Vz IGNhbiBiZSB0YWtlbiBieSBpb2FzaWRfZ2V0KCkgb25jZSBhbgorSU9BU0lEIGlzIGluIHRoZSBG UkVFX1BFTkRJTkcgc3RhdGUuIGlvYXNpZF9mcmVlKCkgY2FuIGJlIGNhbGxlZAorbXVsdGlwbGUg dGltZXMgd2l0aG91dCBhbiBlcnJvciB1bnRpbCBhbGwgcmVmcyBhcmUgZHJvcHBlZC4KKworaW9h c2lkX3B1dCgpIGRlY3JlbWVudHMgYW5kIHRlc3RzIHJlZmNvdW50IG9mIHRoZSBJT0FTSUQuIElm IHJlZmNvdW50CitpcyAwLCBpb2FzaWQgd2lsbCBiZSBmcmVlZC4gRGVsZXRlZCBmcm9tIHRoZSBz eXN0ZW0td2lkZSB4YXJyYXkgYXMKK3dlbGwgYXMgcGVyIHNldCB4YXJyYXkuIFRoZSBJT0FTSUQg d2lsbCBiZSByZXR1cm5lZCB0byB0aGUgcG9vbCBhbmQKK2F2YWlsYWJsZSBmb3IgbmV3IGFsbG9j YXRpb25zLgorCitFdmVudCBub3RpZmljYXRpb25zIGFyZSB1c2VkIHRvIGluZm9ybSB1c2VycyBv ZiBJT0FTSUQgc3RhdHVzIGNoYW5nZS4KK0lPQVNJRF9GUkVFIGV2ZW50IHByb21wdHMgdXNlcnMg dG8gZHJvcCB0aGVpciByZWZlcmVuY2VzIGFmdGVyCitjbGVhcmluZyBpdHMgY29udGV4dC4KKwor Rm9yIGV4YW1wbGUsIG9uIFZULWQgcGxhdGZvcm0gd2hlbiBhbiBJT0FTSUQgaXMgZnJlZWQsIHRl YXJkb3duCithY3Rpb25zIGFyZSBwZXJmb3JtZWQgb24gS1ZNLCBkZXZpY2UgZHJpdmVyIChWRENN KSwgYW5kIHRoZSBJT01NVQorZHJpdmVyLiBUbyBxdWllc2NlIFZDUFUgZm9yIHdvcmsgc3VibWlz c2lvbiwgS1ZNIG5vdGlmaWVyIGhhbmRsZXIgbXVzdAorYmUgY2FsbGVkIGJlZm9yZSBWRENNIGhh bmRsZXIuIFRoZXJlZm9yZSwgS1ZNIGFuZCBWRENNIHNoYWxsIHVzZQorbm90aWZpY2F0aW9uIHBy aW9yaXR5IElPQVNJRF9QUklPX0NQVSBhbmRJT0FTSURfUFJJT19ERVZJQ0UKK3Jlc3BlY3RpdmVs eS4KKworRm9yIGJvdGggS1ZNIGFuZCBWRENNLCBub3RpZmllciBibG9ja3Mgc2hhbGwgYmUgcmVn aXN0ZXJlZCBvbiB0aGUKK0lPQVNJRCBzZXQgc3VjaCB0aGF0ICpvbmx5KiBldmVudHMgZnJvbSB0 aGUgbWF0Y2hpbmcgVk0gYXJlIHJlY2VpdmVkLgorCitJZiBLVk0gYXR0ZW1wdHMgdG8gcmVnaXN0 ZXIgYSBub3RpZmllciBibG9jayBiZWZvcmUgdGhlIElPQVNJRCBzZXQgaXMKK2NyZWF0ZWQgdXNp bmcgdGhlIE1NIHRva2VuLCB0aGUgbm90aWZpZXIgYmxvY2sgd2lsbCBiZSBwbGFjZWQgb24gYQor cGVuZGluZyBsaXN0IGluc2lkZSBJT0FTSUQgY29yZS4gT25jZSB0aGUgdG9rZW4gbWF0Y2hpbmcg SU9BU0lEIHNldAoraXMgY3JlYXRlZCwgSU9BU0lEIHdpbGwgcmVnaXN0ZXIgdGhlIG5vdGlmaWVy IGJsb2NrIGF1dG9tYXRpY2FsbHkuCitJT0FTSUQgY29yZSBkb2VzIG5vdCByZXBsYXkgZXZlbnRz IGZvciB0aGUgZXhpc3RpbmcgSU9BU0lEcyBpbiB0aGUKK3NldC4gRm9yIElPQVNJRCBzZXQgb2Yg TU0gdHlwZSwgbm90aWZpY2F0aW9uIGJsb2NrcyBjYW4gYmUgcmVnaXN0ZXJlZAorb24gZW1wdHkg c2V0cyBvbmx5LiBUaGlzIGlzIHRvIGF2b2lkIGxvc3QgZXZlbnRzLgorCitJT01NVSBkcml2ZXIg c2hhbGwgcmVnaXN0ZXIgbm90aWZpZXIgYmxvY2sgb24gZ2xvYmFsIGNoYWluOjoKKworIHN0YXRp YyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgcGFzaWRfbmJfdnRkID0geworCS5ub3RpZmllcl9jYWxs ID0gcGFzaWRfc3RhdHVzX2NoYW5nZV92dGQsCisJLnByaW9yaXR5ICAgICAgPSBJT0FTSURfUFJJ T19JT01NVSwKKyB9OworCitDdXN0b20gYWxsb2NhdG9yIEFQSXMKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorCis6OgorCisgaW50IGlvYXNpZF9yZWdpc3Rlcl9hbGxvY2F0b3Ioc3RydWN0IGlvYXNp ZF9hbGxvY2F0b3Jfb3BzICphbGxvY2F0b3IpOworCisgdm9pZCBpb2FzaWRfdW5yZWdpc3Rlcl9h bGxvY2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3BzICphbGxvY2F0b3IpOworCitBbGxv Y2F0b3IgQ2hvaWNlcworfn5+fn5+fn5+fn5+fn5+fn4KK0lPQVNJRHMgYXJlIGFsbG9jYXRlZCBm b3IgYm90aCBob3N0IGFuZCBndWVzdCBTVkEvSU9WQSB1c2FnZS4gSG93ZXZlciwKK2FsbG9jYXRv cnMgY2FuIGJlIGRpZmZlcmVudC4gRm9yIGV4YW1wbGUsIG9uIFZULWQgZ3Vlc3QgUEFTSUQKK2Fs bG9jYXRpb24gbXVzdCBiZSBwZXJmb3JtZWQgdmlhIGEgdmlydHVhbCBjb21tYW5kIGludGVyZmFj ZSB3aGljaCBpcworZW11bGF0ZWQgYnkgVk1NLgorCitJT0FTSUQgY29yZSBoYXMgdGhlIG5vdGlv biBvZiAiY3VzdG9tIGFsbG9jYXRvciIgc3VjaCB0aGF0IGd1ZXN0IGNhbgorcmVnaXN0ZXIgdmly dHVhbCBjb21tYW5kIGFsbG9jYXRvciB0aGF0IHByZWNlZGVzIHRoZSBkZWZhdWx0IG9uZS4KKwor TmFtZXNwYWNlcworfn5+fn5+fn5+fgorSU9BU0lEcyBhcmUgbGltaXRlZCBzeXN0ZW0gcmVzb3Vy Y2VzIHRoYXQgZGVmYXVsdCB0byAyMCBiaXRzIGluCitzaXplLiBFYWNoIGRldmljZSBjYW4gaGF2 ZSBpdHMgb3duIFBBU0lEIHRhYmxlIGZvciBzZWN1cml0eSByZWFzb25zLgorVGhlb3JldGljYWxs eSB0aGUgbmFtZXNwYWNlIGNhbiBiZSBwZXIgZGV2aWNlIGFsc28uCisKK0hvd2V2ZXIgSU9BU0lE IG5hbWVzcGFjZSBpcyBzeXN0ZW0td2lkZSBmb3IgdHdvIHJlYXNvbnM6CistIFNpbXBsaWNpdHkK Ky0gU2hhcmluZyByZXNvdXJjZXMgb2YgYSBzaW5nbGUgZGV2aWNlIHRvIG11bHRpcGxlIFZNcy4K KworVGFrZSBWVC1kIGFzIGFuIGV4YW1wbGUsIFZULWQgc3VwcG9ydHMgc2hhcmVkIHdvcmtxdWV1 ZSBhbmQgRU5RQ01EWzFdCit3aGVyZSBvbmUgSU9BU0lEIGNvdWxkIGJlIHVzZWQgdG8gc3VibWl0 IHdvcmsgb24gbXVsdGlwbGUgZGV2aWNlcyB0aGF0CithcmUgc2hhcmVkIHdpdGggb3RoZXIgVk1z LiBUaGlzIHJlcXVpcmVzIElPQVNJRCB0byBiZQorc3lzdGVtLXdpZGUuIFRoaXMgaXMgYWxzbyB0 aGUgcmVhc29uIHdoeSBndWVzdHMgbXVzdCB1c2UgYW4KK2VtdWxhdGVkIHZpcnR1YWwgY29tbWFu ZCBpbnRlcmZhY2UgdG8gYWxsb2NhdGUgSU9BU0lEIGZyb20gdGhlIGhvc3QuCisKK0xpZmUgY3lj bGUKKz09PT09PT09PT0KK1RoaXMgc2VjdGlvbiBjb3ZlcnMgSU9BU0lEIGxpZmUgY3ljbGUgbWFu YWdlbWVudCBmb3IgYm90aCBiYXJlLW1ldGFsCithbmQgZ3Vlc3QgdXNhZ2VzLiBJbiBiYXJlLW1l dGFsIFNWQSwgTU1VIG5vdGlmaWVyIGlzIGRpcmVjdGx5IGhvb2tlZAordXAgd2l0aCBJT01NVSBk cml2ZXIsIHRoZXJlZm9yZSB0aGUgSU9BU0lEIGxpZmUgY3ljbGUgbWF0Y2hlcyB0aGUKK3Byb2Nl c3MgYWRkcmVzcyBzcGFjZSAoTU0pIGxpZmUgY3ljbGUuCisKK0hvd2V2ZXIsIGd1ZXN0IE1NVSBu b3RpZmllciBpcyBub3QgYXZhaWxhYmxlIHRvIGhvc3QgSU9NTVUgZHJpdmVyLAord2hlbiBndWVz dCBNTSB0ZXJtaW5hdGVzIHVuZXhwZWN0ZWRseSwgdGhlIGV2ZW50cyBoYXZlIHRvIGdvIHRocm91 Z2gKK1ZGSU8gYW5kIElPTU1VIFVBUEkgdG8gcmVhY2ggaG9zdCBJT01NVSBkcml2ZXIuIFRoZXJl IGFyZSBhbHNvIG1vcmUKK3BhcnRpZXMgaW52b2x2ZWQgaW4gZ3Vlc3QgU1ZBLCBlLmcuIG9uIElu dGVsIFZULWQgcGxhdGZvcm0sIElPQVNJRHMKK2FyZSB1c2VkIGJ5IElPTU1VIGRyaXZlciwgS1ZN LCBWRENNLCBhbmQgVkZJTy4KKworTmF0aXZlIElPQVNJRCBMaWZlIEN5Y2xlIChWVC1kIEV4YW1w bGUpCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVGhlIG5vcm1h bCBmbG93IG9mIG5hdGl2ZSBTVkEgY29kZSB3aXRoIEludGVsIERhdGEgU3RyZWFtaW5nCitBY2Nl bGVyYXRvcihEU0EpIFsyXSBhcyBleGFtcGxlOgorCisxLiBIb3N0IHVzZXIgb3BlbnMgYWNjZWxl cmF0b3IgRkQsIGUuZy4gRFNBIGRyaXZlciwgb3IgdWFjY2U7CisyLiBEU0EgZHJpdmVyIGFsbG9j YXRlIFdRLCBkbyBzdmFfYmluZF9kZXZpY2UoKTsKKzMuIElPTU1VIGRyaXZlciBjYWxscyBpb2Fz aWRfYWxsb2MoKSwgdGhlbiBiaW5kIFBBU0lEIHdpdGggZGV2aWNlLAorICAgbW11X25vdGlmaWVy X2dldCgpCis0LiBETUEgc3RhcnRzIGJ5IERTQSBkcml2ZXIgdXNlcnNwYWNlCis1LiBEU0EgdXNl cnNwYWNlIGNsb3NlIEZECis2LiBEU0EvdWFjY2Uga2VybmVsIGRyaXZlciBoYW5kbGVzIEZELmNs b3NlKCkKKzcuIERTQSBkcml2ZXIgc3RvcHMgRE1BCis4LiBEU0EgZHJpdmVyIGNhbGxzIHN2YV91 bmJpbmRfZGV2aWNlKCk7Cis5LiBJT01NVSBkcml2ZXIgZG9lcyB1bmJpbmQsIGNsZWFycyBQQVNJ RCBjb250ZXh0IGluIElPTU1VLCBmbHVzaAorICAgVExCcy4gbW11X25vdGlmaWVyX3B1dCgpIGNh bGxlZC4KKzEwLiBtbXVfbm90aWZpZXIucmVsZWFzZSgpIGNhbGxlZCwgSU9NTVUgU1ZBIGNvZGUg Y2FsbHMgaW9hc2lkX2ZyZWUoKSoKKzExLiBUaGUgSU9BU0lEIGlzIHJldHVybmVkIHRvIHRoZSBw b29sLCByZWNsYWltZWQuCisKKzo6CisKKyAgICogV2l0aCBFTlFDTUQsIFBBU0lEIHVzZWQgb24g VlQtZCBpcyBub3QgcmVsZWFzZWQgaW4gbW11X25vdGlmaWVyKCkgYnV0CisgICAgIG1tZHJvcCgp LiBtbWRyb3AgY29tZXMgYWZ0ZXIgRkQgY2xvc2Ugd2hpY2ggZG9lcyBub3QgbWFrZSBhIGRpZmZl cmVuY2UuCisKK0R1cmluZyB0aGUgbm9ybWFsIHRlYXJkb3duLCB0aGUgZm9sbG93aW5nIHRocmVl IGtleSBzdGVwcyB3b3VsZCBoYXBwZW4gaW4KK29yZGVyOiAoNyksICg5KSwgKDExKS4KKworRXhj ZXB0aW9uIGhhcHBlbnMgd2hlbiBwcm9jZXNzIHRlcm1pbmF0ZXMgKmJlZm9yZSogZGV2aWNlIGRy aXZlciBzdG9wcworRE1BIGFuZCBjYWxsIElPTU1VIGRyaXZlciB0byB1bmJpbmQuIFRoZSBkZXRh aWxlZCBmbG93IG9mIHByb2Nlc3MKK2V4aXRzIGFyZSBhcyBmb2xsb3dzOgorCis6OgorCisgICBk b19leGl0KCkgeworCWV4aXRfbW0oKSB7CisJCW1tX3B1dCgpOworCQlleGl0X21tYXAoKSB7CisJ CQlpbnRlbF9pbnZhbGlkYXRlX3JhbmdlKCkgLy9tbXUgbm90aWZpZXIKKwkJCXRsYl9maW5pc2hf bW11KCkKKwkJCW1tdV9ub3RpZmllcl9yZWxlYXNlKG1tKSB7CisJCQkJaW50ZWxfbW1fcmVsZWFz ZSgpIHsKKyAgICg5KQkJCQkJaW50ZWxfaW9tbXVfdGVhcmRvd25fcGFzaWQoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnRlbF9pb21tdV9mbHVzaF90bGJzKCk7 CisJCQkJfQorCQkJCS8vIHRsYl9pbnZhbGlkYXRlX3JhbmdlIGNiIHJlbW92ZWQKKwkJCX0KKwkJ CXVubWFwX3ZtYXMoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGZyZWVfcGd0YWJsZXMoKTsg Ly8gSU9NTVUgY2Fubm90IHdhbGsgUEdUIGFmdGVyIHRoaXMKKwkJfTsKKwl9CisJZXhpdF9maWxl cyh0c2spIHsKKwkJY2xvc2VfZmlsZXMoKSB7CisJCQlkc2FfY2xvc2UoKTsKKyAgICg3KQkJCWRz YV9zdG9wX2RtYSgpOworICAgICAgICAgICAgICAgICAgICAgICAgaW50ZWxfc3ZtX3VuYmluZF9w YXNpZCgpOyAvL25vdGhpbmcgdG8gZG8KKwkJfQorCX0KKyAgIH0KKworICAgbW1kcm9wKCkgLyog c29tZSByYW5kb20gdGltZSBsYXRlciwgbGF6eSBtbSB1c2VyICovIHsKKyAgIAltbV9mcmVlX3Bn ZCgpOworICAgICAgICBkZXN0cm95X2NvbnRleHQobW0pOyB7CisgICAoMTEpCSAgICAgICAgaW9h c2lkX2ZyZWUoKTsKKwl9CisgICB9CisKK0FzIHNob3duIGluIHRoZSBsaXN0IGFib3ZlLCBzdGVw ICMyIGNvdWxkIGhhcHBlbiBiZWZvcmUKKyMxLiBVbnJlY292ZXJhYmxlKFVSKSBmYXVsdHMgY291 bGQgaGFwcGVuIGJldHdlZW4gIzIgYW5kICMxLgorRmF1bHQgcHJvY2Vzc2luZyBpcyBkaXNhYmxl ZCBieSB0aGUgSU9NTVUgZHJpdmVyIGluICMyLCB0aGVyZWZvcmUgdGhlIFVSCitmYXVsdCBuZXZl ciByZWFjaGVzIHRoZSBkcml2ZXIuCisKKworQWxzbyBub3RpY2UgdGhhdCBUTEIgaW52YWxpZGF0 aW9uIG9jY3VycyBhdCBtbXVfbm90aWZpZXIKK2ludmFsaWRhdGVfcmFuZ2UgY2FsbGJhY2sgYXMg d2VsbCBhcyB0aGUgcmVsZWFzZSBjYWxsYmFjay4gVGhlIHJlYXNvbgoraXMgdGhhdCByZWxlYXNl IGNhbGxiYWNrIHdpbGwgZGVsZXRlIElPTU1VIGRyaXZlciBmcm9tIHRoZSBub3RpZmllcgorY2hh aW4gd2hpY2ggbWF5IHNraXAgaW52YWxpZGF0ZV9yYW5nZSgpIGNhbGxzIGR1cmluZyB0aGUgZXhp dCBwYXRoLgorCitUbyBhdm9pZCB1bm5lY2Vzc2FyeSByZXBvcnRpbmcgb2YgVVIgZmF1bHQsIElP TU1VIGRyaXZlciBzaGFsbCBkaXNhYmxlCitmYXVsdCByZXBvcnRpbmcgYWZ0ZXIgZnJlZSBhbmQg YmVmb3JlIHVuYmluZC4KKworR3Vlc3QgSU9BU0lEIExpZmUgQ3ljbGUgKFZULWQgRXhhbXBsZSkK Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitHdWVzdCBJT0FTSUQgbGlm ZSBjeWNsZSBzdGFydHMgd2l0aCBndWVzdCBkcml2ZXIgb3BlbigpLCB0aGlzIGNvdWxkIGJlCit1 YWNjZSBvciBpbmRpdmlkdWFsIGFjY2VsZXJhdG9yIGRyaXZlciBzdWNoIGFzIERTQS4gQXQgRkQg b3BlbiwKK3N2YV9iaW5kX2RldmljZSgpIGlzIGNhbGxlZCB3aGljaCB0cmlnZ2VycyBhIHNlcmll cyBvZiBhY3Rpb25zLgorCitUaGUgZXhhbXBsZSBiZWxvdyBpcyBhbiBpbGx1c3RyYXRpb24gb2Yg Km5vcm1hbCogb3BlcmF0aW9ucyB0aGF0CitpbnZvbHZlcyAqYWxsKiB0aGUgU1cgY29tcG9uZW50 cyBpbiBWVC1kLiBUaGUgZmxvdyBjYW4gYmUgc2ltcGxlciBpZgorbm8gRU5RQ01EIGlzIHN1cHBv cnRlZC4KKworOjoKKworICAgICBWRklPICAgICAgICBJT01NVSAgICAgICAgS1ZNICAgICAgICBW RENNICAgICAgICBJT0FTSUQgICAgICAgUmVmCisgICAuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4KKyAgIDEgICAgICAgICAg ICAgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyL19tbSgpCisgICAyIGlvYXNpZF9hbGxvYygpICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxCisgICAzIGJpbmRf Z3Bhc2lkKCkKKyAgIDQgICAgICAgICAgICAgaW9tbXVfYmluZCgpLT5pb2FzaWRfZ2V0KCkgICAg ICAgICAgICAgICAgICAgICAgIDIKKyAgIDUgICAgICAgICAgICAgaW9hc2lkX25vdGlmeShCSU5E KQorICAgNiAgICAgICAgICAgICAgICAgICAgICAgICAgLT4gaW9hc2lkX2dldCgpICAgICAgICAg ICAgICAgICAgICAgMworICAgNyAgICAgICAgICAgICAgICAgICAgICAgICAgLT4gdm1jc191cGRh dGVfYXRvbWljKCkKKyAgIDggbWRldl93cml0ZShncGFzaWQpCisgICA5ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgaHBhc2lkPQorICAgMTAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGZpbmRfYnlfc3BpZChncGFzaWQpICAgICAgNAorICAgMTEgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHZkZXZfd3JpdGUoaHBhc2lkKQorICAgMTIgLS0tLS0t LS0gR1VFU1QgU1RBUlRTIERNQSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgMTMgLS0t LS0tLS0gR1VFU1QgU1RPUFMgRE1BIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAxNCBt ZGV2X2NsZWFyKGdwYXNpZCkKKyAgIDE1ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB2ZGV2X2NsZWFyKGhwYXNpZCkKKyAgIDE2ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBpb2FzaWRfcHV0KCkgICAgICAgICAgICAgICAzCisgICAxNyB1bmJpbmRfZ3Bhc2lkKCkK KyAgIDE4ICAgICAgICAgICAgaW9tbXVfdWJpbmQoKQorICAgMTkgICAgICAgICAgICBpb2FzaWRf bm90aWZ5KFVOQklORCkKKyAgIDIwICAgICAgICAgICAgICAgICAgICAgICAgICAtPiB2bWNzX3Vw ZGF0ZV9hdG9taWMoKQorICAgMjEgICAgICAgICAgICAgICAgICAgICAgICAgIC0+IGlvYXNpZF9w dXQoKSAgICAgICAgICAgICAgICAgICAgIDIKKyAgIDIyIGlvYXNpZF9mcmVlKCkgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxCisgICAyMyAgICAgICAgICAg IGlvYXNpZF9wdXQoKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMAorICAg MjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVjbGFp bWVkCisgICAtLS0tLS0tLS0tLS0tLSBOZXcgTGlmZSBDeWNsZSBCZWdpbiAtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisgICAxICBpb2FzaWRfYWxsb2MoKSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAtPiAgICAgICAgICAgMQorCisgICBOb3RlOiBJT0FTSUQgTm90aWZpY2F0 aW9uIEV2ZW50czogRlJFRSwgQklORCwgVU5CSU5ECisKK0V4Y2VwdGlvbiBjYXNlcyBhcmlzZSB3 aGVuIGEgZ3Vlc3QgY3Jhc2hlcyBvciBhIG1hbGljaW91cyBndWVzdAorYXR0ZW1wdHMgdG8gY2F1 c2UgZGlzcnVwdGlvbiBvbiB0aGUgaG9zdCBzeXN0ZW0uIFRoZSBmYXVsdCBoYW5kbGluZworcnVs ZXMgYXJlOgorCisxLiBJT0FTSUQgZnJlZSBtdXN0ICphbHdheXMqIHN1Y2NlZWQuCisyLiBBbiBp bmFjdGl2ZSBwZXJpb2QgbWF5IGJlIHJlcXVpcmVkIGJlZm9yZSB0aGUgZnJlZWQgSU9BU0lEIGlz CisgICByZWNsYWltZWQuIER1cmluZyB0aGlzIHBlcmlvZCwgY29uc3VtZXJzIG9mIElPQVNJRCBw ZXJmb3JtIGNsZWFudXAuCiszLiBNYWxmdW5jdGlvbiBpcyBsaW1pdGVkIHRvIHRoZSBndWVzdCBv d25lZCByZXNvdXJjZXMgZm9yIGFsbAorICAgcHJvZ3JhbW1pbmcgZXJyb3JzLgorCitUaGUgcHJp bWFyeSBzb3VyY2Ugb2YgZXhjZXB0aW9uIGlzIHdoZW4gdGhlIGZvbGxvd2luZyBhcmUgb3V0IG9m CitvcmRlcjoKKworMS4gU3RhcnQvU3RvcCBvZiBETUEgYWN0aXZpdHkKKyAgIChHdWVzdCBkZXZp Y2UgZHJpdmVyLCBtZGV2IHZpYSBWRklPKQorMi4gU2V0dXAvVGVhcmRvd24gb2YgSU9NTVUgUEFT SUQgY29udGV4dCwgSU9UTEIsIERldlRMQiBmbHVzaGVzCisgICAoSG9zdCBJT01NVSBkcml2ZXIg YmluZC91bmJpbmQpCiszLiBTZXR1cC9UZWFyZG93biBvZiBWTUNTIFBBU0lEIHRyYW5zbGF0aW9u IHRhYmxlIGVudHJpZXMgKEtWTSkgaW4KKyAgIGNhc2Ugb2YgRU5RQ01ECis0LiBQcm9ncmFtbWlu Zy9DbGVhcmluZyBob3N0IFBBU0lEIGluIFZEQ00gKEhvc3QgVkRDTSBkcml2ZXIpCis1LiBJT0FT SUQgYWxsb2MvZnJlZSAoSG9zdCBJT0FTSUQpCisKK1ZGSU8gaXMgdGhlICpvbmx5KiB1c2VyLWtl cm5lbCBpbnRlcmZhY2UsIHdoaWNoIGlzIHVsdGltYXRlbHkKK3Jlc3BvbnNpYmxlIGZvciBleGNl cHRpb24gaGFuZGxpbmcuCisKKyMxIGlzIHByb2Nlc3NlZCB0aGUgc2FtZSB3YXkgYXMgdGhlIGFz c2lnbmVkIGRldmljZSB0b2RheSBiYXNlZCBvbgorZGV2aWNlIGZpbGUgZGVzY3JpcHRvcnMgYW5k IGV2ZW50cy4gVGhlcmUgaXMgbm8gc3BlY2lhbCBoYW5kbGluZy4KKworIzMgaXMgYmFzZWQgb24g YmluZC91bmJpbmQgZXZlbnRzIGVtaXR0ZWQgYnkgIzIuCisKKyM0IGlzIG5hdHVyYWxseSBhbGln bmVkIHdpdGggSU9BU0lEIGxpZmUgY3ljbGUgaW4gdGhhdCBhbiBpbGxlZ2FsCitndWVzdCBQQVNJ RCBwcm9ncmFtbWluZyB3b3VsZCBmYWlsIGluIG9idGFpbmluZyByZWZlcmVuY2Ugb2YgdGhlCitt YXRjaGluZyBob3N0IElPQVNJRC4KKworIzUgaXMgc2ltaWxhciB0byAjNC4gVGhlIGZhdWx0IHdp bGwgYmUgcmVwb3J0ZWQgdG8gdGhlIHVzZXIgaWYgUEFTSUQKK3VzZWQgaW4gdGhlIEVOUUNNRCBp cyBub3Qgc2V0IHVwIGluIFZNQ1MgUEFTSUQgdHJhbnNsYXRpb24gdGFibGUuCisKK1RoZXJlZm9y ZSwgdGhlIHJlbWFpbmluZyBvdXQgb2Ygb3JkZXIgcHJvYmxlbSBpcyBiZXR3ZWVuICMyIGFuZAor IzUuIEkuZS4gdW5iaW5kIHZzLiBmcmVlLiBNb3JlIHNwZWNpZmljYWxseSwgZnJlZSBiZWZvcmUg dW5iaW5kLgorCitJT0FTSUQgbm90aWZpZXIgYW5kIHJlZmNvdW50aW5nIGFyZSB1c2VkIHRvIGVu c3VyZSBvcmRlci4gRm9sbG93aW5nCithIHB1Ymxpc2hlci1zdWJzY3JpYmVyIHBhdHRlcm4gd2hl cmU6CisKKy0gUHVibGlzaGVyczogVkZJTyAmIElPTU1VCistIFN1YnNjcmliZXJzOiBLVk0sIFZE Q00sIElPTU1VCisKK0lPQVNJRCByZWZlcmVuY2UgbXVzdCBiZSBhY3F1aXJlZCBiZWZvcmUgcmVj ZWl2aW5nIHRoZSBGUkVFIGV2ZW50LiBUaGUKK3JlZmVyZW5jZSBtdXN0IGJlIGRyb3BwZWQgYXQg dGhlIGVuZCBvZiB0aGUgcHJvY2Vzc2luZyBpbiBvcmRlciB0bworcmV0dXJuIHRoZSBJT0FTSUQg dG8gdGhlIHBvb2wuCisKK0xldCdzIGV4YW1pbmUgdGhlIElPQVNJRCBsaWZlIGN5Y2xlIGFnYWlu IHdoZW4gZnJlZSBoYXBwZW5zICpiZWZvcmUqCit1bmJpbmQuIFRoaXMgY291bGQgYmUgYSByZXN1 bHQgb2YgbWlzYmVoYXZpbmcgZ3Vlc3RzIG9yIGNyYXNoLiBBc3N1bWluZworVkZJTyBjYW5ub3Qg ZW5mb3JjZSB1bmJpbmQtPmZyZWUgb3JkZXIuIE5vdGljZSB0aGF0IHRoZSBzZXR1cCBwYXJ0IHVw Cit1bnRpbCBzdGVwICMxMiBpcyBpZGVudGljYWwgdG8gdGhlIG5vcm1hbCBjYXNlLCB0aGUgZmxv dyBiZWxvdyBzdGFydHMKK3dpdGggc3RlcCAxMy4KKworOjoKKworICAgICBWRklPICAgICAgICBJ T01NVSAgICAgICAgS1ZNICAgICAgICBWRENNICAgICAgICBJT0FTSUQgICAgICAgUmVmCisgICAu Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4KKyAgIDEzIC0tLS0tLS0tIEdVRVNUIFNUQVJUUyBETUEgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KKyAgIDE0IC0tLS0tLS0tICpHVUVTVCBNSVNCRUhBVkVTISEhKiAtLS0tLS0t LS0tLS0tLS0tCisgICAxNSBpb2FzaWRfZnJlZSgpCisgICAxNiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNpZF9ub3RpZnkoRlJFRSkKKyAgIDE3ICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWFya19mcmVlX3BlbmRpbmcg KDEpCisgICAxOCAgICAgICAgICAgICAgICAgICAgICAgICAga3ZtX25iX2hhbmRsZXIoRlJFRSkK KyAgIDE5ICAgICAgICAgICAgICAgICAgICAgICAgICB2bWNzX3VwZGF0ZV9hdG9taWMoKQorICAg MjAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNpZF9wdXRfbG9ja2VkKCkgICAtPiAgICAg ICAgICAgMworICAgMjEgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZkY21fbmJf aGFuZGxlcihGUkVFKQorICAgMjIgICAgICAgICAgICBpb21tX25iX2hhbmRsZXIoRlJFRSkKKyAg IDIzIGlvYXNpZF9mcmVlKCkgcmV0dXJucygyKSAgICAgICAgICBzY2hlZHVsZV93b3JrKCkgICAg ICAgICAgIDIKKyAgIDI0ICAgICAgICAgICAgc2NoZWR1bGVfd29yaygpICAgICAgICB2ZGV2X2Ns ZWFyX3drKGhwYXNpZCkKKyAgIDI1ICAgICAgICAgICAgdGVhcmRvd25fcGFzaWRfd2soKQorICAg MjYgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNpZF9wdXQoKSAtPiAgICAg ICAgICAgMQorICAgMjcgICAgICAgICAgICBpb2FzaWRfcHV0KCkgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgMAorICAgMjggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgUmVjbGFpbWVkCisgICAyOSB1bmJpbmRfZ3Bhc2lkKCkKKyAgIDMw ICAgICAgICAgICAgaW9tbXVfdW5iaW5kKCktPmlvYXNpZF9maW5kKCkgRmFpbHMoMykKKyAgIC0t LS0tLS0tLS0tLS0tIE5ldyBMaWZlIEN5Y2xlIEJlZ2luIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KKworTm90ZToKKworMS4gQnkgbWFya2luZyBJT0FTSUQgRlJFRV9QRU5ESU5HIGF0IHN0 ZXAgIzE3LCBubyBuZXcgcmVmZXJlbmNlcyBjYW4gYmUKKyAgIGhlbGQuIGlvYXNpZF9nZXQvZmlu ZCgpIHdpbGwgcmV0dXJuIC1FTk9FTlQ7CisyLiBBZnRlciBzdGVwICMyMywgYWxsIGV2ZW50cyBj YW4gZ28gb3V0IG9mIG9yZGVyLiBTaGFsbCBub3QgYWZmZWN0CisgICB0aGUgb3V0Y29tZS4KKzMu IElPTU1VIGRyaXZlciBmYWlscyB0byBmaW5kIHByaXZhdGUgZGF0YSBmb3IgdW5iaW5kaW5nLiBJ ZiB1bmJpbmQgaXMKKyAgIGNhbGxlZCBhZnRlciB0aGUgc2FtZSBJT0FTSUQgaXMgYWxsb2NhdGVk IGZvciB0aGUgc2FtZSBndWVzdCBhZ2FpbiwKKyAgIHRoaXMgaXMgYSBwcm9ncmFtbWluZyBlcnJv ci4gVGhlIGRhbWFnZSBpcyBsaW1pdGVkIHRvIHRoZSBndWVzdAorICAgaXRzZWxmIHNpbmNlIHVu YmluZCBwZXJmb3JtcyBwZXJtaXNzaW9uIGNoZWNraW5nIGJhc2VkIG9uIHRoZQorICAgSU9BU0lE IHNldCBhc3NvY2lhdGVkIHdpdGggdGhlIGd1ZXN0IHByb2Nlc3MuCis0LiBXb3JrcXVldWVzIGFy ZSB1c2VkIGJ5IFZEQ00gYW5kIElPTU1VIGRyaXZlciBmb3IgcHJvY2Vzc2luZyB0aGF0CisgICBy ZXF1aXJlcyB0aHJlYWQgY29udGV4dC4KKworCitLVk0gUEFTSUQgVHJhbnNsYXRpb24gVGFibGUg VXBkYXRlcworfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KK1BlciBWTSBQQVNJ RCB0cmFuc2xhdGlvbiB0YWJsZSBpcyBtYWludGFpbmVkIGJ5IEtWTSBpbiBvcmRlciB0bworc3Vw cG9ydCBFTlFDTUQgaW4gdGhlIGd1ZXN0LiBUaGUgdGFibGUgY29udGFpbnMgaG9zdC1ndWVzdCBQ QVNJRAordHJhbnNsYXRpb25zIHRvIGJlIGNvbnN1bWVkIGJ5IENQVSB1Y29kZS4gVGhlIHN5bmNo cm9uaXphdGlvbiBvZiB0aGUKK1BBU0lEIHN0YXRlcyBkZXBlbmRzIG9uIFZGSU8vSU9NTVUgZHJp dmVyLCB3aGVyZSBJT0NUTCBhbmQgYXRvbWljCitub3RpZmllcnMgYXJlIHVzZWQuIEtWTSBtdXN0 IHJlZ2lzdGVyIElPQVNJRCBub3RpZmllciBwZXIgVk0gaW5zdGFuY2UKK2R1cmluZyBsYXVuY2gg dGltZS4gVGhlIGZvbGxvd2luZyBldmVudHMgYXJlIGhhbmRsZWQ6CisKKzEuIEJJTkQvVU5CSU5E CisyLiBGUkVFCisKK1J1bGVzOgorCisxLiBNdWx0aXBsZSBkZXZpY2VzIGNhbiBiaW5kIHdpdGgg dGhlIHNhbWUgUEFTSUQsIHRoaXMgY2FuIGJlIGRpZmZlcmVudCBQQ0kKKyAgIGRldmljZXMgb3Ig bWRldnMgd2l0aGluIHRoZSBzYW1lIFBDSSBkZXZpY2UuIEhvd2V2ZXIsIG9ubHkgdGhlCisgICAq Zmlyc3QqIEJJTkQgYW5kICpsYXN0KiBVTkJJTkQgZW1pdCBub3RpZmljYXRpb25zLgorMi4gSU9B U0lEIGNvZGUgaXMgcmVzcG9uc2libGUgZm9yIGVuc3VyaW5nIHRoZSBjb3JyZWN0bmVzcyBvZiBI LUcKKyAgIFBBU0lEIG1hcHBpbmcuIFRoZXJlIGlzIG5vIG5lZWQgZm9yIEtWTSB0byB2YWxpZGF0 ZSB0aGUKKyAgIG5vdGlmaWNhdGlvbiBkYXRhLgorMy4gV2hlbiBVTkJJTkQgaGFwcGVucyAqYWZ0 ZXIqIEZSRUUsIEtWTSB3aWxsIHNlZSBlcnJvciBpbgorICAgaW9hc2lkX2dldCgpIGV2ZW4gd2hl biB0aGUgcmVjbGFpbSBpcyBub3QgZG9uZS4gSU9NTVUgZHJpdmVyIHdpbGwKKyAgIGFsc28gYXZv aWQgc2VuZGluZyBVTkJJTkQgaWYgdGhlIFBBU0lEIGlzIGFscmVhZHkgRlJFRS4KKzQuIFdoZW4g S1ZNIHRlcm1pbmF0ZXMgKmJlZm9yZSogRlJFRSAmIFVOQklORCwgcmVmZXJlbmNlcyB3aWxsIGJl CisgICBkcm9wcGVkIGZvciBhbGwgaG9zdCBQQVNJRHMuCisKK1ZEQ00gUEFTSUQgUHJvZ3JhbW1p bmcKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn4KK1ZEQ00gY29tcG9zZXMgdmlydHVhbCBkZXZpY2Vz IGFuZCBleHBvc2VzIHRoZW0gdG8gdGhlIGd1ZXN0cy4gV2hlbgordGhlIGd1ZXN0IGFsbG9jYXRl cyBhIFBBU0lEIHRoZW4gcHJvZ3JhbSBpdCB0byB0aGUgdmlydHVhbCBkZXZpY2UsIFZEQ00KK2lu dGVyY2VwdHMgdGhlIHByb2dyYW1taW5nIGF0dGVtcHQgdGhlbiBwcm9ncmFtcyB0aGUgbWF0Y2hp bmcgaG9zdAorUEFTSUQgb24gdG8gdGhlIGhhcmR3YXJlLgorQ29udmVyc2VseSwgd2hlbiBhIGRl dmljZSBpcyBnb2luZyBhd2F5LCBWRENNIG11c3QgYmUgaW5mb3JtZWQgc3VjaAordGhhdCBQQVNJ RCBjb250ZXh0IG9uIHRoZSBoYXJkd2FyZSBjYW4gYmUgY2xlYXJlZC4gVGhlcmUgY291bGQgYmUK K211bHRpcGxlIG1kZXZzIGFzc2lnbmVkIHRvIGRpZmZlcmVudCBndWVzdHMgaW4gdGhlIHNhbWUg VkRDTS4gU2luY2UKK3RoZSBQQVNJRCB0YWJsZSBpcyBzaGFyZWQgYXQgUENJIGRldmljZSBsZXZl bCwgbGF6eSBjbGVhcmluZyBpcyBub3QKK3NlY3VyZS4gQSBtYWxpY2lvdXMgZ3Vlc3QgY2FuIGF0 dGFjayBieSB1c2luZyBuZXdseSBmcmVlZCBQQVNJRHMgdGhhdAorYXJlIGFsbG9jYXRlZCBieSBh bm90aGVyIGd1ZXN0LgorCitCeSBob2xkaW5nIGEgcmVmZXJlbmNlIG9mIHRoZSBQQVNJRCB1bnRp bCBWRENNIGNsZWFucyB1cCB0aGUgSFcgY29udGV4dCwKK2l0IGlzIGd1YXJhbnRlZWQgdGhhdCBQ QVNJRCBsaWZlIGN5Y2xlcyBkbyBub3QgY3Jvc3Mgd2l0aGluIHRoZSBzYW1lCitkZXZpY2UuCisK KworUmVmZXJlbmNlCis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09CisxLiBodHRwczovL3NvZnR3YXJlLmludGVsLmNvbS9zaXRlcy9kZWZhdWx0L2Zp bGVzL21hbmFnZWQvYzUvMTUvYXJjaGl0ZWN0dXJlLWluc3RydWN0aW9uLXNldC1leHRlbnNpb25z LXByb2dyYW1taW5nLXJlZmVyZW5jZS5wZGYKKworMi4gaHR0cHM6Ly8wMS5vcmcvYmxvZ3MvMjAx OS9pbnRyb2R1Y2luZy1pbnRlbC1kYXRhLXN0cmVhbWluZy1hY2NlbGVyYXRvcgorCiszLiBodHRw czovL3NvZnR3YXJlLmludGVsLmNvbS9lbi11cy9kb3dubG9hZC9pbnRlbC1kYXRhLXN0cmVhbWlu Zy1hY2NlbGVyYXRvci1wcmVsaW1pbmFyeS1hcmNoaXRlY3R1cmUtc3BlY2lmaWNhdGlvbgotLSAK Mi43LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlv bW11IG1haWxpbmcgbGlzdAppb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczov L2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ==