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=-11.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_2 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1A111C433E2 for ; Fri, 28 Aug 2020 22:17:16 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 CA4BD2080C for ; Fri, 28 Aug 2020 22:17:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CA4BD2080C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.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 fraxinus.osuosl.org (Postfix) with ESMTP id AADD886C6C; Fri, 28 Aug 2020 22:17:15 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id o7Dl-qLEHnAh; Fri, 28 Aug 2020 22:17:13 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id 7FD7186BBC; Fri, 28 Aug 2020 22:17:13 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 5DB22C07FF; Fri, 28 Aug 2020 22:17:13 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id E7C7AC0051 for ; Fri, 28 Aug 2020 22:17:11 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id D094186BBC for ; Fri, 28 Aug 2020 22:17:11 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id WablOv23hhUA for ; Fri, 28 Aug 2020 22:17:09 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by fraxinus.osuosl.org (Postfix) with ESMTPS id 3F75386B87 for ; Fri, 28 Aug 2020 22:17:09 +0000 (UTC) IronPort-SDR: yg0PThdYe7wXRZlrxntgqSVC810gechlEc5FPjSf5Q/GDRyzJ+NaWHiQuw6+DuVujw/Tp6lhlO m4s0CpE5J9+g== X-IronPort-AV: E=McAfee;i="6000,8403,9727"; a="144431412" X-IronPort-AV: E=Sophos;i="5.76,365,1592895600"; d="scan'208";a="144431412" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 15:17:08 -0700 IronPort-SDR: 85o6F007x3QZrQfNItHcNsZ/AjtmpRBpdOehTaY4hZpGz3QxE4PzBW4LBVSaRnM1VvrVmPK7iZ FQVhEcvgaUhA== X-IronPort-AV: E=Sophos;i="5.76,365,1592895600"; d="scan'208";a="313735039" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 15:17:08 -0700 Date: Fri, 28 Aug 2020 15:24:13 -0700 From: Jacob Pan To: Jean-Philippe Brucker Subject: Re: [PATCH v2 1/9] docs: Document IO Address Space ID (IOASID) APIs Message-ID: <20200828152413.49e7fad3@jacob-builder> In-Reply-To: <20200824103239.GA3210689@myrica> References: <1598070918-21321-1-git-send-email-jacob.jun.pan@linux.intel.com> <1598070918-21321-2-git-send-email-jacob.jun.pan@linux.intel.com> <20200824103239.GA3210689@myrica> Organization: OTC X-Mailer: Claws Mail 3.13.2 (GTK+ 2.24.30; x86_64-pc-linux-gnu) MIME-Version: 1.0 Cc: "Tian, Kevin" , Jacob Pan , Raj Ashok , David Woodhouse , LKML , iommu@lists.linux-foundation.org, Jean-Philippe Brucker , Wu Hao X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" SGkgSmVhbiwKClRoYW5rcyBmb3IgdGhlIHJldmlldyEKCk9uIE1vbiwgMjQgQXVnIDIwMjAgMTI6 MzI6MzkgKzAyMDAKSmVhbi1QaGlsaXBwZSBCcnVja2VyIDxqZWFuLXBoaWxpcHBlQGxpbmFyby5v cmc+IHdyb3RlOgoKPiBPbiBGcmksIEF1ZyAyMSwgMjAyMCBhdCAwOTozNToxMFBNIC0wNzAwLCBK YWNvYiBQYW4gd3JvdGU6Cj4gPiBJT0FTSUQgaXMgdXNlZCB0byBpZGVudGlmeSBhZGRyZXNzIHNw YWNlcyB0aGF0IGNhbiBiZSB0YXJnZXRlZCBieQo+ID4gZGV2aWNlIERNQS4gSXQgaXMgYSBzeXN0 ZW0td2lkZSByZXNvdXJjZSB0aGF0IGlzIGVzc2VudGlhbCB0byBpdHMKPiA+IG1hbnkgdXNlcnMu IFRoaXMgZG9jdW1lbnQgaXMgYW4gYXR0ZW1wdCB0byBoZWxwIGRldmVsb3BlcnMgZnJvbSBhbGwK PiA+IHZlbmRvcnMgbmF2aWdhdGUgdGhlIEFQSXMuIEF0IHRoaXMgdGltZSwgQVJNIFNNTVUgYW5k IEludGVs4oCZcwo+ID4gU2NhbGFibGUgSU8gVmlydHVhbGl6YXRpb24gKFNJT1YpIGVuYWJsZWQg cGxhdGZvcm1zIGFyZSB0aGUgcHJpbWFyeQo+ID4gdXNlcnMgb2YgSU9BU0lELiBFeGFtcGxlcyBv ZiBob3cgU0lPViBjb21wb25lbnRzIGludGVyYWN0IHdpdGgKPiA+IElPQVNJRCBBUElzIGFyZSBw cm92aWRlZCBpbiB0aGF0IG1hbnkgQVBJcyBhcmUgZHJpdmVuIGJ5IHRoZQo+ID4gcmVxdWlyZW1l bnRzIGZyb20gU0lPVi4KPiA+IAo+ID4gU2lnbmVkLW9mZi1ieTogTGl1IFlpIEwgPHlpLmwubGl1 QGludGVsLmNvbT4KPiA+IFNpZ25lZC1vZmYtYnk6IFd1IEhhbyA8aGFvLnd1QGludGVsLmNvbT4K PiA+IFNpZ25lZC1vZmYtYnk6IEphY29iIFBhbiA8amFjb2IuanVuLnBhbkBsaW51eC5pbnRlbC5j b20+Cj4gPiAtLS0KPiA+ICBEb2N1bWVudGF0aW9uL2lvYXNpZC5yc3QgfCA2MTgKPiA+ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrIDEgZmlsZSBjaGFuZ2Vk LCA2MTgKPiA+IGluc2VydGlvbnMoKykgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24v aW9hc2lkLnJzdAo+ID4gCj4gPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9pb2FzaWQucnN0 IGIvRG9jdW1lbnRhdGlvbi9pb2FzaWQucnN0ICAKPiAKPiBUaGFua3MgZm9yIHdyaXRpbmcgdGhp cyB1cC4gU2hvdWxkIGl0IGdvIHRvCj4gRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpLywgb3IgRG9j dW1lbnRhdGlvbi9kcml2ZXItYXBpL2lvbW11Lz8gSQo+IHRoaW5rIHRoaXMgYWxzbyBuZWVkcyB0 byBDYyBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnIGFuZAo+IGNvcmJldEBsd24ubmV0Cj4gCkdv b2QgcG9pbnQsIEkgdGhpbmsgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpLyBpcyBnb29kIGZvciBu b3cgYXMgdGhlcmUKYXJlIG5vIG90aGVyIElPTU1VIGRvY3MuCldpbGwgQ0MgSm9uIGFsc28uCgo+ ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAwMC4uYjZhOGNkYzg4 NWZmCj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9Eb2N1bWVudGF0aW9uL2lvYXNpZC5yc3QK PiA+IEBAIC0wLDAgKzEsNjE4IEBACj4gPiArLi4gaW9hc2lkOgo+ID4gKwo+ID4gKz09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPiA+ICtJTyBBZGRyZXNzIFNwYWNlIElECj4g PiArPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo+ID4gKwo+ID4gK0lPQVNJ RCBpcyBhIGdlbmVyaWMgbmFtZSBmb3IgUENJZSBQcm9jZXNzIEFkZHJlc3MgSUQgKFBBU0lEKSBv ciBBUk0KPiA+ICtTTU1VIHN1Yi1zdHJlYW0gSUQuIEFuIElPQVNJRCBpZGVudGlmaWVzIGFuIGFk ZHJlc3Mgc3BhY2UgdGhhdAo+ID4gRE1BICAKPiAKPiAiU3Vic3RyZWFtSUQiCj4gCgo+ID4gK3Jl cXVlc3RzIGNhbiB0YXJnZXQuCj4gPiArCj4gPiArVGhlIHByaW1hcnkgdXNlIGNhc2VzIGZvciBJ T0FTSUQgYXJlIFNoYXJlZCBWaXJ0dWFsIEFkZHJlc3MgKFNWQSkKPiA+IGFuZCArSU8gVmlydHVh bCBBZGRyZXNzIChJT1ZBKS4gSG93ZXZlciwgdGhlIHJlcXVpcmVtZW50cyBmb3IKPiA+IElPQVNJ RCAgCj4gCj4gSU9WQSBhbG9uZSBpc24ndCBhIHVzZSBjYXNlLCBtYXliZSAibXVsdGlwbGUgSU9W QSBzcGFjZXMgcGVyIGRldmljZSI/Cj4gClllcywgSSBtZWFudCBndWVzdCBJT1ZBIGZvciBtZGV2 IHdoaWNoIGhhcyAibXVsdGlwbGUgSU9WQSBzcGFjZXMgcGVyCmRldmljZSIgYmFzZWQgb24gYXV4 IGRvbWFpbi4gSSB3aWxsIGFkZCB0aGlzIHRvIHRoZSBJT1ZBIGNhc2UgZGVzY3JpcHRpb24uCgoi VGhlIHByaW1hcnkgdXNlIGNhc2VzIGZvciBJT0FTSUQgYXJlIFNoYXJlZCBWaXJ0dWFsIEFkZHJl c3MgKFNWQSkgYW5kCm11bHRpcGxlIElPVkEgc3BhY2VzIHBlciBkZXZpY2UuIEhvd2V2ZXIsIHRo ZSByZXF1aXJlbWVudHMgZm9yIElPQVNJRAptYW5hZ2VtZW50IGNhbiB2YXJ5IGFtb25nIGhhcmR3 YXJlIGFyY2hpdGVjdHVyZXMuCgpGb3IgYmFyZW1ldGFsIElPVkEsIElPQVNJRCAjMCBpcyB1c2Vk IGZvciBETUEgcmVxdWVzdCB3aXRob3V0ClBBU0lELiBFdmVuIHRob3VnaCBzb21lIGFyY2hpdGVj dHVyZXMgc3VjaCBhcyBWVC1kIGFsc28gb2ZmZXJzCnRoZSBmbGV4aWJpbGl0eSBvZiB1c2luZyBh bnkgUEFTSURzIGZvciBETUEgcmVxdWVzdCB3aXRob3V0IFBBU0lELgpQQVNJRCAjMCBpcyByZXNl cnZlZCBhbmQgbm90IGFsbG9jYXRlZCBmcm9tIGFueSBpb2FzaWRfc2V0LgoKTXVsdGlwbGUgSU9W QSBzcGFjZXMgcGVyIGRldmljZSBhcmUgbWFwcGVkIHRvIGF1eGlsaWFyeSBkb21haW5zIHdoaWNo CmNhbiBiZSB1c2VkIGZvciBtZWRpYXRlZCBkZXZpY2UgYXNzaWdubWVudCB3aXRoIGFuZCB3aXRo b3V0IGEgdmlydHVhbApJT01NVSAodklPTU1VKS4gQW4gSU9BU0lEIGlzIGFsbG9jYXRlZCBmb3Ig ZWFjaCBhdXhpbGlhcnkgZG9tYWluIGFzIGRlZmF1bHQKUEFTSUQuIFdpdGhvdXQgdklPTU1VLCBk ZWZhdWx0IElPQVNJRCBpcyB1c2VkIGZvciBETUEgbWFwL3VubWFwCkFQSXMuIFdpdGggdklPTU1V LCBkZWZhdWx0IElPQVNJRCBpcyB1c2VkIGZvciBndWVzdCBJT1ZBIHdoZXJlIERNQQpyZXF1ZXN0 IHdpdGggUEFTSUQgaXMgcmVxdWlyZWQgZm9yIHRoZSBkZXZpY2UuIFRoZSByZWFzb24gaXMgdGhh dAp0aGVyZSBpcyBvbmx5IG9uZSBQQVNJRCAjMCBwZXIgZGV2aWNlLCBlLmcuIFZULWQsIFJJRF9Q QVNJRCBpcyBwZXIgUENJCmRldmljZS4KIgoKPiA+ICttYW5hZ2VtZW50IGNhbiB2YXJ5IGFtb25n IGhhcmR3YXJlIGFyY2hpdGVjdHVyZXMuCj4gPiArCj4gPiArVGhpcyBkb2N1bWVudCBjb3ZlcnMg dGhlIGdlbmVyaWMgZmVhdHVyZXMgc3VwcG9ydGVkIGJ5IElPQVNJRAo+ID4gK0FQSXMuIFZlbmRv ci1zcGVjaWZpYyB1c2UgY2FzZXMgYXJlIGFsc28gaWxsdXN0cmF0ZWQgd2l0aCBJbnRlbCdzCj4g PiBWVC1kICtiYXNlZCBwbGF0Zm9ybXMgYXMgdGhlIGZpcnN0IGV4YW1wbGUuCj4gPiArCj4gPiAr Li4gY29udGVudHM6OiA6bG9jYWw6Cj4gPiArCj4gPiArR2xvc3NhcnkKPiA+ICs9PT09PT09PQo+ ID4gK1BBU0lEIC0gUHJvY2VzcyBBZGRyZXNzIFNwYWNlIElECj4gPiArCj4gPiArSU9BU0lEIC0g SU8gQWRkcmVzcyBTcGFjZSBJRCAoZ2VuZXJpYyB0ZXJtIGZvciBQQ0llIFBBU0lEIGFuZAo+ID4g K3N1Yi1zdHJlYW0gSUQgaW4gU01NVSkgIAo+IAo+ICJTdWJzdHJlYW1JRCIKPiAKd2lsbCBmaXgu Cgo+ID4gKwo+ID4gK1NWQS9TVk0gLSBTaGFyZWQgVmlydHVhbCBBZGRyZXNzaW5nL01lbW9yeQo+ ID4gKwo+ID4gK0VOUUNNRCAtIE5ldyBJbnRlbCBYODYgSVNBIGZvciBlZmZpY2llbnQgd29ya3F1 ZXVlIHN1Ym1pc3Npb24gWzFdICAKPiAKPiBNYXliZSBkcm9wIHRoZSAiTmV3IiwgdG8ga2VlcCB0 aGUgZG9jdW1lbnRhdGlvbiBwZXJlbm5pYWwuIEl0IG1pZ2h0IGJlCj4gZ29vZCB0byBhZGQgaW50 ZXJuYWwgbGlua3MgaGVyZSB0byB0aGUgc3BlY2lmaWNhdGlvbnMgVVJMcyBhdCB0aGUKPiBib3R0 b20uCj4gCkdvb2QgaWRlYQoKPiA+ICsKPiA+ICtEU0EgLSBJbnRlbCBEYXRhIFN0cmVhbWluZyBB Y2NlbGVyYXRvciBbMl0KPiA+ICsKPiA+ICtWRENNIC0gVmlydHVhbCBkZXZpY2UgY29tcG9zaXRp b24gbW9kdWxlIFszXQo+ID4gKwo+ID4gK1NJT1YgLSBJbnRlbCBTY2FsYWJsZSBJTyBWaXJ0dWFs aXphdGlvbgo+ID4gKwo+ID4gKwo+ID4gK0tleSBDb25jZXB0cwo+ID4gKz09PT09PT09PT09PQo+ ID4gKwo+ID4gK0lPQVNJRCBTZXQKPiA+ICstLS0tLS0tLS0tLQo+ID4gK0FuIElPQVNJRCBzZXQg aXMgYSBncm91cCBvZiBJT0FTSURzIGFsbG9jYXRlZCBmcm9tIHRoZSBzeXN0ZW0td2lkZQo+ID4g K0lPQVNJRCBwb29sLiBBbiBJT0FTSUQgc2V0IGlzIGNyZWF0ZWQgYW5kIGNhbiBiZSBpZGVudGlm aWVkIGJ5IGEKPiA+ICt0b2tlbiBvZiB1NjQuIFJlZmVyIHRvIElPQVNJRCBzZXQgQVBJcyBmb3Ig bW9yZSBkZXRhaWxzLiAgCj4gCj4gSWRlbnRpZmllZCBlaXRoZXIgYnkgYW4gdTY0IG9yIGFuIG1t X3N0cnVjdCwgcmlnaHQ/ICBNYXliZSBqdXN0IGRyb3AKPiB0aGUgc2Vjb25kIHNlbnRlbmNlIGlm IGl0J3MgZGV0YWlsZWQgaW4gdGhlIElPQVNJRCBzZXQgc2VjdGlvbiBiZWxvdy4KPiAKU291bmRz IGdvb2QuCgo+ID4gKwo+ID4gK0lPQVNJRCBzZXQgaXMgcGFydGljdWxhcmx5IHVzZWZ1bCBmb3Ig Z3Vlc3QgU1ZBIHdoZXJlIGVhY2ggZ3Vlc3QKPiA+IGNvdWxkICtoYXZlIGl0cyBvd24gSU9BU0lE IHNldCBmb3Igc2VjdXJpdHkgYW5kIGVmZmljaWVuY3kgcmVhc29ucy4KPiA+ICsKPiA+ICtJT0FT SUQgU2V0IFByaXZhdGUgSUQgKFNQSUQpCj4gPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQo+ID4gK1NQSURzIGFyZSBpbnRyb2R1Y2VkIGFzIElPQVNJRHMgd2l0aGluIGl0cyBzZXQuIEVh Y2ggU1BJRCBtYXBzIHRvIGEKPiA+ICtzeXN0ZW0td2lkZSBJT0FTSUQgYnV0IHRoZSBuYW1lc3Bh Y2Ugb2YgU1BJRCBpcyB3aXRoaW4gaXRzIElPQVNJRAo+ID4gK3NldC4gIAo+IAo+IFRoZSBpbnRy byBpc24ndCBzdXBlciBjbGVhci4gUGVyaGFwcyB0aGlzIGlzIHNpbXBsZXI6Cj4gIkVhY2ggSU9B U0lEIHNldCBoYXMgYSBwcml2YXRlIG5hbWVzcGFjZSBvZiBTUElEcy4gQW4gU1BJRCBtYXBzIHRv IGEKPiBzaW5nbGUgc3lzdGVtLXdpZGUgSU9BU0lELiIKPiAKU291bmRzIGJldHRlciwgdGhhbmtz IGZvciB0aGUgcmV3cml0ZS4KCj4gPiBTUElEcyBjYW4gYmUgdXNlZCBhcyBndWVzdCBJT0FTSURz IHdoZXJlIGVhY2ggZ3Vlc3QgY291bGQgZG8KPiA+ICtJT0FTSUQgYWxsb2NhdGlvbiBmcm9tIGl0 cyBvd24gcG9vbCBhbmQgbWFwIHRoZW0gdG8gaG9zdCBwaHlzaWNhbAo+ID4gK0lPQVNJRHMuIFNQ SURzIGFyZSBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBzdXBwb3J0aW5nIGxpdmUKPiA+IG1pZ3Jh dGlvbiArd2hlcmUgZGVjb3VwbGluZyBndWVzdCBhbmQgaG9zdCBwaHlzaWNhbCByZXNvdXJjZXMg YXJlCj4gPiBuZWNlc3NhcnkuICsKPiA+ICtGb3IgZXhhbXBsZSwgdHdvIFZNcyBjYW4gYm90aCBh bGxvY2F0ZSBndWVzdCBQQVNJRC9TUElEICMxMDEgYnV0Cj4gPiBtYXAgdG8gK2RpZmZlcmVudCBo b3N0IFBBU0lEcyAjMjAxIGFuZCAjMjAyIHJlc3BlY3RpdmVseSBhcyBzaG93bgo+ID4gaW4gdGhl ICtkaWFncmFtIGJlbG93Lgo+ID4gKzo6Cj4gPiArCj4gPiArIC4tLS0tLS0tLS0tLS0tLS0tLS0u ICAgIC4tLS0tLS0tLS0tLS0tLS0tLS0uCj4gPiArIHwgICBWTSAxICAgICAgICAgICB8ICAgIHwg ICBWTSAyICAgICAgICAgICB8Cj4gPiArIHwgICAgICAgICAgICAgICAgICB8ICAgIHwgICAgICAg ICAgICAgICAgICB8Cj4gPiArIHwtLS0tLS0tLS0tLS0tLS0tLS18ICAgIHwtLS0tLS0tLS0tLS0t LS0tLS18Cj4gPiArIHwgR1BBU0lEL1NQSUQgMTAxICB8ICAgIHwgR1BBU0lEL1NQSUQgMTAxICB8 Cj4gPiArICctLS0tLS0tLS0tLS0tLS0tLS0nICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0nICAgICBH dWVzdAo+ID4gKyBfX19fX19fX19ffF9fX19fX19fX19fX19fX19fX19fX198X19fX19fX19fX19f X19fX19fX19fXwo+ID4gKyAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICB8ICAgICAg ICAgICAgICAgSG9zdAo+ID4gKyAgICAgICAgICAgdiAgICAgICAgICAgICAgICAgICAgICB2Cj4g PiArIC4tLS0tLS0tLS0tLS0tLS0tLS0uICAgIC4tLS0tLS0tLS0tLS0tLS0tLS0uCj4gPiArIHwg SG9zdCBJT0FTSUQgMjAxICB8ICAgIHwgSG9zdCBJT0FTSUQgMjAyICB8Cj4gPiArICctLS0tLS0t LS0tLS0tLS0tLS0nICAgICctLS0tLS0tLS0tLS0tLS0tLS0nCj4gPiArIHwgICBJT0FTSUQgc2V0 IDEgICB8ICAgIHwgICBJT0FTSUQgc2V0IDIgICB8Cj4gPiArICctLS0tLS0tLS0tLS0tLS0tLS0n ICAgICctLS0tLS0tLS0tLS0tLS0tLS0nCj4gPiArCj4gPiArR3Vlc3QgUEFTSUQgaXMgdHJlYXRl ZCBhcyBJT0FTSUQgc2V0IHByaXZhdGUgSUQgKFNQSUQpIHdpdGhpbiBhbgo+ID4gK0lPQVNJRCBz ZXQsIG1hcHBpbmdzIGJldHdlZW4gZ3Vlc3QgYW5kIGhvc3QgSU9BU0lEcyBhcmUgc3RvcmVkIGlu Cj4gPiB0aGUgK3NldCBmb3IgaW5xdWlyeS4KPiA+ICsKPiA+ICtJT0FTSUQgQVBJcwo+ID4gKz09 PT09PT09PT09Cj4gPiArVG8gZ2V0IHRoZSBJT0FTSUQgQVBJcywgdXNlcnMgbXVzdCAjaW5jbHVk ZSA8bGludXgvaW9hc2lkLmg+Lgo+ID4gVGhlc2UgQVBJcyArc2VydmUgdGhlIGZvbGxvd2luZyBm dW5jdGlvbmFsaXRpZXM6Cj4gPiArCj4gPiArICAtIElPQVNJRCBhbGxvY2F0aW9uL0ZyZWUKPiA+ ICsgIC0gR3JvdXAgbWFuYWdlbWVudCBpbiB0aGUgZm9ybSBvZiBpb2FzaWRfc2V0Cj4gPiArICAt IFByaXZhdGUgZGF0YSBzdG9yYWdlIGFuZCBsb29rdXAKPiA+ICsgIC0gUmVmZXJlbmNlIGNvdW50 aW5nCj4gPiArICAtIEV2ZW50IG5vdGlmaWNhdGlvbiBpbiBjYXNlIG9mIHN0YXRlIGNoYW5nZQo+ ID4gKwo+ID4gK0lPQVNJRCBTZXQgTGV2ZWwgQVBJcwo+ID4gKy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCj4gPiArRm9yIHVzZSBjYXNlcyBzdWNoIGFzIGd1ZXN0IFNWQSBpdCBpcyBuZWNlc3Nh cnkgdG8gbWFuYWdlIElPQVNJRHMKPiA+IGF0ICthIGdyb3VwIGxldmVsLiBGb3IgZXhhbXBsZSwg Vk1zIG1heSBhbGxvY2F0ZSBtdWx0aXBsZSBJT0FTSURzCj4gPiBmb3IgK2d1ZXN0IHByb2Nlc3Mg YWRkcmVzcyBzaGFyaW5nICh2U1ZBKS4gSXQgaXMgaW1wZXJhdGl2ZSB0bwo+ID4gZW5mb3JjZSAr Vk0tSU9BU0lEIG93bmVyc2hpcCBzdWNoIHRoYXQgbWFsaWNpb3VzIGd1ZXN0IGNhbm5vdAo+ID4g dGFyZ2V0IERNQSAgCj4gCj4gImEgbWFsaWNpb3VzIGd1ZXN0Igo+IApnb3QgaXQKCj4gPiArdHJh ZmZpYyBvdXRzaWRlIGl0cyBvd24gSU9BU0lEcywgb3IgZnJlZSBhbiBhY3RpdmUgSU9BU0lEIGJl bG9uZwo+ID4gdG8gIAo+IAo+ICJ0aGF0IGJlbG9uZ3MgdG8iCj4gCmdvdCBpdAoKPiA+ICthbm90 aGVyIFZNLgo+ID4gKzo6Cj4gPiArCj4gPiArIHN0cnVjdCBpb2FzaWRfc2V0ICppb2FzaWRfYWxs b2Nfc2V0KHZvaWQgKnRva2VuLCBpb2FzaWRfdCBxdW90YSwKPiA+IHUzMiB0eXBlKSArCj4gPiAr IGludCBpb2FzaWRfYWRqdXN0X3NldChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpbnQgcXVvdGEp OyAgCj4gCj4gVGhlc2UgY291bGQgYmUgbmFtZWQgImlvYXNpZF9zZXRfYWxsb2MiIGFuZCAiaW9h c2lkX3NldF9hZGp1c3QiIHRvIGJlCj4gY29uc2lzdGVudCB3aXRoIHRoZSByZXN0IG9mIHRoZSBB UEkuCj4gCnJpZ2h0Cgo+ID4gKwo+ID4gKyB2b2lkIGlvYXNpZF9zZXRfZ2V0KHN0cnVjdCBpb2Fz aWRfc2V0ICpzZXQpCj4gPiArCj4gPiArIHZvaWQgaW9hc2lkX3NldF9wdXQoc3RydWN0IGlvYXNp ZF9zZXQgKnNldCkKPiA+ICsKPiA+ICsgdm9pZCBpb2FzaWRfc2V0X2dldF9sb2NrZWQoc3RydWN0 IGlvYXNpZF9zZXQgKnNldCkKPiA+ICsKPiA+ICsgdm9pZCBpb2FzaWRfc2V0X3B1dF9sb2NrZWQo c3RydWN0IGlvYXNpZF9zZXQgKnNldCkKPiA+ICsKPiA+ICsgaW50IGlvYXNpZF9zZXRfZm9yX2Vh Y2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZGF0YSwgIAo+IAo+IE1pZ2h0IGJlIG5pY2Vy IHRvIGtlZXAgdGhlIHNhbWUgYXJndW1lbnQgbmFtZXMgd2l0aGluIHRoZSBBUEkuIEhlcmUKPiAi c2V0IiByYXRoZXIgdGhhbiAic2RhdGEiLgo+IAp5ZXMsIHdpbGwgZG8uCgo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAoKmZuKShpb2FzaWRfdCBpZCwgdm9pZAo+ID4g KmRhdGEpLAo+ID4gKwkJCQl2b2lkICpkYXRhKSAgCj4gCj4gKGFsaWdubWVudCkKPiAKaXQgbG9v a2VkIGFsaWduZWQgaW4gZW1hY3MgYW5kIGdlbmVyYXRlZCBodG1sIGRvYy4gbWlnaHQganVzdCB0 aGUgZW1haWw/CkkgaGF2ZSBiZWVuIGhhdmluZyBzbXRwIGlzc3VlcywgaSBhbSB1c2luZyBnbWFp bCBzbXRwIHRoaXMgdGltZS4KCj4gPiArCj4gPiArCj4gPiArSU9BU0lEIHNldCBjb25jZXB0IGlz IGludHJvZHVjZWQgdG8gcmVwcmVzZW50IHN1Y2ggSU9BU0lEIGdyb3Vwcy4KPiA+IEVhY2ggIAo+ IAo+IE9yIGp1c3QgIklPQVNJRCBzZXRzIHJlcHJlc2VudCBzdWNoIElPQVNJRCBncm91cHMiLCBi dXQgbWlnaHQgYmUKPiByZWR1bmRhbnQuCj4gCnJpZ2h0LCBzaW1wbGVyIGlzIGdvb2QKCj4gPiAr SU9BU0lEIHNldCBpcyBjcmVhdGVkIHdpdGggYSB0b2tlbiB3aGljaCBjYW4gYmUgb25lIG9mIHRo ZQo+ID4gZm9sbG93aW5nICt0eXBlczoKPiA+ICsKPiA+ICsgLSBJT0FTSURfU0VUX1RZUEVfTlVM TCAoQXJiaXRyYXJ5IHU2NCB2YWx1ZSkKPiA+ICsgLSBJT0FTSURfU0VUX1RZUEVfTU0gKFNldCB0 b2tlbiBpcyBhIG1tX3N0cnVjdCkKPiA+ICsKPiA+ICtUaGUgZXhwbGljaXQgTU0gdG9rZW4gdHlw ZSBpcyB1c2VmdWwgd2hlbiBtdWx0aXBsZSB1c2VycyBvZiBhbgo+ID4gSU9BU0lEICtzZXQgdW5k ZXIgdGhlIHNhbWUgcHJvY2VzcyBuZWVkIHRvIGNvbW11bmljYXRlIGFib3V0IHRoZWlyCj4gPiBz aGFyZWQgSU9BU0lEcy4gK0UuZy4gQW4gSU9BU0lEIHNldCBjcmVhdGVkIGJ5IFZGSU8gZm9yIG9u ZSBndWVzdAo+ID4gY2FuIGJlIGFzc29jaWF0ZWQgK3dpdGggdGhlIEtWTSBpbnN0YW5jZSBmb3Ig dGhlIHNhbWUgZ3Vlc3Qgc2luY2UKPiA+IHRoZXkgc2hhcmUgYSBjb21tb24gbW1fc3RydWN0LiAr Cj4gPiArVGhlIElPQVNJRCBzZXQgQVBJcyBzZXJ2ZSB0aGUgZm9sbG93aW5nIHB1cnBvc2VzOgo+ ID4gKwo+ID4gKyAtIE93bmVyc2hpcC9wZXJtaXNzaW9uIGVuZm9yY2VtZW50Cj4gPiArIC0gVGFr ZSBjb2xsZWN0aXZlIGFjdGlvbnMsIGUuZy4gZnJlZSBhbiBlbnRpcmUgc2V0Cj4gPiArIC0gRXZl bnQgbm90aWZpY2F0aW9ucyB3aXRoaW4gYSBzZXQKPiA+ICsgLSBMb29rIHVwIGEgc2V0IGJhc2Vk IG9uIHRva2VuCj4gPiArIC0gUXVvdGEgZW5mb3JjZW1lbnQgIAo+IAo+IFRoaXMgcGFyYWdyYXBo IGNvdWxkIGJlIGVhcmxpZXIgaW4gdGhlIHNlY3Rpb24KPiAKTWFrZSBzZW5zZS4gSSB3aWxsIG1v dmUgaXQgYmVmb3JlIGxpc3RpbmcgdGhlIEFQSXMuCj4gPiArCj4gPiArSW5kaXZpZHVhbCBJT0FT SUQgQVBJcwo+ID4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICtPbmNlIGFuIGlvYXNpZF9z ZXQgaXMgY3JlYXRlZCwgSU9BU0lEcyBjYW4gYmUgYWxsb2NhdGVkIGZyb20gdGhlCj4gPiBzZXQu ICtXaXRoaW4gdGhlIElPQVNJRCBzZXQgbmFtZXNwYWNlLCBzZXQgcHJpdmF0ZSBJRCAoU1BJRCkg aXMKPiA+IHN1cHBvcnRlZC4gSW4gK3RoZSBWTSB1c2UgY2FzZSwgU1BJRCBjYW4gYmUgdXNlZCBm b3Igc3RvcmluZyBndWVzdAo+ID4gUEFTSUQuICsKPiA+ICs6Ogo+ID4gKwo+ID4gKyBpb2FzaWRf dCBpb2FzaWRfYWxsb2Moc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgbWluLAo+ID4g aW9hc2lkX3QgbWF4LAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAqcHJpdmF0ZSk7 Cj4gPiArCj4gPiArIGludCBpb2FzaWRfZ2V0KHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNp ZF90IGlvYXNpZCk7Cj4gPiArCj4gPiArIHZvaWQgaW9hc2lkX3B1dChzdHJ1Y3QgaW9hc2lkX3Nl dCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQpOwo+ID4gKwo+ID4gKyBpbnQgaW9hc2lkX2dldF9sb2Nr ZWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkKTsKPiA+ICsKPiA+ICsg dm9pZCBpb2FzaWRfcHV0X2xvY2tlZChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBp b2FzaWQpOwo+ID4gKwo+ID4gKyB2b2lkICppb2FzaWRfZmluZChzdHJ1Y3QgaW9hc2lkX3NldCAq c2V0LCBpb2FzaWRfdCBpb2FzaWQsCj4gPiArICAgICAgICAgICAgICAgICAgIGJvb2wgKCpnZXR0 ZXIpKHZvaWQgKikpOwo+ID4gKwo+ID4gKyBpb2FzaWRfdCBpb2FzaWRfZmluZF9ieV9zcGlkKHN0 cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90Cj4gPiBzcGlkKSArCj4gPiArIGludCBpb2Fz aWRfYXR0YWNoX2RhdGEoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkLAo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKmRhdGEpOwo+ID4gKyBpbnQgaW9hc2lk X2F0dGFjaF9zcGlkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCwKPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICBpb2FzaWRfdCBzc2lkKTsgIAo+IAo+IHMvc3NpZC9z cGlkCj4gCmdvdCBpdAoKPiA+ICsKPiA+ICsKPiA+ICtOb3RpZmljYXRpb25zCj4gPiArLS0tLS0t LS0tLS0tLQo+ID4gK0FuIElPQVNJRCBtYXkgaGF2ZSBtdWx0aXBsZSB1c2VycywgZWFjaCB1c2Vy IG1heSBoYXZlIGhhcmR3YXJlCj4gPiBjb250ZXh0ICthc3NvY2lhdGVkIHdpdGggYW4gSU9BU0lE LiBXaGVuIHRoZSBzdGF0dXMgb2YgYW4gSU9BU0lECj4gPiBjaGFuZ2VzLCArZS5nLiBhbiBJT0FT SUQgaXMgYmVpbmcgZnJlZWQsIHVzZXJzIG5lZWQgdG8gYmUgbm90aWZpZWQKPiA+IHN1Y2ggdGhh dCB0aGUgK2Fzc29jaWF0ZWQgaGFyZHdhcmUgY29udGV4dCBjYW4gYmUgY2xlYXJlZCwgZmx1c2hl ZCwKPiA+IGFuZCBkcmFpbmVkLiArCj4gPiArOjoKPiA+ICsKPiA+ICsgaW50IGlvYXNpZF9yZWdp c3Rlcl9ub3RpZmllcihzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBzdHJ1Y3QKPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBub3RpZmllcl9ibG9jayAqbmIpCj4gPiArCj4gPiArIHZv aWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwKPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sg Km5iKQo+ID4gKwo+ID4gKyBpbnQgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyX21tKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBub3RpZmllcl9ibG9jayAqbmIpCj4gPiArCj4gPiArIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJf bm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdAo+ID4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKPiA+ICsKPiA+ICsg aW50IGlvYXNpZF9ub3RpZnkoaW9hc2lkX3QgaW9hc2lkLCBlbnVtIGlvYXNpZF9ub3RpZnlfdmFs IGNtZCwKPiA+ICsgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IGZsYWdzKQo+ID4gKwo+ ID4gKwo+ID4gK0V2ZW50cwo+ID4gK35+fn5+fgo+ID4gK05vdGlmaWNhdGlvbiBldmVudHMgYXJl IHBlcnRpbmVudCB0byBpbmRpdmlkdWFsIElPQVNJRHMsIHRoZXkgY2FuCj4gPiBiZSArb25lIG9m IHRoZSBmb2xsb3dpbmc6Cj4gPiArCj4gPiArIC0gQUxMT0MKPiA+ICsgLSBGUkVFCj4gPiArIC0g QklORAo+ID4gKyAtIFVOQklORAo+ID4gKwo+ID4gK09yZGVyaW5nCj4gPiArfn5+fn5+fn4KPiA+ ICtPcmRlcmluZyBpcyBzdXBwb3J0ZWQgYnkgSU9BU0lEIG5vdGlmaWNhdGlvbiBwcmlvcml0aWVz IGFzIHRoZQo+ID4gK2ZvbGxvd2luZyAoaW4gYXNjZW5kaW5nIG9yZGVyKToKPiA+ICsKPiA+ICs6 Ogo+ID4gKwo+ID4gKyBlbnVtIGlvYXNpZF9ub3RpZmllcl9wcmlvcyB7Cj4gPiArCUlPQVNJRF9Q UklPX0xBU1QsCj4gPiArCUlPQVNJRF9QUklPX0lPTU1VLAo+ID4gKwlJT0FTSURfUFJJT19ERVZJ Q0UsCj4gPiArCUlPQVNJRF9QUklPX0NQVSwKPiA+ICsgfTsKPiA+ICsKPiA+ICtUaGUgdHlwaWNh bCB1c2UgY2FzZSBpcyB3aGVuIGFuIElPQVNJRCBpcyBmcmVlZCBkdWUgdG8gYW4KPiA+IGV4Y2Vw dGlvbiwgRE1BICtzb3VyY2Ugc2hvdWxkIGJlIHF1aWVzY2VkIGJlZm9yZSB0ZWFyaW5nIGRvd24g b3RoZXIKPiA+IGhhcmR3YXJlIGNvbnRleHRzICtpbiB0aGUgc3lzdGVtLiBUaGlzIHdpbGwgcmVk dWNlIHRoZSBjaHVybiBpbgo+ID4gaGFuZGxpbmcgZmF1bHRzLiBETUEgd29yayArc3VibWlzc2lv biBpcyBwZXJmb3JtZWQgYnkgdGhlIENQVSB3aGljaAo+ID4gaXMgZ3JhbnRlZCBoaWdoZXIgcHJp b3JpdHkgdGhhbiArZGV2aWNlcy4KPiA+ICsKPiA+ICsKPiA+ICtTY29wZXMKPiA+ICt+fn5+fn4K PiA+ICtUaGVyZSBhcmUgdHdvIHR5cGVzIG9mIG5vdGlmaWVycyBpbiBJT0FTSUQgY29yZTogc3lz dGVtLXdpZGUgYW5kCj4gPiAraW9hc2lkX3NldC13aWRlLgo+ID4gKwo+ID4gK1N5c3RlbS13aWRl IG5vdGlmaWVyIGlzIGNhdGVyaW5nIGZvciB1c2VycyB0aGF0IG5lZWQgdG8gaGFuZGxlIGFsbAo+ ID4gK0lPQVNJRHMgaW4gdGhlIHN5c3RlbS4gRS5nLiBUaGUgSU9NTVUgZHJpdmVyIGhhbmRsZXMg YWxsIElPQVNJRHMuCj4gPiArCj4gPiArUGVyIGlvYXNpZF9zZXQgbm90aWZpZXIgY2FuIGJlIHVz ZWQgYnkgVk0gc3BlY2lmaWMgY29tcG9uZW50cyBzdWNoCj4gPiBhcyArS1ZNLiBBZnRlciBhbGws IGVhY2ggS1ZNIGluc3RhbmNlIG9ubHkgY2FyZXMgYWJvdXQgSU9BU0lEcwo+ID4gd2l0aGluIGl0 cyArb3duIHNldC4KPiA+ICsKPiA+ICsKPiA+ICtBdG9taWNpdHkKPiA+ICt+fn5+fn5+fn4KPiA+ ICtJT0FTSUQgbm90aWZpZXJzIGFyZSBhdG9taWMgZHVlIHRvIHNwaW5sb2NrcyB1c2VkIGluc2lk ZSB0aGUgSU9BU0lECj4gPiArY29yZS4gRm9yIHRhc2tzIGNhbm5vdCBiZSBjb21wbGV0ZWQgaW4g dGhlIG5vdGlmaWVyIGhhbmRsZXIsIGFzeW5jCj4gPiB3b3JrICAKPiAKPiAidGFza3MgdGhhdCBj YW5ub3QgYmUiCj4gCmdvdCBpdAoKPiA+ICtjYW4gYmUgc3VibWl0dGVkIHRvIGNvbXBsZXRlIHRo ZSB3b3JrIGxhdGVyIGFzIGxvbmcgYXMgdGhlcmUgaXMgbm8KPiA+ICtvcmRlcmluZyByZXF1aXJl bWVudC4KPiA+ICsKPiA+ICtSZWZlcmVuY2UgY291bnRpbmcKPiA+ICstLS0tLS0tLS0tLS0tLS0t LS0KPiA+ICtJT0FTSUQgbGlmZWN5Y2xlIG1hbmFnZW1lbnQgaXMgYmFzZWQgb24gcmVmZXJlbmNl IGNvdW50aW5nLiBVc2Vycwo+ID4gb2YgK0lPQVNJRCBpbnRlbmQgdG8gYWxpZ24gbGlmZWN5Y2xl IHdpdGggdGhlIElPQVNJRCBuZWVkIHRvIGhvbGQgIAo+IAo+ICJ3aG8gaW50ZW5kIHRvIgo+IApn b3QgaXQKCj4gPiArcmVmZXJlbmNlIG9mIHRoZSBJT0FTSUQuIElPQVNJRCB3aWxsIG5vdCBiZSBy ZXR1cm5lZCB0byB0aGUgcG9vbAo+ID4gZm9yICAKPiAKPiAiYSByZWZlcmVuY2UgdG8gdGhlIElP QVNJRC4gVGhlIElPQVNJRCIKPiAKZ290IGl0Cgo+ID4gK2FsbG9jYXRpb24gdW50aWwgYWxsIHJl ZmVyZW5jZXMgYXJlIGRyb3BwZWQuIENhbGxpbmcgaW9hc2lkX2ZyZWUoKQo+ID4gK3dpbGwgbWFy ayB0aGUgSU9BU0lEIGFzIEZSRUVfUEVORElORyBpZiB0aGUgSU9BU0lEIGhhcyBvdXRzdGFuZGlu Zwo+ID4gK3JlZmVyZW5jZS4gaW9hc2lkX2dldCgpIGlzIG5vdCBhbGxvd2VkIG9uY2UgYW4gSU9B U0lEIGlzIGluIHRoZQo+ID4gK0ZSRUVfUEVORElORyBzdGF0ZS4KPiA+ICsKPiA+ICtFdmVudCBu b3RpZmljYXRpb25zIGFyZSB1c2VkIHRvIGluZm9ybSB1c2VycyBvZiBJT0FTSUQgc3RhdHVzCj4g PiBjaGFuZ2UuICtJT0FTSURfRlJFRSBldmVudCBwcm9tcHRzIHVzZXJzIHRvIGRyb3AgdGhlaXIg cmVmZXJlbmNlcwo+ID4gYWZ0ZXIgK2NsZWFyaW5nIGl0cyBjb250ZXh0Lgo+ID4gKwo+ID4gK0Zv ciBleGFtcGxlLCBvbiBWVC1kIHBsYXRmb3JtIHdoZW4gYW4gSU9BU0lEIGlzIGZyZWVkLCB0ZWFy ZG93bgo+ID4gK2FjdGlvbnMgYXJlIHBlcmZvcm1lZCBvbiBLVk0sIGRldmljZSBkcml2ZXIsIGFu ZCBJT01NVSBkcml2ZXIuCj4gPiArS1ZNIHNoYWxsIHJlZ2lzdGVyIG5vdGlmaWVyIGJsb2NrIHdp dGg6Ogo+ID4gKwo+ID4gKyBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBhc2lkX25iX2t2 bSA9IHsKPiA+ICsJLm5vdGlmaWVyX2NhbGwgPSBwYXNpZF9zdGF0dXNfY2hhbmdlX2t2bSwKPiA+ ICsJLnByaW9yaXR5ICAgICAgPSBJT0FTSURfUFJJT19DUFUsCj4gPiArIH07Cj4gPiArCj4gPiAr VkRDTSBkcml2ZXIgc2hhbGwgcmVnaXN0ZXIgbm90aWZpZXIgYmxvY2sgd2l0aDo6Cj4gPiArCj4g PiArIHN0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgcGFzaWRfbmJfdmRjbSA9IHsKPiA+ICsJ Lm5vdGlmaWVyX2NhbGwgPSBwYXNpZF9zdGF0dXNfY2hhbmdlX3ZkY20sCj4gPiArCS5wcmlvcml0 eSAgICAgID0gSU9BU0lEX1BSSU9fREVWSUNFLAo+ID4gKyB9Owo+ID4gKwo+ID4gK0luIGJvdGgg Y2FzZXMsIG5vdGlmaWVyIGJsb2NrcyBzaGFsbCBiZSByZWdpc3RlcmVkIG9uIHRoZSBJT0FTSUQK PiA+IHNldCArc3VjaCB0aGF0ICpvbmx5KiBldmVudHMgZnJvbSB0aGUgbWF0Y2hpbmcgVk0gaXMg cmVjZWl2ZWQuCj4gPiArCj4gPiArSWYgS1ZNIGF0dGVtcHRzIHRvIHJlZ2lzdGVyIG5vdGlmaWVy IGJsb2NrIGJlZm9yZSB0aGUgSU9BU0lEIHNldCBpcwo+ID4gK2NyZWF0ZWQgZm9yIHRoZSBNTSB0 b2tlbiwgdGhlIG5vdGlmaWVyIGJsb2NrIHdpbGwgYmUgcGxhY2VkIG9uIGEKPiA+ICtwZW5kaW5n IGxpc3QgaW5zaWRlIElPQVNJRCBjb3JlLiBPbmNlIHRoZSB0b2tlbiBtYXRjaGluZyBJT0FTSUQg c2V0Cj4gPiAraXMgY3JlYXRlZCwgSU9BU0lEIHdpbGwgcmVnaXN0ZXIgdGhlIG5vdGlmaWVyIGJs b2NrIGF1dG9tYXRpY2FsbHkuCj4gPiArSU9BU0lEIGNvcmUgZG9lcyBub3QgcmVwbGF5IGV2ZW50 cyBmb3IgdGhlIGV4aXN0aW5nIElPQVNJRHMgaW4gdGhlCj4gPiArc2V0LiBGb3IgSU9BU0lEIHNl dCBvZiBNTSB0eXBlLCBub3RpZmljYXRpb24gYmxvY2tzIGNhbiBiZQo+ID4gcmVnaXN0ZXJlZCAr b24gZW1wdHkgc2V0cyBvbmx5LiBUaGlzIGlzIHRvIGF2b2lkIGxvc3QgZXZlbnRzLgo+ID4gKwo+ ID4gK0lPTU1VIGRyaXZlciBzaGFsbCByZWdpc3RlciBub3RpZmllciBibG9jayBvbiBnbG9iYWwg Y2hhaW46Ogo+ID4gKwo+ID4gKyBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBhc2lkX25i X3Z0ZCA9IHsKPiA+ICsJLm5vdGlmaWVyX2NhbGwgPSBwYXNpZF9zdGF0dXNfY2hhbmdlX3Z0ZCwK PiA+ICsJLnByaW9yaXR5ICAgICAgPSBJT0FTSURfUFJJT19JT01NVSwKPiA+ICsgfTsKPiA+ICsK PiA+ICtDdXN0b20gYWxsb2NhdG9yIEFQSXMKPiA+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ ICsKPiA+ICs6Ogo+ID4gKwo+ID4gKyBpbnQgaW9hc2lkX3JlZ2lzdGVyX2FsbG9jYXRvcihzdHJ1 Y3QgaW9hc2lkX2FsbG9jYXRvcl9vcHMKPiA+ICphbGxvY2F0b3IpOyArCj4gPiArIHZvaWQgaW9h c2lkX3VucmVnaXN0ZXJfYWxsb2NhdG9yKHN0cnVjdCBpb2FzaWRfYWxsb2NhdG9yX29wcwo+ID4g KmFsbG9jYXRvcik7ICsKPiA+ICtBbGxvY2F0b3IgQ2hvaWNlcwo+ID4gK35+fn5+fn5+fn5+fn5+ fn5+Cj4gPiArSU9BU0lEcyBhcmUgYWxsb2NhdGVkIGZvciBib3RoIGhvc3QgYW5kIGd1ZXN0IFNW QS9JT1ZBIHVzYWdlLgo+ID4gSG93ZXZlciwgK2FsbG9jYXRvcnMgY2FuIGJlIGRpZmZlcmVudC4g Rm9yIGV4YW1wbGUsIG9uIFZULWQgZ3Vlc3QKPiA+IFBBU0lEICthbGxvY2F0aW9uIG11c3QgYmUg cGVyZm9ybWVkIHZpYSBhIHZpcnR1YWwgY29tbWFuZCBpbnRlcmZhY2UKPiA+IHdoaWNoIGlzICtl bXVsYXRlZCBieSBWTU0uCj4gPiArCj4gPiArSU9BU0lEIGNvcmUgaGFzIHRoZSBub3Rpb24gb2Yg ImN1c3RvbSBhbGxvY2F0b3IiIHN1Y2ggdGhhdCBndWVzdAo+ID4gY2FuICtyZWdpc3RlciB2aXJ0 dWFsIGNvbW1hbmQgYWxsb2NhdG9yIHRoYXQgcHJlY2VkZXMgdGhlIGRlZmF1bHQKPiA+IG9uZS4g Kwo+ID4gK05hbWVzcGFjZXMKPiA+ICt+fn5+fn5+fn5+Cj4gPiArSU9BU0lEcyBhcmUgbGltaXRl ZCBzeXN0ZW0gcmVzb3VyY2VzIHRoYXQgZGVmYXVsdCB0byAyMCBiaXRzIGluCj4gPiArc2l6ZS4g U2luY2UgZWFjaCBkZXZpY2UgaGFzIGl0cyBvd24gdGFibGUsIHRoZW9yZXRpY2FsbHkgdGhlCj4g PiBuYW1lc3BhY2UgK2NhbiBiZSBwZXIgZGV2aWNlIGFsc28uIEhvd2V2ZXIsIGZvciBzZWN1cml0 eSByZWFzb25zCj4gPiBzaGFyaW5nIFBBU0lEICt0YWJsZXMgYW1vbmcgZGV2aWNlcyBhcmUgbm90 IGdvb2QgZm9yIGlzb2xhdGlvbi4KPiA+IFRoZXJlZm9yZSwgSU9BU0lEICtuYW1lc3BhY2UgaXMg c3lzdGVtLXdpZGUuICAKPiAKPiBJIGRvbid0IGZvbGxvdyB0aGlzIGRldmVsb3BtZW50LiBIYXZp bmcgcGVyLWRldmljZSBQQVNJRCB0YWJsZSB3b3VsZAo+IHdvcmsgZmluZSBmb3IgaXNvbGF0aW9u IChhc3N1bWluZyBubyBoYXJkd2FyZSBidWcgbmVjZXNzaXRhdGluZyBJT01NVQo+IGdyb3Vwcyku IElmIEkgcmVtZW1iZXIgY29ycmVjdGx5IElPQVNJRCBzcGFjZSB3YXMgY2hvc2VuIHRvIGJlCj4g T1Mtd2lkZSBiZWNhdXNlIGl0IHNpbXBsaWZpZXMgdGhlIG1hbmFnZW1lbnQgY29kZSAoc2luZ2xl IFBBU0lEIHBlcgo+IHRhc2spLCBhbmQgaXQgaXMgc3lzdGVtLXdpZGUgYWNyb3NzIFZNcyBvbmx5 IGluIHRoZSBjYXNlIG9mIFZULWQKPiBzY2FsYWJsZSBtb2RlLgo+IApZb3UgYXJlIHJpZ2h0LCBz eXN0ZW0td2lkZSBuYW1lc3BhY2UgaXMgY2hvc2VuIGZvciBzaW1wbGljaXR5IGFuZAplbnFjbWQu IEkgd2lsbCBmaXggdGhhdC4KCj4gPiArCj4gPiArVGhlcmUgYXJlIGFsc28gb3RoZXIgcmVhc29u cyB0byBoYXZlIHRoaXMgc2ltcGxlciBzeXN0ZW0td2lkZQo+ID4gK25hbWVzcGFjZS4gVGFrZSBW VC1kIGFzIGFuIGV4YW1wbGUsIFZULWQgc3VwcG9ydHMgc2hhcmVkIHdvcmtxdWV1ZQo+ID4gK2Fu ZCBFTlFDTURbMV0gd2hlcmUgb25lIElPQVNJRCBjb3VsZCBiZSB1c2VkIHRvIHN1Ym1pdCB3b3Jr IG9uICAKPiAKPiBNYXliZSB1c2UgdGhlIFNwaGlueCBnbG9zc2FyeSBzeW50YXggcmF0aGVyIHRo YW4gIlsxXSIKPiBodHRwczovL3d3dy5zcGhpbngtZG9jLm9yZy9lbi9tYXN0ZXIvdXNhZ2UvcmVz dHJ1Y3R1cmVkdGV4dC9kaXJlY3RpdmVzLmh0bWwjZ2xvc3NhcnktZGlyZWN0aXZlCj4gCkkgd2ls bCBsb29rIGludG8gdGhhdCwgdGhhbmtzIQoKPiA+ICttdWx0aXBsZSBkZXZpY2VzIHRoYXQgYXJl IHNoYXJlZCB3aXRoIG90aGVyIFZNcy4gVGhpcyByZXF1aXJlcwo+ID4gSU9BU0lEICt0byBiZSBz eXN0ZW0td2lkZS4gVGhpcyBpcyBhbHNvIHRoZSByZWFzb24gd2h5IGd1ZXN0cyBtdXN0Cj4gPiB1 c2UgYW4gK2VtdWxhdGVkIHZpcnR1YWwgY29tbWFuZCBpbnRlcmZhY2UgdG8gYWxsb2NhdGUgSU9B U0lEIGZyb20KPiA+IHRoZSBob3N0LiArCj4gPiArCj4gPiArTGlmZSBjeWNsZQo+ID4gKz09PT09 PT09PT0KPiA+ICtUaGlzIHNlY3Rpb24gY292ZXJzIElPQVNJRCBsaWZlY3ljbGUgbWFuYWdlbWVu dCBmb3IgYm90aCBiYXJlLW1ldGFsCj4gPiArYW5kIGd1ZXN0IHVzYWdlcy4gSW4gYmFyZS1tZXRh bCBTVkEsIE1NVSBub3RpZmllciBpcyBkaXJlY3RseQo+ID4gaG9va2VkICt1cCB3aXRoIElPTU1V IGRyaXZlciwgdGhlcmVmb3JlIHRoZSBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UKPiA+IChNTSkgK2xp ZmVjeWNsZSBpcyBhbGlnbmVkIHdpdGggSU9BU0lELgo+ID4gKwo+ID4gK0hvd2V2ZXIsIGd1ZXN0 IE1NVSBub3RpZmllciBpcyBub3QgYXZhaWxhYmxlIHRvIGhvc3QgSU9NTVUgZHJpdmVyLAo+ID4g K3doZW4gZ3Vlc3QgTU0gdGVybWluYXRlcyB1bmV4cGVjdGVkbHksIHRoZSBldmVudHMgaGF2ZSB0 byBnbwo+ID4gdGhyb3VnaCArVkZJTyBhbmQgSU9NTVUgVUFQSSB0byByZWFjaCBob3N0IElPTU1V IGRyaXZlci4gVGhlcmUgYXJlCj4gPiBhbHNvIG1vcmUgK3BhcnRpZXMgaW52b2x2ZWQgaW4gZ3Vl c3QgU1ZBLCBlLmcuIG9uIEludGVsIFZULWQKPiA+IHBsYXRmb3JtLCBJT0FTSURzICthcmUgdXNl ZCBieSBJT01NVSBkcml2ZXIsIEtWTSwgVkRDTSwgYW5kIFZGSU8uCj4gPiArCj4gPiArTmF0aXZl IElPQVNJRCBMaWZlIEN5Y2xlIChWVC1kIEV4YW1wbGUpCj4gPiArLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiArCj4gPiArVGhlIG5vcm1hbCBmbG93IG9mIG5hdGl2 ZSBTVkEgY29kZSB3aXRoIEludGVsIERhdGEgU3RyZWFtaW5nCj4gPiArQWNjZWxlcmF0b3IoRFNB KSBbMl0gYXMgZXhhbXBsZToKPiA+ICsKPiA+ICsxLiBIb3N0IHVzZXIgb3BlbnMgYWNjZWxlcmF0 b3IgRkQsIGUuZy4gRFNBIGRyaXZlciwgb3IgdWFjY2U7Cj4gPiArMi4gRFNBIGRyaXZlciBhbGxv Y2F0ZSBXUSwgZG8gc3ZhX2JpbmRfZGV2aWNlKCk7Cj4gPiArMy4gSU9NTVUgZHJpdmVyIGNhbGxz IGlvYXNpZF9hbGxvYygpLCB0aGVuIGJpbmQgUEFTSUQgd2l0aCBkZXZpY2UsCj4gPiArICAgbW11 X25vdGlmaWVyX2dldCgpCj4gPiArNC4gRE1BIHN0YXJ0cyBieSBEU0EgZHJpdmVyIHVzZXJzcGFj ZQo+ID4gKzUuIERTQSB1c2Vyc3BhY2UgY2xvc2UgRkQKPiA+ICs2LiBEU0EvdWFjY2Uga2VybmVs IGRyaXZlciBoYW5kbGVzIEZELmNsb3NlKCkKPiA+ICs3LiBEU0EgZHJpdmVyIHN0b3BzIERNQQo+ ID4gKzguIERTQSBkcml2ZXIgY2FsbHMgc3ZhX3VuYmluZF9kZXZpY2UoKTsKPiA+ICs5LiBJT01N VSBkcml2ZXIgZG9lcyB1bmJpbmQsIGNsZWFycyBQQVNJRCBjb250ZXh0IGluIElPTU1VLCBmbHVz aAo+ID4gKyAgIFRMQnMuIG1tdV9ub3RpZmllcl9wdXQoKSBjYWxsZWQuCj4gPiArMTAuIG1tdV9u b3RpZmllci5yZWxlYXNlKCkgY2FsbGVkLCBJT01NVSBTVkEgY29kZSBjYWxscwo+ID4gaW9hc2lk X2ZyZWUoKSogKzExLiBUaGUgSU9BU0lEIGlzIHJldHVybmVkIHRvIHRoZSBwb29sLCByZWNsYWlt ZWQuCj4gPiArCj4gPiArOjoKPiA+ICsgIAo+IAo+IFVzZSBhIGZvb3Rub3RlPwo+IGh0dHBzOi8v d3d3LnNwaGlueC1kb2Mub3JnL2VuL21hc3Rlci91c2FnZS9yZXN0cnVjdHVyZWR0ZXh0L2Jhc2lj cy5odG1sI2Zvb3Rub3Rlcwo+IApkaXR0bwoKPiA+ICsgICAqIFdpdGggRU5RQ01ELCBQQVNJRCB1 c2VkIG9uIFZULWQgaXMgbm90IHJlbGVhc2VkIGluCj4gPiBtbXVfbm90aWZpZXIoKSBidXQKPiA+ ICsgICAgIG1tZHJvcCgpLiBtbWRyb3AgY29tZXMgYWZ0ZXIgRkQgY2xvc2UuIFNob3VsZCBub3Qg bWF0dGVyLiAgCj4gCj4gImNvbWVzIGFmdGVyIEZEIGNsb3NlLCB3aGljaCBkb2Vzbid0IG1ha2Ug YSBkaWZmZXJlbmNlPyIKPiBUaGUgZm9sbG93aW5nIG1pZ2h0IG5vdCBiZSBuZWNlc3Nhcnkgc2lu Y2UgZWFybHkgcHJvY2VzcyB0ZXJtaW5hdGlvbgo+IGlzIGRlc2NyaWJlZCBsYXRlci4KPiAKeWVz LCBpdCBpcyByZWR1bmRhbnQuIEkgd2lsbCByZW1vdmUgaXQuCgo+ID4gKyAgICAgSWYgdGhlIHVz ZXIgcHJvY2VzcyBkaWVzIHVuZXhwZWN0ZWRseSwgU3RlcCAjMTAgbWF5IGNvbWUKPiA+IGJlZm9y ZQo+ID4gKyAgICAgU3RlcCAjNSwgaW4gYmV0d2VlbiwgYWxsIERNQSBmYXVsdHMgZGlzY2FyZGVk LiBQUlEgcmVzcG9uZGVkCj4gPiB3aXRoICAKPiAKPiBQUlEgaGFzbid0IGJlZW4gZGVmaW5lZCBp biB0aGlzIGRvY3VtZW50Lgo+IAp3aWxsIHJlbW92ZQoKPiA+ICsgICAgIGNvZGUgSU5WQUxJRCBS RVFVRVNULgo+ID4gKwo+ID4gK0R1cmluZyB0aGUgbm9ybWFsIHRlYXJkb3duLCB0aGUgZm9sbG93 aW5nIHRocmVlIHN0ZXBzIHdvdWxkIGhhcHBlbgo+ID4gaW4gK29yZGVyOgo+ID4gKwo+ID4gKzEu IERldmljZSBkcml2ZXIgc3RvcHMgRE1BIHJlcXVlc3QKPiA+ICsyLiBJT01NVSBkcml2ZXIgdW5i aW5kcyBQQVNJRCBhbmQgbW0sIGZsdXNoIGFsbCBUTEJzLCBkcmFpbgo+ID4gaW4tZmxpZ2h0Cj4g PiArICAgcmVxdWVzdHMuCj4gPiArMy4gSU9BU0lEIGZyZWVkCj4gPiArCj4gPiArRXhjZXB0aW9u IGhhcHBlbnMgd2hlbiBwcm9jZXNzIHRlcm1pbmF0ZXMgKmJlZm9yZSogZGV2aWNlIGRyaXZlcgo+ ID4gc3RvcHMgK0RNQSBhbmQgY2FsbCBJT01NVSBkcml2ZXIgdG8gdW5iaW5kLiBUaGUgZmxvdyBv ZiBwcm9jZXNzCj4gPiBleGlzdHMgYXJlIGFzICAKPiAKPiAiZXhpdHMiCj4gCndpbGwgZml4Cgo+ ID4gK2ZvbGxvd3M6Cj4gPiArCj4gPiArOjoKPiA+ICsKPiA+ICsgICBkb19leGl0KCkgewo+ID4g KwlleGl0X21tKCkgewo+ID4gKwkJbW1fcHV0KCk7Cj4gPiArCQlleGl0X21tYXAoKSB7Cj4gPiAr CQkJaW50ZWxfaW52YWxpZGF0ZV9yYW5nZSgpIC8vbW11IG5vdGlmaWVyCj4gPiArCQkJdGxiX2Zp bmlzaF9tbXUoKQo+ID4gKwkJCW1tdV9ub3RpZmllcl9yZWxlYXNlKG1tKSB7Cj4gPiArCQkJCWlu dGVsX2lvbW11X3JlbGVhc2UoKSB7Cj4gPiArICAgWzJdCj4gPiBpbnRlbF9pb21tdV90ZWFyZG93 bl9wYXNpZCgpOyAgCj4gCj4gUGFyZW50aGVzZXMgbWlnaHQgYmUgYmV0dGVyIHRoYW4gc3F1YXJl IGJyYWNrZXRzIGZvciBzdGVwIG51bWJlcnMKPiAKeWVzLCBpdCBnZXRzIGhpZ2hsaWdodCBhcyB3 ZWxsLiB0aGFua3MhCgo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBpbnRlbF9pb21tdV9mbHVzaF90bGJzKCk7Cj4gPiArCQkJCX0KPiA+ICsJCQkJLy8gdGxiX2lu dmFsaWRhdGVfcmFuZ2UgY2IgcmVtb3ZlZAo+ID4gKwkJCX0KPiA+ICsJCQl1bm1hcF92bWFzKCk7 Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgZnJlZV9wZ3RhYmxlcygpOyAvLyBJT01NVSBj YW5ub3Qgd2FsayBQR1QKPiA+IGFmdGVyIHRoaXMKPiA+ICsJCX07Cj4gPiArCX0KPiA+ICsJZXhp dF9maWxlcyh0c2spIHsKPiA+ICsJCWNsb3NlX2ZpbGVzKCkgewo+ID4gKwkJCWRzYV9jbG9zZSgp Owo+ID4gKyAgIFsxXQkJCWRzYV9zdG9wX2RtYSgpOwo+ID4gKyAgICAgICAgICAgICAgICAgICAg ICAgIGludGVsX3N2bV91bmJpbmRfcGFzaWQoKTsgLy9ub3RoaW5nIHRvIGRvCj4gPiArCQl9Cj4g PiArCX0KPiA+ICsgICB9Cj4gPiArCj4gPiArICAgbW1kcm9wKCkgLyogc29tZSByYW5kb20gdGlt ZSBsYXRlciwgbGF6eSBtbSB1c2VyICovIHsKPiA+ICsgICAJbW1fZnJlZV9wZ2QoKTsKPiA+ICsg ICAgICAgIGRlc3Ryb3lfY29udGV4dChtbSk7IHsKPiA+ICsgICBbM10JICAgICAgICBpb2FzaWRf ZnJlZSgpOwo+ID4gKwl9Cj4gPiArICAgfQo+ID4gKwo+ID4gK0FzIHNob3duIGluIHRoZSBsaXN0 IGFib3ZlLCBzdGVwICMyIGNvdWxkIGhhcHBlbiBiZWZvcmUKPiA+ICsjMS4gVW5yZWNvdmVyYWJs ZShVUikgZmF1bHRzIGNvdWxkIGhhcHBlbiBiZXR3ZWVuICMyIGFuZCAjMS4KPiA+ICsKPiA+ICtB bHNvIG5vdGljZSB0aGF0IFRMQiBpbnZhbGlkYXRpb24gb2NjdXJzIGF0IG1tdV9ub3RpZmllcgo+ ID4gK2ludmFsaWRhdGVfcmFuZ2UgY2FsbGJhY2sgYXMgd2VsbCBhcyB0aGUgcmVsZWFzZSBjYWxs YmFjay4gVGhlCj4gPiByZWFzb24gK2lzIHRoYXQgcmVsZWFzZSBjYWxsYmFjayB3aWxsIGRlbGV0 ZSBJT01NVSBkcml2ZXIgZnJvbSB0aGUKPiA+IG5vdGlmaWVyICtjaGFpbiB3aGljaCBtYXkgc2tp cCBpbnZhbGlkYXRlX3JhbmdlKCkgY2FsbHMgZHVyaW5nIHRoZQo+ID4gZXhpdCBwYXRoLiArCj4g PiArVG8gYXZvaWQgdW5uZWNlc3NhcnkgcmVwb3J0aW5nIG9mIFVSIGZhdWx0LCBJT01NVSBkcml2 ZXIgc2hhbGwKPiA+IGRpc2FibGUgK2ZhdWx0IHJlcG9ydGluZyBhZnRlciBmcmVlIGFuZCBiZWZv cmUgdW5iaW5kLgo+ID4gKwo+ID4gK0d1ZXN0IElPQVNJRCBMaWZlIEN5Y2xlIChWVC1kIEV4YW1w bGUpCj4gPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICtHdWVz dCBJT0FTSUQgbGlmZSBjeWNsZSBzdGFydHMgd2l0aCBndWVzdCBkcml2ZXIgb3BlbigpLCB0aGlz Cj4gPiBjb3VsZCBiZSArdWFjY2Ugb3IgaW5kaXZpZHVhbCBhY2NlbGVyYXRvciBkcml2ZXIgc3Vj aCBhcyBEU0EuIEF0IEZECj4gPiBvcGVuLCArc3ZhX2JpbmRfZGV2aWNlKCkgaXMgY2FsbGVkIHdo aWNoIHRyaWdnZXJzIGEgc2VyaWVzIG9mCj4gPiBhY3Rpb25zLiArCj4gPiArVGhlIGV4YW1wbGUg YmVsb3cgaXMgYW4gaWxsdXN0cmF0aW9uIG9mICpub3JtYWwqIG9wZXJhdGlvbnMgdGhhdAo+ID4g K2ludm9sdmVzICphbGwqIHRoZSBTVyBjb21wb25lbnRzIGluIFZULWQuIFRoZSBmbG93IGNhbiBi ZSBzaW1wbGVyCj4gPiBpZiArbm8gRU5RQ01EIGlzIHN1cHBvcnRlZC4KPiA+ICsKPiA+ICs6Ogo+ ID4gKwo+ID4gKyAgICAgVkZJTyAgICAgICAgSU9NTVUgICAgICAgIEtWTSAgICAgICAgVkRDTSAg ICAgICAgSU9BU0lECj4gPiBSZWYKPiA+ICsgICAuLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4KPiA+ICsgICAxICAgICAgICAg ICAgIGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllci9fbW0oKQo+ID4gKyAgIDIgaW9hc2lkX2FsbG9j KCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEKPiA+ICsg ICAzIGJpbmRfZ3Bhc2lkKCkKPiA+ICsgICA0ICAgICAgICAgICAgIGlvbW11X2JpbmQoKS0+aW9h c2lkX2dldCgpICAgICAgICAgICAgICAgICAgICAgICAyCj4gPiArICAgNSAgICAgICAgICAgICBp b2FzaWRfbm90aWZ5KEJJTkQpCj4gPiArICAgNiAgICAgICAgICAgICAgICAgICAgICAgICAgLT4g aW9hc2lkX2dldCgpICAgICAgICAgICAgICAgICAgICAgMwo+ID4gKyAgIDcgICAgICAgICAgICAg ICAgICAgICAgICAgIC0+IHZtY3NfdXBkYXRlX2F0b21pYygpCj4gPiArICAgOCBtZGV2X3dyaXRl KGdwYXNpZCkKPiA+ICsgICA5ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaHBh c2lkPQo+ID4gKyAgIDEwICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmaW5kX2J5 X3NwaWQoZ3Bhc2lkKSAgICAgIDQKPiA+ICsgICAxMSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdmRldl93cml0ZShocGFzaWQpCj4gPiArICAgMTIgLS0tLS0tLS0gR1VFU1QgU1RB UlRTIERNQSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKyAgIDEzIC0tLS0tLS0tIEdV RVNUIFNUT1BTIERNQSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKyAgIDE0IG1kZXZf Y2xlYXIoZ3Bhc2lkKQo+ID4gKyAgIDE1ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB2ZGV2X2NsZWFyKGhwYXNpZCkKPiA+ICsgICAxNiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgaW9hc2lkX3B1dCgpCj4gPiAzCj4gPiArICAgMTcgdW5iaW5kX2dwYXNpZCgpCj4g PiArICAgMTggICAgICAgICAgICBpb21tdV91YmluZCgpCj4gPiArICAgMTkgICAgICAgICAgICBp b2FzaWRfbm90aWZ5KFVOQklORCkKPiA+ICsgICAyMCAgICAgICAgICAgICAgICAgICAgICAgICAg LT4gdm1jc191cGRhdGVfYXRvbWljKCkKPiA+ICsgICAyMSAgICAgICAgICAgICAgICAgICAgICAg ICAgLT4gaW9hc2lkX3B1dCgpCj4gPiAyCj4gPiArICAgMjIgaW9hc2lkX2ZyZWUoKQo+ID4gMQo+ ID4gKyAgIDIzICAgICAgICAgICAgaW9hc2lkX3B1dCgpCj4gPiAwCj4gPiArICAgMjQgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVjbGFpbWVkCj4gPiAr ICAgLS0tLS0tLS0tLS0tLS0gTmV3IExpZmUgQ3ljbGUgQmVnaW4gLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQo+ID4gKyAgIDEgIGlvYXNpZF9hbGxvYygpICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIC0+Cj4gPiAxICsKPiA+ICsgICBOb3RlOiBJT0FTSUQgTm90aWZpY2F0aW9u IEV2ZW50czogRlJFRSwgQklORCwgVU5CSU5ECj4gPiArCj4gPiArRXhjZXB0aW9uIGNhc2VzIGFy aXNlIHdoZW4gYSBndWVzdCBjcmFzaGVzIG9yIGEgbWFsaWNpb3VzIGd1ZXN0Cj4gPiArYXR0ZW1w dHMgdG8gY2F1c2UgZGlzcnVwdGlvbiBvbiB0aGUgaG9zdCBzeXN0ZW0uIFRoZSBmYXVsdCBoYW5k bGluZwo+ID4gK3J1bGVzIGFyZToKPiA+ICsKPiA+ICsxLiBJT0FTSUQgZnJlZSBtdXN0ICphbHdh eXMqIHN1Y2NlZWQuCj4gPiArMi4gQW4gaW5hY3RpdmUgcGVyaW9kIG1heSBiZSByZXF1aXJlZCBi ZWZvcmUgdGhlIGZyZWVkIElPQVNJRCBpcwo+ID4gKyAgIHJlY2xhaW1lZC4gRHVyaW5nIHRoaXMg cGVyaW9kLCBjb25zdW1lcnMgb2YgSU9BU0lEIHBlcmZvcm0KPiA+IGNsZWFudXAuICszLiBNYWxm dW5jdGlvbiBpcyBsaW1pdGVkIHRvIHRoZSBndWVzdCBvd25lZCByZXNvdXJjZXMKPiA+IGZvciBh bGwKPiA+ICsgICBwcm9ncmFtbWluZyBlcnJvcnMuCj4gPiArCj4gPiArVGhlIHByaW1hcnkgc291 cmNlIG9mIGV4Y2VwdGlvbiBpcyB3aGVuIHRoZSBmb2xsb3dpbmcgYXJlIG91dCBvZgo+ID4gK29y ZGVyOgo+ID4gKwo+ID4gKzEuIFN0YXJ0L1N0b3Agb2YgRE1BIGFjdGl2aXR5Cj4gPiArICAgKEd1 ZXN0IGRldmljZSBkcml2ZXIsIG1kZXYgdmlhIFZGSU8pCj4gPiArMi4gU2V0dXAvVGVhcmRvd24g b2YgSU9NTVUgUEFTSUQgY29udGV4dCwgSU9UTEIsIERldlRMQiBmbHVzaGVzCj4gPiArICAgKEhv c3QgSU9NTVUgZHJpdmVyIGJpbmQvdW5iaW5kKQo+ID4gKzMuIFNldHVwL1RlYXJkb3duIG9mIFZN Q1MgUEFTSUQgdHJhbnNsYXRpb24gdGFibGUgZW50cmllcyAoS1ZNKSBpbgo+ID4gKyAgIGNhc2Ug b2YgRU5RQ01ECj4gPiArNC4gUHJvZ3JhbW1pbmcvQ2xlYXJpbmcgaG9zdCBQQVNJRCBpbiBWRENN IChIb3N0IFZEQ00gZHJpdmVyKQo+ID4gKzUuIElPQVNJRCBhbGxvYy9mcmVlIChIb3N0IElPQVNJ RCkKPiA+ICsKPiA+ICtWRklPIGlzIHRoZSAqb25seSogdXNlci1rZXJuZWwgaW50ZXJmYWNlLCB3 aGljaCBpcyB1bHRpbWF0ZWx5Cj4gPiArcmVzcG9uc2libGUgZm9yIGV4Y2VwdGlvbiBoYW5kbGlu Z3MuICAKPiAKPiAiaGFuZGxpbmciCj4gCmdvdCBpdAoKPiA+ICsKPiA+ICsjMSBpcyBwcm9jZXNz ZWQgdGhlIHNhbWUgd2F5IGFzIHRoZSBhc3NpZ25lZCBkZXZpY2UgdG9kYXkgYmFzZWQgb24KPiA+ ICtkZXZpY2UgZmlsZSBkZXNjcmlwdG9ycyBhbmQgZXZlbnRzLiBUaGVyZSBpcyBubyBzcGVjaWFs IGhhbmRsaW5nLgo+ID4gKwo+ID4gKyMzIGlzIGJhc2VkIG9uIGJpbmQvdW5iaW5kIGV2ZW50cyBl bWl0dGVkIGJ5ICMyLgo+ID4gKwo+ID4gKyM0IGlzIG5hdHVyYWxseSBhbGlnbmVkIHdpdGggSU9B U0lEIGxpZmUgY3ljbGUgaW4gdGhhdCBhbiBpbGxlZ2FsCj4gPiArZ3Vlc3QgUEFTSUQgcHJvZ3Jh bW1pbmcgd291bGQgZmFpbCBpbiBvYnRhaW5pbmcgcmVmZXJlbmNlIG9mIHRoZQo+ID4gK21hdGNo aW5nIGhvc3QgSU9BU0lELgo+ID4gKwo+ID4gKyM1IGlzIHNpbWlsYXIgdG8gIzQuIFRoZSBmYXVs dCB3aWxsIGJlIHJlcG9ydGVkIHRvIHRoZSB1c2VyIGlmCj4gPiBQQVNJRCArdXNlZCBpbiB0aGUg RU5RQ01EIGlzIG5vdCBzZXQgdXAgaW4gVk1DUyBQQVNJRCB0cmFuc2xhdGlvbgo+ID4gdGFibGUu ICsKPiA+ICtUaGVyZWZvcmUsIHRoZSByZW1haW5pbmcgb3V0IG9mIG9yZGVyIHByb2JsZW0gaXMg YmV0d2VlbiAjMiBhbmQKPiA+ICsjNS4gSS5lLiB1bmJpbmQgdnMuIGZyZWUuIE1vcmUgc3BlY2lm aWNhbGx5LCBmcmVlIGJlZm9yZSB1bmJpbmQuCj4gPiArCj4gPiArSU9BU0lEIG5vdGlmaWVyIGFu ZCByZWZjb3VudGluZyBhcmUgdXNlZCB0byBlbnN1cmUgb3JkZXIuIEZvbGxvd2luZwo+ID4gK2Eg cHVibGlzaGVyLXN1YnNjcmliZXIgcGF0dGVybiB3aGVyZToKPiA+ICsKPiA+ICstIFB1Ymxpc2hl cnM6IFZGSU8gJiBJT01NVQo+ID4gKy0gU3Vic2NyaWJlcnM6IEtWTSwgVkRDTSwgSU9NTVUKPiA+ ICsKPiA+ICtJT0FTSUQgbm90aWZpZXIgaXMgYXRvbWljIHdoaWNoIHJlcXVpcmVzIHN1YnNjcmli ZXJzIHRvIGRvIHF1aWNrCj4gPiAraGFuZGxpbmcgb2YgdGhlIGV2ZW50IGluIHRoZSBhdG9taWMg Y29udGV4dC4gV29ya3F1ZXVlIGNhbiBiZSB1c2VkCj4gPiBmb3IgK2FueSBwcm9jZXNzaW5nIHRo YXQgcmVxdWlyZXMgdGhyZWFkIGNvbnRleHQuIElPQVNJRCByZWZlcmVuY2UKPiA+IG11c3QgYmUg K2FjcXVpcmVkIGJlZm9yZSByZWNlaXZpbmcgdGhlIEZSRUUgZXZlbnQuIFRoZSByZWZlcmVuY2UK PiA+IG11c3QgYmUgK2Ryb3BwZWQgYXQgdGhlIGVuZCBvZiB0aGUgcHJvY2Vzc2luZyBpbiBvcmRl ciB0byByZXR1cm4KPiA+IHRoZSBJT0FTSUQgdG8gK3RoZSBwb29sLgo+ID4gKwo+ID4gK0xldCdz IGV4YW1pbmUgdGhlIElPQVNJRCBsaWZlIGN5Y2xlIGFnYWluIHdoZW4gZnJlZSBoYXBwZW5zCj4g PiAqYmVmb3JlKiArdW5iaW5kLiBUaGlzIGNvdWxkIGJlIGEgcmVzdWx0IG9mIG1pc2JlaGF2aW5n IGd1ZXN0cyBvcgo+ID4gY3Jhc2guIEFzc3VtaW5nICtWRklPIGNhbm5vdCBlbmZvcmNlIHVuYmlu ZC0+ZnJlZSBvcmRlci4gTm90aWNlCj4gPiB0aGF0IHRoZSBzZXR1cCBwYXJ0IHVwICt1bnRpbCBz dGVwICMxMiBpcyBpZGVudGljYWwgdG8gdGhlIG5vcm1hbAo+ID4gY2FzZSwgdGhlIGZsb3cgYmVs b3cgc3RhcnRzICt3aXRoIHN0ZXAgMTMuCj4gPiArCj4gPiArOjoKPiA+ICsKPiA+ICsgICAgIFZG SU8gICAgICAgIElPTU1VICAgICAgICBLVk0gICAgICAgIFZEQ00gICAgICAgIElPQVNJRAo+ID4g UmVmCj4gPiArICAgLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uCj4gPiArICAgMTMgLS0tLS0tLS0gR1VFU1QgU1RBUlRTIERN QSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKyAgIDE0IC0tLS0tLS0tICpHVUVTVCBN SVNCRUhBVkVTISEhKiAtLS0tLS0tLS0tLS0tLS0tCj4gPiArICAgMTUgaW9hc2lkX2ZyZWUoKQo+ ID4gKyAgIDE2Cj4gPiBpb2FzaWRfbm90aWZ5KEZSRUUpCj4gPiArICAgMTcKPiA+IG1hcmtfaW9h c2lkX2luYWN0aXZlWzFdCj4gPiArICAgMTggICAgICAgICAgICAgICAgICAgICAgICAgIGt2bV9u Yl9oYW5kbGVyKEZSRUUpCj4gPiArICAgMTkgICAgICAgICAgICAgICAgICAgICAgICAgIHZtY3Nf dXBkYXRlX2F0b21pYygpCj4gPiArICAgMjAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNp ZF9wdXRfbG9ja2VkKCkgICAtPiAgICAgICAgICAgMwo+ID4gKyAgIDIxICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB2ZGNtX25iX2hhbmRsZXIoRlJFRSkKPiA+ICsgICAyMiAgICAg ICAgICAgIGlvbW1fbmJfaGFuZGxlcihGUkVFKQo+ID4gKyAgIDIzIGlvYXNpZF9mcmVlKCkgcmV0 dXJuc1syXSAgICAgICAgICBzY2hlZHVsZV93b3JrKCkgICAgICAgICAgIDIKPiA+ICsgICAyNCAg ICAgICAgICAgIHNjaGVkdWxlX3dvcmsoKSAgICAgICAgdmRldl9jbGVhcl93ayhocGFzaWQpCj4g PiArICAgMjUgICAgICAgICAgICB0ZWFyZG93bl9wYXNpZF93aygpCj4gPiArICAgMjYgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNpZF9wdXQoKSAtPiAgICAgICAgICAgMQo+ ID4gKyAgIDI3ICAgICAgICAgICAgaW9hc2lkX3B1dCgpICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDAKPiA+ICsgICAyOCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBSZWNsYWltZWQKPiA+ICsgICAyOSB1bmJpbmRfZ3Bhc2lkKCkKPiA+ ICsgICAzMCAgICAgICAgICAgIGlvbW11X3VuYmluZCgpLT5pb2FzaWRfZmluZCgpIEZhaWxzWzNd Cj4gPiArICAgLS0tLS0tLS0tLS0tLS0gTmV3IExpZmUgQ3ljbGUgQmVnaW4gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQo+ID4gKwo+ID4gK05vdGU6Cj4gPiArCj4gPiArMS4gQnkgbWFya2lu ZyBJT0FTSUQgaW5hY3RpdmUgYXQgc3RlcCAjMTcsIG5vIG5ldyByZWZlcmVuY2VzIGNhbgo+ID4g YmUgIAo+IAo+IElzICJpbmFjdGl2ZSIgRlJFRV9QRU5ESU5HPwo+IAp5ZXMsIHdpbGwgZml4LgoK PiA+ICsgICBoZWxkLiBpb2FzaWRfZ2V0L2ZpbmQoKSB3aWxsIHJldHVybiAtRU5PRU5UOwo+ID4g KzIuIEFmdGVyIHN0ZXAgIzIzLCBhbGwgZXZlbnRzIGNhbiBnbyBvdXQgb2Ygb3JkZXIuIFNoYWxs IG5vdCBhZmZlY3QKPiA+ICsgICB0aGUgb3V0Y29tZS4KPiA+ICszLiBJT01NVSBkcml2ZXIgZmFp bHMgdG8gZmluZCBwcml2YXRlIGRhdGEgZm9yIHVuYmluZGluZy4gSWYKPiA+IHVuYmluZCBpcwo+ ID4gKyAgIGNhbGxlZCBhZnRlciB0aGUgc2FtZSBJT0FTSUQgaXMgYWxsb2NhdGVkIGZvciB0aGUg c2FtZSBndWVzdAo+ID4gYWdhaW4sCj4gPiArICAgdGhpcyBpcyBhIHByb2dyYW1taW5nIGVycm9y LiBUaGUgZGFtYWdlIGlzIGxpbWl0ZWQgdG8gdGhlIGd1ZXN0Cj4gPiArICAgaXRzZWxmIHNpbmNl IHVuYmluZCBwZXJmb3JtcyBwZXJtaXNzaW9uIGNoZWNraW5nIGJhc2VkIG9uIHRoZQo+ID4gKyAg IElPQVNJRCBzZXQgYXNzb2NpYXRlZCB3aXRoIHRoZSBndWVzdCBwcm9jZXNzLgo+ID4gKwo+ID4g K0tWTSBQQVNJRCBUcmFuc2xhdGlvbiBUYWJsZSBVcGRhdGVzCj4gPiArfn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn4KPiA+ICtQZXIgVk0gUEFTSUQgdHJhbnNsYXRpb24gdGFibGUg aXMgbWFpbnRhaW5lZCBieSBLVk0gaW4gb3JkZXIgdG8KPiA+ICtzdXBwb3J0IEVOUUNNRCBpbiB0 aGUgZ3Vlc3QuIFRoZSB0YWJsZSBjb250YWlucyBob3N0LWd1ZXN0IFBBU0lECj4gPiArdHJhbnNs YXRpb25zIHRvIGJlIGNvbnN1bWVkIGJ5IENQVSB1Y29kZS4gVGhlIHN5bmNocm9uaXphdGlvbiBv Zgo+ID4gdGhlICtQQVNJRCBzdGF0ZXMgZGVwZW5kcyBvbiBWRklPL0lPTU1VIGRyaXZlciwgd2hl cmUgSU9DVEwgYW5kCj4gPiBhdG9taWMgK25vdGlmaWVycyBhcmUgdXNlZC4gS1ZNIG11c3QgcmVn aXN0ZXIgSU9BU0lEIG5vdGlmaWVyIHBlcgo+ID4gVk0gaW5zdGFuY2UgK2R1cmluZyBsYXVuY2gg dGltZS4gVGhlIGZvbGxvd2luZyBldmVudHMgYXJlIGhhbmRsZWQ6Cj4gPiArCj4gPiArMS4gQklO RC9VTkJJTkQKPiA+ICsyLiBGUkVFCj4gPiArCj4gPiArUnVsZXM6Cj4gPiArCj4gPiArMS4gTXVs dGlwbGUgZGV2aWNlcyBjYW4gYmluZCB3aXRoIHRoZSBzYW1lIFBBU0lELCB0aGlzIGNhbiBiZQo+ ID4gZGlmZmVyZW50IFBDSQo+ID4gKyAgIGRldmljZXMgb3IgbWRldnMgd2l0aGluIHRoZSBzYW1l IFBDSSBkZXZpY2UuIEhvd2V2ZXIsIG9ubHkgdGhlCj4gPiArICAgKmZpcnN0KiBCSU5EIGFuZCAq bGFzdCogVU5CSU5EIGVtaXQgbm90aWZpY2F0aW9ucy4KPiA+ICsyLiBJT0FTSUQgY29kZSBpcyBy ZXNwb25zaWJsZSBmb3IgZW5zdXJpbmcgdGhlIGNvcnJlY3RuZXNzIG9mIEgtRwo+ID4gKyAgIFBB U0lEIG1hcHBpbmcuIFRoZXJlIGlzIG5vIG5lZWQgZm9yIEtWTSB0byB2YWxpZGF0ZSB0aGUKPiA+ ICsgICBub3RpZmljYXRpb24gZGF0YS4KPiA+ICszLiBXaGVuIFVOQklORCBoYXBwZW5zICphZnRl ciogRlJFRSwgS1ZNIHdpbGwgc2VlIGVycm9yIGluCj4gPiArICAgaW9hc2lkX2dldCgpIGV2ZW4g d2hlbiB0aGUgcmVjbGFpbSBpcyBub3QgZG9uZS4gSU9NTVUgZHJpdmVyCj4gPiB3aWxsCj4gPiAr ICAgYWxzbyBhdm9pZCBzZW5kaW5nIFVOQklORCBpZiB0aGUgUEFTSUQgaXMgYWxyZWFkeSBGUkVF Lgo+ID4gKzQuIFdoZW4gS1ZNIHRlcm1pbmF0ZXMgKmJlZm9yZSogRlJFRSAmIFVOQklORCwgcmVm ZXJlbmNlcyB3aWxsIGJlCj4gPiArICAgZHJvcHBlZCBmb3IgYWxsIGhvc3QgUEFTSURzLgo+ID4g Kwo+ID4gK1ZEQ00gUEFTSUQgUHJvZ3JhbW1pbmcKPiA+ICt+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ Cj4gPiArVkRDTSBjb21wb3NlcyB2aXJ0dWFsIGRldmljZXMgYW5kIGV4cG9zZXMgdGhlbSB0byB0 aGUgZ3Vlc3RzLiBXaGVuCj4gPiArdGhlIGd1ZXN0IGFsbG9jYXRlcyBhIFBBU0lEIHRoZW4gcHJv Z3JhbSBpdCB0byB0aGUgdmlydHVhbCBkZXZpY2UsCj4gPiBWRENNICtpbnRlcmNlcHRzIHRoZSBw cm9ncmFtbWluZyBhdHRlbXB0IHRoZW4gcHJvZ3JhbSB0aGUgbWF0Y2hpbmcKPiA+IGhvc3QgIAo+ IAo+ICJwcm9ncmFtcyIKPiAKPiBUaGFua3MsCj4gSmVhbgo+IAo+ID4gK1BBU0lEIG9uIHRvIHRo ZSBoYXJkd2FyZS4KPiA+ICtDb252ZXJzZWx5LCB3aGVuIGEgZGV2aWNlIGlzIGdvaW5nIGF3YXks IFZEQ00gbXVzdCBiZSBpbmZvcm1lZCBzdWNoCj4gPiArdGhhdCBQQVNJRCBjb250ZXh0IG9uIHRo ZSBoYXJkd2FyZSBjYW4gYmUgY2xlYXJlZC4gVGhlcmUgY291bGQgYmUKPiA+ICttdWx0aXBsZSBt ZGV2cyBhc3NpZ25lZCB0byBkaWZmZXJlbnQgZ3Vlc3RzIGluIHRoZSBzYW1lIFZEQ00uIFNpbmNl Cj4gPiArdGhlIFBBU0lEIHRhYmxlIGlzIHNoYXJlZCBhdCBQQ0kgZGV2aWNlIGxldmVsLCBsYXp5 IGNsZWFyaW5nIGlzIG5vdAo+ID4gK3NlY3VyZS4gQSBtYWxpY2lvdXMgZ3Vlc3QgY2FuIGF0dGFj ayBieSB1c2luZyBuZXdseSBmcmVlZCBQQVNJRHMKPiA+IHRoYXQgK2FyZSBhbGxvY2F0ZWQgYnkg YW5vdGhlciBndWVzdC4KPiA+ICsKPiA+ICtCeSBob2xkaW5nIGEgcmVmZXJlbmNlIG9mIHRoZSBQ QVNJRCB1bnRpbCBWRENNIGNsZWFucyB1cCB0aGUgSFcKPiA+IGNvbnRleHQsICtpdCBpcyBndWFy YW50ZWVkIHRoYXQgUEFTSUQgbGlmZSBjeWNsZXMgZG8gbm90IGNyb3NzCj4gPiB3aXRoaW4gdGhl IHNhbWUgK2RldmljZS4KPiA+ICsKPiA+ICsKPiA+ICtSZWZlcmVuY2UKPiA+ICs9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Cj4gPiArMS4KPiA+IGh0 dHBzOi8vc29mdHdhcmUuaW50ZWwuY29tL3NpdGVzL2RlZmF1bHQvZmlsZXMvbWFuYWdlZC9jNS8x NS9hcmNoaXRlY3R1cmUtaW5zdHJ1Y3Rpb24tc2V0LWV4dGVuc2lvbnMtcHJvZ3JhbW1pbmctcmVm ZXJlbmNlLnBkZgo+ID4gKyArMi4KPiA+IGh0dHBzOi8vMDEub3JnL2Jsb2dzLzIwMTkvaW50cm9k dWNpbmctaW50ZWwtZGF0YS1zdHJlYW1pbmctYWNjZWxlcmF0b3IKPiA+ICsgKzMuCj4gPiBodHRw czovL3NvZnR3YXJlLmludGVsLmNvbS9lbi11cy9kb3dubG9hZC9pbnRlbC1kYXRhLXN0cmVhbWlu Zy1hY2NlbGVyYXRvci1wcmVsaW1pbmFyeS1hcmNoaXRlY3R1cmUtc3BlY2lmaWNhdGlvbgo+ID4g LS0gMi43LjQKPiA+ICAgCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KPiBpb21tdSBtYWlsaW5nIGxpc3QKPiBpb21tdUBsaXN0cy5saW51eC1mb3VuZGF0 aW9uLm9yZwo+IGh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2lvbW11CltKYWNvYiBQYW5dCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBsaXN0cy5saW51eC1mb3VuZGF0 aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5m by9pb21tdQ== 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=-11.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_2 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0B777C433E6 for ; Fri, 28 Aug 2020 22:34:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B8207208A9 for ; Fri, 28 Aug 2020 22:34:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726791AbgH1WeS convert rfc822-to-8bit (ORCPT ); Fri, 28 Aug 2020 18:34:18 -0400 Received: from mga12.intel.com ([192.55.52.136]:2307 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726338AbgH1WeK (ORCPT ); Fri, 28 Aug 2020 18:34:10 -0400 IronPort-SDR: XyjPmcSYQTb+x1M+qtN7EEyxNd842ka9lNT8hmRIx9H6drtjOttuhQQLCYAaKz5i8Zf+bcTpsz 7Pi3o2DOogEQ== X-IronPort-AV: E=McAfee;i="6000,8403,9727"; a="136297248" X-IronPort-AV: E=Sophos;i="5.76,365,1592895600"; d="scan'208";a="136297248" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 15:17:08 -0700 IronPort-SDR: 85o6F007x3QZrQfNItHcNsZ/AjtmpRBpdOehTaY4hZpGz3QxE4PzBW4LBVSaRnM1VvrVmPK7iZ FQVhEcvgaUhA== X-IronPort-AV: E=Sophos;i="5.76,365,1592895600"; d="scan'208";a="313735039" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 15:17:08 -0700 Date: Fri, 28 Aug 2020 15:24:13 -0700 From: Jacob Pan To: Jean-Philippe Brucker Cc: Jacob Pan , "Tian, Kevin" , Raj Ashok , Jean-Philippe Brucker , LKML , iommu@lists.linux-foundation.org, Wu Hao , David Woodhouse , jacob.jun.pan@linux.intel.com Subject: Re: [PATCH v2 1/9] docs: Document IO Address Space ID (IOASID) APIs Message-ID: <20200828152413.49e7fad3@jacob-builder> In-Reply-To: <20200824103239.GA3210689@myrica> References: <1598070918-21321-1-git-send-email-jacob.jun.pan@linux.intel.com> <1598070918-21321-2-git-send-email-jacob.jun.pan@linux.intel.com> <20200824103239.GA3210689@myrica> Organization: OTC X-Mailer: Claws Mail 3.13.2 (GTK+ 2.24.30; x86_64-pc-linux-gnu) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Jean, Thanks for the review! On Mon, 24 Aug 2020 12:32:39 +0200 Jean-Philippe Brucker wrote: > On Fri, Aug 21, 2020 at 09:35:10PM -0700, Jacob Pan wrote: > > IOASID is used to identify address spaces that can be targeted by > > device DMA. It is a system-wide resource that is essential to its > > many users. This document is an attempt to help developers from all > > vendors navigate the APIs. At this time, ARM SMMU and Intel’s > > Scalable IO Virtualization (SIOV) enabled platforms are the primary > > users of IOASID. Examples of how SIOV components interact with > > IOASID APIs are provided in that many APIs are driven by the > > requirements from SIOV. > > > > Signed-off-by: Liu Yi L > > Signed-off-by: Wu Hao > > Signed-off-by: Jacob Pan > > --- > > Documentation/ioasid.rst | 618 > > +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 618 > > insertions(+) create mode 100644 Documentation/ioasid.rst > > > > diff --git a/Documentation/ioasid.rst b/Documentation/ioasid.rst > > Thanks for writing this up. Should it go to > Documentation/driver-api/, or Documentation/driver-api/iommu/? I > think this also needs to Cc linux-doc@vger.kernel.org and > corbet@lwn.net > Good point, I think Documentation/driver-api/ is good for now as there are no other IOMMU docs. Will CC Jon also. > > new file mode 100644 > > index 000000000000..b6a8cdc885ff > > --- /dev/null > > +++ b/Documentation/ioasid.rst > > @@ -0,0 +1,618 @@ > > +.. ioasid: > > + > > +===================================== > > +IO Address Space ID > > +===================================== > > + > > +IOASID is a generic name for PCIe Process Address ID (PASID) or ARM > > +SMMU sub-stream ID. An IOASID identifies an address space that > > DMA > > "SubstreamID" > > > +requests can target. > > + > > +The primary use cases for IOASID are Shared Virtual Address (SVA) > > and +IO Virtual Address (IOVA). However, the requirements for > > IOASID > > IOVA alone isn't a use case, maybe "multiple IOVA spaces per device"? > Yes, I meant guest IOVA for mdev which has "multiple IOVA spaces per device" based on aux domain. I will add this to the IOVA case description. "The primary use cases for IOASID are Shared Virtual Address (SVA) and multiple IOVA spaces per device. However, the requirements for IOASID management can vary among hardware architectures. For baremetal IOVA, IOASID #0 is used for DMA request without PASID. Even though some architectures such as VT-d also offers the flexibility of using any PASIDs for DMA request without PASID. PASID #0 is reserved and not allocated from any ioasid_set. Multiple IOVA spaces per device are mapped to auxiliary domains which can be used for mediated device assignment with and without a virtual IOMMU (vIOMMU). An IOASID is allocated for each auxiliary domain as default PASID. Without vIOMMU, default IOASID is used for DMA map/unmap APIs. With vIOMMU, default IOASID is used for guest IOVA where DMA request with PASID is required for the device. The reason is that there is only one PASID #0 per device, e.g. VT-d, RID_PASID is per PCI device. " > > +management can vary among hardware architectures. > > + > > +This document covers the generic features supported by IOASID > > +APIs. Vendor-specific use cases are also illustrated with Intel's > > VT-d +based platforms as the first example. > > + > > +.. contents:: :local: > > + > > +Glossary > > +======== > > +PASID - Process Address Space ID > > + > > +IOASID - IO Address Space ID (generic term for PCIe PASID and > > +sub-stream ID in SMMU) > > "SubstreamID" > will fix. > > + > > +SVA/SVM - Shared Virtual Addressing/Memory > > + > > +ENQCMD - New Intel X86 ISA for efficient workqueue submission [1] > > Maybe drop the "New", to keep the documentation perennial. It might be > good to add internal links here to the specifications URLs at the > bottom. > Good idea > > + > > +DSA - Intel Data Streaming Accelerator [2] > > + > > +VDCM - Virtual device composition module [3] > > + > > +SIOV - Intel Scalable IO Virtualization > > + > > + > > +Key Concepts > > +============ > > + > > +IOASID Set > > +----------- > > +An IOASID set is a group of IOASIDs allocated from the system-wide > > +IOASID pool. An IOASID set is created and can be identified by a > > +token of u64. Refer to IOASID set APIs for more details. > > Identified either by an u64 or an mm_struct, right? Maybe just drop > the second sentence if it's detailed in the IOASID set section below. > Sounds good. > > + > > +IOASID set is particularly useful for guest SVA where each guest > > could +have its own IOASID set for security and efficiency reasons. > > + > > +IOASID Set Private ID (SPID) > > +---------------------------- > > +SPIDs are introduced as IOASIDs within its set. Each SPID maps to a > > +system-wide IOASID but the namespace of SPID is within its IOASID > > +set. > > The intro isn't super clear. Perhaps this is simpler: > "Each IOASID set has a private namespace of SPIDs. An SPID maps to a > single system-wide IOASID." > Sounds better, thanks for the rewrite. > > SPIDs can be used as guest IOASIDs where each guest could do > > +IOASID allocation from its own pool and map them to host physical > > +IOASIDs. SPIDs are particularly useful for supporting live > > migration +where decoupling guest and host physical resources are > > necessary. + > > +For example, two VMs can both allocate guest PASID/SPID #101 but > > map to +different host PASIDs #201 and #202 respectively as shown > > in the +diagram below. > > +:: > > + > > + .------------------. .------------------. > > + | VM 1 | | VM 2 | > > + | | | | > > + |------------------| |------------------| > > + | GPASID/SPID 101 | | GPASID/SPID 101 | > > + '------------------' -------------------' Guest > > + __________|______________________|______________________ > > + | | Host > > + v v > > + .------------------. .------------------. > > + | Host IOASID 201 | | Host IOASID 202 | > > + '------------------' '------------------' > > + | IOASID set 1 | | IOASID set 2 | > > + '------------------' '------------------' > > + > > +Guest PASID is treated as IOASID set private ID (SPID) within an > > +IOASID set, mappings between guest and host IOASIDs are stored in > > the +set for inquiry. > > + > > +IOASID APIs > > +=========== > > +To get the IOASID APIs, users must #include . > > These APIs +serve the following functionalities: > > + > > + - IOASID allocation/Free > > + - Group management in the form of ioasid_set > > + - Private data storage and lookup > > + - Reference counting > > + - Event notification in case of state change > > + > > +IOASID Set Level APIs > > +-------------------------- > > +For use cases such as guest SVA it is necessary to manage IOASIDs > > at +a group level. For example, VMs may allocate multiple IOASIDs > > for +guest process address sharing (vSVA). It is imperative to > > enforce +VM-IOASID ownership such that malicious guest cannot > > target DMA > > "a malicious guest" > got it > > +traffic outside its own IOASIDs, or free an active IOASID belong > > to > > "that belongs to" > got it > > +another VM. > > +:: > > + > > + struct ioasid_set *ioasid_alloc_set(void *token, ioasid_t quota, > > u32 type) + > > + int ioasid_adjust_set(struct ioasid_set *set, int quota); > > These could be named "ioasid_set_alloc" and "ioasid_set_adjust" to be > consistent with the rest of the API. > right > > + > > + void ioasid_set_get(struct ioasid_set *set) > > + > > + void ioasid_set_put(struct ioasid_set *set) > > + > > + void ioasid_set_get_locked(struct ioasid_set *set) > > + > > + void ioasid_set_put_locked(struct ioasid_set *set) > > + > > + int ioasid_set_for_each_ioasid(struct ioasid_set *sdata, > > Might be nicer to keep the same argument names within the API. Here > "set" rather than "sdata". > yes, will do. > > + void (*fn)(ioasid_t id, void > > *data), > > + void *data) > > (alignment) > it looked aligned in emacs and generated html doc. might just the email? I have been having smtp issues, i am using gmail smtp this time. > > + > > + > > +IOASID set concept is introduced to represent such IOASID groups. > > Each > > Or just "IOASID sets represent such IOASID groups", but might be > redundant. > right, simpler is good > > +IOASID set is created with a token which can be one of the > > following +types: > > + > > + - IOASID_SET_TYPE_NULL (Arbitrary u64 value) > > + - IOASID_SET_TYPE_MM (Set token is a mm_struct) > > + > > +The explicit MM token type is useful when multiple users of an > > IOASID +set under the same process need to communicate about their > > shared IOASIDs. +E.g. An IOASID set created by VFIO for one guest > > can be associated +with the KVM instance for the same guest since > > they share a common mm_struct. + > > +The IOASID set APIs serve the following purposes: > > + > > + - Ownership/permission enforcement > > + - Take collective actions, e.g. free an entire set > > + - Event notifications within a set > > + - Look up a set based on token > > + - Quota enforcement > > This paragraph could be earlier in the section > Make sense. I will move it before listing the APIs. > > + > > +Individual IOASID APIs > > +---------------------- > > +Once an ioasid_set is created, IOASIDs can be allocated from the > > set. +Within the IOASID set namespace, set private ID (SPID) is > > supported. In +the VM use case, SPID can be used for storing guest > > PASID. + > > +:: > > + > > + ioasid_t ioasid_alloc(struct ioasid_set *set, ioasid_t min, > > ioasid_t max, > > + void *private); > > + > > + int ioasid_get(struct ioasid_set *set, ioasid_t ioasid); > > + > > + void ioasid_put(struct ioasid_set *set, ioasid_t ioasid); > > + > > + int ioasid_get_locked(struct ioasid_set *set, ioasid_t ioasid); > > + > > + void ioasid_put_locked(struct ioasid_set *set, ioasid_t ioasid); > > + > > + void *ioasid_find(struct ioasid_set *set, ioasid_t ioasid, > > + bool (*getter)(void *)); > > + > > + ioasid_t ioasid_find_by_spid(struct ioasid_set *set, ioasid_t > > spid) + > > + int ioasid_attach_data(struct ioasid_set *set, ioasid_t ioasid, > > + void *data); > > + int ioasid_attach_spid(struct ioasid_set *set, ioasid_t ioasid, > > + ioasid_t ssid); > > s/ssid/spid > got it > > + > > + > > +Notifications > > +------------- > > +An IOASID may have multiple users, each user may have hardware > > context +associated with an IOASID. When the status of an IOASID > > changes, +e.g. an IOASID is being freed, users need to be notified > > such that the +associated hardware context can be cleared, flushed, > > and drained. + > > +:: > > + > > + int ioasid_register_notifier(struct ioasid_set *set, struct > > + notifier_block *nb) > > + > > + void ioasid_unregister_notifier(struct ioasid_set *set, > > + struct notifier_block *nb) > > + > > + int ioasid_register_notifier_mm(struct mm_struct *mm, struct > > + notifier_block *nb) > > + > > + void ioasid_unregister_notifier_mm(struct mm_struct *mm, struct > > + notifier_block *nb) > > + > > + int ioasid_notify(ioasid_t ioasid, enum ioasid_notify_val cmd, > > + unsigned int flags) > > + > > + > > +Events > > +~~~~~~ > > +Notification events are pertinent to individual IOASIDs, they can > > be +one of the following: > > + > > + - ALLOC > > + - FREE > > + - BIND > > + - UNBIND > > + > > +Ordering > > +~~~~~~~~ > > +Ordering is supported by IOASID notification priorities as the > > +following (in ascending order): > > + > > +:: > > + > > + enum ioasid_notifier_prios { > > + IOASID_PRIO_LAST, > > + IOASID_PRIO_IOMMU, > > + IOASID_PRIO_DEVICE, > > + IOASID_PRIO_CPU, > > + }; > > + > > +The typical use case is when an IOASID is freed due to an > > exception, DMA +source should be quiesced before tearing down other > > hardware contexts +in the system. This will reduce the churn in > > handling faults. DMA work +submission is performed by the CPU which > > is granted higher priority than +devices. > > + > > + > > +Scopes > > +~~~~~~ > > +There are two types of notifiers in IOASID core: system-wide and > > +ioasid_set-wide. > > + > > +System-wide notifier is catering for users that need to handle all > > +IOASIDs in the system. E.g. The IOMMU driver handles all IOASIDs. > > + > > +Per ioasid_set notifier can be used by VM specific components such > > as +KVM. After all, each KVM instance only cares about IOASIDs > > within its +own set. > > + > > + > > +Atomicity > > +~~~~~~~~~ > > +IOASID notifiers are atomic due to spinlocks used inside the IOASID > > +core. For tasks cannot be completed in the notifier handler, async > > work > > "tasks that cannot be" > got it > > +can be submitted to complete the work later as long as there is no > > +ordering requirement. > > + > > +Reference counting > > +------------------ > > +IOASID lifecycle management is based on reference counting. Users > > of +IOASID intend to align lifecycle with the IOASID need to hold > > "who intend to" > got it > > +reference of the IOASID. IOASID will not be returned to the pool > > for > > "a reference to the IOASID. The IOASID" > got it > > +allocation until all references are dropped. Calling ioasid_free() > > +will mark the IOASID as FREE_PENDING if the IOASID has outstanding > > +reference. ioasid_get() is not allowed once an IOASID is in the > > +FREE_PENDING state. > > + > > +Event notifications are used to inform users of IOASID status > > change. +IOASID_FREE event prompts users to drop their references > > after +clearing its context. > > + > > +For example, on VT-d platform when an IOASID is freed, teardown > > +actions are performed on KVM, device driver, and IOMMU driver. > > +KVM shall register notifier block with:: > > + > > + static struct notifier_block pasid_nb_kvm = { > > + .notifier_call = pasid_status_change_kvm, > > + .priority = IOASID_PRIO_CPU, > > + }; > > + > > +VDCM driver shall register notifier block with:: > > + > > + static struct notifier_block pasid_nb_vdcm = { > > + .notifier_call = pasid_status_change_vdcm, > > + .priority = IOASID_PRIO_DEVICE, > > + }; > > + > > +In both cases, notifier blocks shall be registered on the IOASID > > set +such that *only* events from the matching VM is received. > > + > > +If KVM attempts to register notifier block before the IOASID set is > > +created for the MM token, the notifier block will be placed on a > > +pending list inside IOASID core. Once the token matching IOASID set > > +is created, IOASID will register the notifier block automatically. > > +IOASID core does not replay events for the existing IOASIDs in the > > +set. For IOASID set of MM type, notification blocks can be > > registered +on empty sets only. This is to avoid lost events. > > + > > +IOMMU driver shall register notifier block on global chain:: > > + > > + static struct notifier_block pasid_nb_vtd = { > > + .notifier_call = pasid_status_change_vtd, > > + .priority = IOASID_PRIO_IOMMU, > > + }; > > + > > +Custom allocator APIs > > +--------------------- > > + > > +:: > > + > > + int ioasid_register_allocator(struct ioasid_allocator_ops > > *allocator); + > > + void ioasid_unregister_allocator(struct ioasid_allocator_ops > > *allocator); + > > +Allocator Choices > > +~~~~~~~~~~~~~~~~~ > > +IOASIDs are allocated for both host and guest SVA/IOVA usage. > > However, +allocators can be different. For example, on VT-d guest > > PASID +allocation must be performed via a virtual command interface > > which is +emulated by VMM. > > + > > +IOASID core has the notion of "custom allocator" such that guest > > can +register virtual command allocator that precedes the default > > one. + > > +Namespaces > > +~~~~~~~~~~ > > +IOASIDs are limited system resources that default to 20 bits in > > +size. Since each device has its own table, theoretically the > > namespace +can be per device also. However, for security reasons > > sharing PASID +tables among devices are not good for isolation. > > Therefore, IOASID +namespace is system-wide. > > I don't follow this development. Having per-device PASID table would > work fine for isolation (assuming no hardware bug necessitating IOMMU > groups). If I remember correctly IOASID space was chosen to be > OS-wide because it simplifies the management code (single PASID per > task), and it is system-wide across VMs only in the case of VT-d > scalable mode. > You are right, system-wide namespace is chosen for simplicity and enqcmd. I will fix that. > > + > > +There are also other reasons to have this simpler system-wide > > +namespace. Take VT-d as an example, VT-d supports shared workqueue > > +and ENQCMD[1] where one IOASID could be used to submit work on > > Maybe use the Sphinx glossary syntax rather than "[1]" > https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html#glossary-directive > I will look into that, thanks! > > +multiple devices that are shared with other VMs. This requires > > IOASID +to be system-wide. This is also the reason why guests must > > use an +emulated virtual command interface to allocate IOASID from > > the host. + > > + > > +Life cycle > > +========== > > +This section covers IOASID lifecycle management for both bare-metal > > +and guest usages. In bare-metal SVA, MMU notifier is directly > > hooked +up with IOMMU driver, therefore the process address space > > (MM) +lifecycle is aligned with IOASID. > > + > > +However, guest MMU notifier is not available to host IOMMU driver, > > +when guest MM terminates unexpectedly, the events have to go > > through +VFIO and IOMMU UAPI to reach host IOMMU driver. There are > > also more +parties involved in guest SVA, e.g. on Intel VT-d > > platform, IOASIDs +are used by IOMMU driver, KVM, VDCM, and VFIO. > > + > > +Native IOASID Life Cycle (VT-d Example) > > +--------------------------------------- > > + > > +The normal flow of native SVA code with Intel Data Streaming > > +Accelerator(DSA) [2] as example: > > + > > +1. Host user opens accelerator FD, e.g. DSA driver, or uacce; > > +2. DSA driver allocate WQ, do sva_bind_device(); > > +3. IOMMU driver calls ioasid_alloc(), then bind PASID with device, > > + mmu_notifier_get() > > +4. DMA starts by DSA driver userspace > > +5. DSA userspace close FD > > +6. DSA/uacce kernel driver handles FD.close() > > +7. DSA driver stops DMA > > +8. DSA driver calls sva_unbind_device(); > > +9. IOMMU driver does unbind, clears PASID context in IOMMU, flush > > + TLBs. mmu_notifier_put() called. > > +10. mmu_notifier.release() called, IOMMU SVA code calls > > ioasid_free()* +11. The IOASID is returned to the pool, reclaimed. > > + > > +:: > > + > > Use a footnote? > https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html#footnotes > ditto > > + * With ENQCMD, PASID used on VT-d is not released in > > mmu_notifier() but > > + mmdrop(). mmdrop comes after FD close. Should not matter. > > "comes after FD close, which doesn't make a difference?" > The following might not be necessary since early process termination > is described later. > yes, it is redundant. I will remove it. > > + If the user process dies unexpectedly, Step #10 may come > > before > > + Step #5, in between, all DMA faults discarded. PRQ responded > > with > > PRQ hasn't been defined in this document. > will remove > > + code INVALID REQUEST. > > + > > +During the normal teardown, the following three steps would happen > > in +order: > > + > > +1. Device driver stops DMA request > > +2. IOMMU driver unbinds PASID and mm, flush all TLBs, drain > > in-flight > > + requests. > > +3. IOASID freed > > + > > +Exception happens when process terminates *before* device driver > > stops +DMA and call IOMMU driver to unbind. The flow of process > > exists are as > > "exits" > will fix > > +follows: > > + > > +:: > > + > > + do_exit() { > > + exit_mm() { > > + mm_put(); > > + exit_mmap() { > > + intel_invalidate_range() //mmu notifier > > + tlb_finish_mmu() > > + mmu_notifier_release(mm) { > > + intel_iommu_release() { > > + [2] > > intel_iommu_teardown_pasid(); > > Parentheses might be better than square brackets for step numbers > yes, it gets highlight as well. thanks! > > + intel_iommu_flush_tlbs(); > > + } > > + // tlb_invalidate_range cb removed > > + } > > + unmap_vmas(); > > + free_pgtables(); // IOMMU cannot walk PGT > > after this > > + }; > > + } > > + exit_files(tsk) { > > + close_files() { > > + dsa_close(); > > + [1] dsa_stop_dma(); > > + intel_svm_unbind_pasid(); //nothing to do > > + } > > + } > > + } > > + > > + mmdrop() /* some random time later, lazy mm user */ { > > + mm_free_pgd(); > > + destroy_context(mm); { > > + [3] ioasid_free(); > > + } > > + } > > + > > +As shown in the list above, step #2 could happen before > > +#1. Unrecoverable(UR) faults could happen between #2 and #1. > > + > > +Also notice that TLB invalidation occurs at mmu_notifier > > +invalidate_range callback as well as the release callback. The > > reason +is that release callback will delete IOMMU driver from the > > notifier +chain which may skip invalidate_range() calls during the > > exit path. + > > +To avoid unnecessary reporting of UR fault, IOMMU driver shall > > disable +fault reporting after free and before unbind. > > + > > +Guest IOASID Life Cycle (VT-d Example) > > +-------------------------------------- > > +Guest IOASID life cycle starts with guest driver open(), this > > could be +uacce or individual accelerator driver such as DSA. At FD > > open, +sva_bind_device() is called which triggers a series of > > actions. + > > +The example below is an illustration of *normal* operations that > > +involves *all* the SW components in VT-d. The flow can be simpler > > if +no ENQCMD is supported. > > + > > +:: > > + > > + VFIO IOMMU KVM VDCM IOASID > > Ref > > + .................................................................. > > + 1 ioasid_register_notifier/_mm() > > + 2 ioasid_alloc() 1 > > + 3 bind_gpasid() > > + 4 iommu_bind()->ioasid_get() 2 > > + 5 ioasid_notify(BIND) > > + 6 -> ioasid_get() 3 > > + 7 -> vmcs_update_atomic() > > + 8 mdev_write(gpasid) > > + 9 hpasid= > > + 10 find_by_spid(gpasid) 4 > > + 11 vdev_write(hpasid) > > + 12 -------- GUEST STARTS DMA -------------------------- > > + 13 -------- GUEST STOPS DMA -------------------------- > > + 14 mdev_clear(gpasid) > > + 15 vdev_clear(hpasid) > > + 16 ioasid_put() > > 3 > > + 17 unbind_gpasid() > > + 18 iommu_ubind() > > + 19 ioasid_notify(UNBIND) > > + 20 -> vmcs_update_atomic() > > + 21 -> ioasid_put() > > 2 > > + 22 ioasid_free() > > 1 > > + 23 ioasid_put() > > 0 > > + 24 Reclaimed > > + -------------- New Life Cycle Begin ---------------------------- > > + 1 ioasid_alloc() -> > > 1 + > > + Note: IOASID Notification Events: FREE, BIND, UNBIND > > + > > +Exception cases arise when a guest crashes or a malicious guest > > +attempts to cause disruption on the host system. The fault handling > > +rules are: > > + > > +1. IOASID free must *always* succeed. > > +2. An inactive period may be required before the freed IOASID is > > + reclaimed. During this period, consumers of IOASID perform > > cleanup. +3. Malfunction is limited to the guest owned resources > > for all > > + programming errors. > > + > > +The primary source of exception is when the following are out of > > +order: > > + > > +1. Start/Stop of DMA activity > > + (Guest device driver, mdev via VFIO) > > +2. Setup/Teardown of IOMMU PASID context, IOTLB, DevTLB flushes > > + (Host IOMMU driver bind/unbind) > > +3. Setup/Teardown of VMCS PASID translation table entries (KVM) in > > + case of ENQCMD > > +4. Programming/Clearing host PASID in VDCM (Host VDCM driver) > > +5. IOASID alloc/free (Host IOASID) > > + > > +VFIO is the *only* user-kernel interface, which is ultimately > > +responsible for exception handlings. > > "handling" > got it > > + > > +#1 is processed the same way as the assigned device today based on > > +device file descriptors and events. There is no special handling. > > + > > +#3 is based on bind/unbind events emitted by #2. > > + > > +#4 is naturally aligned with IOASID life cycle in that an illegal > > +guest PASID programming would fail in obtaining reference of the > > +matching host IOASID. > > + > > +#5 is similar to #4. The fault will be reported to the user if > > PASID +used in the ENQCMD is not set up in VMCS PASID translation > > table. + > > +Therefore, the remaining out of order problem is between #2 and > > +#5. I.e. unbind vs. free. More specifically, free before unbind. > > + > > +IOASID notifier and refcounting are used to ensure order. Following > > +a publisher-subscriber pattern where: > > + > > +- Publishers: VFIO & IOMMU > > +- Subscribers: KVM, VDCM, IOMMU > > + > > +IOASID notifier is atomic which requires subscribers to do quick > > +handling of the event in the atomic context. Workqueue can be used > > for +any processing that requires thread context. IOASID reference > > must be +acquired before receiving the FREE event. The reference > > must be +dropped at the end of the processing in order to return > > the IOASID to +the pool. > > + > > +Let's examine the IOASID life cycle again when free happens > > *before* +unbind. This could be a result of misbehaving guests or > > crash. Assuming +VFIO cannot enforce unbind->free order. Notice > > that the setup part up +until step #12 is identical to the normal > > case, the flow below starts +with step 13. > > + > > +:: > > + > > + VFIO IOMMU KVM VDCM IOASID > > Ref > > + .................................................................. > > + 13 -------- GUEST STARTS DMA -------------------------- > > + 14 -------- *GUEST MISBEHAVES!!!* ---------------- > > + 15 ioasid_free() > > + 16 > > ioasid_notify(FREE) > > + 17 > > mark_ioasid_inactive[1] > > + 18 kvm_nb_handler(FREE) > > + 19 vmcs_update_atomic() > > + 20 ioasid_put_locked() -> 3 > > + 21 vdcm_nb_handler(FREE) > > + 22 iomm_nb_handler(FREE) > > + 23 ioasid_free() returns[2] schedule_work() 2 > > + 24 schedule_work() vdev_clear_wk(hpasid) > > + 25 teardown_pasid_wk() > > + 26 ioasid_put() -> 1 > > + 27 ioasid_put() 0 > > + 28 Reclaimed > > + 29 unbind_gpasid() > > + 30 iommu_unbind()->ioasid_find() Fails[3] > > + -------------- New Life Cycle Begin ---------------------------- > > + > > +Note: > > + > > +1. By marking IOASID inactive at step #17, no new references can > > be > > Is "inactive" FREE_PENDING? > yes, will fix. > > + held. ioasid_get/find() will return -ENOENT; > > +2. After step #23, all events can go out of order. Shall not affect > > + the outcome. > > +3. IOMMU driver fails to find private data for unbinding. If > > unbind is > > + called after the same IOASID is allocated for the same guest > > again, > > + this is a programming error. The damage is limited to the guest > > + itself since unbind performs permission checking based on the > > + IOASID set associated with the guest process. > > + > > +KVM PASID Translation Table Updates > > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > +Per VM PASID translation table is maintained by KVM in order to > > +support ENQCMD in the guest. The table contains host-guest PASID > > +translations to be consumed by CPU ucode. The synchronization of > > the +PASID states depends on VFIO/IOMMU driver, where IOCTL and > > atomic +notifiers are used. KVM must register IOASID notifier per > > VM instance +during launch time. The following events are handled: > > + > > +1. BIND/UNBIND > > +2. FREE > > + > > +Rules: > > + > > +1. Multiple devices can bind with the same PASID, this can be > > different PCI > > + devices or mdevs within the same PCI device. However, only the > > + *first* BIND and *last* UNBIND emit notifications. > > +2. IOASID code is responsible for ensuring the correctness of H-G > > + PASID mapping. There is no need for KVM to validate the > > + notification data. > > +3. When UNBIND happens *after* FREE, KVM will see error in > > + ioasid_get() even when the reclaim is not done. IOMMU driver > > will > > + also avoid sending UNBIND if the PASID is already FREE. > > +4. When KVM terminates *before* FREE & UNBIND, references will be > > + dropped for all host PASIDs. > > + > > +VDCM PASID Programming > > +~~~~~~~~~~~~~~~~~~~~~~ > > +VDCM composes virtual devices and exposes them to the guests. When > > +the guest allocates a PASID then program it to the virtual device, > > VDCM +intercepts the programming attempt then program the matching > > host > > "programs" > > Thanks, > Jean > > > +PASID on to the hardware. > > +Conversely, when a device is going away, VDCM must be informed such > > +that PASID context on the hardware can be cleared. There could be > > +multiple mdevs assigned to different guests in the same VDCM. Since > > +the PASID table is shared at PCI device level, lazy clearing is not > > +secure. A malicious guest can attack by using newly freed PASIDs > > that +are allocated by another guest. > > + > > +By holding a reference of the PASID until VDCM cleans up the HW > > context, +it is guaranteed that PASID life cycles do not cross > > within the same +device. > > + > > + > > +Reference > > +==================================================== > > +1. > > https://software.intel.com/sites/default/files/managed/c5/15/architecture-instruction-set-extensions-programming-reference.pdf > > + +2. > > https://01.org/blogs/2019/introducing-intel-data-streaming-accelerator > > + +3. > > https://software.intel.com/en-us/download/intel-data-streaming-accelerator-preliminary-architecture-specification > > -- 2.7.4 > > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu [Jacob Pan]