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=-5.0 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,URIBL_RED,USER_AGENT_SANE_1 autolearn=no 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 A8E9DC4707F for ; Fri, 28 May 2021 02:25:24 +0000 (UTC) Received: from smtp1.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 40127613B8 for ; Fri, 28 May 2021 02:25:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 40127613B8 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.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 smtp1.osuosl.org (Postfix) with ESMTP id 0556D84346; Fri, 28 May 2021 02:25:24 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id kbJIudnWvn9u; Fri, 28 May 2021 02:25:21 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp1.osuosl.org (Postfix) with ESMTP id 4483583EEA; Fri, 28 May 2021 02:25:20 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id CD6C4C000E; Fri, 28 May 2021 02:25:20 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [IPv6:2605:bc80:3010::137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 2C0B5C0001 for ; Fri, 28 May 2021 02:25:19 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id 180C3404F0 for ; Fri, 28 May 2021 02:25:19 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp4.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id g8XiciWZmIHu for ; Fri, 28 May 2021 02:25:16 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by smtp4.osuosl.org (Postfix) with ESMTPS id E18BC404E3 for ; Fri, 28 May 2021 02:25:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1622168714; 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=9lqzBMvp2F4atd5FG2S+oqtp3y5JoqeU46lsxMgML98=; b=M508zORTWqoQKx77KsqeeRMwGi8K6X5I+6iail2Y/tjSY8QS4x9/tA6d7neCJJ3tRLv7mA T4tzZqCVBNAKRFOWOEIAZJPiClg17GFdwDLodmujtqLvsSEa2gIPPA5sknK9/GM1/vRRM7 dkrDOQ6Hf6nASoUgpd6KWe/LjU1bTFk= Received: from mail-pl1-f199.google.com (mail-pl1-f199.google.com [209.85.214.199]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-246-osYEv5txO2SB12aUh3stcQ-1; Thu, 27 May 2021 22:25:12 -0400 X-MC-Unique: osYEv5txO2SB12aUh3stcQ-1 Received: by mail-pl1-f199.google.com with SMTP id x15-20020a170902e04fb02900f5295925dbso686429plx.9 for ; Thu, 27 May 2021 19:25:12 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=9lqzBMvp2F4atd5FG2S+oqtp3y5JoqeU46lsxMgML98=; b=ldi5f1V0dmSF21fvw3D8DV+VJPCZChJJLgyWcVLY6A6ufcDMdnExdOZzXppKOL0YTh 1itfVueQfCazEgQvYYuksDv+En7Gdnt25nu0OvtoW60uEVn6U5DH1yb1b/pr2iDnZM/X FRi4KDyT4tsjcsCWK37UB8QacwDEWzwU1+LRZQuc4+lMvSbfkXXRoMEbup74tg3f6abR gzr+NFx9wbOETMhI7cZMpzzSUIK2TX6cQ8hcMas1t5Ds52kfmOhbV5SeOKy+0tlnFDnY CrrT8fGMCB3uQf0MAYdoYh3IS1IUu9Iv1yvFdVbSHwtJgQLfsGYHcCVfgO7hvgZDYwdv CGIQ== X-Gm-Message-State: AOAM530zBFr2dsbSnh9IGVC5rtllGrBT0qD2SMhe6Q8NQpczqTJY9EJA Jb0r6OFE9svy8NfgZbY+wANaPOCcuVfO7C0OKTFaqAszXmG1qCIH/U9qojCjyyL9EREa52hyuwc t8l0+wToSf0hkMGN+7pIJbPyMzUDvdA== X-Received: by 2002:a17:90a:950c:: with SMTP id t12mr1730316pjo.135.1622168710634; Thu, 27 May 2021 19:25:10 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzPPzP4HrBY4Q7r7nlD0Tlrx0lBK6eDVCNKZO3GUAQaXomgC19WjxjfWTu2WDGMLhwnBWW9sA== X-Received: by 2002:a17:90a:950c:: with SMTP id t12mr1730254pjo.135.1622168709674; Thu, 27 May 2021 19:25:09 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id 204sm2941993pfy.56.2021.05.27.19.25.01 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 27 May 2021 19:25:09 -0700 (PDT) Subject: Re: [RFC] /dev/ioasid uAPI proposal To: "Tian, Kevin" , LKML , Joerg Roedel , Jason Gunthorpe , Lu Baolu , David Woodhouse , "iommu@lists.linux-foundation.org" , "kvm@vger.kernel.org" , "Alex Williamson (alex.williamson@redhat.com)" References: From: Jason Wang Message-ID: Date: Fri, 28 May 2021 10:24:56 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.10.2 MIME-Version: 1.0 In-Reply-To: Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: Jean-Philippe Brucker , "Jiang, Dave" , "Raj, Ashok" , Jonathan Corbet , Kirti Wankhede , David Gibson , Robin Murphy , "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-Transfer-Encoding: base64 Content-Type: text/plain; charset="gbk"; Format="flowed" Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" CtTaIDIwMjEvNS8yNyDPws7nMzo1OCwgVGlhbiwgS2V2aW4g0LS1wDoKPiAvZGV2L2lvYXNpZCBw cm92aWRlcyBhbiB1bmlmaWVkIGludGVyZmFjZSBmb3IgbWFuYWdpbmcgSS9PIHBhZ2UgdGFibGVz IGZvcgo+IGRldmljZXMgYXNzaWduZWQgdG8gdXNlcnNwYWNlLiBEZXZpY2UgcGFzc3Rocm91Z2gg ZnJhbWV3b3JrcyAoVkZJTywgdkRQQSwKPiBldGMuKSBhcmUgZXhwZWN0ZWQgdG8gdXNlIHRoaXMg aW50ZXJmYWNlIGluc3RlYWQgb2YgY3JlYXRpbmcgdGhlaXIgb3duIGxvZ2ljIHRvCj4gaXNvbGF0 ZSB1bnRydXN0ZWQgZGV2aWNlIERNQXMgaW5pdGlhdGVkIGJ5IHVzZXJzcGFjZS4KCgpOb3QgYSBu YXRpdmUgc3BlYWtlciBidXQgL2Rldi9pb2FzIHNlZW1zIGJldHRlcj8KCgo+Cj4gVGhpcyBwcm9w b3NhbCBkZXNjcmliZXMgdGhlIHVBUEkgb2YgL2Rldi9pb2FzaWQgYW5kIGFsc28gc2FtcGxlIHNl cXVlbmNlcwo+IHdpdGggVkZJTyBhcyBleGFtcGxlIGluIHR5cGljYWwgdXNhZ2VzLiBUaGUgZHJp dmVyLWZhY2luZyBrZXJuZWwgQVBJIHByb3ZpZGVkCj4gYnkgdGhlIGlvbW11IGxheWVyIGlzIHN0 aWxsIFRCRCwgd2hpY2ggY2FuIGJlIGRpc2N1c3NlZCBhZnRlciBjb25zZW5zdXMgaXMKPiBtYWRl IG9uIHRoaXMgdUFQSS4KPgo+IEl0J3MgYmFzZWQgb24gYSBsZW5ndGh5IGRpc2N1c3Npb24gc3Rh cnRpbmcgZnJvbSBoZXJlOgo+IAlodHRwczovL2xvcmUua2VybmVsLm9yZy9saW51eC1pb21tdS8y MDIxMDMzMDEzMjgzMC5HTzIzNTYyODFAbnZpZGlhLmNvbS8KPgo+IEl0IGVuZHMgdXAgdG8gYmUg YSBsb25nIHdyaXRpbmcgZHVlIHRvIG1hbnkgdGhpbmdzIHRvIGJlIHN1bW1hcml6ZWQgYW5kCj4g bm9uLXRyaXZpYWwgZWZmb3J0IHJlcXVpcmVkIHRvIGNvbm5lY3QgdGhlbSBpbnRvIGEgY29tcGxl dGUgcHJvcG9zYWwuCj4gSG9wZSBpdCBwcm92aWRlcyBhIGNsZWFuIGJhc2UgdG8gY29udmVyZ2Uu Cj4KPiBUT0MKPiA9PT09Cj4gMS4gVGVybWlub2xvZ2llcyBhbmQgQ29uY2VwdHMKPiAyLiB1QVBJ IFByb3Bvc2FsCj4gICAgICAyLjEuIC9kZXYvaW9hc2lkIHVBUEkKPiAgICAgIDIuMi4gL2Rldi92 ZmlvIHVBUEkKPiAgICAgIDIuMy4gL2Rldi9rdm0gdUFQSQo+IDMuIFNhbXBsZSBzdHJ1Y3R1cmVz IGFuZCBoZWxwZXIgZnVuY3Rpb25zCj4gNC4gUEFTSUQgdmlydHVhbGl6YXRpb24KPiA1LiBVc2Ug Q2FzZXMgYW5kIEZsb3dzCj4gICAgICA1LjEuIEEgc2ltcGxlIGV4YW1wbGUKPiAgICAgIDUuMi4g TXVsdGlwbGUgSU9BU0lEcyAobm8gbmVzdGluZykKPiAgICAgIDUuMy4gSU9BU0lEIG5lc3Rpbmcg KHNvZnR3YXJlKQo+ICAgICAgNS40LiBJT0FTSUQgbmVzdGluZyAoaGFyZHdhcmUpCj4gICAgICA1 LjUuIEd1ZXN0IFNWQSAodlNWQSkKPiAgICAgIDUuNi4gSS9PIHBhZ2UgZmF1bHQKPiAgICAgIDUu Ny4gQklORF9QQVNJRF9UQUJMRQo+ID09PT0KPgo+IDEuIFRlcm1pbm9sb2dpZXMgYW5kIENvbmNl cHRzCj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPgo+IElPQVNJ RCBGRCBpcyB0aGUgY29udGFpbmVyIGhvbGRpbmcgbXVsdGlwbGUgSS9PIGFkZHJlc3Mgc3BhY2Vz LiBVc2VyCj4gbWFuYWdlcyB0aG9zZSBhZGRyZXNzIHNwYWNlcyB0aHJvdWdoIEZEIG9wZXJhdGlv bnMuIE11bHRpcGxlIEZEJ3MgYXJlCj4gYWxsb3dlZCBwZXIgcHJvY2VzcywgYnV0IHdpdGggdGhp cyBwcm9wb3NhbCBvbmUgRkQgc2hvdWxkIGJlIHN1ZmZpY2llbnQgZm9yCj4gYWxsIGludGVuZGVk IHVzYWdlcy4KPgo+IElPQVNJRCBpcyB0aGUgRkQtbG9jYWwgc29mdHdhcmUgaGFuZGxlIHJlcHJl c2VudGluZyBhbiBJL08gYWRkcmVzcyBzcGFjZS4KPiBFYWNoIElPQVNJRCBpcyBhc3NvY2lhdGVk IHdpdGggYSBzaW5nbGUgSS9PIHBhZ2UgdGFibGUuIElPQVNJRHMgY2FuIGJlCj4gbmVzdGVkIHRv Z2V0aGVyLCBpbXBseWluZyB0aGUgb3V0cHV0IGFkZHJlc3MgZnJvbSBvbmUgSS9PIHBhZ2UgdGFi bGUKPiAocmVwcmVzZW50ZWQgYnkgY2hpbGQgSU9BU0lEKSBtdXN0IGJlIGZ1cnRoZXIgdHJhbnNs YXRlZCBieSBhbm90aGVyIEkvTwo+IHBhZ2UgdGFibGUgKHJlcHJlc2VudGVkIGJ5IHBhcmVudCBJ T0FTSUQpLgo+Cj4gSS9PIGFkZHJlc3Mgc3BhY2UgY2FuIGJlIG1hbmFnZWQgdGhyb3VnaCB0d28g cHJvdG9jb2xzLCBhY2NvcmRpbmcgdG8KPiB3aGV0aGVyIHRoZSBjb3JyZXNwb25kaW5nIEkvTyBw YWdlIHRhYmxlIGlzIGNvbnN0cnVjdGVkIGJ5IHRoZSBrZXJuZWwgb3IKPiB0aGUgdXNlci4gV2hl biBrZXJuZWwtbWFuYWdlZCwgYSBkbWEgbWFwcGluZyBwcm90b2NvbCAoc2ltaWxhciB0bwo+IGV4 aXN0aW5nIFZGSU8gaW9tbXUgdHlwZTEpIGlzIHByb3ZpZGVkIGZvciB0aGUgdXNlciB0byBleHBs aWNpdGx5IHNwZWNpZnkKPiBob3cgdGhlIEkvTyBhZGRyZXNzIHNwYWNlIGlzIG1hcHBlZC4gT3Ro ZXJ3aXNlLCBhIGRpZmZlcmVudCBwcm90b2NvbCBpcwo+IHByb3ZpZGVkIGZvciB0aGUgdXNlciB0 byBiaW5kIGFuIHVzZXItbWFuYWdlZCBJL08gcGFnZSB0YWJsZSB0byB0aGUKPiBJT01NVSwgcGx1 cyBuZWNlc3NhcnkgY29tbWFuZHMgZm9yIGlvdGxiIGludmFsaWRhdGlvbiBhbmQgSS9PIGZhdWx0 Cj4gaGFuZGxpbmcuCj4KPiBQZ3RhYmxlIGJpbmRpbmcgcHJvdG9jb2wgY2FuIGJlIHVzZWQgb25s eSBvbiB0aGUgY2hpbGQgSU9BU0lEJ3MsIGltcGx5aW5nCj4gSU9BU0lEIG5lc3RpbmcgbXVzdCBi ZSBlbmFibGVkLiBUaGlzIGlzIGJlY2F1c2UgdGhlIGtlcm5lbCBkb2Vzbid0IHRydXN0Cj4gdXNl cnNwYWNlLiBOZXN0aW5nIGFsbG93cyB0aGUga2VybmVsIHRvIGVuZm9yY2UgaXRzIERNQSBpc29s YXRpb24gcG9saWN5Cj4gdGhyb3VnaCB0aGUgcGFyZW50IElPQVNJRC4KPgo+IElPQVNJRCBuZXN0 aW5nIGNhbiBiZSBpbXBsZW1lbnRlZCBpbiB0d28gd2F5czogaGFyZHdhcmUgbmVzdGluZyBhbmQK PiBzb2Z0d2FyZSBuZXN0aW5nLiBXaXRoIGhhcmR3YXJlIHN1cHBvcnQgdGhlIGNoaWxkIGFuZCBw YXJlbnQgSS9PIHBhZ2UKPiB0YWJsZXMgYXJlIHdhbGtlZCBjb25zZWN1dGl2ZWx5IGJ5IHRoZSBJ T01NVSB0byBmb3JtIGEgbmVzdGVkIHRyYW5zbGF0aW9uLgo+IFdoZW4gaXQncyBpbXBsZW1lbnRl ZCBpbiBzb2Z0d2FyZSwgdGhlIGlvYXNpZCBkcml2ZXIKCgpOZWVkIHRvIGV4cGxhaW4gd2hhdCBk aWQgImlvYXNpZCBkcml2ZXIiIG1lYW4uCgpJIGd1ZXNzIGl0J3MgdGhlIG1vZHVsZSB0aGF0IGlt cGxlbWVudHMgdGhlIElPQVNJRCBhYnN0cmFjdGlvbjoKCjEpIFJJRAoyKSBSSUQrUEFTSUQKMykg b3RoZXJzCgpBbmQgaWYgeWVzLCBkb2VzIGl0IGFsbG93IHRoZSBkZXZpY2UgZm9yIHNvZnR3YXJl IHNwZWNpZmljIGltcGxlbWVudGF0aW9uOgoKMSkgc3dpb3RsYiBvcgoyKSBkZXZpY2Ugc3BlY2lm aWMgSU9BU0lEIGltcGxlbWVudGF0aW9uCgoKPiBpcyByZXNwb25zaWJsZSBmb3IKPiBtZXJnaW5n IHRoZSB0d28tbGV2ZWwgbWFwcGluZ3MgaW50byBhIHNpbmdsZS1sZXZlbCBzaGFkb3cgSS9PIHBh Z2UgdGFibGUuCj4gU29mdHdhcmUgbmVzdGluZyByZXF1aXJlcyBib3RoIGNoaWxkL3BhcmVudCBw YWdlIHRhYmxlcyBvcGVyYXRlZCB0aHJvdWdoCj4gdGhlIGRtYSBtYXBwaW5nIHByb3RvY29sLCBz byBhbnkgY2hhbmdlIGluIGVpdGhlciBsZXZlbCBjYW4gYmUgY2FwdHVyZWQKPiBieSB0aGUga2Vy bmVsIHRvIHVwZGF0ZSB0aGUgY29ycmVzcG9uZGluZyBzaGFkb3cgbWFwcGluZy4KPgo+IEFuIEkv TyBhZGRyZXNzIHNwYWNlIHRha2VzIGVmZmVjdCBpbiB0aGUgSU9NTVUgb25seSBhZnRlciBpdCBp cyBhdHRhY2hlZAo+IHRvIGEgZGV2aWNlLiBUaGUgZGV2aWNlIGluIHRoZSAvZGV2L2lvYXNpZCBj b250ZXh0IGFsd2F5cyByZWZlcnMgdG8gYQo+IHBoeXNpY2FsIG9uZSBvciAncGRldicgKFBGIG9y IFZGKS4KPgo+IE9uZSBJL08gYWRkcmVzcyBzcGFjZSBjb3VsZCBiZSBhdHRhY2hlZCB0byBtdWx0 aXBsZSBkZXZpY2VzLiBJbiB0aGlzIGNhc2UsCj4gL2Rldi9pb2FzaWQgdUFQSSBhcHBsaWVzIHRv IGFsbCBhdHRhY2hlZCBkZXZpY2VzIHVuZGVyIHRoZSBzcGVjaWZpZWQgSU9BU0lELgo+Cj4gQmFz ZWQgb24gdGhlIHVuZGVybHlpbmcgSU9NTVUgY2FwYWJpbGl0eSBvbmUgZGV2aWNlIG1pZ2h0IGJl IGFsbG93ZWQKPiB0byBhdHRhY2ggdG8gbXVsdGlwbGUgSS9PIGFkZHJlc3Mgc3BhY2VzLCB3aXRo IERNQXMgYWNjZXNzaW5nIHRoZW0gYnkKPiBjYXJyeWluZyBkaWZmZXJlbnQgcm91dGluZyBpbmZv cm1hdGlvbi4gT25lIG9mIHRoZW0gaXMgdGhlIGRlZmF1bHQgSS9PCj4gYWRkcmVzcyBzcGFjZSBy b3V0ZWQgYnkgUENJIFJlcXVlc3RvciBJRCAoUklEKSBvciBBUk0gU3RyZWFtIElELiBUaGUKPiBy ZW1haW5pbmcgYXJlIHJvdXRlZCBieSBSSUQgKyBQcm9jZXNzIEFkZHJlc3MgU3BhY2UgSUQgKFBB U0lEKSBvcgo+IFN0cmVhbStTdWJzdHJlYW0gSUQuIEZvciBzaW1wbGljaXR5IHRoZSBmb2xsb3dp bmcgY29udGV4dCB1c2VzIFJJRCBhbmQKPiBQQVNJRCB3aGVuIHRhbGtpbmcgYWJvdXQgdGhlIHJv dXRpbmcgaW5mb3JtYXRpb24gZm9yIEkvTyBhZGRyZXNzIHNwYWNlcy4KPgo+IERldmljZSBhdHRh Y2htZW50IGlzIGluaXRpYXRlZCB0aHJvdWdoIHBhc3N0aHJvdWdoIGZyYW1ld29yayB1QVBJICh1 c2UKPiBWRklPIGZvciBzaW1wbGljaXR5IGluIGZvbGxvd2luZyBjb250ZXh0KS4gVkZJTyBpcyBy ZXNwb25zaWJsZSBmb3IgaWRlbnRpZnlpbmcKPiB0aGUgcm91dGluZyBpbmZvcm1hdGlvbiBhbmQg cmVnaXN0ZXJpbmcgaXQgdG8gdGhlIGlvYXNpZCBkcml2ZXIgd2hlbiBjYWxsaW5nCj4gaW9hc2lk IGF0dGFjaCBoZWxwZXIgZnVuY3Rpb24uIEl0IGNvdWxkIGJlIFJJRCBpZiB0aGUgYXNzaWduZWQg ZGV2aWNlIGlzCj4gcGRldiAoUEYvVkYpIG9yIFJJRCtQQVNJRCBpZiB0aGUgZGV2aWNlIGlzIG1l ZGlhdGVkIChtZGV2KS4gSW4gYWRkaXRpb24sCj4gdXNlciBtaWdodCBhbHNvIHByb3ZpZGUgaXRz IHZpZXcgb2YgdmlydHVhbCByb3V0aW5nIGluZm9ybWF0aW9uICh2UEFTSUQpIGluCj4gdGhlIGF0 dGFjaCBjYWxsLCBlLmcuIHdoZW4gbXVsdGlwbGUgdXNlci1tYW5hZ2VkIEkvTyBhZGRyZXNzIHNw YWNlcyBhcmUKPiBhdHRhY2hlZCB0byB0aGUgdmZpb19kZXZpY2UuIEluIHRoaXMgY2FzZSBWRklP IG11c3QgZmlndXJlIG91dCB3aGV0aGVyCj4gdlBBU0lEIHNob3VsZCBiZSBkaXJlY3RseSB1c2Vk IChmb3IgcGRldikgb3IgY29udmVydGVkIHRvIGEga2VybmVsLQo+IGFsbG9jYXRlZCBvbmUgKHBQ QVNJRCwgZm9yIG1kZXYpIGZvciBwaHlzaWNhbCByb3V0aW5nIChzZWUgc2VjdGlvbiA0KS4KPgo+ IERldmljZSBtdXN0IGJlIGJvdW5kIHRvIGFuIElPQVNJRCBGRCBiZWZvcmUgYXR0YWNoIG9wZXJh dGlvbiBjYW4gYmUKPiBjb25kdWN0ZWQuIFRoaXMgaXMgYWxzbyB0aHJvdWdoIFZGSU8gdUFQSS4g SW4gdGhpcyBwcm9wb3NhbCBvbmUgZGV2aWNlCj4gc2hvdWxkIG5vdCBiZSBib3VuZCB0byBtdWx0 aXBsZSBGRCdzLiBOb3Qgc3VyZSBhYm91dCB0aGUgZ2FpbiBvZgo+IGFsbG93aW5nIGl0IGV4Y2Vw dCBhZGRpbmcgdW5uZWNlc3NhcnkgY29tcGxleGl0eS4gQnV0IGlmIG90aGVycyBoYXZlCj4gZGlm ZmVyZW50IHZpZXcgd2UgY2FuIGZ1cnRoZXIgZGlzY3Vzcy4KPgo+IFZGSU8gbXVzdCBlbnN1cmUg aXRzIGRldmljZSBjb21wb3NlcyBETUFzIHdpdGggdGhlIHJvdXRpbmcgaW5mb3JtYXRpb24KPiBh dHRhY2hlZCB0byB0aGUgSU9BU0lELiBGb3IgcGRldiBpdCBuYXR1cmFsbHkgaGFwcGVucyBzaW5j ZSB2UEFTSUQgaXMKPiBkaXJlY3RseSBwcm9ncmFtbWVkIHRvIHRoZSBkZXZpY2UgYnkgZ3Vlc3Qg c29mdHdhcmUuIEZvciBtZGV2IHRoaXMKPiBpbXBsaWVzIGFueSBndWVzdCBvcGVyYXRpb24gY2Fy cnlpbmcgYSB2UEFTSUQgb24gdGhpcyBkZXZpY2UgbXVzdCBiZQo+IHRyYXBwZWQgaW50byBWRklP IGFuZCB0aGVuIGNvbnZlcnRlZCB0byBwUEFTSUQgYmVmb3JlIHNlbnQgdG8gdGhlCj4gZGV2aWNl LiBBIGRldGFpbCBleHBsYW5hdGlvbiBhYm91dCBQQVNJRCB2aXJ0dWFsaXphdGlvbiBwb2xpY2ll cyBjYW4gYmUKPiBmb3VuZCBpbiBzZWN0aW9uIDQuCj4KPiBNb2Rlcm4gZGV2aWNlcyBtYXkgc3Vw cG9ydCBhIHNjYWxhYmxlIHdvcmtsb2FkIHN1Ym1pc3Npb24gaW50ZXJmYWNlCj4gYmFzZWQgb24g UENJIERNV3IgY2FwYWJpbGl0eSwgYWxsb3dpbmcgYSBzaW5nbGUgd29yayBxdWV1ZSB0byBhY2Nl c3MKPiBtdWx0aXBsZSBJL08gYWRkcmVzcyBzcGFjZXMuIE9uZSBleGFtcGxlIGlzIEludGVsIEVO UUNNRCwgaGF2aW5nCj4gUEFTSUQgc2F2ZWQgaW4gdGhlIENQVSBNU1IgYW5kIGNhcnJpZWQgaW4g dGhlIGluc3RydWN0aW9uIHBheWxvYWQKPiB3aGVuIHNlbnQgb3V0IHRvIHRoZSBkZXZpY2UuIFRo ZW4gYSBzaW5nbGUgd29yayBxdWV1ZSBzaGFyZWQgYnkKPiBtdWx0aXBsZSBwcm9jZXNzZXMgY2Fu IGNvbXBvc2UgRE1BcyBjYXJyeWluZyBkaWZmZXJlbnQgUEFTSURzLgo+Cj4gV2hlbiBleGVjdXRp bmcgRU5RQ01EIGluIHRoZSBndWVzdCwgdGhlIENQVSBNU1IgaW5jbHVkZXMgYSB2UEFTSUQKPiB3 aGljaCwgaWYgdGFyZ2V0aW5nIGEgbWRldiwgbXVzdCBiZSBjb252ZXJ0ZWQgdG8gcFBBU0lEIGJl Zm9yZSBzZW50Cj4gdG8gdGhlIHdpcmUuIEludGVsIENQVSBwcm92aWRlcyBhIGhhcmR3YXJlIFBB U0lEIHRyYW5zbGF0aW9uIGNhcGFiaWxpdHkKPiBmb3IgYXV0by1jb252ZXJzaW9uIGluIHRoZSBm YXN0IHBhdGguIFRoZSB1c2VyIGlzIGV4cGVjdGVkIHRvIHNldHVwIHRoZQo+IFBBU0lEIG1hcHBp bmcgdGhyb3VnaCBLVk0gdUFQSSwgd2l0aCBpbmZvcm1hdGlvbiBhYm91dCB7dnBhc2lkLAo+IGlv YXNpZF9mZCwgaW9hc2lkfS4gVGhlIGlvYXNpZCBkcml2ZXIgcHJvdmlkZXMgaGVscGVyIGZ1bmN0 aW9uIGZvciBLVk0KPiB0byBmaWd1cmUgb3V0IHRoZSBhY3R1YWwgcFBBU0lEIGdpdmVuIGFuIElP QVNJRC4KPgo+IFdpdGggYWJvdmUgZGVzaWduIC9kZXYvaW9hc2lkIHVBUEkgaXMgYWxsIGFib3V0 IEkvTyBhZGRyZXNzIHNwYWNlcy4KPiBJdCBkb2Vzbid0IGluY2x1ZGUgYW55IGRldmljZSByb3V0 aW5nIGluZm9ybWF0aW9uLCB3aGljaCBpcyBvbmx5Cj4gaW5kaXJlY3RseSByZWdpc3RlcmVkIHRv IHRoZSBpb2FzaWQgZHJpdmVyIHRocm91Z2ggVkZJTyB1QVBJLiBGb3IKPiBleGFtcGxlLCBJL08g cGFnZSBmYXVsdCBpcyBhbHdheXMgcmVwb3J0ZWQgdG8gdXNlcnNwYWNlIHBlciBJT0FTSUQsCj4g YWx0aG91Z2ggaXQncyBwaHlzaWNhbGx5IHJlcG9ydGVkIHBlciBkZXZpY2UgKFJJRCtQQVNJRCku IElmIHRoZXJlIGlzIGEKPiBuZWVkIG9mIGZ1cnRoZXIgcmVsYXlpbmcgdGhpcyBmYXVsdCBpbnRv IHRoZSBndWVzdCwgdGhlIHVzZXIgaXMgcmVzcG9uc2libGUKPiBvZiBpZGVudGlmeWluZyB0aGUg ZGV2aWNlIGF0dGFjaGVkIHRvIHRoaXMgSU9BU0lEIChyYW5kb21seSBwaWNrIG9uZSBpZgo+IG11 bHRpcGxlIGF0dGFjaGVkIGRldmljZXMpIGFuZCB0aGVuIGdlbmVyYXRlcyBhIHBlci1kZXZpY2Ug dmlydHVhbCBJL08KPiBwYWdlIGZhdWx0IGludG8gZ3Vlc3QuIFNpbWlsYXJseSB0aGUgaW90bGIg aW52YWxpZGF0aW9uIHVBUEkgZGVzY3JpYmVzIHRoZQo+IGdyYW51bGFyaXR5IGluIHRoZSBJL08g YWRkcmVzcyBzcGFjZSAoYWxsLCBvciBhIHJhbmdlKSwgZGlmZmVyZW50IGZyb20gdGhlCj4gdW5k ZXJseWluZyBJT01NVSBzZW1hbnRpY3MgKGRvbWFpbi13aWRlLCBQQVNJRC13aWRlLCByYW5nZS1i YXNlZCkuCj4KPiBJL08gcGFnZSB0YWJsZXMgcm91dGVkIHRocm91Z2ggUEFTSUQgYXJlIGluc3Rh bGxlZCBpbiBhIHBlci1SSUQgUEFTSUQKPiB0YWJsZSBzdHJ1Y3R1cmUuCgoKSSdtIG5vdCBzdXJl IHRoaXMgaXMgdHJ1ZSBmb3IgYWxsIGFyY2hzLgoKCj4gICBTb21lIHBsYXRmb3JtcyBpbXBsZW1l bnQgdGhlIFBBU0lEIHRhYmxlIGluIHRoZSBndWVzdAo+IHBoeXNpY2FsIHNwYWNlIChHUEEpLCBl eHBlY3RpbmcgaXQgbWFuYWdlZCBieSB0aGUgZ3Vlc3QuIFRoZSBndWVzdAo+IFBBU0lEIHRhYmxl IGlzIGJvdW5kIHRvIHRoZSBJT01NVSBhbHNvIGJ5IGF0dGFjaGluZyB0byBhbiBJT0FTSUQsCj4g cmVwcmVzZW50aW5nIHRoZSBwZXItUklEIHZQQVNJRCBzcGFjZS4KPgo+IFdlIHByb3Bvc2UgdGhl IGhvc3Qga2VybmVsIG5lZWRzIHRvIGV4cGxpY2l0bHkgdHJhY2sgIGd1ZXN0IEkvTyBwYWdlCj4g dGFibGVzIGV2ZW4gb24gdGhlc2UgcGxhdGZvcm1zLCBpLmUuIHRoZSBzYW1lIHBndGFibGUgYmlu ZGluZyBwcm90b2NvbAo+IHNob3VsZCBiZSB1c2VkIHVuaXZlcnNhbGx5IG9uIGFsbCBwbGF0Zm9y bXMgKHdpdGggb25seSBkaWZmZXJlbmNlIG9uIHdobwo+IGFjdHVhbGx5IHdyaXRlcyB0aGUgUEFT SUQgdGFibGUpLiBPbmUgb3BpbmlvbiBmcm9tIHByZXZpb3VzIGRpc2N1c3Npb24KPiB3YXMgdHJl YXRpbmcgdGhpcyBzcGVjaWFsIElPQVNJRCBhcyBhIGNvbnRhaW5lciBmb3IgYWxsIGd1ZXN0IEkv TyBwYWdlCj4gdGFibGVzIGkuZS4gaGlkaW5nIHRoZW0gZnJvbSB0aGUgaG9zdC4gSG93ZXZlciB0 aGlzIHdheSBzaWduaWZpY2FudGx5Cj4gdmlvbGF0ZXMgdGhlIHBoaWxvc29waHkgaW4gdGhpcyAv ZGV2L2lvYXNpZCBwcm9wb3NhbC4gSXQgaXMgbm90IG9uZSBJT0FTSUQKPiBvbmUgYWRkcmVzcyBz cGFjZSBhbnkgbW9yZS4gRGV2aWNlIHJvdXRpbmcgaW5mb3JtYXRpb24gKGluZGlyZWN0bHkKPiBt YXJraW5nIGhpZGRlbiBJL08gc3BhY2VzKSBoYXMgdG8gYmUgY2FycmllZCBpbiBpb3RsYiBpbnZh bGlkYXRpb24gYW5kCj4gcGFnZSBmYXVsdGluZyB1QVBJIHRvIGhlbHAgY29ubmVjdCB2SU9NTVUg d2l0aCB0aGUgdW5kZXJseWluZwo+IHBJT01NVS4gVGhpcyBpcyBvbmUgZGVzaWduIGNob2ljZSB0 byBiZSBjb25maXJtZWQgd2l0aCBBUk0gZ3V5cy4KPgo+IERldmljZXMgbWF5IHNpdCBiZWhpbmQg SU9NTVUncyB3aXRoIGluY29tcGF0aWJsZSBjYXBhYmlsaXRpZXMuIFRoZQo+IGRpZmZlcmVuY2Ug bWF5IGxpZSBpbiB0aGUgSS9PIHBhZ2UgdGFibGUgZm9ybWF0LCBvciBhdmFpbGFiaWxpdHkgb2Yg YW4gdXNlcgo+IHZpc2libGUgdUFQSSAoZS5nLiBoYXJkd2FyZSBuZXN0aW5nKS4gL2Rldi9pb2Fz aWQgaXMgcmVzcG9uc2libGUgZm9yCj4gY2hlY2tpbmcgdGhlIGluY29tcGF0aWJpbGl0eSBiZXR3 ZWVuIG5ld2x5LWF0dGFjaGVkIGRldmljZSBhbmQgZXhpc3RpbmcKPiBkZXZpY2VzIHVuZGVyIHRo ZSBzcGVjaWZpYyBJT0FTSUQgYW5kLCBpZiBmb3VuZCwgcmV0dXJuaW5nIGVycm9yIHRvIHVzZXIu Cj4gVXBvbiBzdWNoIGVycm9yIHRoZSB1c2VyIHNob3VsZCBjcmVhdGUgYSBuZXcgSU9BU0lEIGZv ciB0aGUgaW5jb21wYXRpYmxlCj4gZGV2aWNlLgo+Cj4gVGhlcmUgaXMgbm8gZXhwbGljaXQgZ3Jv dXAgZW5mb3JjZW1lbnQgaW4gL2Rldi9pb2FzaWQgdUFQSSwgZHVlIHRvIG5vCj4gZGV2aWNlIG5v dGF0aW9uIGluIHRoaXMgaW50ZXJmYWNlIGFzIGFmb3JlbWVudGlvbmVkLiBCdXQgdGhlIGlvYXNp ZCBkcml2ZXIKPiBkb2VzIGltcGxpY2l0IGNoZWNrIHRvIG1ha2Ugc3VyZSB0aGF0IGRldmljZXMg d2l0aGluIGFuIGlvbW11IGdyb3VwCj4gbXVzdCBiZSBhbGwgYXR0YWNoZWQgdG8gdGhlIHNhbWUg SU9BU0lEIGJlZm9yZSB0aGlzIElPQVNJRCBzdGFydHMgdG8KPiBhY2NlcHQgYW55IHVBUEkgY29t bWFuZC4gT3RoZXJ3aXNlIGVycm9yIGluZm9ybWF0aW9uIGlzIHJldHVybmVkIHRvCj4gdGhlIHVz ZXIuCj4KPiBUaGVyZSB3YXMgYSBsb25nIGRlYmF0ZSBpbiBwcmV2aW91cyBkaXNjdXNzaW9uIHdo ZXRoZXIgVkZJTyBzaG91bGQga2VlcAo+IGV4cGxpY2l0IGNvbnRhaW5lci9ncm91cCBzZW1hbnRp Y3MgaW4gaXRzIHVBUEkuIEphc29uIEd1bnRob3JwZSBwcm9wb3Nlcwo+IGEgc2ltcGxpZmllZCBt b2RlbCB3aGVyZSBldmVyeSBkZXZpY2UgYm91bmQgdG8gVkZJTyBpcyBleHBsaWNpdGx5IGxpc3Rl ZAo+IHVuZGVyIC9kZXYvdmZpbyB0aHVzIGEgZGV2aWNlIGZkIGNhbiBiZSBhY3F1aXJlZCB3L28g Z29pbmcgdGhyb3VnaCBsZWdhY3kKPiBjb250YWluZXIvZ3JvdXAgaW50ZXJmYWNlLiBJbiB0aGlz IGNhc2UgdGhlIHVzZXIgaXMgcmVzcG9uc2libGUgZm9yCj4gdW5kZXJzdGFuZGluZyB0aGUgZ3Jv dXAgdG9wb2xvZ3kgYW5kIG1lZXRpbmcgdGhlIGltcGxpY2l0IGdyb3VwIGNoZWNrCj4gY3JpdGVy aWEgZW5mb3JjZWQgaW4gL2Rldi9pb2FzaWQuIFRoZSB1c2UgY2FzZSBleGFtcGxlcyBpbiB0aGlz IHByb3Bvc2FsCj4gYXJlIGJhc2VkIG9uIHRoZSBuZXcgbW9kZWwuCj4KPiBPZiBjb3Vyc2UgZm9y IGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgVkZJTyBzdGlsbCBuZWVkcyB0byBrZWVwIHRoZSBleGlz dGluZwo+IHVBUEkgYW5kIHZmaW8gaW9tbXUgdHlwZTEgd2lsbCBiZWNvbWUgYSBzaGltIGxheWVy IGNvbm5lY3RpbmcgVkZJTwo+IGlvbW11IG9wcyB0byBpbnRlcm5hbCBpb2FzaWQgaGVscGVyIGZ1 bmN0aW9ucy4KPgo+IE5vdGVzOgo+IC0gICBJdCBtaWdodCBiZSBjb25mdXNpbmcgYXMgSU9BU0lE IGlzIGFsc28gdXNlZCBpbiB0aGUga2VybmVsIChkcml2ZXJzLwo+ICAgICAgaW9tbXUvaW9hc2lk LmMpIHRvIHJlcHJlc2VudCBQQ0kgUEFTSUQgb3IgQVJNIHN1YnN0cmVhbSBJRC4gV2UgbmVlZAo+ ICAgICAgZmluZCBhIGJldHRlciBuYW1lIGxhdGVyIHRvIGRpZmZlcmVudGlhdGUuCj4KPiAtICAg UFBDIGhhcyBub3QgYmUgY29uc2lkZXJlZCB5ZXQgYXMgd2UgaGF2ZW4ndCBnb3QgdGltZSB0byBm dWxseSB1bmRlcnN0YW5kCj4gICAgICBpdHMgc2VtYW50aWNzLiBBY2NvcmRpbmcgdG8gcHJldmlv dXMgZGlzY3Vzc2lvbiB0aGVyZSBpcyBzb21lIGdlbmVyYWxpdHkKPiAgICAgIGJldHdlZW4gUFBD IHdpbmRvdy1iYXNlZCBzY2hlbWUgYW5kIFZGSU8gdHlwZTEgc2VtYW50aWNzLiBMZXQncwo+ICAg ICAgZmlyc3QgbWFrZSBjb25zZW5zdXMgb24gdGhpcyBwcm9wb3NhbCBhbmQgdGhlbiBmdXJ0aGVy IGRpc2N1c3MgaG93IHRvCj4gICAgICBleHRlbmQgaXQgdG8gY292ZXIgUFBDJ3MgcmVxdWlyZW1l bnQuCj4KPiAtICAgVGhlcmUgaXMgYSBwcm90b2NvbCBiZXR3ZWVuIHZmaW8gZ3JvdXAgYW5kIGt2 bS4gTmVlZHMgdG8gdGhpbmsgYWJvdXQKPiAgICAgIGhvdyBpdCB3aWxsIGJlIGFmZmVjdGVkIGZv bGxvd2luZyB0aGlzIHByb3Bvc2FsLgo+Cj4gLSAgIG1kZXYgaW4gdGhpcyBjb250ZXh0IHJlZmVy cyB0byBtZWRpYXRlZCBzdWJmdW5jdGlvbnMgKGUuZy4gSW50ZWwgU0lPVikKPiAgICAgIHdoaWNo IGNhbiBiZSBwaHlzaWNhbGx5IGlzb2xhdGVkIGluLWJldHdlZW4gdGhyb3VnaCBQQVNJRC1ncmFu dWxhcgo+ICAgICAgSU9NTVUgcHJvdGVjdGlvbi4gSGlzdG9yaWNhbGx5IHBlb3BsZSBhbHNvIGRp c2N1c3NlZCBvbmUgdXNhZ2UgYnkKPiAgICAgIG1lZGlhdGluZyBhIHBkZXYgaW50byBhIG1kZXYu IFRoaXMgdXNhZ2UgaXMgbm90IGNvdmVyZWQgaGVyZSwgYW5kIGlzCj4gICAgICBzdXBwb3NlZCB0 byBiZSByZXBsYWNlZCBieSBNYXgncyB3b3JrIHdoaWNoIGFsbG93cyBvdmVycmlkaW5nIHZhcmlv dXMKPiAgICAgIFZGSU8gb3BlcmF0aW9ucyBpbiB2ZmlvLXBjaSBkcml2ZXIuCj4KPiAyLiB1QVBJ IFByb3Bvc2FsCj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+Cj4gL2Rldi9pb2FzaWQgdUFQSSBj b3ZlcnMgZXZlcnl0aGluZyBhYm91dCBtYW5hZ2luZyBJL08gYWRkcmVzcyBzcGFjZXMuCj4KPiAv ZGV2L3ZmaW8gdUFQSSBidWlsZHMgY29ubmVjdGlvbiBiZXR3ZWVuIGRldmljZXMgYW5kIEkvTyBh ZGRyZXNzIHNwYWNlcy4KPgo+IC9kZXYva3ZtIHVBUEkgaXMgb3B0aW9uYWwgcmVxdWlyZWQgYXMg ZmFyIGFzIEVOUUNNRCBpcyBjb25jZXJuZWQuCj4KPgo+IDIuMS4gL2Rldi9pb2FzaWQgdUFQSQo+ ICsrKysrKysrKysrKysrKysrCj4KPiAvKgo+ICAgICogQ2hlY2sgd2hldGhlciBhbiB1QVBJIGV4 dGVuc2lvbiBpcyBzdXBwb3J0ZWQuCj4gICAgKgo+ICAgICogVGhpcyBpcyBmb3IgRkQtbGV2ZWwg Y2FwYWJpbGl0aWVzLCBzdWNoIGFzIGxvY2tlZCBwYWdlIHByZS1yZWdpc3RyYXRpb24uCj4gICAg KiBJT0FTSUQtbGV2ZWwgY2FwYWJpbGl0aWVzIGFyZSByZXBvcnRlZCB0aHJvdWdoIElPQVNJRF9H RVRfSU5GTy4KPiAgICAqCj4gICAgKiBSZXR1cm46IDAgaWYgbm90IHN1cHBvcnRlZCwgMSBpZiBz dXBwb3J0ZWQuCj4gICAgKi8KPiAjZGVmaW5lIElPQVNJRF9DSEVDS19FWFRFTlNJT04JX0lPKElP QVNJRF9UWVBFLCBJT0FTSURfQkFTRSArIDApCj4KPgo+IC8qCj4gICAgKiBSZWdpc3RlciB1c2Vy IHNwYWNlIG1lbW9yeSB3aGVyZSBETUEgaXMgYWxsb3dlZC4KPiAgICAqCj4gICAgKiBJdCBwaW5z IHVzZXIgcGFnZXMgYW5kIGRvZXMgdGhlIGxvY2tlZCBtZW1vcnkgYWNjb3VudGluZyBzbyBzdWIt Cj4gICAgKiBzZXF1ZW50IElPQVNJRF9NQVAvVU5NQVBfRE1BIGNhbGxzIGdldCBmYXN0ZXIuCj4g ICAgKgo+ICAgICogV2hlbiB0aGlzIGlvY3RsIGlzIG5vdCB1c2VkLCBvbmUgdXNlciBwYWdlIG1p Z2h0IGJlIGFjY291bnRlZAo+ICAgICogbXVsdGlwbGUgdGltZXMgd2hlbiBpdCBpcyBtYXBwZWQg YnkgbXVsdGlwbGUgSU9BU0lEcyB3aGljaCBhcmUKPiAgICAqIG5vdCBuZXN0ZWQgdG9nZXRoZXIu Cj4gICAgKgo+ICAgICogSW5wdXQgcGFyYW1ldGVyczoKPiAgICAqCS0gdmFkZHI7Cj4gICAgKgkt IHNpemU7Cj4gICAgKgo+ICAgICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3MsIC1lcnJubyBvbiBmYWls dXJlLgo+ICAgICovCj4gI2RlZmluZSBJT0FTSURfUkVHSVNURVJfTUVNT1JZCV9JTyhJT0FTSURf VFlQRSwgSU9BU0lEX0JBU0UgKyAxKQo+ICNkZWZpbmUgSU9BU0lEX1VOUkVHSVNURVJfTUVNT1JZ CV9JTyhJT0FTSURfVFlQRSwgSU9BU0lEX0JBU0UgKyAyKQo+Cj4KPiAvKgo+ICAgICogQWxsb2Nh dGUgYW4gSU9BU0lELgo+ICAgICoKPiAgICAqIElPQVNJRCBpcyB0aGUgRkQtbG9jYWwgc29mdHdh cmUgaGFuZGxlIHJlcHJlc2VudGluZyBhbiBJL08gYWRkcmVzcwo+ICAgICogc3BhY2UuIEVhY2gg SU9BU0lEIGlzIGFzc29jaWF0ZWQgd2l0aCBhIHNpbmdsZSBJL08gcGFnZSB0YWJsZS4gVXNlcgo+ ICAgICogbXVzdCBjYWxsIHRoaXMgaW9jdGwgdG8gZ2V0IGFuIElPQVNJRCBmb3IgZXZlcnkgSS9P IGFkZHJlc3Mgc3BhY2UgdGhhdCBpcwo+ICAgICogaW50ZW5kZWQgdG8gYmUgZW5hYmxlZCBpbiB0 aGUgSU9NTVUuCj4gICAgKgo+ICAgICogQSBuZXdseS1jcmVhdGVkIElPQVNJRCBkb2Vzbid0IGFj Y2VwdCBhbnkgY29tbWFuZCBiZWZvcmUgaXQgaXMKPiAgICAqIGF0dGFjaGVkIHRvIGEgZGV2aWNl LiBPbmNlIGF0dGFjaGVkLCBhbiBlbXB0eSBJL08gcGFnZSB0YWJsZSBpcwo+ICAgICogYm91bmQg d2l0aCB0aGUgSU9NTVUgdGhlbiB0aGUgdXNlciBjb3VsZCB1c2UgZWl0aGVyIERNQSBtYXBwaW5n Cj4gICAgKiBvciBwZ3RhYmxlIGJpbmRpbmcgY29tbWFuZHMgdG8gbWFuYWdlIHRoaXMgSS9PIHBh Z2UgdGFibGUuCj4gICAgKgo+ICAgICogRGV2aWNlIGF0dGFjaG1lbnQgaXMgaW5pdGlhdGVkIHRo cm91Z2ggZGV2aWNlIGRyaXZlciB1QVBJIChlLmcuIFZGSU8pCj4gICAgKgo+ICAgICogUmV0dXJu OiBhbGxvY2F0ZWQgaW9hc2lkIG9uIHN1Y2Nlc3MsIC1lcnJubyBvbiBmYWlsdXJlLgo+ICAgICov Cj4gI2RlZmluZSBJT0FTSURfQUxMT0MJX0lPKElPQVNJRF9UWVBFLCBJT0FTSURfQkFTRSArIDMp Cj4gI2RlZmluZSBJT0FTSURfRlJFRQlfSU8oSU9BU0lEX1RZUEUsIElPQVNJRF9CQVNFICsgNCkK CgpJIHdvdWxkIGxpa2UgdG8ga25vdyB0aGUgcmVhc29uIGZvciBzdWNoIGluZGlyZWN0aW9uLgoK SXQgbG9va3MgdG8gbWUgdGhlIGlvYXNpZCBmZCBpcyBzdWZmaWNpZW50IGZvciBwZXJmb3JtaW5n IGFueSBvcGVyYXRpb25zLgoKU3VjaCBhbGxvY2F0aW9uIG9ubHkgd29yayBpZiBhcyBpb2FzIGZk IGNhbiBoYXZlIG11bHRpcGxlIGlvYXNpZCB3aGljaCAKc2VlbXMgbm90IHRoZSBjYXNlIHlvdSBk ZXNjcmliZSBoZXJlLgoKCj4KPgo+IC8qCj4gICAgKiBHZXQgaW5mb3JtYXRpb24gYWJvdXQgYW4g SS9PIGFkZHJlc3Mgc3BhY2UKPiAgICAqCj4gICAgKiBTdXBwb3J0ZWQgY2FwYWJpbGl0aWVzOgo+ ICAgICoJLSBWRklPIHR5cGUxIG1hcC91bm1hcDsKPiAgICAqCS0gcGd0YWJsZS9wYXNpZF90YWJs ZSBiaW5kaW5nCj4gICAgKgktIGhhcmR3YXJlIG5lc3RpbmcgdnMuIHNvZnR3YXJlIG5lc3Rpbmc7 Cj4gICAgKgktIC4uLgo+ICAgICoKPiAgICAqIFJlbGF0ZWQgYXR0cmlidXRlczoKPiAgICAqIAkt IHN1cHBvcnRlZCBwYWdlIHNpemVzLCByZXNlcnZlZCBJT1ZBIHJhbmdlcyAoRE1BIG1hcHBpbmcp Owo+ICAgICoJLSB2ZW5kb3IgcGd0YWJsZSBmb3JtYXRzIChwZ3RhYmxlIGJpbmRpbmcpOwo+ICAg ICoJLSBudW1iZXIgb2YgY2hpbGQgSU9BU0lEcyAobmVzdGluZyk7Cj4gICAgKgktIC4uLgo+ICAg ICoKPiAgICAqIEFib3ZlIGluZm9ybWF0aW9uIGlzIGF2YWlsYWJsZSBvbmx5IGFmdGVyIG9uZSBv ciBtb3JlIGRldmljZXMgYXJlCj4gICAgKiBhdHRhY2hlZCB0byB0aGUgc3BlY2lmaWVkIElPQVNJ RC4gT3RoZXJ3aXNlIHRoZSBJT0FTSUQgaXMganVzdCBhCj4gICAgKiBudW1iZXIgdy9vIGFueSBj YXBhYmlsaXR5IG9yIGF0dHJpYnV0ZS4KPiAgICAqCj4gICAgKiBJbnB1dCBwYXJhbWV0ZXJzOgo+ ICAgICoJLSB1MzIgaW9hc2lkOwo+ICAgICoKPiAgICAqIE91dHB1dCBwYXJhbWV0ZXJzOgo+ICAg ICoJLSBtYW55LiBUQkQuCj4gICAgKi8KPiAjZGVmaW5lIElPQVNJRF9HRVRfSU5GTwlfSU8oSU9B U0lEX1RZUEUsIElPQVNJRF9CQVNFICsgNSkKPgo+Cj4gLyoKPiAgICAqIE1hcC91bm1hcCBwcm9j ZXNzIHZpcnR1YWwgYWRkcmVzc2VzIHRvIEkvTyB2aXJ0dWFsIGFkZHJlc3Nlcy4KPiAgICAqCj4g ICAgKiBQcm92aWRlIFZGSU8gdHlwZTEgZXF1aXZhbGVudCBzZW1hbnRpY3MuIFN0YXJ0IHdpdGgg dGhlIHNhbWUKPiAgICAqIHJlc3RyaWN0aW9uIGUuZy4gdGhlIHVubWFwIHNpemUgc2hvdWxkIG1h dGNoIHRob3NlIHVzZWQgaW4gdGhlCj4gICAgKiBvcmlnaW5hbCBtYXBwaW5nIGNhbGwuCj4gICAg Kgo+ICAgICogSWYgSU9BU0lEX1JFR0lTVEVSX01FTU9SWSBoYXMgYmVlbiBjYWxsZWQsIHRoZSBt YXBwZWQgdmFkZHIKPiAgICAqIG11c3QgYmUgYWxyZWFkeSBpbiB0aGUgcHJlcmVnaXN0ZXJlZCBs aXN0Lgo+ICAgICoKPiAgICAqIElucHV0IHBhcmFtZXRlcnM6Cj4gICAgKgktIHUzMiBpb2FzaWQ7 Cj4gICAgKgktIHJlZmVyIHRvIHZmaW9faW9tbXVfdHlwZTFfZG1hX3t1bn1tYXAKPiAgICAqCj4g ICAgKiBSZXR1cm46IDAgb24gc3VjY2VzcywgLWVycm5vIG9uIGZhaWx1cmUuCj4gICAgKi8KPiAj ZGVmaW5lIElPQVNJRF9NQVBfRE1BCV9JTyhJT0FTSURfVFlQRSwgSU9BU0lEX0JBU0UgKyA2KQo+ ICNkZWZpbmUgSU9BU0lEX1VOTUFQX0RNQQlfSU8oSU9BU0lEX1RZUEUsIElPQVNJRF9CQVNFICsg NykKPgo+Cj4gLyoKPiAgICAqIENyZWF0ZSBhIG5lc3RpbmcgSU9BU0lEIChjaGlsZCkgb24gYW4g ZXhpc3RpbmcgSU9BU0lEIChwYXJlbnQpCj4gICAgKgo+ICAgICogSU9BU0lEcyBjYW4gYmUgbmVz dGVkIHRvZ2V0aGVyLCBpbXBseWluZyB0aGF0IHRoZSBvdXRwdXQgYWRkcmVzcwo+ICAgICogZnJv bSBvbmUgSS9PIHBhZ2UgdGFibGUgKGNoaWxkKSBtdXN0IGJlIGZ1cnRoZXIgdHJhbnNsYXRlZCBi eQo+ICAgICogYW5vdGhlciBJL08gcGFnZSB0YWJsZSAocGFyZW50KS4KPiAgICAqCj4gICAgKiBB cyB0aGUgY2hpbGQgYWRkcyBlc3NlbnRpYWxseSBhbm90aGVyIHJlZmVyZW5jZSB0byB0aGUgSS9P IHBhZ2UgdGFibGUKPiAgICAqIHJlcHJlc2VudGVkIGJ5IHRoZSBwYXJlbnQsIGFueSBkZXZpY2Ug YXR0YWNoZWQgdG8gdGhlIGNoaWxkIGlvYXNpZAo+ICAgICogbXVzdCBiZSBhbHJlYWR5IGF0dGFj aGVkIHRvIHRoZSBwYXJlbnQuCj4gICAgKgo+ICAgICogSW4gY29uY2VwdCB0aGVyZSBpcyBubyBs aW1pdCBvbiB0aGUgbnVtYmVyIG9mIHRoZSBuZXN0aW5nIGxldmVscy4KPiAgICAqIEhvd2V2ZXIg Zm9yIHRoZSBtYWpvcml0eSBjYXNlIG9uZSBuZXN0aW5nIGxldmVsIGlzIHN1ZmZpY2llbnQuIFRo ZQo+ICAgICogdXNlciBzaG91bGQgY2hlY2sgd2hldGhlciBhbiBJT0FTSUQgc3VwcG9ydHMgbmVz dGluZyB0aHJvdWdoCj4gICAgKiBJT0FTSURfR0VUX0lORk8uIEZvciBleGFtcGxlLCBpZiBvbmx5 IG9uZSBuZXN0aW5nIGxldmVsIGlzIGFsbG93ZWQsCj4gICAgKiB0aGUgbmVzdGluZyBjYXBhYmls aXR5IGlzIHJlcG9ydGVkIG9ubHkgb24gdGhlIHBhcmVudCBpbnN0ZWFkIG9mIHRoZQo+ICAgICog Y2hpbGQuCj4gICAgKgo+ICAgICogVXNlciBhbHNvIG5lZWRzIGNoZWNrICh2aWEgSU9BU0lEX0dF VF9JTkZPKSB3aGV0aGVyIHRoZSBuZXN0aW5nCj4gICAgKiBpcyBpbXBsZW1lbnRlZCBpbiBoYXJk d2FyZSBvciBzb2Z0d2FyZS4gSWYgc29mdHdhcmUtYmFzZWQsIERNQQo+ICAgICogbWFwcGluZyBw cm90b2NvbCBzaG91bGQgYmUgdXNlZCBvbiB0aGUgY2hpbGQgSU9BU0lELiBPdGhlcndpc2UsCj4g ICAgKiB0aGUgY2hpbGQgc2hvdWxkIGJlIG9wZXJhdGVkIHdpdGggcGd0YWJsZSBiaW5kaW5nIHBy b3RvY29sLgo+ICAgICoKPiAgICAqIElucHV0IHBhcmFtZXRlcnM6Cj4gICAgKgktIHUzMiBwYXJl bnRfaW9hc2lkOwo+ICAgICoKPiAgICAqIFJldHVybjogY2hpbGRfaW9hc2lkIG9uIHN1Y2Nlc3Ms IC1lcnJubyBvbiBmYWlsdXJlOwo+ICAgICovCj4gI2RlZmluZSBJT0FTSURfQ1JFQVRFX05FU1RJ TkcJX0lPKElPQVNJRF9UWVBFLCBJT0FTSURfQkFTRSArIDgpCj4KPgo+IC8qCj4gICAgKiBCaW5k IGFuIHVzZXItbWFuYWdlZCBJL08gcGFnZSB0YWJsZSB3aXRoIHRoZSBJT01NVQo+ICAgICoKPiAg ICAqIEJlY2F1c2UgdXNlciBwYWdlIHRhYmxlIGlzIHVudHJ1c3RlZCwgSU9BU0lEIG5lc3Rpbmcg bXVzdCBiZSBlbmFibGVkCj4gICAgKiBmb3IgdGhpcyBpb2FzaWQgc28gdGhlIGtlcm5lbCBjYW4g ZW5mb3JjZSBpdHMgRE1BIGlzb2xhdGlvbiBwb2xpY3kKPiAgICAqIHRocm91Z2ggdGhlIHBhcmVu dCBpb2FzaWQuCj4gICAgKgo+ICAgICogUGd0YWJsZSBiaW5kaW5nIHByb3RvY29sIGlzIGRpZmZl cmVudCBmcm9tIERNQSBtYXBwaW5nLiBUaGUgbGF0dGVyCj4gICAgKiBoYXMgdGhlIEkvTyBwYWdl IHRhYmxlIGNvbnN0cnVjdGVkIGJ5IHRoZSBrZXJuZWwgYW5kIHVwZGF0ZWQKPiAgICAqIGFjY29y ZGluZyB0byB1c2VyIE1BUC9VTk1BUCBjb21tYW5kcy4gV2l0aCBwZ3RhYmxlIGJpbmRpbmcgdGhl Cj4gICAgKiB3aG9sZSBwYWdlIHRhYmxlIGlzIGNyZWF0ZWQgYW5kIHVwZGF0ZWQgYnkgdXNlcnNw YWNlLCB0aHVzIGRpZmZlcmVudAo+ICAgICogc2V0IG9mIGNvbW1hbmRzIGFyZSByZXF1aXJlZCAo YmluZCwgaW90bGIgaW52YWxpZGF0aW9uLCBwYWdlIGZhdWx0LCBldGMuKS4KPiAgICAqCj4gICAg KiBCZWNhdXNlIHRoZSBwYWdlIHRhYmxlIGlzIGRpcmVjdGx5IHdhbGtlZCBieSB0aGUgSU9NTVUs IHRoZSB1c2VyCj4gICAgKiBtdXN0ICB1c2UgYSBmb3JtYXQgY29tcGF0aWJsZSB0byB0aGUgdW5k ZXJseWluZyBoYXJkd2FyZS4gSXQgY2FuCj4gICAgKiBjaGVjayB0aGUgZm9ybWF0IGluZm9ybWF0 aW9uIHRocm91Z2ggSU9BU0lEX0dFVF9JTkZPLgo+ICAgICoKPiAgICAqIFRoZSBwYWdlIHRhYmxl IGlzIGJvdW5kIHRvIHRoZSBJT01NVSBhY2NvcmRpbmcgdG8gdGhlIHJvdXRpbmcKPiAgICAqIGlu Zm9ybWF0aW9uIG9mIGVhY2ggYXR0YWNoZWQgZGV2aWNlIHVuZGVyIHRoZSBzcGVjaWZpZWQgSU9B U0lELiBUaGUKPiAgICAqIHJvdXRpbmcgaW5mb3JtYXRpb24gKFJJRCBhbmQgb3B0aW9uYWwgUEFT SUQpIGlzIHJlZ2lzdGVyZWQgd2hlbiBhCj4gICAgKiBkZXZpY2UgaXMgYXR0YWNoZWQgdG8gdGhp cyBJT0FTSUQgdGhyb3VnaCBWRklPIHVBUEkuCj4gICAgKgo+ICAgICogSW5wdXQgcGFyYW1ldGVy czoKPiAgICAqCS0gY2hpbGRfaW9hc2lkOwo+ICAgICoJLSBhZGRyZXNzIG9mIHRoZSB1c2VyIHBh Z2UgdGFibGU7Cj4gICAgKgktIGZvcm1hdHMgKHZlbmRvciwgYWRkcmVzc193aWR0aCwgZXRjLik7 Cj4gICAgKgo+ICAgICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3MsIC1lcnJubyBvbiBmYWlsdXJlLgo+ ICAgICovCj4gI2RlZmluZSBJT0FTSURfQklORF9QR1RBQkxFCQlfSU8oSU9BU0lEX1RZUEUsIElP QVNJRF9CQVNFICsgOSkKPiAjZGVmaW5lIElPQVNJRF9VTkJJTkRfUEdUQUJMRQlfSU8oSU9BU0lE X1RZUEUsIElPQVNJRF9CQVNFICsgMTApCj4KPgo+IC8qCj4gICAgKiBCaW5kIGFuIHVzZXItbWFu YWdlZCBQQVNJRCB0YWJsZSB0byB0aGUgSU9NTVUKPiAgICAqCj4gICAgKiBUaGlzIGlzIHJlcXVp cmVkIGZvciBwbGF0Zm9ybXMgd2hpY2ggcGxhY2UgUEFTSUQgdGFibGUgaW4gdGhlIEdQQSBzcGFj ZS4KPiAgICAqIEluIHRoaXMgY2FzZSB0aGUgc3BlY2lmaWVkIElPQVNJRCByZXByZXNlbnRzIHRo ZSBwZXItUklEIFBBU0lEIHNwYWNlLgo+ICAgICoKPiAgICAqIEFsdGVybmF0aXZlbHkgdGhpcyBt YXkgYmUgcmVwbGFjZWQgYnkgSU9BU0lEX0JJTkRfUEdUQUJMRSBwbHVzIGEKPiAgICAqIHNwZWNp YWwgZmxhZyB0byBpbmRpY2F0ZSB0aGUgZGlmZmVyZW5jZSBmcm9tIG5vcm1hbCBJL08gYWRkcmVz cyBzcGFjZXMuCj4gICAgKgo+ICAgICogVGhlIGZvcm1hdCBpbmZvIG9mIHRoZSBQQVNJRCB0YWJs ZSBpcyByZXBvcnRlZCBpbiBJT0FTSURfR0VUX0lORk8uCj4gICAgKgo+ICAgICogQXMgZXhwbGFp bmVkIGluIHRoZSBkZXNpZ24gc2VjdGlvbiwgdXNlci1tYW5hZ2VkIEkvTyBwYWdlIHRhYmxlcyBt dXN0Cj4gICAgKiBiZSBleHBsaWNpdGx5IGJvdW5kIHRvIHRoZSBrZXJuZWwgZXZlbiBvbiB0aGVz ZSBwbGF0Zm9ybXMuIEl0IGFsbG93cwo+ICAgICogdGhlIGtlcm5lbCB0byB1bmlmb3JtbHkgbWFu YWdlIEkvTyBhZGRyZXNzIHNwYWNlcyBjcm9zcyBhbGwgcGxhdGZvcm1zLgo+ICAgICogT3RoZXJ3 aXNlLCB0aGUgaW90bGIgaW52YWxpZGF0aW9uIGFuZCBwYWdlIGZhdWx0aW5nIHVBUEkgbXVzdCBi ZSBoYWNrZWQKPiAgICAqIHRvIGNhcnJ5IGRldmljZSByb3V0aW5nIGluZm9ybWF0aW9uIHRvIGlu ZGlyZWN0bHkgbWFyayB0aGUgaGlkZGVuIEkvTwo+ICAgICogYWRkcmVzcyBzcGFjZXMuCj4gICAg Kgo+ICAgICogSW5wdXQgcGFyYW1ldGVyczoKPiAgICAqCS0gY2hpbGRfaW9hc2lkOwo+ICAgICoJ LSBhZGRyZXNzIG9mIFBBU0lEIHRhYmxlOwo+ICAgICoJLSBmb3JtYXRzICh2ZW5kb3IsIHNpemUs IGV0Yy4pOwo+ICAgICoKPiAgICAqIFJldHVybjogMCBvbiBzdWNjZXNzLCAtZXJybm8gb24gZmFp bHVyZS4KPiAgICAqLwo+ICNkZWZpbmUgSU9BU0lEX0JJTkRfUEFTSURfVEFCTEUJX0lPKElPQVNJ RF9UWVBFLCBJT0FTSURfQkFTRSArIDExKQo+ICNkZWZpbmUgSU9BU0lEX1VOQklORF9QQVNJRF9U QUJMRQlfSU8oSU9BU0lEX1RZUEUsIElPQVNJRF9CQVNFICsgMTIpCj4KPgo+IC8qCj4gICAgKiBJ bnZhbGlkYXRlIElPVExCIGZvciBhbiB1c2VyLW1hbmFnZWQgSS9PIHBhZ2UgdGFibGUKPiAgICAq Cj4gICAgKiBVbmxpa2Ugd2hhdCdzIGRlZmluZWQgaW4gaW5jbHVkZS91YXBpL2xpbnV4L2lvbW11 LmgsIHRoaXMgY29tbWFuZAo+ICAgICogZG9lc24ndCBhbGxvdyB0aGUgdXNlciB0byBzcGVjaWZ5 IGNhY2hlIHR5cGUgYW5kIGxpa2VseSBzdXBwb3J0IG9ubHkKPiAgICAqIHR3byBncmFudWxhcml0 aWVzIChhbGwsIG9yIGEgc3BlY2lmaWVkIHJhbmdlKSBpbiB0aGUgSS9PIGFkZHJlc3Mgc3BhY2Uu Cj4gICAgKgo+ICAgICogUGh5c2ljYWwgSU9NTVUgaGF2ZSB0aHJlZSBjYWNoZSB0eXBlcyAoaW90 bGIsIGRldl9pb3RsYiBhbmQgcGFzaWQKPiAgICAqIGNhY2hlKS4gSWYgdGhlIElPQVNJRCByZXBy ZXNlbnRzIGFuIEkvTyBhZGRyZXNzIHNwYWNlLCB0aGUgaW52YWxpZGF0aW9uCj4gICAgKiBhbHdh eXMgYXBwbGllcyB0byB0aGUgaW90bGIgKGFuZCBkZXZfaW90bGIgaWYgZW5hYmxlZCkuIElmIHRo ZSBJT0FTSUQKPiAgICAqIHJlcHJlc2VudHMgYSB2UEFTSUQgc3BhY2UsIHRoZW4gdGhpcyBjb21t YW5kIGFwcGxpZXMgdG8gdGhlIFBBU0lECj4gICAgKiBjYWNoZS4KPiAgICAqCj4gICAgKiBTaW1p bGFybHkgdGhpcyBjb21tYW5kIGRvZXNuJ3QgcHJvdmlkZSBJT01NVS1saWtlIGdyYW51bGFyaXR5 Cj4gICAgKiBpbmZvIChkb21haW4td2lkZSwgcGFzaWQtd2lkZSwgcmFuZ2UtYmFzZWQpLCBzaW5j ZSBpdCdzIGFsbCBhYm91dCB0aGUKPiAgICAqIEkvTyBhZGRyZXNzIHNwYWNlIGl0c2VsZi4gVGhl IGlvYXNpZCBkcml2ZXIgd2Fsa3MgdGhlIGF0dGFjaGVkCj4gICAgKiByb3V0aW5nIGluZm9ybWF0 aW9uIHRvIG1hdGNoIHRoZSBJT01NVSBzZW1hbnRpY3MgdW5kZXIgdGhlCj4gICAgKiBob29kLgo+ ICAgICoKPiAgICAqIElucHV0IHBhcmFtZXRlcnM6Cj4gICAgKgktIGNoaWxkX2lvYXNpZDsKPiAg ICAqCS0gZ3JhbnVsYXJpdHkKPiAgICAqCj4gICAgKiBSZXR1cm46IDAgb24gc3VjY2VzcywgLWVy cm5vIG9uIGZhaWx1cmUKPiAgICAqLwo+ICNkZWZpbmUgSU9BU0lEX0lOVkFMSURBVEVfQ0FDSEUJ X0lPKElPQVNJRF9UWVBFLCBJT0FTSURfQkFTRSArIDEzKQo+Cj4KPiAvKgo+ICAgICogUGFnZSBm YXVsdCByZXBvcnQgYW5kIHJlc3BvbnNlCj4gICAgKgo+ICAgICogVGhpcyBpcyBUQkQuIENhbiBi ZSBhZGRlZCBhZnRlciBvdGhlciBwYXJ0cyBhcmUgY2xlYXJlZCB1cC4gTGlrZWx5IGl0Cj4gICAg KiB3aWxsIGJlIGEgcmluZyBidWZmZXIgc2hhcmVkIGJldHdlZW4gdXNlci9rZXJuZWwsIGFuIGV2 ZW50ZmQgdG8gbm90aWZ5Cj4gICAgKiB0aGUgdXNlciBhbmQgYW4gaW9jdGwgdG8gY29tcGxldGUg dGhlIGZhdWx0Lgo+ICAgICoKPiAgICAqIFRoZSBmYXVsdCBkYXRhIGlzIHBlciBJL08gYWRkcmVz cyBzcGFjZSwgaS5lLjogSU9BU0lEICsgZmF1bHRpbmdfYWRkcgo+ICAgICovCj4KPgo+IC8qCj4g ICAgKiBEaXJ0eSBwYWdlIHRyYWNraW5nCj4gICAgKgo+ICAgICogVHJhY2sgYW5kIHJlcG9ydCBt ZW1vcnkgcGFnZXMgZGlydGllZCBpbiBJL08gYWRkcmVzcyBzcGFjZXMuIFRoZXJlCj4gICAgKiBp cyBhbiBvbmdvaW5nIHdvcmsgYnkgS3Vua3VuIEppYW5nIGJ5IGV4dGVuZGluZyBleGlzdGluZyBW RklPIHR5cGUxLgo+ICAgICogSXQgbmVlZHMgYmUgYWRhcHRlZCB0byAvZGV2L2lvYXNpZCBsYXRl ci4KPiAgICAqLwo+Cj4KPiAyLjIuIC9kZXYvdmZpbyB1QVBJCj4gKysrKysrKysrKysrKysrKwo+ Cj4gLyoKPiAgICAqIEJpbmQgYSB2ZmlvX2RldmljZSB0byB0aGUgc3BlY2lmaWVkIElPQVNJRCBm ZAo+ICAgICoKPiAgICAqIE11bHRpcGxlIHZmaW8gZGV2aWNlcyBjYW4gYmUgYm91bmQgdG8gYSBz aW5nbGUgaW9hc2lkX2ZkLCBidXQgYSBzaW5nbGUKPiAgICAqIHZmaW8gZGV2aWNlIHNob3VsZCBu b3QgYmUgYm91bmQgdG8gbXVsdGlwbGUgaW9hc2lkX2ZkJ3MuCj4gICAgKgo+ICAgICogSW5wdXQg cGFyYW1ldGVyczoKPiAgICAqCS0gaW9hc2lkX2ZkOwo+ICAgICoKPiAgICAqIFJldHVybjogMCBv biBzdWNjZXNzLCAtZXJybm8gb24gZmFpbHVyZS4KPiAgICAqLwo+ICNkZWZpbmUgVkZJT19CSU5E X0lPQVNJRF9GRAkJX0lPKFZGSU9fVFlQRSwgVkZJT19CQVNFICsgMjIpCj4gI2RlZmluZSBWRklP X1VOQklORF9JT0FTSURfRkQJX0lPKFZGSU9fVFlQRSwgVkZJT19CQVNFICsgMjMpCj4KPgo+IC8q Cj4gICAgKiBBdHRhY2ggYSB2ZmlvIGRldmljZSB0byB0aGUgc3BlY2lmaWVkIElPQVNJRAo+ICAg ICoKPiAgICAqIE11bHRpcGxlIHZmaW8gZGV2aWNlcyBjYW4gYmUgYXR0YWNoZWQgdG8gdGhlIHNh bWUgSU9BU0lELCBhbmQgdmljZQo+ICAgICogdmVyc2EuCj4gICAgKgo+ICAgICogVXNlciBtYXkg b3B0aW9uYWxseSBwcm92aWRlIGEgInZpcnR1YWwgUEFTSUQiIHRvIG1hcmsgYW4gSS9PIHBhZ2UK PiAgICAqIHRhYmxlIG9uIHRoaXMgdmZpbyBkZXZpY2UuIFdoZXRoZXIgdGhlIHZpcnR1YWwgUEFT SUQgaXMgcGh5c2ljYWxseSB1c2VkCj4gICAgKiBvciBjb252ZXJ0ZWQgdG8gYW5vdGhlciBrZXJu ZWwtYWxsb2NhdGVkIFBBU0lEIGlzIGEgcG9saWN5IGluIHZmaW8gZGV2aWNlCj4gICAgKiBkcml2 ZXIuCj4gICAgKgo+ICAgICogVGhlcmUgaXMgbm8gbmVlZCB0byBzcGVjaWZ5IGlvYXNpZF9mZCBp biB0aGlzIGNhbGwgZHVlIHRvIHRoZSBhc3N1bXB0aW9uCj4gICAgKiBvZiAxOjEgY29ubmVjdGlv biBiZXR3ZWVuIHZmaW8gZGV2aWNlIGFuZCB0aGUgYm91bmQgZmQuCj4gICAgKgo+ICAgICogSW5w dXQgcGFyYW1ldGVyOgo+ICAgICoJLSBpb2FzaWQ7Cj4gICAgKgktIGZsYWc7Cj4gICAgKgktIHVz ZXJfcGFzaWQgKGlmIHNwZWNpZmllZCk7Cj4gICAgKgo+ICAgICogUmV0dXJuOiAwIG9uIHN1Y2Nl c3MsIC1lcnJubyBvbiBmYWlsdXJlLgo+ICAgICovCj4gI2RlZmluZSBWRklPX0FUVEFDSF9JT0FT SUQJCV9JTyhWRklPX1RZUEUsIFZGSU9fQkFTRSArIDI0KQo+ICNkZWZpbmUgVkZJT19ERVRBQ0hf SU9BU0lECQlfSU8oVkZJT19UWVBFLCBWRklPX0JBU0UgKyAyNSkKPgo+Cj4gMi4zLiBLVk0gdUFQ SQo+ICsrKysrKysrKysrKwo+Cj4gLyoKPiAgICAqIFVwZGF0ZSBDUFUgUEFTSUQgbWFwcGluZwo+ ICAgICoKPiAgICAqIFRoaXMgaXMgbmVjZXNzYXJ5IHdoZW4gRU5RQ01EIHdpbGwgYmUgdXNlZCBp biB0aGUgZ3Vlc3Qgd2hpbGUgdGhlCj4gICAgKiB0YXJnZXRlZCBkZXZpY2UgZG9lc24ndCBhY2Nl cHQgdGhlIHZQQVNJRCBzYXZlZCBpbiB0aGUgQ1BVIE1TUi4KPiAgICAqCj4gICAgKiBUaGlzIGNv bW1hbmQgYWxsb3dzIHVzZXIgdG8gc2V0L2NsZWFyIHRoZSB2UEFTSUQtPnBQQVNJRCBtYXBwaW5n Cj4gICAgKiBpbiB0aGUgQ1BVLCBieSBwcm92aWRpbmcgdGhlIElPQVNJRCAoYW5kIEZEKSBpbmZv cm1hdGlvbiByZXByZXNlbnRpbmcKPiAgICAqIHRoZSBJL08gYWRkcmVzcyBzcGFjZSBtYXJrZWQg YnkgdGhpcyB2UEFTSUQuCj4gICAgKgo+ICAgICogSW5wdXQgcGFyYW1ldGVyczoKPiAgICAqCS0g dXNlcl9wYXNpZDsKPiAgICAqCS0gaW9hc2lkX2ZkOwo+ICAgICoJLSBpb2FzaWQ7Cj4gICAgKi8K PiAjZGVmaW5lIEtWTV9NQVBfUEFTSUQJX0lPKEtWTUlPLCAweGYwKQo+ICNkZWZpbmUgS1ZNX1VO TUFQX1BBU0lECV9JTyhLVk1JTywgMHhmMSkKPgo+Cj4gMy4gU2FtcGxlIHN0cnVjdHVyZXMgYW5k IGhlbHBlciBmdW5jdGlvbnMKPiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQo+Cj4gVGhyZWUgaGVscGVyIGZ1bmN0aW9ucyBhcmUgcHJvdmlk ZWQgdG8gc3VwcG9ydCBWRklPX0JJTkRfSU9BU0lEX0ZEOgo+Cj4gCXN0cnVjdCBpb2FzaWRfY3R4 ICppb2FzaWRfY3R4X2ZkZ2V0KGludCBmZCk7Cj4gCWludCBpb2FzaWRfcmVnaXN0ZXJfZGV2aWNl KHN0cnVjdCBpb2FzaWRfY3R4ICpjdHgsIHN0cnVjdCBpb2FzaWRfZGV2ICpkZXYpOwo+IAlpbnQg aW9hc2lkX3VucmVnaXN0ZXJfZGV2aWNlKHN0cnVjdCBpb2FzaWRfZGV2ICpkZXYpOwo+Cj4gQW4g aW9hc2lkX2N0eCBpcyBjcmVhdGVkIGZvciBlYWNoIGZkOgo+Cj4gCXN0cnVjdCBpb2FzaWRfY3R4 IHsKPiAJCS8vIGEgbGlzdCBvZiBhbGxvY2F0ZWQgSU9BU0lEIGRhdGEncwo+IAkJc3RydWN0IGxp c3RfaGVhZAkJaW9hc2lkX2xpc3Q7Cj4gCQkvLyBhIGxpc3Qgb2YgcmVnaXN0ZXJlZCBkZXZpY2Vz Cj4gCQlzdHJ1Y3QgbGlzdF9oZWFkCQlkZXZfbGlzdDsKPiAJCS8vIGEgbGlzdCBvZiBwcmUtcmVn aXN0ZXJlZCB2aXJ0dWFsIGFkZHJlc3MgcmFuZ2VzCj4gCQlzdHJ1Y3QgbGlzdF9oZWFkCQlwcmVy ZWdfbGlzdDsKPiAJfTsKPgo+IEVhY2ggcmVnaXN0ZXJlZCBkZXZpY2UgaXMgcmVwcmVzZW50ZWQg YnkgaW9hc2lkX2RldjoKPgo+IAlzdHJ1Y3QgaW9hc2lkX2RldiB7Cj4gCQlzdHJ1Y3QgbGlzdF9o ZWFkCQluZXh0Owo+IAkJc3RydWN0IGlvYXNpZF9jdHgJKmN0eDsKPiAJCS8vIGFsd2F5cyBiZSB0 aGUgcGh5c2ljYWwgZGV2aWNlCj4gCQlzdHJ1Y3QgZGV2aWNlIAkJKmRldmljZTsKPiAJCXN0cnVj dCBrcmVmCQlrcmVmOwo+IAl9Owo+Cj4gQmVjYXVzZSB3ZSBhc3N1bWUgb25lIHZmaW9fZGV2aWNl IGNvbm5lY3RlZCB0byBhdCBtb3N0IG9uZSBpb2FzaWRfZmQsCj4gaGVyZSBpb2FzaWRfZGV2IGNv dWxkIGJlIGVtYmVkZGVkIGluIHZmaW9fZGV2aWNlIGFuZCB0aGVuIGxpbmtlZCB0bwo+IGlvYXNp ZF9jdHgtPmRldl9saXN0IHdoZW4gcmVnaXN0cmF0aW9uIHN1Y2NlZWRzLiBGb3IgbWRldiB0aGUg c3RydWN0Cj4gZGV2aWNlIHNob3VsZCBiZSB0aGUgcG9pbnRlciB0byB0aGUgcGFyZW50IGRldmlj ZS4gUEFTSUQgbWFya2luZyB0aGlzCj4gbWRldiBpcyBzcGVjaWZpZWQgbGF0ZXIgd2hlbiBWRklP X0FUVEFDSF9JT0FTSUQuCj4KPiBBbiBpb2FzaWRfZGF0YSBpcyBjcmVhdGVkIHdoZW4gSU9BU0lE X0FMTE9DLCBhcyB0aGUgbWFpbiBvYmplY3QKPiBkZXNjcmliaW5nIGNoYXJhY3RlcmlzdGljcyBh Ym91dCBhbiBJL08gcGFnZSB0YWJsZToKPgo+IAlzdHJ1Y3QgaW9hc2lkX2RhdGEgewo+IAkJLy8g bGluayB0byBpb2FzaWRfY3R4LT5pb2FzaWRfbGlzdAo+IAkJc3RydWN0IGxpc3RfaGVhZAkJbmV4 dDsKPgo+IAkJLy8gdGhlIElPQVNJRCBudW1iZXIKPiAJCXUzMgkJCWlvYXNpZDsKPgo+IAkJLy8g dGhlIGhhbmRsZSB0byBjb252ZXkgaW9tbXUgb3BlcmF0aW9ucwo+IAkJLy8gaG9sZCB0aGUgcGdk IChUQkQgdW50aWwgZGlzY3Vzc2luZyBpb21tdSBhcGkpCj4gCQlzdHJ1Y3QgaW9tbXVfZG9tYWlu ICpkb21haW47Cj4KPiAJCS8vIG1hcCBtZXRhZGF0YSAodmZpbyB0eXBlMSBzZW1hbnRpY3MpCj4g CQlzdHJ1Y3QgcmJfbm9kZQkJZG1hX2xpc3Q7Cj4KPiAJCS8vIHBvaW50ZXIgdG8gdXNlci1tYW5h Z2VkIHBndGFibGUgKGZvciBuZXN0aW5nIGNhc2UpCj4gCQl1NjQJCQl1c2VyX3BnZDsKPgo+IAkJ Ly8gbGluayB0byB0aGUgcGFyZW50IGlvYXNpZCAoZm9yIG5lc3RpbmcpCj4gCQlzdHJ1Y3QgaW9h c2lkX2RhdGEJKnBhcmVudDsKPgo+IAkJLy8gY2FjaGUgdGhlIGdsb2JhbCBQQVNJRCBzaGFyZWQg YnkgRU5RQ01ELWNhcGFibGUKPiAJCS8vIGRldmljZXMgKHNlZSBiZWxvdyBleHBsYW5hdGlvbiBp biBzZWN0aW9uIDQpCj4gCQl1MzIJCQlwYXNpZDsKPgo+IAkJLy8gYSBsaXN0IG9mIGRldmljZSBh dHRhY2ggZGF0YSAocm91dGluZyBpbmZvcm1hdGlvbikKPiAJCXN0cnVjdCBsaXN0X2hlYWQJCWF0 dGFjaF9kYXRhOwo+Cj4gCQkvLyBhIGxpc3Qgb2YgcGFydGlhbGx5LWF0dGFjaGVkIGRldmljZXMg KGdyb3VwKQo+IAkJc3RydWN0IGxpc3RfaGVhZAkJcGFydGlhbF9kZXZpY2VzOwo+Cj4gCQkvLyBh IGxpc3Qgb2YgZmF1bHRfZGF0YSByZXBvcnRlZCBmcm9tIHRoZSBpb21tdSBsYXllcgo+IAkJc3Ry dWN0IGxpc3RfaGVhZAkJZmF1bHRfZGF0YTsKPgo+IAkJLi4uCj4gCX0KPgo+IGlvYXNpZF9kYXRh IGFuZCBpb21tdV9kb21haW4gaGF2ZSBvdmVybGFwcGluZyByb2xlcyBhcyBib3RoIGFyZQo+IGlu dHJvZHVjZWQgdG8gcmVwcmVzZW50IGFuIEkvTyBhZGRyZXNzIHNwYWNlLiBJdCBpcyBzdGlsbCBh IGJpZyBUQkQgaG93Cj4gdGhlIHR3byBzaG91bGQgYmUgY29yZWxhdGVkIG9yIGV2ZW4gbWVyZ2Vk LCBhbmQgd2hldGhlciBuZXcgaW9tbXUKPiBvcHMgYXJlIHJlcXVpcmVkIHRvIGhhbmRsZSBSSUQr UEFTSUQgZXhwbGljaXRseS4gV2UgbGVhdmUgdGhpcyBhcyBvcGVuCj4gZm9yIG5vdyBhcyB0aGlz IHByb3Bvc2FsIGlzIG1haW5seSBhYm91dCB1QVBJLiBGb3Igc2ltcGxpZmljYXRpb24KPiBwdXJw b3NlIHRoZSB0d28gb2JqZWN0cyBhcmUga2VwdCBzZXBhcmF0ZSBpbiB0aGlzIGNvbnRleHQsIGFz c3VtaW5nIGFuCj4gMToxIGNvbm5lY3Rpb24gaW4tYmV0d2VlbiBhbmQgdGhlIGRvbWFpbiBhcyB0 aGUgcGxhY2UtaG9sZGVyCj4gcmVwcmVzZW50aW5nIHRoZSAxc3QgY2xhc3Mgb2JqZWN0IGluIHRo ZSBpb21tdSBvcHMuCj4KPiBUd28gaGVscGVyIGZ1bmN0aW9ucyBhcmUgcHJvdmlkZWQgdG8gc3Vw cG9ydCBWRklPX0FUVEFDSF9JT0FTSUQ6Cj4KPiAJc3RydWN0IGF0dGFjaF9pbmZvIHsKPiAJCXUz Mglpb2FzaWQ7Cj4gCQkvLyBJZiB2YWxpZCwgdGhlIFBBU0lEIHRvIGJlIHVzZWQgcGh5c2ljYWxs eQo+IAkJdTMyCXBhc2lkOwo+IAl9Owo+IAlpbnQgaW9hc2lkX2RldmljZV9hdHRhY2goc3RydWN0 IGlvYXNpZF9kZXYgKmRldiwKPiAJCXN0cnVjdCBhdHRhY2hfaW5mbyBpbmZvKTsKPiAJaW50IGlv YXNpZF9kZXZpY2VfZGV0YWNoKHN0cnVjdCBpb2FzaWRfZGV2ICpkZXYsIHUzMiBpb2FzaWQpOwo+ Cj4gVGhlIHBhc2lkIHBhcmFtZXRlciBpcyBvcHRpb25hbGx5IHByb3ZpZGVkIGJhc2VkIG9uIHRo ZSBwb2xpY3kgaW4gdmZpbwo+IGRldmljZSBkcml2ZXIuIEl0IGNvdWxkIGJlIHRoZSBQQVNJRCBt YXJraW5nIHRoZSBkZWZhdWx0IEkvTyBhZGRyZXNzCj4gc3BhY2UgZm9yIGEgbWRldiwgb3IgdGhl IHVzZXItcHJvdmlkZWQgUEFTSUQgbWFya2luZyBhbiB1c2VyIEkvTyBwYWdlCj4gdGFibGUsIG9y IGFub3RoZXIga2VybmVsLWFsbG9jYXRlZCBQQVNJRCBiYWNraW5nIHRoZSB1c2VyLXByb3ZpZGVk IG9uZS4KPiBQbGVhc2UgY2hlY2sgbmV4dCBzZWN0aW9uIGZvciBkZXRhaWwgZXhwbGFuYXRpb24u Cj4KPiBBIG5ldyBvYmplY3QgaXMgaW50cm9kdWNlZCBhbmQgbGlua2VkIHRvIGlvYXNpZF9kYXRh LT5hdHRhY2hfZGF0YSBmb3IKPiBlYWNoIHN1Y2Nlc3NmdWwgYXR0YWNoIG9wZXJhdGlvbjoKPgo+ IAlzdHJ1Y3QgaW9hc2lkX2F0dGFjaF9kYXRhIHsKPiAJCXN0cnVjdCBsaXN0X2hlYWQJCW5leHQ7 Cj4gCQlzdHJ1Y3QgaW9hc2lkX2RldgkqZGV2Owo+IAkJdTMyIAkJCXBhc2lkOwo+IAl9Cj4KPiBB cyBleHBsYWluZWQgaW4gdGhlIGRlc2lnbiBzZWN0aW9uLCB0aGVyZSBpcyBubyBleHBsaWNpdCBn cm91cCBlbmZvcmNlbWVudAo+IGluIC9kZXYvaW9hc2lkIHVBUEkgb3IgaGVscGVyIGZ1bmN0aW9u cy4gQnV0IHRoZSBpb2FzaWQgZHJpdmVyIGRvZXMKPiBpbXBsaWNpdCBncm91cCBjaGVjayAtIGJl Zm9yZSBldmVyeSBkZXZpY2Ugd2l0aGluIGFuIGlvbW11IGdyb3VwIGlzCj4gYXR0YWNoZWQgdG8g dGhpcyBJT0FTSUQsIHRoZSBwcmV2aW91c2x5LWF0dGFjaGVkIGRldmljZXMgaW4gdGhpcyBncm91 cCBhcmUKPiBwdXQgaW4gaW9hc2lkX2RhdGEtPnBhcnRpYWxfZGV2aWNlcy4gVGhlIElPQVNJRCBy ZWplY3RzIGFueSBjb21tYW5kIGlmCj4gdGhlIHBhcnRpYWxfZGV2aWNlcyBsaXN0IGlzIG5vdCBl bXB0eS4KPgo+IFRoZW4gaXMgdGhlIGxhc3QgaGVscGVyIGZ1bmN0aW9uOgo+IAl1MzIgaW9hc2lk X2dldF9nbG9iYWxfcGFzaWQoc3RydWN0IGlvYXNpZF9jdHggKmN0eCwKPiAJCXUzMiBpb2FzaWQs IGJvb2wgYWxsb2MpOwo+Cj4gaW9hc2lkX2dldF9nbG9iYWxfcGFzaWQgaXMgbmVjZXNzYXJ5IGlu IHNjZW5hcmlvcyB3aGVyZSBtdWx0aXBsZSBkZXZpY2VzCj4gd2FudCB0byBzaGFyZSBhIHNhbWUg UEFTSUQgdmFsdWUgb24gdGhlIGF0dGFjaGVkIEkvTyBwYWdlIHRhYmxlIChlLmcuCj4gd2hlbiBF TlFDTUQgaXMgZW5hYmxlZCwgYXMgZXhwbGFpbmVkIGluIG5leHQgc2VjdGlvbikuIFdlIG5lZWQg YQo+IGNlbnRyYWxpemVkIHBsYWNlIChpb2FzaWRfZGF0YS0+cGFzaWQpIHRvIGhvbGQgdGhpcyB2 YWx1ZSAoYWxsb2NhdGVkIHdoZW4KPiBmaXJzdCBjYWxsZWQgd2l0aCBhbGxvYz10cnVlKS4gdmZp byBkZXZpY2UgZHJpdmVyIGNhbGxzIHRoaXMgZnVuY3Rpb24gKGFsbG9jPQo+IHRydWUpIHRvIGdl dCB0aGUgZ2xvYmFsIFBBU0lEIGZvciBhbiBpb2FzaWQgYmVmb3JlIGNhbGxpbmcgaW9hc2lkX2Rl dmljZV8KPiBhdHRhY2guIEtWTSBhbHNvIGNhbGxzIHRoaXMgZnVuY3Rpb24gKGFsbG9jPWZhbHNl KSB0byBzZXR1cCBQQVNJRCB0cmFuc2xhdGlvbgo+IHN0cnVjdHVyZSB3aGVuIHVzZXIgY2FsbHMg S1ZNX01BUF9QQVNJRC4KPgo+IDQuIFBBU0lEIFZpcnR1YWxpemF0aW9uCj4gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCj4KPiBXaGVuIGd1ZXN0IFNWQSAodlNWQSkgaXMgZW5hYmxlZCwg bXVsdGlwbGUgR1ZBIGFkZHJlc3Mgc3BhY2VzIGFyZQo+IGNyZWF0ZWQgb24gdGhlIGFzc2lnbmVk IHZmaW8gZGV2aWNlLiBUaGlzIGxlYWRzIHRvIHRoZSBjb25jZXB0cyBvZgo+ICJ2aXJ0dWFsIFBB U0lEIiAodlBBU0lEKSB2cy4gInBoeXNpY2FsIFBBU0lEIiAocFBBU0lEKS4gdlBBU0lEIGlzIGFz c2lnbmVkCj4gYnkgdGhlIGd1ZXN0IHRvIG1hcmsgYW4gR1ZBIGFkZHJlc3Mgc3BhY2Ugd2hpbGUg cFBBU0lEIGlzIHRoZSBvbmUKPiBzZWxlY3RlZCBieSB0aGUgaG9zdCBhbmQgYWN0dWFsbHkgcm91 dGVkIGluIHRoZSB3aXJlLgo+Cj4gdlBBU0lEIGlzIGNvbnZleWVkIHRvIHRoZSBrZXJuZWwgd2hl biB1c2VyIGNhbGxzIFZGSU9fQVRUQUNIX0lPQVNJRC4KPgo+IHZmaW8gZGV2aWNlIGRyaXZlciB0 cmFuc2xhdGVzIHZQQVNJRCB0byBwUEFTSUQgYmVmb3JlIGNhbGxpbmcgaW9hc2lkX2F0dGFjaF8K PiBkZXZpY2UsIHdpdGggdHdvIGZhY3RvcnMgdG8gYmUgY29uc2lkZXJlZDoKPgo+IC0gICAgV2hl dGhlciB2UEFTSUQgaXMgZGlyZWN0bHkgdXNlZCAodlBBU0lEPT1wUEFTSUQpIGluIHRoZSB3aXJl LCBvcgo+ICAgICAgIHNob3VsZCBiZSBpbnN0ZWFkIGNvbnZlcnRlZCB0byBhIG5ld2x5LWFsbG9j YXRlZCBvbmUgKHZQQVNJRCE9Cj4gICAgICAgcFBBU0lEKTsKPgo+IC0gICAgSWYgdlBBU0lEIT1w UEFTSUQsIHdoZXRoZXIgcFBBU0lEIGlzIGFsbG9jYXRlZCBmcm9tIHBlci1SSUQgUEFTSUQKPiAg ICAgICBzcGFjZSBvciBhIGdsb2JhbCBQQVNJRCBzcGFjZSAoaW1wbHlpbmcgc2hhcmluZyBwUEFT SUQgY3Jvc3MgZGV2aWNlcywKPiAgICAgICBlLmcuIHdoZW4gc3VwcG9ydGluZyBJbnRlbCBFTlFD TUQgd2hpY2ggcHV0cyBQQVNJRCBpbiBhIENQVSBNU1IKPiAgICAgICBhcyBwYXJ0IG9mIHRoZSBw cm9jZXNzIGNvbnRleHQpOwo+Cj4gVGhlIGFjdHVhbCBwb2xpY3kgZGVwZW5kcyBvbiBwZGV2IHZz LiBtZGV2LCBhbmQgd2hldGhlciBFTlFDTUQgaXMKPiBzdXBwb3J0ZWQuIFRoZXJlIGFyZSB0aHJl ZSBwb3NzaWJsZSBzY2VuYXJpb3M6Cj4KPiAoTm90ZTogL2Rldi9pb2FzaWQgdUFQSSBpcyBub3Qg YWZmZWN0ZWQgYnkgdW5kZXJseWluZyBQQVNJRCB2aXJ0dWFsaXphdGlvbgo+IHBvbGljaWVzLikK Pgo+IDEpICBwZGV2ICh3LyBvciB3L28gRU5RQ01EKTogdlBBU0lEPT1wUEFTSUQKPgo+ICAgICAg IHZQQVNJRHMgYXJlIGRpcmVjdGx5IHByb2dyYW1tZWQgYnkgdGhlIGd1ZXN0IHRvIHRoZSBhc3Np Z25lZCBNTUlPCj4gICAgICAgYmFyLCBpbXBseWluZyBhbGwgRE1BcyBvdXQgb2YgdGhpcyBkZXZp Y2UgaGF2aW5nIHZQQVNJRCBpbiB0aGUgcGFja2V0Cj4gICAgICAgaGVhZGVyLiBUaGlzIG1hbmRh dGVzIHZQQVNJRD09cFBBU0lELCBzb3J0IG9mIGRlbGVnYXRpbmcgdGhlIGVudGlyZQo+ICAgICAg IHBlci1SSUQgUEFTSUQgc3BhY2UgdG8gdGhlIGd1ZXN0Lgo+Cj4gICAgICAgV2hlbiBFTlFDTUQg aXMgZW5hYmxlZCwgdGhlIENQVSBNU1Igd2hlbiBydW5uaW5nIGEgZ3Vlc3QgdGFzawo+ICAgICAg IGNvbnRhaW5zIGEgdlBBU0lELiBJbiB0aGlzIGNhc2UgdGhlIENQVSBQQVNJRCB0cmFuc2xhdGlv biBjYXBhYmlsaXR5Cj4gICAgICAgc2hvdWxkIGJlIGRpc2FibGVkIHNvIHRoaXMgdlBBU0lEIGlu IENQVSBNU1IgaXMgZGlyZWN0bHkgc2VudCB0byB0aGUKPiAgICAgICB3aXJlLgo+Cj4gICAgICAg VGhpcyBlbnN1cmVzIGNvbnNpc3RlbnQgdlBBU0lEIHVzYWdlIG9uIHBkZXYgcmVnYXJkbGVzcyBv ZiB0aGUKPiAgICAgICB3b3JrbG9hZCBzdWJtaXR0ZWQgdGhyb3VnaCBhIE1NSU8gcmVnaXN0ZXIg b3IgRU5RQ01EIGluc3RydWN0aW9uLgo+Cj4gMikgIG1kZXY6IHZQQVNJRCE9cFBBU0lEIChwZXIt UklEIGlmIHcvbyBFTlFDTUQsIG90aGVyd2lzZSBnbG9iYWwpCj4KPiAgICAgICBQQVNJRHMgYXJl IGFsc28gdXNlZCBieSBrZXJuZWwgdG8gbWFyayB0aGUgZGVmYXVsdCBJL08gYWRkcmVzcyBzcGFj ZQo+ICAgICAgIGZvciBtZGV2LCB0aHVzIGNhbm5vdCBiZSBkZWxlZ2F0ZWQgdG8gdGhlIGd1ZXN0 LiBJbnN0ZWFkLCB0aGUgbWRldgo+ICAgICAgIGRyaXZlciBtdXN0IGFsbG9jYXRlIGEgbmV3IHBQ QVNJRCBmb3IgZWFjaCB2UEFTSUQgKHRodXMgdlBBU0lEIT0KPiAgICAgICBwUEFTSUQpIGFuZCB0 aGVuIHVzZSBwUEFTSUQgd2hlbiBhdHRhY2hpbmcgdGhpcyBtZGV2IHRvIGFuIGlvYXNpZC4KPgo+ ICAgICAgIFRoZSBtZGV2IGRyaXZlciBuZWVkcyBjYWNoZSB0aGUgUEFTSUQgbWFwcGluZyBzbyBp biBtZWRpYXRpb24KPiAgICAgICBwYXRoIHZQQVNJRCBwcm9ncmFtbWVkIGJ5IHRoZSBndWVzdCBj YW4gYmUgY29udmVydGVkIHRvIHBQQVNJRAo+ICAgICAgIGJlZm9yZSB1cGRhdGluZyB0aGUgcGh5 c2ljYWwgTU1JTyByZWdpc3Rlci4gVGhlIG1hcHBpbmcgc2hvdWxkCj4gICAgICAgYWxzbyBiZSBz YXZlZCBpbiB0aGUgQ1BVIFBBU0lEIHRyYW5zbGF0aW9uIHN0cnVjdHVyZSAodmlhIEtWTSB1QVBJ KSwKPiAgICAgICBzbyB0aGUgdlBBU0lEIHNhdmVkIGluIHRoZSBDUFUgTVNSIGlzIGF1dG8tdHJh bnNsYXRlZCB0byBwUEFTSUQKPiAgICAgICBiZWZvcmUgc2VudCB0byB0aGUgd2lyZSwgd2hlbiBF TlFDTUQgaXMgZW5hYmxlZC4KPgo+ICAgICAgIEdlbmVyYWxseSBwUEFTSUQgY291bGQgYmUgYWxs b2NhdGVkIGZyb20gdGhlIHBlci1SSUQgUEFTSUQgc3BhY2UKPiAgICAgICBpZiBhbGwgbWRldidz IGNyZWF0ZWQgb24gdGhlIHBhcmVudCBkZXZpY2UgZG9uJ3Qgc3VwcG9ydCBFTlFDTUQuCj4KPiAg ICAgICBIb3dldmVyIGlmIHRoZSBwYXJlbnQgc3VwcG9ydHMgRU5RQ01ELWNhcGFibGUgbWRldiwg cFBBU0lEcwo+ICAgICAgIG11c3QgYmUgYWxsb2NhdGVkIGZyb20gYSBnbG9iYWwgcG9vbCBiZWNh dXNlIHRoZSBDUFUgUEFTSUQKPiAgICAgICB0cmFuc2xhdGlvbiBzdHJ1Y3R1cmUgaXMgcGVyLVZN LiBJdCBpbXBsaWVzIHRoYXQgd2hlbiBhbiBndWVzdCBJL08KPiAgICAgICBwYWdlIHRhYmxlIGlz IGF0dGFjaGVkIHRvIHR3byBtZGV2cyB3aXRoIGEgc2luZ2xlIHZQQVNJRCAoaS5lLiBiaW5kCj4g ICAgICAgdG8gdGhlIHNhbWUgZ3Vlc3QgcHJvY2VzcyksIGEgc2FtZSBwUEFTSUQgc2hvdWxkIGJl IHVzZWQgZm9yCj4gICAgICAgYm90aCBtZGV2cyBldmVuIHdoZW4gdGhleSBiZWxvbmcgdG8gZGlm ZmVyZW50IHBhcmVudHMuIFNoYXJpbmcKPiAgICAgICBwUEFTSUQgY3Jvc3MgbWRldnMgaXMgYWNo aWV2ZWQgYnkgY2FsbGluZyBhZm9yZW1lbnRpb25lZCBpb2FzaWRfCj4gICAgICAgZ2V0X2dsb2Jh bF9wYXNpZCgpLgo+Cj4gMykgIE1peCBwZGV2L21kZXYgdG9nZXRoZXIKPgo+ICAgICAgIEFib3Zl IHBvbGljaWVzIGFyZSBwZXIgZGV2aWNlIHR5cGUgdGh1cyBhcmUgbm90IGFmZmVjdGVkIHdoZW4g bWl4aW5nCj4gICAgICAgdGhvc2UgZGV2aWNlIHR5cGVzIHRvZ2V0aGVyICh3aGVuIGFzc2lnbmVk IHRvIGEgc2luZ2xlIGd1ZXN0KS4gSG93ZXZlciwKPiAgICAgICB0aGVyZSBpcyBvbmUgZXhjZXB0 aW9uIC0gd2hlbiBib3RoIHBkZXYvbWRldiBzdXBwb3J0IEVOUUNNRC4KPgo+ICAgICAgIFJlbWVt YmVyIHRoZSB0d28gdHlwZXMgaGF2ZSBjb25mbGljdGluZyByZXF1aXJlbWVudHMgb24gd2hldGhl cgo+ICAgICAgIENQVSBQQVNJRCB0cmFuc2xhdGlvbiBzaG91bGQgYmUgZW5hYmxlZC4gVGhpcyBj YXBhYmlsaXR5IGlzIHBlci1WTSwKPiAgICAgICBhbmQgbXVzdCBiZSBlbmFibGVkIGZvciBtZGV2 IGlzb2xhdGlvbi4gV2hlbiBlbmFibGVkLCBwZGV2IHdpbGwKPiAgICAgICByZWNlaXZlIGEgbWRl diBwUEFTSUQgdmlvbGF0aW5nIGl0cyB2UEFTSUQgZXhwZWN0YXRpb24uCj4KPiAgICAgICBJbiBw cmV2aW91cyB0aHJlYWQgYSBQQVNJRCByYW5nZSBzcGxpdCBzY2hlbWUgd2FzIGRpc2N1c3NlZCB0 byBzdXBwb3J0Cj4gICAgICAgdGhpcyBjb21iaW5hdGlvbiwgYnV0IHdlIGhhdmVuJ3Qgd29ya2Vk IG91dCBhIGNsZWFuIHVBUEkgZGVzaWduIHlldC4KPiAgICAgICBUaGVyZWZvcmUgaW4gdGhpcyBw cm9wb3NhbCB3ZSBkZWNpZGUgdG8gbm90IHN1cHBvcnQgaXQsIGltcGx5aW5nIHRoZQo+ICAgICAg IHVzZXIgc2hvdWxkIGhhdmUgc29tZSBpbnRlbGxpZ2VuY2UgdG8gYXZvaWQgc3VjaCBzY2VuYXJp by4gSXQgY291bGQgYmUKPiAgICAgICBhIFRPRE8gdGFzayBmb3IgZnV0dXJlLgo+Cj4gSW4gc3Bp dGUgb2YgdGhvc2Ugc3VidGxlIGNvbnNpZGVyYXRpb25zLCB0aGUga2VybmVsIGltcGxlbWVudGF0 aW9uIGNvdWxkCj4gc3RhcnQgc2ltcGxlLCBlLmcuOgo+Cj4gLSAgICB2PT1wIGZvciBwZGV2Owo+ IC0gICAgdiE9cCBhbmQgYWx3YXlzIHVzZSBhIGdsb2JhbCBQQVNJRCBwb29sIGZvciBhbGwgbWRl didzOwo+Cj4gUmVnYXJkbGVzcyBvZiB0aGUga2VybmVsIHBvbGljeSwgdGhlIHVzZXIgcG9saWN5 IGlzIHVuY2hhbmdlZDoKPgo+IC0gICAgcHJvdmlkZSB2UEFTSUQgd2hlbiBjYWxsaW5nIFZGSU9f QVRUQUNIX0lPQVNJRDsKPiAtICAgIGNhbGwgS1ZNIHVBUEkgdG8gc2V0dXAgQ1BVIFBBU0lEIHRy YW5zbGF0aW9uIGlmIEVOUUNNRC1jYXBhYmxlIG1kZXY7Cj4gLSAgICBEb24ndCBleHBvc2UgRU5R Q01EIGNhcGFiaWxpdHkgb24gYm90aCBwZGV2IGFuZCBtZGV2Owo+Cj4gU2FtcGxlIHVzZXIgZmxv dyBpcyBkZXNjcmliZWQgaW4gc2VjdGlvbiA1LjUuCj4KPiA1LiBVc2UgQ2FzZXMgYW5kIEZsb3dz Cj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+Cj4gSGVyZSBhc3N1bWUgVkZJTyB3 aWxsIHN1cHBvcnQgYSBuZXcgbW9kZWwgd2hlcmUgZXZlcnkgYm91bmQgZGV2aWNlCj4gaXMgZXhw bGljaXRseSBsaXN0ZWQgdW5kZXIgL2Rldi92ZmlvIHRodXMgYSBkZXZpY2UgZmQgY2FuIGJlIGFj cXVpcmVkIHcvbwo+IGdvaW5nIHRocm91Z2ggbGVnYWN5IGNvbnRhaW5lci9ncm91cCBpbnRlcmZh Y2UuIEZvciBpbGx1c3RyYXRpb24gcHVycG9zZQo+IHRob3NlIGRldmljZXMgYXJlIGp1c3QgY2Fs bGVkIGRldlsxLi4uTl06Cj4KPiAJZGV2aWNlX2ZkWzEuLi5OXSA9IG9wZW4oIi9kZXYvdmZpby9k ZXZpY2VzL2RldlsxLi4uTl0iLCBtb2RlKTsKPgo+IEFzIGV4cGxhaW5lZCBlYXJsaWVyLCBvbmUg SU9BU0lEIGZkIGlzIHN1ZmZpY2llbnQgZm9yIGFsbCBpbnRlbmRlZCB1c2UgY2FzZXM6Cj4KPiAJ aW9hc2lkX2ZkID0gb3BlbigiL2Rldi9pb2FzaWQiLCBtb2RlKTsKPgo+IEZvciBzaW1wbGljaXR5 IGJlbG93IGV4YW1wbGVzIGFyZSBhbGwgbWFkZSBmb3IgdGhlIHZpcnR1YWxpemF0aW9uIHN0b3J5 Lgo+IFRoZXkgYXJlIHJlcHJlc2VudGF0aXZlIGFuZCBjb3VsZCBiZSBlYXNpbHkgYWRhcHRlZCB0 byBhIG5vbi12aXJ0dWFsaXphdGlvbgo+IHNjZW5hcmlvLgo+Cj4gVGhyZWUgdHlwZXMgb2YgSU9B U0lEcyBhcmUgY29uc2lkZXJlZDoKPgo+IAlncGFfaW9hc2lkWzEuLi5OXTogCWZvciBHUEEgYWRk cmVzcyBzcGFjZQo+IAlnaW92YV9pb2FzaWRbMS4uLk5dOglmb3IgZ3Vlc3QgSU9WQSBhZGRyZXNz IHNwYWNlCj4gCWd2YV9pb2FzaWRbMS4uLk5dOglmb3IgZ3Vlc3QgQ1BVIFZBIGFkZHJlc3Mgc3Bh Y2UKPgo+IEF0IGxlYXN0IG9uZSBncGFfaW9hc2lkIG11c3QgYWx3YXlzIGJlIGNyZWF0ZWQgcGVy IGd1ZXN0LCB3aGlsZSB0aGUgb3RoZXIKPiB0d28gYXJlIHJlbGV2YW50IGFzIGZhciBhcyB2SU9N TVUgaXMgY29uY2VybmVkLgo+Cj4gRXhhbXBsZXMgaGVyZSBhcHBseSB0byBib3RoIHBkZXYgYW5k IG1kZXYsIGlmIG5vdCBleHBsaWNpdGx5IG1hcmtlZCBvdXQKPiAoZS5nLiBpbiBzZWN0aW9uIDUu NSkuIFZGSU8gZGV2aWNlIGRyaXZlciBpbiB0aGUga2VybmVsIHdpbGwgZmlndXJlIG91dCB0aGUK PiBhc3NvY2lhdGVkIHJvdXRpbmcgaW5mb3JtYXRpb24gaW4gdGhlIGF0dGFjaGluZyBvcGVyYXRp b24uCj4KPiBGb3IgaWxsdXN0cmF0aW9uIHNpbXBsaWNpdHksIElPQVNJRF9DSEVDS19FWFRFTlNJ T04gYW5kIElPQVNJRF9HRVRfCj4gSU5GTyBhcmUgc2tpcHBlZCBpbiB0aGVzZSBleGFtcGxlcy4K Pgo+IDUuMS4gQSBzaW1wbGUgZXhhbXBsZQo+ICsrKysrKysrKysrKysrKysrKwo+Cj4gRGV2MSBp cyBhc3NpZ25lZCB0byB0aGUgZ3Vlc3QuIE9uZSBncGFfaW9hc2lkIGlzIGNyZWF0ZWQuIFRoZSBH UEEgYWRkcmVzcwo+IHNwYWNlIGlzIG1hbmFnZWQgdGhyb3VnaCBETUEgbWFwcGluZyBwcm90b2Nv bDoKPgo+IAkvKiBCaW5kIGRldmljZSB0byBJT0FTSUQgZmQgKi8KPiAJZGV2aWNlX2ZkID0gb3Bl bigiL2Rldi92ZmlvL2RldmljZXMvZGV2MSIsIG1vZGUpOwo+IAlpb2FzaWRfZmQgPSBvcGVuKCIv ZGV2L2lvYXNpZCIsIG1vZGUpOwo+IAlpb2N0bChkZXZpY2VfZmQsIFZGSU9fQklORF9JT0FTSURf RkQsIGlvYXNpZF9mZCk7Cj4KPiAJLyogQXR0YWNoIGRldmljZSB0byBJT0FTSUQgKi8KPiAJZ3Bh X2lvYXNpZCA9IGlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0FMTE9DKTsKPiAJYXRfZGF0YSA9IHsg LmlvYXNpZCA9IGdwYV9pb2FzaWR9Owo+IAlpb2N0bChkZXZpY2VfZmQsIFZGSU9fQVRUQUNIX0lP QVNJRCwgJmF0X2RhdGEpOwo+Cj4gCS8qIFNldHVwIEdQQSBtYXBwaW5nICovCj4gCWRtYV9tYXAg PSB7Cj4gCQkuaW9hc2lkCT0gZ3BhX2lvYXNpZDsKPiAJCS5pb3ZhCT0gMDsJCS8vIEdQQQo+IAkJ LnZhZGRyCT0gMHg0MDAwMDAwMDsJLy8gSFZBCj4gCQkuc2l6ZQk9IDFHQjsKPiAJfTsKPiAJaW9j dGwoaW9hc2lkX2ZkLCBJT0FTSURfRE1BX01BUCwgJmRtYV9tYXApOwo+Cj4gSWYgdGhlIGd1ZXN0 IGlzIGFzc2lnbmVkIHdpdGggbW9yZSB0aGFuIGRldjEsIHVzZXIgZm9sbG93cyBhYm92ZSBzZXF1 ZW5jZQo+IHRvIGF0dGFjaCBvdGhlciBkZXZpY2VzIHRvIHRoZSBzYW1lIGdwYV9pb2FzaWQgaS5l LiBzaGFyaW5nIHRoZSBHUEEKPiBhZGRyZXNzIHNwYWNlIGNyb3NzIGFsbCBhc3NpZ25lZCBkZXZp Y2VzLgo+Cj4gNS4yLiBNdWx0aXBsZSBJT0FTSURzIChubyBuZXN0aW5nKQo+ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysKPgo+IERldjEgYW5kIGRldjIgYXJlIGFzc2lnbmVkIHRvIHRoZSBn dWVzdC4gdklPTU1VIGlzIGVuYWJsZWQuIEluaXRpYWxseQo+IGJvdGggZGV2aWNlcyBhcmUgYXR0 YWNoZWQgdG8gZ3BhX2lvYXNpZC4gQWZ0ZXIgYm9vdCB0aGUgZ3Vlc3QgY3JlYXRlcwo+IGFuIEdJ T1ZBIGFkZHJlc3Mgc3BhY2UgKGdpb3ZhX2lvYXNpZCkgZm9yIGRldjIsIGxlYXZpbmcgZGV2MSBp biBwYXNzCj4gdGhyb3VnaCBtb2RlIChncGFfaW9hc2lkKS4KPgo+IFN1cHBvc2UgSU9BU0lEIG5l c3RpbmcgaXMgbm90IHN1cHBvcnRlZCBpbiB0aGlzIGNhc2UuIFFlbXUgbmVlZCB0bwo+IGdlbmVy YXRlIHNoYWRvdyBtYXBwaW5ncyBpbiB1c2Vyc3BhY2UgZm9yIGdpb3ZhX2lvYXNpZCAobGlrZSBo b3cKPiBWRklPIHdvcmtzIHRvZGF5KS4KPgo+IFRvIGF2b2lkIGR1cGxpY2F0ZWQgbG9ja2VkIHBh Z2UgYWNjb3VudGluZywgaXQncyByZWNvbW1lbmRlZCB0byBwcmUtCj4gcmVnaXN0ZXIgdGhlIHZp cnR1YWwgYWRkcmVzcyByYW5nZSB0aGF0IHdpbGwgYmUgdXNlZCBmb3IgRE1BOgo+Cj4gCWRldmlj ZV9mZDEgPSBvcGVuKCIvZGV2L3ZmaW8vZGV2aWNlcy9kZXYxIiwgbW9kZSk7Cj4gCWRldmljZV9m ZDIgPSBvcGVuKCIvZGV2L3ZmaW8vZGV2aWNlcy9kZXYyIiwgbW9kZSk7Cj4gCWlvYXNpZF9mZCA9 IG9wZW4oIi9kZXYvaW9hc2lkIiwgbW9kZSk7Cj4gCWlvY3RsKGRldmljZV9mZDEsIFZGSU9fQklO RF9JT0FTSURfRkQsIGlvYXNpZF9mZCk7Cj4gCWlvY3RsKGRldmljZV9mZDIsIFZGSU9fQklORF9J T0FTSURfRkQsIGlvYXNpZF9mZCk7Cj4KPiAJLyogcHJlLXJlZ2lzdGVyIHRoZSB2aXJ0dWFsIGFk ZHJlc3MgcmFuZ2UgZm9yIGFjY291bnRpbmcgKi8KPiAJbWVtX2luZm8gPSB7IC52YWRkciA9IDB4 NDAwMDAwMDA7IC5zaXplID0gMUdCIH07Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX1JFR0lT VEVSX01FTU9SWSwgJm1lbV9pbmZvKTsKPgo+IAkvKiBBdHRhY2ggZGV2MSBhbmQgZGV2MiB0byBn cGFfaW9hc2lkICovCj4gCWdwYV9pb2FzaWQgPSBpb2N0bChpb2FzaWRfZmQsIElPQVNJRF9BTExP Qyk7Cj4gCWF0X2RhdGEgPSB7IC5pb2FzaWQgPSBncGFfaW9hc2lkfTsKPiAJaW9jdGwoZGV2aWNl X2ZkMSwgVkZJT19BVFRBQ0hfSU9BU0lELCAmYXRfZGF0YSk7Cj4gCWlvY3RsKGRldmljZV9mZDIs IFZGSU9fQVRUQUNIX0lPQVNJRCwgJmF0X2RhdGEpOwo+Cj4gCS8qIFNldHVwIEdQQSBtYXBwaW5n ICovCj4gCWRtYV9tYXAgPSB7Cj4gCQkuaW9hc2lkCT0gZ3BhX2lvYXNpZDsKPiAJCS5pb3ZhCT0g MDsgCQkvLyBHUEEKPiAJCS52YWRkcgk9IDB4NDAwMDAwMDA7CS8vIEhWQQo+IAkJLnNpemUJPSAx R0I7Cj4gCX07Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0RNQV9NQVAsICZkbWFfbWFwKTsK Pgo+IAkvKiBBZnRlciBib290LCBndWVzdCBlbmFibGVzIGFuIEdJT1ZBIHNwYWNlIGZvciBkZXYy ICovCj4gCWdpb3ZhX2lvYXNpZCA9IGlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0FMTE9DKTsKPgo+ IAkvKiBGaXJzdCBkZXRhY2ggZGV2MiBmcm9tIHByZXZpb3VzIGFkZHJlc3Mgc3BhY2UgKi8KPiAJ YXRfZGF0YSA9IHsgLmlvYXNpZCA9IGdwYV9pb2FzaWR9Owo+IAlpb2N0bChkZXZpY2VfZmQyLCBW RklPX0RFVEFDSF9JT0FTSUQsICZhdF9kYXRhKTsKPgo+IAkvKiBUaGVuIGF0dGFjaCBkZXYyIHRv IHRoZSBuZXcgYWRkcmVzcyBzcGFjZSAqLwo+IAlhdF9kYXRhID0geyAuaW9hc2lkID0gZ2lvdmFf aW9hc2lkfTsKPiAJaW9jdGwoZGV2aWNlX2ZkMiwgVkZJT19BVFRBQ0hfSU9BU0lELCAmYXRfZGF0 YSk7Cj4KPiAJLyogU2V0dXAgYSBzaGFkb3cgRE1BIG1hcHBpbmcgYWNjb3JkaW5nIHRvIHZJT01N VQo+IAkgICogR0lPVkEgKDB4MjAwMCkgLT4gR1BBICgweDEwMDApIC0+IEhWQSAoMHg0MDAwMTAw MCkKPiAJICAqLwo+IAlkbWFfbWFwID0gewo+IAkJLmlvYXNpZAk9IGdpb3ZhX2lvYXNpZDsKPiAJ CS5pb3ZhCT0gMHgyMDAwOyAJLy8gR0lPVkEKPiAJCS52YWRkcgk9IDB4NDAwMDEwMDA7CS8vIEhW QQo+IAkJLnNpemUJPSA0S0I7Cj4gCX07Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0RNQV9N QVAsICZkbWFfbWFwKTsKPgo+IDUuMy4gSU9BU0lEIG5lc3RpbmcgKHNvZnR3YXJlKQo+ICsrKysr KysrKysrKysrKysrKysrKysrKysKPgo+IFNhbWUgdXNhZ2Ugc2NlbmFyaW8gYXMgNS4yLCB3aXRo IHNvZnR3YXJlLWJhc2VkIElPQVNJRCBuZXN0aW5nCj4gYXZhaWxhYmxlLiBJbiB0aGlzIG1vZGUg aXQgaXMgdGhlIGtlcm5lbCBpbnN0ZWFkIG9mIHVzZXIgdG8gY3JlYXRlIHRoZQo+IHNoYWRvdyBt YXBwaW5nLgo+Cj4gVGhlIGZsb3cgYmVmb3JlIGd1ZXN0IGJvb3RzIGlzIHNhbWUgYXMgNS4yLCBl eGNlcHQgb25lIHBvaW50LiBCZWNhdXNlCj4gZ2lvdmFfaW9hc2lkIGlzIG5lc3RlZCBvbiBncGFf aW9hc2lkLCBsb2NrZWQgYWNjb3VudGluZyBpcyBvbmx5Cj4gY29uZHVjdGVkIGZvciBncGFfaW9h c2lkLiBTbyBpdCdzIG5vdCBuZWNlc3NhcnkgdG8gcHJlLXJlZ2lzdGVyIHZpcnR1YWwKPiBtZW1v cnkuCj4KPiBUbyBzYXZlIHNwYWNlIHdlIG9ubHkgbGlzdCB0aGUgc3RlcHMgYWZ0ZXIgYm9vdHMg KGkuZS4gYm90aCBkZXYxL2RldjIKPiBoYXZlIGJlZW4gYXR0YWNoZWQgdG8gZ3BhX2lvYXNpZCBi ZWZvcmUgZ3Vlc3QgYm9vdHMpOgo+Cj4gCS8qIEFmdGVyIGJvb3RzICovCj4gCS8qIE1ha2UgR0lP VkEgc3BhY2UgbmVzdGVkIG9uIEdQQSBzcGFjZSAqLwo+IAlnaW92YV9pb2FzaWQgPSBpb2N0bChp b2FzaWRfZmQsIElPQVNJRF9DUkVBVEVfTkVTVElORywKPiAJCQkJZ3BhX2lvYXNpZCk7Cj4KPiAJ LyogQXR0YWNoIGRldjIgdG8gdGhlIG5ldyBhZGRyZXNzIHNwYWNlIChjaGlsZCkKPiAJICAqIE5v dGUgZGV2MiBpcyBzdGlsbCBhdHRhY2hlZCB0byBncGFfaW9hc2lkIChwYXJlbnQpCj4gCSAgKi8K PiAJYXRfZGF0YSA9IHsgLmlvYXNpZCA9IGdpb3ZhX2lvYXNpZH07Cj4gCWlvY3RsKGRldmljZV9m ZDIsIFZGSU9fQVRUQUNIX0lPQVNJRCwgJmF0X2RhdGEpOwoKCkZvciB2RFBBLCB3ZSBuZWVkIHNv bWV0aGluZyBzaW1pbGFyLiBBbmQgaW4gdGhlIGZ1dHVyZSwgdkRQQSBtYXkgYWxsb3cgCm11bHRp cGxlIGlvYXNpZCB0byBiZSBhdHRhY2hlZCB0byBhIHNpbmdsZSBkZXZpY2UuIEl0IHNob3VsZCB3 b3JrIHdpdGggCnRoZSBjdXJyZW50IGRlc2lnbi4KCgo+Cj4gCS8qIFNldHVwIGEgR0lPVkEtPkdQ QSBtYXBwaW5nIGZvciBnaW92YV9pb2FzaWQsIHdoaWNoIHdpbGwgYmUKPiAJICAqIG1lcmdlZCBi eSB0aGUga2VybmVsIHdpdGggR1BBLT5IVkEgbWFwcGluZyBvZiBncGFfaW9hc2lkCj4gCSAgKiB0 byBmb3JtIGEgc2hhZG93IG1hcHBpbmcuCj4gCSAgKi8KPiAJZG1hX21hcCA9IHsKPiAJCS5pb2Fz aWQJPSBnaW92YV9pb2FzaWQ7Cj4gCQkuaW92YQk9IDB4MjAwMDsJLy8gR0lPVkEKPiAJCS52YWRk cgk9IDB4MTAwMDsJLy8gR1BBCj4gCQkuc2l6ZQk9IDRLQjsKPiAJfTsKPiAJaW9jdGwoaW9hc2lk X2ZkLCBJT0FTSURfRE1BX01BUCwgJmRtYV9tYXApOwo+Cj4gNS40LiBJT0FTSUQgbmVzdGluZyAo aGFyZHdhcmUpCj4gKysrKysrKysrKysrKysrKysrKysrKysrKwo+Cj4gU2FtZSB1c2FnZSBzY2Vu YXJpbyBhcyA1LjIsIHdpdGggaGFyZHdhcmUtYmFzZWQgSU9BU0lEIG5lc3RpbmcKPiBhdmFpbGFi bGUuIEluIHRoaXMgbW9kZSB0aGUgcGd0YWJsZSBiaW5kaW5nIHByb3RvY29sIGlzIHVzZWQgdG8K PiBiaW5kIHRoZSBndWVzdCBJT1ZBIHBhZ2UgdGFibGUgd2l0aCB0aGUgSU9NTVU6Cj4KPiAJLyog QWZ0ZXIgYm9vdHMgKi8KPiAJLyogTWFrZSBHSU9WQSBzcGFjZSBuZXN0ZWQgb24gR1BBIHNwYWNl ICovCj4gCWdpb3ZhX2lvYXNpZCA9IGlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0NSRUFURV9ORVNU SU5HLAo+IAkJCQlncGFfaW9hc2lkKTsKPgo+IAkvKiBBdHRhY2ggZGV2MiB0byB0aGUgbmV3IGFk ZHJlc3Mgc3BhY2UgKGNoaWxkKQo+IAkgICogTm90ZSBkZXYyIGlzIHN0aWxsIGF0dGFjaGVkIHRv IGdwYV9pb2FzaWQgKHBhcmVudCkKPiAJICAqLwo+IAlhdF9kYXRhID0geyAuaW9hc2lkID0gZ2lv dmFfaW9hc2lkfTsKPiAJaW9jdGwoZGV2aWNlX2ZkMiwgVkZJT19BVFRBQ0hfSU9BU0lELCAmYXRf ZGF0YSk7CgoKSSBndWVzcyBWRklPX0FUVEFDSF9JT0FTSUQgd2lsbCBmYWlsIGlmIHRoZSB1bmRl cmxheWVyIGRvZXNuJ3Qgc3VwcG9ydCAKaGFyZHdhcmUgbmVzdGluZy4gT3IgaXMgdGhlcmUgd2F5 IHRvIGRldGVjdCB0aGUgY2FwYWJpbGl0eSBiZWZvcmU/CgpJIHRoaW5rIEdFVF9JTkZPIG9ubHkg d29ya3MgYWZ0ZXIgdGhlIEFUVEFDSC4KCgo+Cj4gCS8qIEJpbmQgZ3Vlc3QgSS9PIHBhZ2UgdGFi bGUgICovCj4gCWJpbmRfZGF0YSA9IHsKPiAJCS5pb2FzaWQJPSBnaW92YV9pb2FzaWQ7Cj4gCQku YWRkcgk9IGdpb3ZhX3BndGFibGU7Cj4gCQkvLyBhbmQgZm9ybWF0IGluZm9ybWF0aW9uCj4gCX07 Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0JJTkRfUEdUQUJMRSwgJmJpbmRfZGF0YSk7Cj4K PiAJLyogSW52YWxpZGF0ZSBJT1RMQiB3aGVuIHJlcXVpcmVkICovCj4gCWludl9kYXRhID0gewo+ IAkJLmlvYXNpZAk9IGdpb3ZhX2lvYXNpZDsKPiAJCS8vIGdyYW51bGFyIGluZm9ybWF0aW9uCj4g CX07Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0lOVkFMSURBVEVfQ0FDSEUsICZpbnZfZGF0 YSk7Cj4KPiAJLyogU2VlIDUuNiBmb3IgSS9PIHBhZ2UgZmF1bHQgaGFuZGxpbmcgKi8KPiAJCj4g NS41LiBHdWVzdCBTVkEgKHZTVkEpCj4gKysrKysrKysrKysrKysrKysrCj4KPiBBZnRlciBib290 cyB0aGUgZ3Vlc3QgZnVydGhlciBjcmVhdGUgYSBHVkEgYWRkcmVzcyBzcGFjZXMgKGdwYXNpZDEp IG9uCj4gZGV2MS4gRGV2MiBpcyBub3QgYWZmZWN0ZWQgKHN0aWxsIGF0dGFjaGVkIHRvIGdpb3Zh X2lvYXNpZCkuCj4KPiBBcyBleHBsYWluZWQgaW4gc2VjdGlvbiA0LCB1c2VyIHNob3VsZCBhdm9p ZCBleHBvc2UgRU5RQ01EIG9uIGJvdGgKPiBwZGV2IGFuZCBtZGV2Lgo+Cj4gVGhlIHNlcXVlbmNl IGFwcGxpZXMgdG8gYWxsIGRldmljZSB0eXBlcyAoYmVpbmcgcGRldiBvciBtZGV2KSwgZXhjZXB0 Cj4gb25lIGFkZGl0aW9uYWwgc3RlcCB0byBjYWxsIEtWTSBmb3IgRU5RQ01ELWNhcGFibGUgbWRl djoKCgpNeSB1bmRlcnN0YW5kaW5nIGlzIEVOUUNNRCBpcyBJbnRlbCBzcGVjaWZpYyBhbmQgbm90 IGEgcmVxdWlyZW1lbnQgZm9yIApoYXZpbmcgdlNWQS4KCgo+Cj4gCS8qIEFmdGVyIGJvb3RzICov Cj4gCS8qIE1ha2UgR1ZBIHNwYWNlIG5lc3RlZCBvbiBHUEEgc3BhY2UgKi8KPiAJZ3ZhX2lvYXNp ZCA9IGlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0NSRUFURV9ORVNUSU5HLAo+IAkJCQlncGFfaW9h c2lkKTsKPgo+IAkvKiBBdHRhY2ggZGV2MSB0byB0aGUgbmV3IGFkZHJlc3Mgc3BhY2UgYW5kIHNw ZWNpZnkgdlBBU0lEICovCj4gCWF0X2RhdGEgPSB7Cj4gCQkuaW9hc2lkCQk9IGd2YV9pb2FzaWQ7 Cj4gCQkuZmxhZyAJCT0gSU9BU0lEX0FUVEFDSF9VU0VSX1BBU0lEOwo+IAkJLnVzZXJfcGFzaWQJ PSBncGFzaWQxOwo+IAl9Owo+IAlpb2N0bChkZXZpY2VfZmQxLCBWRklPX0FUVEFDSF9JT0FTSUQs ICZhdF9kYXRhKTsKPgo+IAkvKiBpZiBkZXYxIGlzIEVOUUNNRC1jYXBhYmxlIG1kZXYsIHVwZGF0 ZSBDUFUgUEFTSUQKPiAJICAqIHRyYW5zbGF0aW9uIHN0cnVjdHVyZSB0aHJvdWdoIEtWTQo+IAkg ICovCj4gCXBhX2RhdGEgPSB7Cj4gCQkuaW9hc2lkX2ZkCT0gaW9hc2lkX2ZkOwo+IAkJLmlvYXNp ZAkJPSBndmFfaW9hc2lkOwo+IAkJLmd1ZXN0X3Bhc2lkCT0gZ3Bhc2lkMTsKPiAJfTsKPiAJaW9j dGwoa3ZtX2ZkLCBLVk1fTUFQX1BBU0lELCAmcGFfZGF0YSk7Cj4KPiAJLyogQmluZCBndWVzdCBJ L08gcGFnZSB0YWJsZSAgKi8KPiAJYmluZF9kYXRhID0gewo+IAkJLmlvYXNpZAk9IGd2YV9pb2Fz aWQ7Cj4gCQkuYWRkcgk9IGd2YV9wZ3RhYmxlMTsKPiAJCS8vIGFuZCBmb3JtYXQgaW5mb3JtYXRp b24KPiAJfTsKPiAJaW9jdGwoaW9hc2lkX2ZkLCBJT0FTSURfQklORF9QR1RBQkxFLCAmYmluZF9k YXRhKTsKPgo+IAkuLi4KPgo+Cj4gNS42LiBJL08gcGFnZSBmYXVsdAo+ICsrKysrKysrKysrKysr Kwo+Cj4gKHVBUEkgaXMgVEJELiBIZXJlIGlzIGp1c3QgYWJvdXQgdGhlIGhpZ2gtbGV2ZWwgZmxv dyBmcm9tIGhvc3QgSU9NTVUgZHJpdmVyCj4gdG8gZ3Vlc3QgSU9NTVUgZHJpdmVyIGFuZCBiYWNr d2FyZHMpLgo+Cj4gLSAgIEhvc3QgSU9NTVUgZHJpdmVyIHJlY2VpdmVzIGEgcGFnZSByZXF1ZXN0 IHdpdGggcmF3IGZhdWx0X2RhdGEge3JpZCwKPiAgICAgIHBhc2lkLCBhZGRyfTsKPgo+IC0gICBI b3N0IElPTU1VIGRyaXZlciBpZGVudGlmaWVzIHRoZSBmYXVsdGluZyBJL08gcGFnZSB0YWJsZSBh Y2NvcmRpbmcgdG8KPiAgICAgIGluZm9ybWF0aW9uIHJlZ2lzdGVyZWQgYnkgSU9BU0lEIGZhdWx0 IGhhbmRsZXI7Cj4KPiAtICAgSU9BU0lEIGZhdWx0IGhhbmRsZXIgaXMgY2FsbGVkIHdpdGggcmF3 IGZhdWx0X2RhdGEgKHJpZCwgcGFzaWQsIGFkZHIpLCB3aGljaAo+ICAgICAgaXMgc2F2ZWQgaW4g aW9hc2lkX2RhdGEtPmZhdWx0X2RhdGEgKHVzZWQgZm9yIHJlc3BvbnNlKTsKPgo+IC0gICBJT0FT SUQgZmF1bHQgaGFuZGxlciBnZW5lcmF0ZXMgYW4gdXNlciBmYXVsdF9kYXRhIChpb2FzaWQsIGFk ZHIpLCBsaW5rcyBpdAo+ICAgICAgdG8gdGhlIHNoYXJlZCByaW5nIGJ1ZmZlciBhbmQgdHJpZ2dl cnMgZXZlbnRmZCB0byB1c2Vyc3BhY2U7Cj4KPiAtICAgVXBvbiByZWNlaXZlZCBldmVudCwgUWVt dSBuZWVkcyB0byBmaW5kIHRoZSB2aXJ0dWFsIHJvdXRpbmcgaW5mb3JtYXRpb24KPiAgICAgICh2 X3JpZCArIHZfcGFzaWQpIG9mIHRoZSBkZXZpY2UgYXR0YWNoZWQgdG8gdGhlIGZhdWx0aW5nIGlv YXNpZC4gSWYgdGhlcmUgYXJlCj4gICAgICBtdWx0aXBsZSwgcGljayBhIHJhbmRvbSBvbmUuIFRo aXMgc2hvdWxkIGJlIGZpbmUgc2luY2UgdGhlIHB1cnBvc2UgaXMgdG8KPiAgICAgIGZpeCB0aGUg SS9PIHBhZ2UgdGFibGUgb24gdGhlIGd1ZXN0Owo+Cj4gLSAgIFFlbXUgZ2VuZXJhdGVzIGEgdmly dHVhbCBJL08gcGFnZSBmYXVsdCB0aHJvdWdoIHZJT01NVSBpbnRvIGd1ZXN0LAo+ICAgICAgY2Fy cnlpbmcgdGhlIHZpcnR1YWwgZmF1bHQgZGF0YSAodl9yaWQsIHZfcGFzaWQsIGFkZHIpOwo+Cj4g LSAgIEd1ZXN0IElPTU1VIGRyaXZlciBmaXhlcyB1cCB0aGUgZmF1bHQsIHVwZGF0ZXMgdGhlIEkv TyBwYWdlIHRhYmxlLCBhbmQKPiAgICAgIHRoZW4gc2VuZHMgYSBwYWdlIHJlc3BvbnNlIHdpdGgg dmlydHVhbCBjb21wbGV0aW9uIGRhdGEgKHZfcmlkLCB2X3Bhc2lkLAo+ICAgICAgcmVzcG9uc2Vf Y29kZSkgdG8gdklPTU1VOwo+Cj4gLSAgIFFlbXUgZmluZHMgdGhlIHBlbmRpbmcgZmF1bHQgZXZl bnQsIGNvbnZlcnRzIHZpcnR1YWwgY29tcGxldGlvbiBkYXRhCj4gICAgICBpbnRvIChpb2FzaWQs IHJlc3BvbnNlX2NvZGUpLCBhbmQgdGhlbiBjYWxscyBhIC9kZXYvaW9hc2lkIGlvY3RsIHRvCj4g ICAgICBjb21wbGV0ZSB0aGUgcGVuZGluZyBmYXVsdDsKPgo+IC0gICAvZGV2L2lvYXNpZCBmaW5k cyBvdXQgdGhlIHBlbmRpbmcgZmF1bHQgZGF0YSB7cmlkLCBwYXNpZCwgYWRkcn0gc2F2ZWQgaW4K PiAgICAgIGlvYXNpZF9kYXRhLT5mYXVsdF9kYXRhLCBhbmQgdGhlbiBjYWxscyBpb21tdSBhcGkg dG8gY29tcGxldGUgaXQgd2l0aAo+ICAgICAge3JpZCwgcGFzaWQsIHJlc3BvbnNlX2NvZGV9Owo+ Cj4gNS43LiBCSU5EX1BBU0lEX1RBQkxFCj4gKysrKysrKysrKysrKysrKysrKysKPgo+IFBBU0lE IHRhYmxlIGlzIHB1dCBpbiB0aGUgR1BBIHNwYWNlIG9uIHNvbWUgcGxhdGZvcm0sIHRodXMgbXVz dCBiZSB1cGRhdGVkCj4gYnkgdGhlIGd1ZXN0LiBJdCBpcyB0cmVhdGVkIGFzIGFub3RoZXIgdXNl ciBwYWdlIHRhYmxlIHRvIGJlIGJvdW5kIHdpdGggdGhlCj4gSU9NTVUuCj4KPiBBcyBleHBsYWlu ZWQgZWFybGllciwgdGhlIHVzZXIgc3RpbGwgbmVlZHMgdG8gZXhwbGljaXRseSBiaW5kIGV2ZXJ5 IHVzZXIgSS9PCj4gcGFnZSB0YWJsZSB0byB0aGUga2VybmVsIHNvIHRoZSBzYW1lIHBndGFibGUg YmluZGluZyBwcm90b2NvbCAoYmluZCwgY2FjaGUKPiBpbnZhbGlkYXRlIGFuZCBmYXVsdCBoYW5k bGluZykgaXMgdW5pZmllZCBjcm9zcyBwbGF0Zm9ybXMuCj4KPiB2SU9NTVVzIG1heSBpbmNsdWRl IGEgY2FjaGluZyBtb2RlIChvciBwYXJhdmlydHVhbGl6ZWQgd2F5KSB3aGljaCwgb25jZQo+IGVu YWJsZWQsIHJlcXVpcmVzIHRoZSBndWVzdCB0byBpbnZhbGlkYXRlIFBBU0lEIGNhY2hlIGZvciBh bnkgY2hhbmdlIG9uIHRoZQo+IFBBU0lEIHRhYmxlLiBUaGlzIGFsbG93cyBRZW11IHRvIHRyYWNr IHRoZSBsaWZlc3BhbiBvZiBndWVzdCBJL08gcGFnZSB0YWJsZXMuCj4KPiBJbiBjYXNlIG9mIG1p c3Npbmcgc3VjaCBjYXBhYmlsaXR5LCBRZW11IGNvdWxkIGVuYWJsZSB3cml0ZS1wcm90ZWN0aW9u IG9uCj4gdGhlIGd1ZXN0IFBBU0lEIHRhYmxlIHRvIGFjaGlldmUgdGhlIHNhbWUgZWZmZWN0Lgo+ Cj4gCS8qIEFmdGVyIGJvb3RzICovCj4gCS8qIE1ha2UgdlBBU0lEIHNwYWNlIG5lc3RlZCBvbiBH UEEgc3BhY2UgKi8KPiAJcGFzaWR0YmxfaW9hc2lkID0gaW9jdGwoaW9hc2lkX2ZkLCBJT0FTSURf Q1JFQVRFX05FU1RJTkcsCj4gCQkJCWdwYV9pb2FzaWQpOwo+Cj4gCS8qIEF0dGFjaCBkZXYxIHRv IHBhc2lkdGJsX2lvYXNpZCAqLwo+IAlhdF9kYXRhID0geyAuaW9hc2lkID0gcGFzaWR0YmxfaW9h c2lkfTsKPiAJaW9jdGwoZGV2aWNlX2ZkMSwgVkZJT19BVFRBQ0hfSU9BU0lELCAmYXRfZGF0YSk7 Cj4KPiAJLyogQmluZCBQQVNJRCB0YWJsZSAqLwo+IAliaW5kX2RhdGEgPSB7Cj4gCQkuaW9hc2lk CT0gcGFzaWR0YmxfaW9hc2lkOwo+IAkJLmFkZHIJPSBncGFfcGFzaWRfdGFibGU7Cj4gCQkvLyBh bmQgZm9ybWF0IGluZm9ybWF0aW9uCj4gCX07Cj4gCWlvY3RsKGlvYXNpZF9mZCwgSU9BU0lEX0JJ TkRfUEFTSURfVEFCTEUsICZiaW5kX2RhdGEpOwo+Cj4gCS8qIHZJT01NVSBkZXRlY3RzIGEgbmV3 IEdWQSBJL08gc3BhY2UgY3JlYXRlZCAqLwo+IAlndmFfaW9hc2lkID0gaW9jdGwoaW9hc2lkX2Zk LCBJT0FTSURfQ1JFQVRFX05FU1RJTkcsCj4gCQkJCWdwYV9pb2FzaWQpOwo+Cj4gCS8qIEF0dGFj aCBkZXYxIHRvIHRoZSBuZXcgYWRkcmVzcyBzcGFjZSwgd2l0aCBncGFzaWQxICovCj4gCWF0X2Rh dGEgPSB7Cj4gCQkuaW9hc2lkCQk9IGd2YV9pb2FzaWQ7Cj4gCQkuZmxhZyAJCT0gSU9BU0lEX0FU VEFDSF9VU0VSX1BBU0lEOwo+IAkJLnVzZXJfcGFzaWQJPSBncGFzaWQxOwo+IAl9Owo+IAlpb2N0 bChkZXZpY2VfZmQxLCBWRklPX0FUVEFDSF9JT0FTSUQsICZhdF9kYXRhKTsKCgpEbyB3ZSBuZWVk IFZGSU9fREVUQUNIX0lPQVNJRD8KClRoYW5rcwoKCj4KPiAJLyogQmluZCBndWVzdCBJL08gcGFn ZSB0YWJsZS4gQmVjYXVzZSBTRVRfUEFTSURfVEFCTEUgaGFzIGJlZW4KPiAJICAqIHVzZWQsIHRo ZSBrZXJuZWwgd2lsbCBub3QgdXBkYXRlIHRoZSBQQVNJRCB0YWJsZS4gSW5zdGVhZCwganVzdAo+ IAkgICogdHJhY2sgdGhlIGJvdW5kIEkvTyBwYWdlIHRhYmxlIGZvciBoYW5kbGluZyBpbnZhbGlk YXRpb24gYW5kCj4gCSAgKiBJL08gcGFnZSBmYXVsdHMuCj4gCSAgKi8KPiAJYmluZF9kYXRhID0g ewo+IAkJLmlvYXNpZAk9IGd2YV9pb2FzaWQ7Cj4gCQkuYWRkcgk9IGd2YV9wZ3RhYmxlMTsKPiAJ CS8vIGFuZCBmb3JtYXQgaW5mb3JtYXRpb24KPiAJfTsKPiAJaW9jdGwoaW9hc2lkX2ZkLCBJT0FT SURfQklORF9QR1RBQkxFLCAmYmluZF9kYXRhKTsKPgo+IAkuLi4KPgo+IFRoYW5rcwo+IEtldmlu Cj4KCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwppb21t dSBtYWlsaW5nIGxpc3QKaW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9s aXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vaW9tbXU= 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=-7.6 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=no 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 99E37C47089 for ; Fri, 28 May 2021 02:28:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 650FB611BD for ; Fri, 28 May 2021 02:28:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235874AbhE1C1D (ORCPT ); Thu, 27 May 2021 22:27:03 -0400 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:41907 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234421AbhE1C1D (ORCPT ); Thu, 27 May 2021 22:27:03 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1622168714; 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=9lqzBMvp2F4atd5FG2S+oqtp3y5JoqeU46lsxMgML98=; b=M508zORTWqoQKx77KsqeeRMwGi8K6X5I+6iail2Y/tjSY8QS4x9/tA6d7neCJJ3tRLv7mA T4tzZqCVBNAKRFOWOEIAZJPiClg17GFdwDLodmujtqLvsSEa2gIPPA5sknK9/GM1/vRRM7 dkrDOQ6Hf6nASoUgpd6KWe/LjU1bTFk= Received: from mail-pl1-f199.google.com (mail-pl1-f199.google.com [209.85.214.199]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-485-IB1rWyQvNsCIAUstWU_YRA-1; Thu, 27 May 2021 22:25:12 -0400 X-MC-Unique: IB1rWyQvNsCIAUstWU_YRA-1 Received: by mail-pl1-f199.google.com with SMTP id u12-20020a170902e20cb02900f0f5990fedso692047plb.7 for ; Thu, 27 May 2021 19:25:12 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=9lqzBMvp2F4atd5FG2S+oqtp3y5JoqeU46lsxMgML98=; b=aNa1PPe/M857ryn1r7uivif+M+q/QE2FsbLfliPF77yeiw9UKdBedynhw9eJzxX0BD gkYcbQdlG0ScksJ8InwgydYYNaTY4FYEiAFtyfrGSwfF3bHSV0V9QWtSsi0Xj/NrjZvM 4550VdXfxIvDGB6H9Gn+RAokg7hoQUU1jrgDohli9j7l9Px/DadrUAovmYiOy1ItpKB+ 9Z6Ho63FoiVq0Bv5Oim0zqxFyjC2tOiO2czFiEQCv8N5EJuJ2KZaN/FAltgG5QkpRea6 2FeGJxZE6MnAZQuHbSKAHWZtsRw9N/TANNEAutIvQhsp7QVH4rh+iF9CumE8K32HIn57 n3OA== X-Gm-Message-State: AOAM531sXaLFf6qF7/NXsyKYEIQVsyf2vDIGwNk4Y3+isqnQI9w2gGYv EM3Qk6tmPbdZZBcHDtAqoKgQm9RmxI6D+OXAV619YGiq6GiiN5Mi4R/yiuM5NjWbFAIm5xtcPHy I4Ayb36xYAb1c X-Received: by 2002:a17:90a:950c:: with SMTP id t12mr1730344pjo.135.1622168710908; Thu, 27 May 2021 19:25:10 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzPPzP4HrBY4Q7r7nlD0Tlrx0lBK6eDVCNKZO3GUAQaXomgC19WjxjfWTu2WDGMLhwnBWW9sA== X-Received: by 2002:a17:90a:950c:: with SMTP id t12mr1730254pjo.135.1622168709674; Thu, 27 May 2021 19:25:09 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id 204sm2941993pfy.56.2021.05.27.19.25.01 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 27 May 2021 19:25:09 -0700 (PDT) Subject: Re: [RFC] /dev/ioasid uAPI proposal To: "Tian, Kevin" , LKML , Joerg Roedel , Jason Gunthorpe , Lu Baolu , David Woodhouse , "iommu@lists.linux-foundation.org" , "kvm@vger.kernel.org" , "Alex Williamson (alex.williamson@redhat.com)" Cc: Eric Auger , Jonathan Corbet , "Raj, Ashok" , "Liu, Yi L" , "Wu, Hao" , "Jiang, Dave" , Jacob Pan , Jean-Philippe Brucker , David Gibson , Kirti Wankhede , Robin Murphy References: From: Jason Wang Message-ID: Date: Fri, 28 May 2021 10:24:56 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.10.2 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=gbk; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org ÔÚ 2021/5/27 ÏÂÎç3:58, Tian, Kevin дµÀ: > /dev/ioasid provides an unified interface for managing I/O page tables for > devices assigned to userspace. Device passthrough frameworks (VFIO, vDPA, > etc.) are expected to use this interface instead of creating their own logic to > isolate untrusted device DMAs initiated by userspace. Not a native speaker but /dev/ioas seems better? > > This proposal describes the uAPI of /dev/ioasid and also sample sequences > with VFIO as example in typical usages. The driver-facing kernel API provided > by the iommu layer is still TBD, which can be discussed after consensus is > made on this uAPI. > > It's based on a lengthy discussion starting from here: > https://lore.kernel.org/linux-iommu/20210330132830.GO2356281@nvidia.com/ > > It ends up to be a long writing due to many things to be summarized and > non-trivial effort required to connect them into a complete proposal. > Hope it provides a clean base to converge. > > TOC > ==== > 1. Terminologies and Concepts > 2. uAPI Proposal > 2.1. /dev/ioasid uAPI > 2.2. /dev/vfio uAPI > 2.3. /dev/kvm uAPI > 3. Sample structures and helper functions > 4. PASID virtualization > 5. Use Cases and Flows > 5.1. A simple example > 5.2. Multiple IOASIDs (no nesting) > 5.3. IOASID nesting (software) > 5.4. IOASID nesting (hardware) > 5.5. Guest SVA (vSVA) > 5.6. I/O page fault > 5.7. BIND_PASID_TABLE > ==== > > 1. Terminologies and Concepts > ----------------------------------------- > > IOASID FD is the container holding multiple I/O address spaces. User > manages those address spaces through FD operations. Multiple FD's are > allowed per process, but with this proposal one FD should be sufficient for > all intended usages. > > IOASID is the FD-local software handle representing an I/O address space. > Each IOASID is associated with a single I/O page table. IOASIDs can be > nested together, implying the output address from one I/O page table > (represented by child IOASID) must be further translated by another I/O > page table (represented by parent IOASID). > > I/O address space can be managed through two protocols, according to > whether the corresponding I/O page table is constructed by the kernel or > the user. When kernel-managed, a dma mapping protocol (similar to > existing VFIO iommu type1) is provided for the user to explicitly specify > how the I/O address space is mapped. Otherwise, a different protocol is > provided for the user to bind an user-managed I/O page table to the > IOMMU, plus necessary commands for iotlb invalidation and I/O fault > handling. > > Pgtable binding protocol can be used only on the child IOASID's, implying > IOASID nesting must be enabled. This is because the kernel doesn't trust > userspace. Nesting allows the kernel to enforce its DMA isolation policy > through the parent IOASID. > > IOASID nesting can be implemented in two ways: hardware nesting and > software nesting. With hardware support the child and parent I/O page > tables are walked consecutively by the IOMMU to form a nested translation. > When it's implemented in software, the ioasid driver Need to explain what did "ioasid driver" mean. I guess it's the module that implements the IOASID abstraction: 1) RID 2) RID+PASID 3) others And if yes, does it allow the device for software specific implementation: 1) swiotlb or 2) device specific IOASID implementation > is responsible for > merging the two-level mappings into a single-level shadow I/O page table. > Software nesting requires both child/parent page tables operated through > the dma mapping protocol, so any change in either level can be captured > by the kernel to update the corresponding shadow mapping. > > An I/O address space takes effect in the IOMMU only after it is attached > to a device. The device in the /dev/ioasid context always refers to a > physical one or 'pdev' (PF or VF). > > One I/O address space could be attached to multiple devices. In this case, > /dev/ioasid uAPI applies to all attached devices under the specified IOASID. > > Based on the underlying IOMMU capability one device might be allowed > to attach to multiple I/O address spaces, with DMAs accessing them by > carrying different routing information. One of them is the default I/O > address space routed by PCI Requestor ID (RID) or ARM Stream ID. The > remaining are routed by RID + Process Address Space ID (PASID) or > Stream+Substream ID. For simplicity the following context uses RID and > PASID when talking about the routing information for I/O address spaces. > > Device attachment is initiated through passthrough framework uAPI (use > VFIO for simplicity in following context). VFIO is responsible for identifying > the routing information and registering it to the ioasid driver when calling > ioasid attach helper function. It could be RID if the assigned device is > pdev (PF/VF) or RID+PASID if the device is mediated (mdev). In addition, > user might also provide its view of virtual routing information (vPASID) in > the attach call, e.g. when multiple user-managed I/O address spaces are > attached to the vfio_device. In this case VFIO must figure out whether > vPASID should be directly used (for pdev) or converted to a kernel- > allocated one (pPASID, for mdev) for physical routing (see section 4). > > Device must be bound to an IOASID FD before attach operation can be > conducted. This is also through VFIO uAPI. In this proposal one device > should not be bound to multiple FD's. Not sure about the gain of > allowing it except adding unnecessary complexity. But if others have > different view we can further discuss. > > VFIO must ensure its device composes DMAs with the routing information > attached to the IOASID. For pdev it naturally happens since vPASID is > directly programmed to the device by guest software. For mdev this > implies any guest operation carrying a vPASID on this device must be > trapped into VFIO and then converted to pPASID before sent to the > device. A detail explanation about PASID virtualization policies can be > found in section 4. > > Modern devices may support a scalable workload submission interface > based on PCI DMWr capability, allowing a single work queue to access > multiple I/O address spaces. One example is Intel ENQCMD, having > PASID saved in the CPU MSR and carried in the instruction payload > when sent out to the device. Then a single work queue shared by > multiple processes can compose DMAs carrying different PASIDs. > > When executing ENQCMD in the guest, the CPU MSR includes a vPASID > which, if targeting a mdev, must be converted to pPASID before sent > to the wire. Intel CPU provides a hardware PASID translation capability > for auto-conversion in the fast path. The user is expected to setup the > PASID mapping through KVM uAPI, with information about {vpasid, > ioasid_fd, ioasid}. The ioasid driver provides helper function for KVM > to figure out the actual pPASID given an IOASID. > > With above design /dev/ioasid uAPI is all about I/O address spaces. > It doesn't include any device routing information, which is only > indirectly registered to the ioasid driver through VFIO uAPI. For > example, I/O page fault is always reported to userspace per IOASID, > although it's physically reported per device (RID+PASID). If there is a > need of further relaying this fault into the guest, the user is responsible > of identifying the device attached to this IOASID (randomly pick one if > multiple attached devices) and then generates a per-device virtual I/O > page fault into guest. Similarly the iotlb invalidation uAPI describes the > granularity in the I/O address space (all, or a range), different from the > underlying IOMMU semantics (domain-wide, PASID-wide, range-based). > > I/O page tables routed through PASID are installed in a per-RID PASID > table structure. I'm not sure this is true for all archs. > Some platforms implement the PASID table in the guest > physical space (GPA), expecting it managed by the guest. The guest > PASID table is bound to the IOMMU also by attaching to an IOASID, > representing the per-RID vPASID space. > > We propose the host kernel needs to explicitly track guest I/O page > tables even on these platforms, i.e. the same pgtable binding protocol > should be used universally on all platforms (with only difference on who > actually writes the PASID table). One opinion from previous discussion > was treating this special IOASID as a container for all guest I/O page > tables i.e. hiding them from the host. However this way significantly > violates the philosophy in this /dev/ioasid proposal. It is not one IOASID > one address space any more. Device routing information (indirectly > marking hidden I/O spaces) has to be carried in iotlb invalidation and > page faulting uAPI to help connect vIOMMU with the underlying > pIOMMU. This is one design choice to be confirmed with ARM guys. > > Devices may sit behind IOMMU's with incompatible capabilities. The > difference may lie in the I/O page table format, or availability of an user > visible uAPI (e.g. hardware nesting). /dev/ioasid is responsible for > checking the incompatibility between newly-attached device and existing > devices under the specific IOASID and, if found, returning error to user. > Upon such error the user should create a new IOASID for the incompatible > device. > > There is no explicit group enforcement in /dev/ioasid uAPI, due to no > device notation in this interface as aforementioned. But the ioasid driver > does implicit check to make sure that devices within an iommu group > must be all attached to the same IOASID before this IOASID starts to > accept any uAPI command. Otherwise error information is returned to > the user. > > There was a long debate in previous discussion whether VFIO should keep > explicit container/group semantics in its uAPI. Jason Gunthorpe proposes > a simplified model where every device bound to VFIO is explicitly listed > under /dev/vfio thus a device fd can be acquired w/o going through legacy > container/group interface. In this case the user is responsible for > understanding the group topology and meeting the implicit group check > criteria enforced in /dev/ioasid. The use case examples in this proposal > are based on the new model. > > Of course for backward compatibility VFIO still needs to keep the existing > uAPI and vfio iommu type1 will become a shim layer connecting VFIO > iommu ops to internal ioasid helper functions. > > Notes: > - It might be confusing as IOASID is also used in the kernel (drivers/ > iommu/ioasid.c) to represent PCI PASID or ARM substream ID. We need > find a better name later to differentiate. > > - PPC has not be considered yet as we haven't got time to fully understand > its semantics. According to previous discussion there is some generality > between PPC window-based scheme and VFIO type1 semantics. Let's > first make consensus on this proposal and then further discuss how to > extend it to cover PPC's requirement. > > - There is a protocol between vfio group and kvm. Needs to think about > how it will be affected following this proposal. > > - mdev in this context refers to mediated subfunctions (e.g. Intel SIOV) > which can be physically isolated in-between through PASID-granular > IOMMU protection. Historically people also discussed one usage by > mediating a pdev into a mdev. This usage is not covered here, and is > supposed to be replaced by Max's work which allows overriding various > VFIO operations in vfio-pci driver. > > 2. uAPI Proposal > ---------------------- > > /dev/ioasid uAPI covers everything about managing I/O address spaces. > > /dev/vfio uAPI builds connection between devices and I/O address spaces. > > /dev/kvm uAPI is optional required as far as ENQCMD is concerned. > > > 2.1. /dev/ioasid uAPI > +++++++++++++++++ > > /* > * Check whether an uAPI extension is supported. > * > * This is for FD-level capabilities, such as locked page pre-registration. > * IOASID-level capabilities are reported through IOASID_GET_INFO. > * > * Return: 0 if not supported, 1 if supported. > */ > #define IOASID_CHECK_EXTENSION _IO(IOASID_TYPE, IOASID_BASE + 0) > > > /* > * Register user space memory where DMA is allowed. > * > * It pins user pages and does the locked memory accounting so sub- > * sequent IOASID_MAP/UNMAP_DMA calls get faster. > * > * When this ioctl is not used, one user page might be accounted > * multiple times when it is mapped by multiple IOASIDs which are > * not nested together. > * > * Input parameters: > * - vaddr; > * - size; > * > * Return: 0 on success, -errno on failure. > */ > #define IOASID_REGISTER_MEMORY _IO(IOASID_TYPE, IOASID_BASE + 1) > #define IOASID_UNREGISTER_MEMORY _IO(IOASID_TYPE, IOASID_BASE + 2) > > > /* > * Allocate an IOASID. > * > * IOASID is the FD-local software handle representing an I/O address > * space. Each IOASID is associated with a single I/O page table. User > * must call this ioctl to get an IOASID for every I/O address space that is > * intended to be enabled in the IOMMU. > * > * A newly-created IOASID doesn't accept any command before it is > * attached to a device. Once attached, an empty I/O page table is > * bound with the IOMMU then the user could use either DMA mapping > * or pgtable binding commands to manage this I/O page table. > * > * Device attachment is initiated through device driver uAPI (e.g. VFIO) > * > * Return: allocated ioasid on success, -errno on failure. > */ > #define IOASID_ALLOC _IO(IOASID_TYPE, IOASID_BASE + 3) > #define IOASID_FREE _IO(IOASID_TYPE, IOASID_BASE + 4) I would like to know the reason for such indirection. It looks to me the ioasid fd is sufficient for performing any operations. Such allocation only work if as ioas fd can have multiple ioasid which seems not the case you describe here. > > > /* > * Get information about an I/O address space > * > * Supported capabilities: > * - VFIO type1 map/unmap; > * - pgtable/pasid_table binding > * - hardware nesting vs. software nesting; > * - ... > * > * Related attributes: > * - supported page sizes, reserved IOVA ranges (DMA mapping); > * - vendor pgtable formats (pgtable binding); > * - number of child IOASIDs (nesting); > * - ... > * > * Above information is available only after one or more devices are > * attached to the specified IOASID. Otherwise the IOASID is just a > * number w/o any capability or attribute. > * > * Input parameters: > * - u32 ioasid; > * > * Output parameters: > * - many. TBD. > */ > #define IOASID_GET_INFO _IO(IOASID_TYPE, IOASID_BASE + 5) > > > /* > * Map/unmap process virtual addresses to I/O virtual addresses. > * > * Provide VFIO type1 equivalent semantics. Start with the same > * restriction e.g. the unmap size should match those used in the > * original mapping call. > * > * If IOASID_REGISTER_MEMORY has been called, the mapped vaddr > * must be already in the preregistered list. > * > * Input parameters: > * - u32 ioasid; > * - refer to vfio_iommu_type1_dma_{un}map > * > * Return: 0 on success, -errno on failure. > */ > #define IOASID_MAP_DMA _IO(IOASID_TYPE, IOASID_BASE + 6) > #define IOASID_UNMAP_DMA _IO(IOASID_TYPE, IOASID_BASE + 7) > > > /* > * Create a nesting IOASID (child) on an existing IOASID (parent) > * > * IOASIDs can be nested together, implying that the output address > * from one I/O page table (child) must be further translated by > * another I/O page table (parent). > * > * As the child adds essentially another reference to the I/O page table > * represented by the parent, any device attached to the child ioasid > * must be already attached to the parent. > * > * In concept there is no limit on the number of the nesting levels. > * However for the majority case one nesting level is sufficient. The > * user should check whether an IOASID supports nesting through > * IOASID_GET_INFO. For example, if only one nesting level is allowed, > * the nesting capability is reported only on the parent instead of the > * child. > * > * User also needs check (via IOASID_GET_INFO) whether the nesting > * is implemented in hardware or software. If software-based, DMA > * mapping protocol should be used on the child IOASID. Otherwise, > * the child should be operated with pgtable binding protocol. > * > * Input parameters: > * - u32 parent_ioasid; > * > * Return: child_ioasid on success, -errno on failure; > */ > #define IOASID_CREATE_NESTING _IO(IOASID_TYPE, IOASID_BASE + 8) > > > /* > * Bind an user-managed I/O page table with the IOMMU > * > * Because user page table is untrusted, IOASID nesting must be enabled > * for this ioasid so the kernel can enforce its DMA isolation policy > * through the parent ioasid. > * > * Pgtable binding protocol is different from DMA mapping. The latter > * has the I/O page table constructed by the kernel and updated > * according to user MAP/UNMAP commands. With pgtable binding the > * whole page table is created and updated by userspace, thus different > * set of commands are required (bind, iotlb invalidation, page fault, etc.). > * > * Because the page table is directly walked by the IOMMU, the user > * must use a format compatible to the underlying hardware. It can > * check the format information through IOASID_GET_INFO. > * > * The page table is bound to the IOMMU according to the routing > * information of each attached device under the specified IOASID. The > * routing information (RID and optional PASID) is registered when a > * device is attached to this IOASID through VFIO uAPI. > * > * Input parameters: > * - child_ioasid; > * - address of the user page table; > * - formats (vendor, address_width, etc.); > * > * Return: 0 on success, -errno on failure. > */ > #define IOASID_BIND_PGTABLE _IO(IOASID_TYPE, IOASID_BASE + 9) > #define IOASID_UNBIND_PGTABLE _IO(IOASID_TYPE, IOASID_BASE + 10) > > > /* > * Bind an user-managed PASID table to the IOMMU > * > * This is required for platforms which place PASID table in the GPA space. > * In this case the specified IOASID represents the per-RID PASID space. > * > * Alternatively this may be replaced by IOASID_BIND_PGTABLE plus a > * special flag to indicate the difference from normal I/O address spaces. > * > * The format info of the PASID table is reported in IOASID_GET_INFO. > * > * As explained in the design section, user-managed I/O page tables must > * be explicitly bound to the kernel even on these platforms. It allows > * the kernel to uniformly manage I/O address spaces cross all platforms. > * Otherwise, the iotlb invalidation and page faulting uAPI must be hacked > * to carry device routing information to indirectly mark the hidden I/O > * address spaces. > * > * Input parameters: > * - child_ioasid; > * - address of PASID table; > * - formats (vendor, size, etc.); > * > * Return: 0 on success, -errno on failure. > */ > #define IOASID_BIND_PASID_TABLE _IO(IOASID_TYPE, IOASID_BASE + 11) > #define IOASID_UNBIND_PASID_TABLE _IO(IOASID_TYPE, IOASID_BASE + 12) > > > /* > * Invalidate IOTLB for an user-managed I/O page table > * > * Unlike what's defined in include/uapi/linux/iommu.h, this command > * doesn't allow the user to specify cache type and likely support only > * two granularities (all, or a specified range) in the I/O address space. > * > * Physical IOMMU have three cache types (iotlb, dev_iotlb and pasid > * cache). If the IOASID represents an I/O address space, the invalidation > * always applies to the iotlb (and dev_iotlb if enabled). If the IOASID > * represents a vPASID space, then this command applies to the PASID > * cache. > * > * Similarly this command doesn't provide IOMMU-like granularity > * info (domain-wide, pasid-wide, range-based), since it's all about the > * I/O address space itself. The ioasid driver walks the attached > * routing information to match the IOMMU semantics under the > * hood. > * > * Input parameters: > * - child_ioasid; > * - granularity > * > * Return: 0 on success, -errno on failure > */ > #define IOASID_INVALIDATE_CACHE _IO(IOASID_TYPE, IOASID_BASE + 13) > > > /* > * Page fault report and response > * > * This is TBD. Can be added after other parts are cleared up. Likely it > * will be a ring buffer shared between user/kernel, an eventfd to notify > * the user and an ioctl to complete the fault. > * > * The fault data is per I/O address space, i.e.: IOASID + faulting_addr > */ > > > /* > * Dirty page tracking > * > * Track and report memory pages dirtied in I/O address spaces. There > * is an ongoing work by Kunkun Jiang by extending existing VFIO type1. > * It needs be adapted to /dev/ioasid later. > */ > > > 2.2. /dev/vfio uAPI > ++++++++++++++++ > > /* > * Bind a vfio_device to the specified IOASID fd > * > * Multiple vfio devices can be bound to a single ioasid_fd, but a single > * vfio device should not be bound to multiple ioasid_fd's. > * > * Input parameters: > * - ioasid_fd; > * > * Return: 0 on success, -errno on failure. > */ > #define VFIO_BIND_IOASID_FD _IO(VFIO_TYPE, VFIO_BASE + 22) > #define VFIO_UNBIND_IOASID_FD _IO(VFIO_TYPE, VFIO_BASE + 23) > > > /* > * Attach a vfio device to the specified IOASID > * > * Multiple vfio devices can be attached to the same IOASID, and vice > * versa. > * > * User may optionally provide a "virtual PASID" to mark an I/O page > * table on this vfio device. Whether the virtual PASID is physically used > * or converted to another kernel-allocated PASID is a policy in vfio device > * driver. > * > * There is no need to specify ioasid_fd in this call due to the assumption > * of 1:1 connection between vfio device and the bound fd. > * > * Input parameter: > * - ioasid; > * - flag; > * - user_pasid (if specified); > * > * Return: 0 on success, -errno on failure. > */ > #define VFIO_ATTACH_IOASID _IO(VFIO_TYPE, VFIO_BASE + 24) > #define VFIO_DETACH_IOASID _IO(VFIO_TYPE, VFIO_BASE + 25) > > > 2.3. KVM uAPI > ++++++++++++ > > /* > * Update CPU PASID mapping > * > * This is necessary when ENQCMD will be used in the guest while the > * targeted device doesn't accept the vPASID saved in the CPU MSR. > * > * This command allows user to set/clear the vPASID->pPASID mapping > * in the CPU, by providing the IOASID (and FD) information representing > * the I/O address space marked by this vPASID. > * > * Input parameters: > * - user_pasid; > * - ioasid_fd; > * - ioasid; > */ > #define KVM_MAP_PASID _IO(KVMIO, 0xf0) > #define KVM_UNMAP_PASID _IO(KVMIO, 0xf1) > > > 3. Sample structures and helper functions > -------------------------------------------------------- > > Three helper functions are provided to support VFIO_BIND_IOASID_FD: > > struct ioasid_ctx *ioasid_ctx_fdget(int fd); > int ioasid_register_device(struct ioasid_ctx *ctx, struct ioasid_dev *dev); > int ioasid_unregister_device(struct ioasid_dev *dev); > > An ioasid_ctx is created for each fd: > > struct ioasid_ctx { > // a list of allocated IOASID data's > struct list_head ioasid_list; > // a list of registered devices > struct list_head dev_list; > // a list of pre-registered virtual address ranges > struct list_head prereg_list; > }; > > Each registered device is represented by ioasid_dev: > > struct ioasid_dev { > struct list_head next; > struct ioasid_ctx *ctx; > // always be the physical device > struct device *device; > struct kref kref; > }; > > Because we assume one vfio_device connected to at most one ioasid_fd, > here ioasid_dev could be embedded in vfio_device and then linked to > ioasid_ctx->dev_list when registration succeeds. For mdev the struct > device should be the pointer to the parent device. PASID marking this > mdev is specified later when VFIO_ATTACH_IOASID. > > An ioasid_data is created when IOASID_ALLOC, as the main object > describing characteristics about an I/O page table: > > struct ioasid_data { > // link to ioasid_ctx->ioasid_list > struct list_head next; > > // the IOASID number > u32 ioasid; > > // the handle to convey iommu operations > // hold the pgd (TBD until discussing iommu api) > struct iommu_domain *domain; > > // map metadata (vfio type1 semantics) > struct rb_node dma_list; > > // pointer to user-managed pgtable (for nesting case) > u64 user_pgd; > > // link to the parent ioasid (for nesting) > struct ioasid_data *parent; > > // cache the global PASID shared by ENQCMD-capable > // devices (see below explanation in section 4) > u32 pasid; > > // a list of device attach data (routing information) > struct list_head attach_data; > > // a list of partially-attached devices (group) > struct list_head partial_devices; > > // a list of fault_data reported from the iommu layer > struct list_head fault_data; > > ... > } > > ioasid_data and iommu_domain have overlapping roles as both are > introduced to represent an I/O address space. It is still a big TBD how > the two should be corelated or even merged, and whether new iommu > ops are required to handle RID+PASID explicitly. We leave this as open > for now as this proposal is mainly about uAPI. For simplification > purpose the two objects are kept separate in this context, assuming an > 1:1 connection in-between and the domain as the place-holder > representing the 1st class object in the iommu ops. > > Two helper functions are provided to support VFIO_ATTACH_IOASID: > > struct attach_info { > u32 ioasid; > // If valid, the PASID to be used physically > u32 pasid; > }; > int ioasid_device_attach(struct ioasid_dev *dev, > struct attach_info info); > int ioasid_device_detach(struct ioasid_dev *dev, u32 ioasid); > > The pasid parameter is optionally provided based on the policy in vfio > device driver. It could be the PASID marking the default I/O address > space for a mdev, or the user-provided PASID marking an user I/O page > table, or another kernel-allocated PASID backing the user-provided one. > Please check next section for detail explanation. > > A new object is introduced and linked to ioasid_data->attach_data for > each successful attach operation: > > struct ioasid_attach_data { > struct list_head next; > struct ioasid_dev *dev; > u32 pasid; > } > > As explained in the design section, there is no explicit group enforcement > in /dev/ioasid uAPI or helper functions. But the ioasid driver does > implicit group check - before every device within an iommu group is > attached to this IOASID, the previously-attached devices in this group are > put in ioasid_data->partial_devices. The IOASID rejects any command if > the partial_devices list is not empty. > > Then is the last helper function: > u32 ioasid_get_global_pasid(struct ioasid_ctx *ctx, > u32 ioasid, bool alloc); > > ioasid_get_global_pasid is necessary in scenarios where multiple devices > want to share a same PASID value on the attached I/O page table (e.g. > when ENQCMD is enabled, as explained in next section). We need a > centralized place (ioasid_data->pasid) to hold this value (allocated when > first called with alloc=true). vfio device driver calls this function (alloc= > true) to get the global PASID for an ioasid before calling ioasid_device_ > attach. KVM also calls this function (alloc=false) to setup PASID translation > structure when user calls KVM_MAP_PASID. > > 4. PASID Virtualization > ------------------------------ > > When guest SVA (vSVA) is enabled, multiple GVA address spaces are > created on the assigned vfio device. This leads to the concepts of > "virtual PASID" (vPASID) vs. "physical PASID" (pPASID). vPASID is assigned > by the guest to mark an GVA address space while pPASID is the one > selected by the host and actually routed in the wire. > > vPASID is conveyed to the kernel when user calls VFIO_ATTACH_IOASID. > > vfio device driver translates vPASID to pPASID before calling ioasid_attach_ > device, with two factors to be considered: > > - Whether vPASID is directly used (vPASID==pPASID) in the wire, or > should be instead converted to a newly-allocated one (vPASID!= > pPASID); > > - If vPASID!=pPASID, whether pPASID is allocated from per-RID PASID > space or a global PASID space (implying sharing pPASID cross devices, > e.g. when supporting Intel ENQCMD which puts PASID in a CPU MSR > as part of the process context); > > The actual policy depends on pdev vs. mdev, and whether ENQCMD is > supported. There are three possible scenarios: > > (Note: /dev/ioasid uAPI is not affected by underlying PASID virtualization > policies.) > > 1) pdev (w/ or w/o ENQCMD): vPASID==pPASID > > vPASIDs are directly programmed by the guest to the assigned MMIO > bar, implying all DMAs out of this device having vPASID in the packet > header. This mandates vPASID==pPASID, sort of delegating the entire > per-RID PASID space to the guest. > > When ENQCMD is enabled, the CPU MSR when running a guest task > contains a vPASID. In this case the CPU PASID translation capability > should be disabled so this vPASID in CPU MSR is directly sent to the > wire. > > This ensures consistent vPASID usage on pdev regardless of the > workload submitted through a MMIO register or ENQCMD instruction. > > 2) mdev: vPASID!=pPASID (per-RID if w/o ENQCMD, otherwise global) > > PASIDs are also used by kernel to mark the default I/O address space > for mdev, thus cannot be delegated to the guest. Instead, the mdev > driver must allocate a new pPASID for each vPASID (thus vPASID!= > pPASID) and then use pPASID when attaching this mdev to an ioasid. > > The mdev driver needs cache the PASID mapping so in mediation > path vPASID programmed by the guest can be converted to pPASID > before updating the physical MMIO register. The mapping should > also be saved in the CPU PASID translation structure (via KVM uAPI), > so the vPASID saved in the CPU MSR is auto-translated to pPASID > before sent to the wire, when ENQCMD is enabled. > > Generally pPASID could be allocated from the per-RID PASID space > if all mdev's created on the parent device don't support ENQCMD. > > However if the parent supports ENQCMD-capable mdev, pPASIDs > must be allocated from a global pool because the CPU PASID > translation structure is per-VM. It implies that when an guest I/O > page table is attached to two mdevs with a single vPASID (i.e. bind > to the same guest process), a same pPASID should be used for > both mdevs even when they belong to different parents. Sharing > pPASID cross mdevs is achieved by calling aforementioned ioasid_ > get_global_pasid(). > > 3) Mix pdev/mdev together > > Above policies are per device type thus are not affected when mixing > those device types together (when assigned to a single guest). However, > there is one exception - when both pdev/mdev support ENQCMD. > > Remember the two types have conflicting requirements on whether > CPU PASID translation should be enabled. This capability is per-VM, > and must be enabled for mdev isolation. When enabled, pdev will > receive a mdev pPASID violating its vPASID expectation. > > In previous thread a PASID range split scheme was discussed to support > this combination, but we haven't worked out a clean uAPI design yet. > Therefore in this proposal we decide to not support it, implying the > user should have some intelligence to avoid such scenario. It could be > a TODO task for future. > > In spite of those subtle considerations, the kernel implementation could > start simple, e.g.: > > - v==p for pdev; > - v!=p and always use a global PASID pool for all mdev's; > > Regardless of the kernel policy, the user policy is unchanged: > > - provide vPASID when calling VFIO_ATTACH_IOASID; > - call KVM uAPI to setup CPU PASID translation if ENQCMD-capable mdev; > - Don't expose ENQCMD capability on both pdev and mdev; > > Sample user flow is described in section 5.5. > > 5. Use Cases and Flows > ------------------------------- > > Here assume VFIO will support a new model where every bound device > is explicitly listed under /dev/vfio thus a device fd can be acquired w/o > going through legacy container/group interface. For illustration purpose > those devices are just called dev[1...N]: > > device_fd[1...N] = open("/dev/vfio/devices/dev[1...N]", mode); > > As explained earlier, one IOASID fd is sufficient for all intended use cases: > > ioasid_fd = open("/dev/ioasid", mode); > > For simplicity below examples are all made for the virtualization story. > They are representative and could be easily adapted to a non-virtualization > scenario. > > Three types of IOASIDs are considered: > > gpa_ioasid[1...N]: for GPA address space > giova_ioasid[1...N]: for guest IOVA address space > gva_ioasid[1...N]: for guest CPU VA address space > > At least one gpa_ioasid must always be created per guest, while the other > two are relevant as far as vIOMMU is concerned. > > Examples here apply to both pdev and mdev, if not explicitly marked out > (e.g. in section 5.5). VFIO device driver in the kernel will figure out the > associated routing information in the attaching operation. > > For illustration simplicity, IOASID_CHECK_EXTENSION and IOASID_GET_ > INFO are skipped in these examples. > > 5.1. A simple example > ++++++++++++++++++ > > Dev1 is assigned to the guest. One gpa_ioasid is created. The GPA address > space is managed through DMA mapping protocol: > > /* Bind device to IOASID fd */ > device_fd = open("/dev/vfio/devices/dev1", mode); > ioasid_fd = open("/dev/ioasid", mode); > ioctl(device_fd, VFIO_BIND_IOASID_FD, ioasid_fd); > > /* Attach device to IOASID */ > gpa_ioasid = ioctl(ioasid_fd, IOASID_ALLOC); > at_data = { .ioasid = gpa_ioasid}; > ioctl(device_fd, VFIO_ATTACH_IOASID, &at_data); > > /* Setup GPA mapping */ > dma_map = { > .ioasid = gpa_ioasid; > .iova = 0; // GPA > .vaddr = 0x40000000; // HVA > .size = 1GB; > }; > ioctl(ioasid_fd, IOASID_DMA_MAP, &dma_map); > > If the guest is assigned with more than dev1, user follows above sequence > to attach other devices to the same gpa_ioasid i.e. sharing the GPA > address space cross all assigned devices. > > 5.2. Multiple IOASIDs (no nesting) > ++++++++++++++++++++++++++++ > > Dev1 and dev2 are assigned to the guest. vIOMMU is enabled. Initially > both devices are attached to gpa_ioasid. After boot the guest creates > an GIOVA address space (giova_ioasid) for dev2, leaving dev1 in pass > through mode (gpa_ioasid). > > Suppose IOASID nesting is not supported in this case. Qemu need to > generate shadow mappings in userspace for giova_ioasid (like how > VFIO works today). > > To avoid duplicated locked page accounting, it's recommended to pre- > register the virtual address range that will be used for DMA: > > device_fd1 = open("/dev/vfio/devices/dev1", mode); > device_fd2 = open("/dev/vfio/devices/dev2", mode); > ioasid_fd = open("/dev/ioasid", mode); > ioctl(device_fd1, VFIO_BIND_IOASID_FD, ioasid_fd); > ioctl(device_fd2, VFIO_BIND_IOASID_FD, ioasid_fd); > > /* pre-register the virtual address range for accounting */ > mem_info = { .vaddr = 0x40000000; .size = 1GB }; > ioctl(ioasid_fd, IOASID_REGISTER_MEMORY, &mem_info); > > /* Attach dev1 and dev2 to gpa_ioasid */ > gpa_ioasid = ioctl(ioasid_fd, IOASID_ALLOC); > at_data = { .ioasid = gpa_ioasid}; > ioctl(device_fd1, VFIO_ATTACH_IOASID, &at_data); > ioctl(device_fd2, VFIO_ATTACH_IOASID, &at_data); > > /* Setup GPA mapping */ > dma_map = { > .ioasid = gpa_ioasid; > .iova = 0; // GPA > .vaddr = 0x40000000; // HVA > .size = 1GB; > }; > ioctl(ioasid_fd, IOASID_DMA_MAP, &dma_map); > > /* After boot, guest enables an GIOVA space for dev2 */ > giova_ioasid = ioctl(ioasid_fd, IOASID_ALLOC); > > /* First detach dev2 from previous address space */ > at_data = { .ioasid = gpa_ioasid}; > ioctl(device_fd2, VFIO_DETACH_IOASID, &at_data); > > /* Then attach dev2 to the new address space */ > at_data = { .ioasid = giova_ioasid}; > ioctl(device_fd2, VFIO_ATTACH_IOASID, &at_data); > > /* Setup a shadow DMA mapping according to vIOMMU > * GIOVA (0x2000) -> GPA (0x1000) -> HVA (0x40001000) > */ > dma_map = { > .ioasid = giova_ioasid; > .iova = 0x2000; // GIOVA > .vaddr = 0x40001000; // HVA > .size = 4KB; > }; > ioctl(ioasid_fd, IOASID_DMA_MAP, &dma_map); > > 5.3. IOASID nesting (software) > +++++++++++++++++++++++++ > > Same usage scenario as 5.2, with software-based IOASID nesting > available. In this mode it is the kernel instead of user to create the > shadow mapping. > > The flow before guest boots is same as 5.2, except one point. Because > giova_ioasid is nested on gpa_ioasid, locked accounting is only > conducted for gpa_ioasid. So it's not necessary to pre-register virtual > memory. > > To save space we only list the steps after boots (i.e. both dev1/dev2 > have been attached to gpa_ioasid before guest boots): > > /* After boots */ > /* Make GIOVA space nested on GPA space */ > giova_ioasid = ioctl(ioasid_fd, IOASID_CREATE_NESTING, > gpa_ioasid); > > /* Attach dev2 to the new address space (child) > * Note dev2 is still attached to gpa_ioasid (parent) > */ > at_data = { .ioasid = giova_ioasid}; > ioctl(device_fd2, VFIO_ATTACH_IOASID, &at_data); For vDPA, we need something similar. And in the future, vDPA may allow multiple ioasid to be attached to a single device. It should work with the current design. > > /* Setup a GIOVA->GPA mapping for giova_ioasid, which will be > * merged by the kernel with GPA->HVA mapping of gpa_ioasid > * to form a shadow mapping. > */ > dma_map = { > .ioasid = giova_ioasid; > .iova = 0x2000; // GIOVA > .vaddr = 0x1000; // GPA > .size = 4KB; > }; > ioctl(ioasid_fd, IOASID_DMA_MAP, &dma_map); > > 5.4. IOASID nesting (hardware) > +++++++++++++++++++++++++ > > Same usage scenario as 5.2, with hardware-based IOASID nesting > available. In this mode the pgtable binding protocol is used to > bind the guest IOVA page table with the IOMMU: > > /* After boots */ > /* Make GIOVA space nested on GPA space */ > giova_ioasid = ioctl(ioasid_fd, IOASID_CREATE_NESTING, > gpa_ioasid); > > /* Attach dev2 to the new address space (child) > * Note dev2 is still attached to gpa_ioasid (parent) > */ > at_data = { .ioasid = giova_ioasid}; > ioctl(device_fd2, VFIO_ATTACH_IOASID, &at_data); I guess VFIO_ATTACH_IOASID will fail if the underlayer doesn't support hardware nesting. Or is there way to detect the capability before? I think GET_INFO only works after the ATTACH. > > /* Bind guest I/O page table */ > bind_data = { > .ioasid = giova_ioasid; > .addr = giova_pgtable; > // and format information > }; > ioctl(ioasid_fd, IOASID_BIND_PGTABLE, &bind_data); > > /* Invalidate IOTLB when required */ > inv_data = { > .ioasid = giova_ioasid; > // granular information > }; > ioctl(ioasid_fd, IOASID_INVALIDATE_CACHE, &inv_data); > > /* See 5.6 for I/O page fault handling */ > > 5.5. Guest SVA (vSVA) > ++++++++++++++++++ > > After boots the guest further create a GVA address spaces (gpasid1) on > dev1. Dev2 is not affected (still attached to giova_ioasid). > > As explained in section 4, user should avoid expose ENQCMD on both > pdev and mdev. > > The sequence applies to all device types (being pdev or mdev), except > one additional step to call KVM for ENQCMD-capable mdev: My understanding is ENQCMD is Intel specific and not a requirement for having vSVA. > > /* After boots */ > /* Make GVA space nested on GPA space */ > gva_ioasid = ioctl(ioasid_fd, IOASID_CREATE_NESTING, > gpa_ioasid); > > /* Attach dev1 to the new address space and specify vPASID */ > at_data = { > .ioasid = gva_ioasid; > .flag = IOASID_ATTACH_USER_PASID; > .user_pasid = gpasid1; > }; > ioctl(device_fd1, VFIO_ATTACH_IOASID, &at_data); > > /* if dev1 is ENQCMD-capable mdev, update CPU PASID > * translation structure through KVM > */ > pa_data = { > .ioasid_fd = ioasid_fd; > .ioasid = gva_ioasid; > .guest_pasid = gpasid1; > }; > ioctl(kvm_fd, KVM_MAP_PASID, &pa_data); > > /* Bind guest I/O page table */ > bind_data = { > .ioasid = gva_ioasid; > .addr = gva_pgtable1; > // and format information > }; > ioctl(ioasid_fd, IOASID_BIND_PGTABLE, &bind_data); > > ... > > > 5.6. I/O page fault > +++++++++++++++ > > (uAPI is TBD. Here is just about the high-level flow from host IOMMU driver > to guest IOMMU driver and backwards). > > - Host IOMMU driver receives a page request with raw fault_data {rid, > pasid, addr}; > > - Host IOMMU driver identifies the faulting I/O page table according to > information registered by IOASID fault handler; > > - IOASID fault handler is called with raw fault_data (rid, pasid, addr), which > is saved in ioasid_data->fault_data (used for response); > > - IOASID fault handler generates an user fault_data (ioasid, addr), links it > to the shared ring buffer and triggers eventfd to userspace; > > - Upon received event, Qemu needs to find the virtual routing information > (v_rid + v_pasid) of the device attached to the faulting ioasid. If there are > multiple, pick a random one. This should be fine since the purpose is to > fix the I/O page table on the guest; > > - Qemu generates a virtual I/O page fault through vIOMMU into guest, > carrying the virtual fault data (v_rid, v_pasid, addr); > > - Guest IOMMU driver fixes up the fault, updates the I/O page table, and > then sends a page response with virtual completion data (v_rid, v_pasid, > response_code) to vIOMMU; > > - Qemu finds the pending fault event, converts virtual completion data > into (ioasid, response_code), and then calls a /dev/ioasid ioctl to > complete the pending fault; > > - /dev/ioasid finds out the pending fault data {rid, pasid, addr} saved in > ioasid_data->fault_data, and then calls iommu api to complete it with > {rid, pasid, response_code}; > > 5.7. BIND_PASID_TABLE > ++++++++++++++++++++ > > PASID table is put in the GPA space on some platform, thus must be updated > by the guest. It is treated as another user page table to be bound with the > IOMMU. > > As explained earlier, the user still needs to explicitly bind every user I/O > page table to the kernel so the same pgtable binding protocol (bind, cache > invalidate and fault handling) is unified cross platforms. > > vIOMMUs may include a caching mode (or paravirtualized way) which, once > enabled, requires the guest to invalidate PASID cache for any change on the > PASID table. This allows Qemu to track the lifespan of guest I/O page tables. > > In case of missing such capability, Qemu could enable write-protection on > the guest PASID table to achieve the same effect. > > /* After boots */ > /* Make vPASID space nested on GPA space */ > pasidtbl_ioasid = ioctl(ioasid_fd, IOASID_CREATE_NESTING, > gpa_ioasid); > > /* Attach dev1 to pasidtbl_ioasid */ > at_data = { .ioasid = pasidtbl_ioasid}; > ioctl(device_fd1, VFIO_ATTACH_IOASID, &at_data); > > /* Bind PASID table */ > bind_data = { > .ioasid = pasidtbl_ioasid; > .addr = gpa_pasid_table; > // and format information > }; > ioctl(ioasid_fd, IOASID_BIND_PASID_TABLE, &bind_data); > > /* vIOMMU detects a new GVA I/O space created */ > gva_ioasid = ioctl(ioasid_fd, IOASID_CREATE_NESTING, > gpa_ioasid); > > /* Attach dev1 to the new address space, with gpasid1 */ > at_data = { > .ioasid = gva_ioasid; > .flag = IOASID_ATTACH_USER_PASID; > .user_pasid = gpasid1; > }; > ioctl(device_fd1, VFIO_ATTACH_IOASID, &at_data); Do we need VFIO_DETACH_IOASID? Thanks > > /* Bind guest I/O page table. Because SET_PASID_TABLE has been > * used, the kernel will not update the PASID table. Instead, just > * track the bound I/O page table for handling invalidation and > * I/O page faults. > */ > bind_data = { > .ioasid = gva_ioasid; > .addr = gva_pgtable1; > // and format information > }; > ioctl(ioasid_fd, IOASID_BIND_PGTABLE, &bind_data); > > ... > > Thanks > Kevin >