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 EE12BC433E2 for ; Fri, 28 Aug 2020 16:54:10 +0000 (UTC) Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C661020738 for ; Fri, 28 Aug 2020 16:54:10 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C661020738 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 whitealder.osuosl.org (Postfix) with ESMTP id 980E288057; Fri, 28 Aug 2020 16:54:10 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 8GemJQmNPviY; Fri, 28 Aug 2020 16:54:07 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by whitealder.osuosl.org (Postfix) with ESMTP id 51F718806D; Fri, 28 Aug 2020 16:54:07 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 4256EC07FF; Fri, 28 Aug 2020 16:54:07 +0000 (UTC) Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id CAF30C0051 for ; Fri, 28 Aug 2020 16:54:05 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id B8A5488674 for ; Fri, 28 Aug 2020 16:54:05 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id znX6k+ZcAS+S for ; Fri, 28 Aug 2020 16:54:03 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by hemlock.osuosl.org (Postfix) with ESMTPS id 918AF88659 for ; Fri, 28 Aug 2020 16:54:03 +0000 (UTC) IronPort-SDR: FKAdX66arQfPzolK10fSt2+fdwqeT9pX0gSCqcjrRyPgCyWjjw689RT7j6RKMC0r3lakGjlpiH KwzaU3SOnYqA== X-IronPort-AV: E=McAfee;i="6000,8403,9727"; a="156704128" X-IronPort-AV: E=Sophos;i="5.76,364,1592895600"; d="scan'208";a="156704128" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 09:54:02 -0700 IronPort-SDR: tD0lLztNFbDkl9g9wSfZG83YCD/SoJKb/Als6u5szKMDiXTwtEN0Cio7W7dHfBa5DcLZiuyyOP BSa5hk+TKTlg== X-IronPort-AV: E=Sophos;i="5.76,364,1592895600"; d="scan'208";a="296177334" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga003-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 09:54:02 -0700 Date: Fri, 28 Aug 2020 10:01:07 -0700 From: Jacob Pan To: Lu Baolu Subject: Re: [PATCH v2 1/9] docs: Document IO Address Space ID (IOASID) APIs Message-ID: <20200828100107.55ae32c1@jacob-builder> In-Reply-To: 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> 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" SGkgQmFvbHUsCgpUaGFua3MgZm9yIHRoZSByZXZpZXchCgpPbiBTdW4sIDIzIEF1ZyAyMDIwIDE1 OjA1OjA4ICswODAwCkx1IEJhb2x1IDxiYW9sdS5sdUBsaW51eC5pbnRlbC5jb20+IHdyb3RlOgoK PiBIaSBKYWNvYiwKPiAKPiBPbiAyMDIwLzgvMjIgMTI6MzUsIEphY29iIFBhbiB3cm90ZToKPiA+ IElPQVNJRCBpcyB1c2VkIHRvIGlkZW50aWZ5IGFkZHJlc3Mgc3BhY2VzIHRoYXQgY2FuIGJlIHRh cmdldGVkIGJ5Cj4gPiBkZXZpY2UgRE1BLiBJdCBpcyBhIHN5c3RlbS13aWRlIHJlc291cmNlIHRo YXQgaXMgZXNzZW50aWFsIHRvIGl0cwo+ID4gbWFueSB1c2Vycy4gVGhpcyBkb2N1bWVudCBpcyBh biBhdHRlbXB0IHRvIGhlbHAgZGV2ZWxvcGVycyBmcm9tIGFsbAo+ID4gdmVuZG9ycyBuYXZpZ2F0 ZSB0aGUgQVBJcy4gQXQgdGhpcyB0aW1lLCBBUk0gU01NVSBhbmQgSW50ZWzigJlzCj4gPiBTY2Fs YWJsZSBJTyBWaXJ0dWFsaXphdGlvbiAoU0lPVikgZW5hYmxlZCBwbGF0Zm9ybXMgYXJlIHRoZSBw cmltYXJ5Cj4gPiB1c2VycyBvZiBJT0FTSUQuIEV4YW1wbGVzIG9mIGhvdyBTSU9WIGNvbXBvbmVu dHMgaW50ZXJhY3Qgd2l0aAo+ID4gSU9BU0lEIEFQSXMgYXJlIHByb3ZpZGVkIGluIHRoYXQgbWFu eSBBUElzIGFyZSBkcml2ZW4gYnkgdGhlCj4gPiByZXF1aXJlbWVudHMgZnJvbSBTSU9WLgo+ID4g Cj4gPiBTaWduZWQtb2ZmLWJ5OiBMaXUgWWkgTCA8eWkubC5saXVAaW50ZWwuY29tPgo+ID4gU2ln bmVkLW9mZi1ieTogV3UgSGFvIDxoYW8ud3VAaW50ZWwuY29tPgo+ID4gU2lnbmVkLW9mZi1ieTog SmFjb2IgUGFuIDxqYWNvYi5qdW4ucGFuQGxpbnV4LmludGVsLmNvbT4KPiA+IC0tLQo+ID4gICBE b2N1bWVudGF0aW9uL2lvYXNpZC5yc3QgfCA2MTgKPiA+ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrIDEgZmlsZSBjaGFuZ2VkLCA2MTgKPiA+IGluc2VydGlv bnMoKykgY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vaW9hc2lkLnJzdAo+ID4gCj4g PiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9pb2FzaWQucnN0IGIvRG9jdW1lbnRhdGlvbi9p b2FzaWQucnN0Cj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggMDAwMDAwMDAwMDAw Li5iNmE4Y2RjODg1ZmYKPiA+IC0tLSAvZGV2L251bGwKPiA+ICsrKyBiL0RvY3VtZW50YXRpb24v aW9hc2lkLnJzdAo+ID4gQEAgLTAsMCArMSw2MTggQEAKPiA+ICsuLiBpb2FzaWQ6Cj4gPiArCj4g PiArPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo+ID4gK0lPIEFkZHJlc3Mg U3BhY2UgSUQKPiA+ICs9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Cj4gPiAr Cj4gPiArSU9BU0lEIGlzIGEgZ2VuZXJpYyBuYW1lIGZvciBQQ0llIFByb2Nlc3MgQWRkcmVzcyBJ RCAoUEFTSUQpIG9yIEFSTQo+ID4gK1NNTVUgc3ViLXN0cmVhbSBJRC4gQW4gSU9BU0lEIGlkZW50 aWZpZXMgYW4gYWRkcmVzcyBzcGFjZSB0aGF0IERNQQo+ID4gK3JlcXVlc3RzIGNhbiB0YXJnZXQu Cj4gPiArCj4gPiArVGhlIHByaW1hcnkgdXNlIGNhc2VzIGZvciBJT0FTSUQgYXJlIFNoYXJlZCBW aXJ0dWFsIEFkZHJlc3MgKFNWQSkKPiA+IGFuZCArSU8gVmlydHVhbCBBZGRyZXNzIChJT1ZBKS4g SG93ZXZlciwgdGhlIHJlcXVpcmVtZW50cyBmb3IKPiA+IElPQVNJRCAgCj4gCj4gQ2FuIHlvdSBw bGVhc2UgZWxhYm9yYXRlIGEgYml0IG1vcmUgYWJvdXQgaG93IGlvYXNpZCBpcyB1c2VkIGJ5IElP VkE/Cj4gCkdvb2QgcG9pbnQsIEkgd2lsbCBhZGQgYSBwYXJhZ3JhcGggZm9yIElPVkEgdXNhZ2Uu IFNvbWV0aGluZyBsaWtlIHRoaXM6CiJGb3IgSU9WQSwgSU9BU0lEICMwIGlzIHR5cGljYWxseSB1 c2VkIGZvciBETUEgcmVxdWVzdCB3aXRob3V0ClBBU0lELiBIb3dldmVyLCBzb21lIGFyY2hpdGVj dHVyZXMgc3VjaCBhcyBWVC1kIGFsc28gb2ZmZXJzIHRoZQpmbGV4aWJpbGl0eSBvZiB1c2luZyBh bnkgUEFTSUQgZm9yIERNQSByZXF1ZXN0IHdpdGhvdXQgUEFTSUQuIEZvcgpleGFtcGxlLCBvbiBW VC1kIFBBU0lEICMwIGlzIHVzZWQgZm9yIFBDSSBkZXZpY2UgUklEMlBBU0lEIGFuZCBmb3IKU0lP ViBlYWNoIGF1eGlsYXJ5IGRvbWFpbiBhbHNvIGFsbG9jYXRlcyBhIG5vbi16ZXJvIGRlZmF1bHQg UEFTSUQgZm9yCkRNQSByZXF1ZXN0IHcvbyBQQVNJRC4gUEFTSUQgIzAsIGlzIHJlc2VydmVkIGFu ZCBub3QgYWxsb2NhdGVkIGZyb20gYW55CmlvYXNpZF9zZXQuIgoKCj4gPiArbWFuYWdlbWVudCBj YW4gdmFyeSBhbW9uZyBoYXJkd2FyZSBhcmNoaXRlY3R1cmVzLgo+ID4gKwo+ID4gK1RoaXMgZG9j dW1lbnQgY292ZXJzIHRoZSBnZW5lcmljIGZlYXR1cmVzIHN1cHBvcnRlZCBieSBJT0FTSUQKPiA+ ICtBUElzLiBWZW5kb3Itc3BlY2lmaWMgdXNlIGNhc2VzIGFyZSBhbHNvIGlsbHVzdHJhdGVkIHdp dGggSW50ZWwncwo+ID4gVlQtZCArYmFzZWQgcGxhdGZvcm1zIGFzIHRoZSBmaXJzdCBleGFtcGxl Lgo+ID4gKwo+ID4gKy4uIGNvbnRlbnRzOjogOmxvY2FsOgo+ID4gKwo+ID4gK0dsb3NzYXJ5Cj4g PiArPT09PT09PT0KPiA+ICtQQVNJRCAtIFByb2Nlc3MgQWRkcmVzcyBTcGFjZSBJRAo+ID4gKwo+ ID4gK0lPQVNJRCAtIElPIEFkZHJlc3MgU3BhY2UgSUQgKGdlbmVyaWMgdGVybSBmb3IgUENJZSBQ QVNJRCBhbmQKPiA+ICtzdWItc3RyZWFtIElEIGluIFNNTVUpCj4gPiArCj4gPiArU1ZBL1NWTSAt IFNoYXJlZCBWaXJ0dWFsIEFkZHJlc3NpbmcvTWVtb3J5Cj4gPiArCj4gPiArRU5RQ01EIC0gTmV3 IEludGVsIFg4NiBJU0EgZm9yIGVmZmljaWVudCB3b3JrcXVldWUgc3VibWlzc2lvbiBbMV0KPiA+ ICsKPiA+ICtEU0EgLSBJbnRlbCBEYXRhIFN0cmVhbWluZyBBY2NlbGVyYXRvciBbMl0KPiA+ICsK PiA+ICtWRENNIC0gVmlydHVhbCBkZXZpY2UgY29tcG9zaXRpb24gbW9kdWxlIFszXSAgCj4gCj4g Q2FwaXRhbGl6ZSB0aGUgZmlyc3QgbGV0dGVyIG9mIGVhY2ggd29yZC4KPiAKd2lsbCBkby4KCj4g PiArCj4gPiArU0lPViAtIEludGVsIFNjYWxhYmxlIElPIFZpcnR1YWxpemF0aW9uCj4gPiArCj4g PiArCj4gPiArS2V5IENvbmNlcHRzCj4gPiArPT09PT09PT09PT09Cj4gPiArCj4gPiArSU9BU0lE IFNldAo+ID4gKy0tLS0tLS0tLS0tCj4gPiArQW4gSU9BU0lEIHNldCBpcyBhIGdyb3VwIG9mIElP QVNJRHMgYWxsb2NhdGVkIGZyb20gdGhlIHN5c3RlbS13aWRlCj4gPiArSU9BU0lEIHBvb2wuIEFu IElPQVNJRCBzZXQgaXMgY3JlYXRlZCBhbmQgY2FuIGJlIGlkZW50aWZpZWQgYnkgYQo+ID4gK3Rv a2VuIG9mIHU2NC4gUmVmZXIgdG8gSU9BU0lEIHNldCBBUElzIGZvciBtb3JlIGRldGFpbHMuCj4g PiArCj4gPiArSU9BU0lEIHNldCBpcyBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBndWVzdCBTVkEg d2hlcmUgZWFjaCBndWVzdAo+ID4gY291bGQgK2hhdmUgaXRzIG93biBJT0FTSUQgc2V0IGZvciBz ZWN1cml0eSBhbmQgZWZmaWNpZW5jeSByZWFzb25zLgo+ID4gKwo+ID4gK0lPQVNJRCBTZXQgUHJp dmF0ZSBJRCAoU1BJRCkKPiA+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiArU1BJ RHMgYXJlIGludHJvZHVjZWQgYXMgSU9BU0lEcyB3aXRoaW4gaXRzIHNldC4gRWFjaCBTUElEIG1h cHMgdG8gYQo+ID4gK3N5c3RlbS13aWRlIElPQVNJRCBidXQgdGhlIG5hbWVzcGFjZSBvZiBTUElE IGlzIHdpdGhpbiBpdHMgSU9BU0lECj4gPiArc2V0LiBTUElEcyBjYW4gYmUgdXNlZCBhcyBndWVz dCBJT0FTSURzIHdoZXJlIGVhY2ggZ3Vlc3QgY291bGQgZG8KPiA+ICtJT0FTSUQgYWxsb2NhdGlv biBmcm9tIGl0cyBvd24gcG9vbCBhbmQgbWFwIHRoZW0gdG8gaG9zdCBwaHlzaWNhbAo+ID4gK0lP QVNJRHMuIFNQSURzIGFyZSBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBzdXBwb3J0aW5nIGxpdmUK PiA+IG1pZ3JhdGlvbiArd2hlcmUgZGVjb3VwbGluZyBndWVzdCBhbmQgaG9zdCBwaHlzaWNhbCBy ZXNvdXJjZXMgYXJlCj4gPiBuZWNlc3NhcnkuICsKPiA+ICtGb3IgZXhhbXBsZSwgdHdvIFZNcyBj YW4gYm90aCBhbGxvY2F0ZSBndWVzdCBQQVNJRC9TUElEICMxMDEgYnV0Cj4gPiBtYXAgdG8gK2Rp ZmZlcmVudCBob3N0IFBBU0lEcyAjMjAxIGFuZCAjMjAyIHJlc3BlY3RpdmVseSBhcyBzaG93bgo+ ID4gaW4gdGhlICtkaWFncmFtIGJlbG93Lgo+ID4gKzo6Cj4gPiArCj4gPiArIC4tLS0tLS0tLS0t LS0tLS0tLS0uICAgIC4tLS0tLS0tLS0tLS0tLS0tLS0uCj4gPiArIHwgICBWTSAxICAgICAgICAg ICB8ICAgIHwgICBWTSAyICAgICAgICAgICB8Cj4gPiArIHwgICAgICAgICAgICAgICAgICB8ICAg IHwgICAgICAgICAgICAgICAgICB8Cj4gPiArIHwtLS0tLS0tLS0tLS0tLS0tLS18ICAgIHwtLS0t LS0tLS0tLS0tLS0tLS18Cj4gPiArIHwgR1BBU0lEL1NQSUQgMTAxICB8ICAgIHwgR1BBU0lEL1NQ SUQgMTAxICB8Cj4gPiArICctLS0tLS0tLS0tLS0tLS0tLS0nICAgIC0tLS0tLS0tLS0tLS0tLS0t LS0nICAgICBHdWVzdAo+ID4gKyBfX19fX19fX19ffF9fX19fX19fX19fX19fX19fX19fX198X19f X19fX19fX19fX19fX19fX19fXwo+ID4gKyAgICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAg ICB8ICAgICAgICAgICAgICAgSG9zdAo+ID4gKyAgICAgICAgICAgdiAgICAgICAgICAgICAgICAg ICAgICB2Cj4gPiArIC4tLS0tLS0tLS0tLS0tLS0tLS0uICAgIC4tLS0tLS0tLS0tLS0tLS0tLS0u Cj4gPiArIHwgSG9zdCBJT0FTSUQgMjAxICB8ICAgIHwgSG9zdCBJT0FTSUQgMjAyICB8Cj4gPiAr ICctLS0tLS0tLS0tLS0tLS0tLS0nICAgICctLS0tLS0tLS0tLS0tLS0tLS0nCj4gPiArIHwgICBJ T0FTSUQgc2V0IDEgICB8ICAgIHwgICBJT0FTSUQgc2V0IDIgICB8Cj4gPiArICctLS0tLS0tLS0t LS0tLS0tLS0nICAgICctLS0tLS0tLS0tLS0tLS0tLS0nCj4gPiArCj4gPiArR3Vlc3QgUEFTSUQg aXMgdHJlYXRlZCBhcyBJT0FTSUQgc2V0IHByaXZhdGUgSUQgKFNQSUQpIHdpdGhpbiBhbgo+ID4g K0lPQVNJRCBzZXQsIG1hcHBpbmdzIGJldHdlZW4gZ3Vlc3QgYW5kIGhvc3QgSU9BU0lEcyBhcmUg c3RvcmVkIGluCj4gPiB0aGUgK3NldCBmb3IgaW5xdWlyeS4gIAo+IAo+IElzIHRoZXJlIGEgcmVh bCBJT0FTSUQgc2V0IGFsbG9jYXRlZCBpbiB0aGUgaG9zdCB3aGljaCByZXByZXNlbnQgdGhlCj4g U1BJRD8KPiAKU1BJRHMgYXJlIG5vdCBhbGxvY2F0ZWQgZnJvbSB0aGUgaG9zdCBJT0FTSUQgc2V0 LCBidXQgdGhlIGJhY2tpbmcgaG9zdApJT0FTSUQgb2YgdGhlIFNQSUQgaXMuIFNvIHRoZSBzYW1l IFNQSUQgIyBjYW4gYmVsb25nIHRvIGRpZmZlcmVudApJT0FTSUQgc2V0LgoKU1BJRHMgYXJlIGFs bG9jYXRlZCBieSBWTU0gYW5kIGdpdmVuIHRvIHRoZSBob3N0LCBJT0FTSUQgY29kZSBpbiB0aGUK aG9zdCBqdXN0IHN0b3JlcyBpdCBpbiB0aGUgaW9hc2lkX3NldC4KCj4gPiArCj4gPiArSU9BU0lE IEFQSXMKPiA+ICs9PT09PT09PT09PQo+ID4gK1RvIGdldCB0aGUgSU9BU0lEIEFQSXMsIHVzZXJz IG11c3QgI2luY2x1ZGUgPGxpbnV4L2lvYXNpZC5oPi4KPiA+IFRoZXNlIEFQSXMgK3NlcnZlIHRo ZSBmb2xsb3dpbmcgZnVuY3Rpb25hbGl0aWVzOgo+ID4gKwo+ID4gKyAgLSBJT0FTSUQgYWxsb2Nh dGlvbi9GcmVlCj4gPiArICAtIEdyb3VwIG1hbmFnZW1lbnQgaW4gdGhlIGZvcm0gb2YgaW9hc2lk X3NldAo+ID4gKyAgLSBQcml2YXRlIGRhdGEgc3RvcmFnZSBhbmQgbG9va3VwCj4gPiArICAtIFJl ZmVyZW5jZSBjb3VudGluZwo+ID4gKyAgLSBFdmVudCBub3RpZmljYXRpb24gaW4gY2FzZSBvZiBz dGF0ZSBjaGFuZ2UKPiA+ICsKPiA+ICtJT0FTSUQgU2V0IExldmVsIEFQSXMKPiA+ICstLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gK0ZvciB1c2UgY2FzZXMgc3VjaCBhcyBndWVzdCBTVkEg aXQgaXMgbmVjZXNzYXJ5IHRvIG1hbmFnZSBJT0FTSURzCj4gPiBhdCArYSBncm91cCBsZXZlbC4g Rm9yIGV4YW1wbGUsIFZNcyBtYXkgYWxsb2NhdGUgbXVsdGlwbGUgSU9BU0lEcwo+ID4gZm9yICtn dWVzdCBwcm9jZXNzIGFkZHJlc3Mgc2hhcmluZyAodlNWQSkuIEl0IGlzIGltcGVyYXRpdmUgdG8K PiA+IGVuZm9yY2UgK1ZNLUlPQVNJRCBvd25lcnNoaXAgc3VjaCB0aGF0IG1hbGljaW91cyBndWVz dCBjYW5ub3QKPiA+IHRhcmdldCBETUEgK3RyYWZmaWMgb3V0c2lkZSBpdHMgb3duIElPQVNJRHMs IG9yIGZyZWUgYW4gYWN0aXZlCj4gPiBJT0FTSUQgYmVsb25nIHRvICthbm90aGVyIFZNLgo+ID4g Kzo6Cj4gPiArCj4gPiArIHN0cnVjdCBpb2FzaWRfc2V0ICppb2FzaWRfYWxsb2Nfc2V0KHZvaWQg KnRva2VuLCBpb2FzaWRfdCBxdW90YSwKPiA+IHUzMiB0eXBlKSArCj4gPiArIGludCBpb2FzaWRf YWRqdXN0X3NldChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpbnQgcXVvdGEpOwo+ID4gKwo+ID4g KyB2b2lkIGlvYXNpZF9zZXRfZ2V0KHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQpCj4gPiArCj4gPiAr IHZvaWQgaW9hc2lkX3NldF9wdXQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCkKPiA+ICsKPiA+ICsg dm9pZCBpb2FzaWRfc2V0X2dldF9sb2NrZWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCkKPiA+ICsK PiA+ICsgdm9pZCBpb2FzaWRfc2V0X3B1dF9sb2NrZWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCkK PiA+ICsKPiA+ICsgaW50IGlvYXNpZF9zZXRfZm9yX2VhY2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRf c2V0ICpzZGF0YSwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKCpm bikoaW9hc2lkX3QgaWQsIHZvaWQKPiA+ICpkYXRhKSwKPiA+ICsJCQkJdm9pZCAqZGF0YSkKPiA+ ICsKPiA+ICsKPiA+ICtJT0FTSUQgc2V0IGNvbmNlcHQgaXMgaW50cm9kdWNlZCB0byByZXByZXNl bnQgc3VjaCBJT0FTSUQgZ3JvdXBzLgo+ID4gRWFjaCArSU9BU0lEIHNldCBpcyBjcmVhdGVkIHdp dGggYSB0b2tlbiB3aGljaCBjYW4gYmUgb25lIG9mIHRoZQo+ID4gZm9sbG93aW5nICt0eXBlczoK PiA+ICsKPiA+ICsgLSBJT0FTSURfU0VUX1RZUEVfTlVMTCAoQXJiaXRyYXJ5IHU2NCB2YWx1ZSkK PiA+ICsgLSBJT0FTSURfU0VUX1RZUEVfTU0gKFNldCB0b2tlbiBpcyBhIG1tX3N0cnVjdCkKPiA+ ICsKPiA+ICtUaGUgZXhwbGljaXQgTU0gdG9rZW4gdHlwZSBpcyB1c2VmdWwgd2hlbiBtdWx0aXBs ZSB1c2VycyBvZiBhbgo+ID4gSU9BU0lEICtzZXQgdW5kZXIgdGhlIHNhbWUgcHJvY2VzcyBuZWVk IHRvIGNvbW11bmljYXRlIGFib3V0IHRoZWlyCj4gPiBzaGFyZWQgSU9BU0lEcy4gK0UuZy4gQW4g SU9BU0lEIHNldCBjcmVhdGVkIGJ5IFZGSU8gZm9yIG9uZSBndWVzdAo+ID4gY2FuIGJlIGFzc29j aWF0ZWQgK3dpdGggdGhlIEtWTSBpbnN0YW5jZSBmb3IgdGhlIHNhbWUgZ3Vlc3Qgc2luY2UKPiA+ IHRoZXkgc2hhcmUgYSBjb21tb24gbW1fc3RydWN0LiArCj4gPiArVGhlIElPQVNJRCBzZXQgQVBJ cyBzZXJ2ZSB0aGUgZm9sbG93aW5nIHB1cnBvc2VzOgo+ID4gKwo+ID4gKyAtIE93bmVyc2hpcC9w ZXJtaXNzaW9uIGVuZm9yY2VtZW50Cj4gPiArIC0gVGFrZSBjb2xsZWN0aXZlIGFjdGlvbnMsIGUu Zy4gZnJlZSBhbiBlbnRpcmUgc2V0Cj4gPiArIC0gRXZlbnQgbm90aWZpY2F0aW9ucyB3aXRoaW4g YSBzZXQKPiA+ICsgLSBMb29rIHVwIGEgc2V0IGJhc2VkIG9uIHRva2VuCj4gPiArIC0gUXVvdGEg ZW5mb3JjZW1lbnQKPiA+ICsKPiA+ICtJbmRpdmlkdWFsIElPQVNJRCBBUElzCj4gPiArLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQo+ID4gK09uY2UgYW4gaW9hc2lkX3NldCBpcyBjcmVhdGVkLCBJT0FT SURzIGNhbiBiZSBhbGxvY2F0ZWQgZnJvbSB0aGUKPiA+IHNldC4gK1dpdGhpbiB0aGUgSU9BU0lE IHNldCBuYW1lc3BhY2UsIHNldCBwcml2YXRlIElEIChTUElEKSBpcwo+ID4gc3VwcG9ydGVkLiBJ biArdGhlIFZNIHVzZSBjYXNlLCBTUElEIGNhbiBiZSB1c2VkIGZvciBzdG9yaW5nIGd1ZXN0Cj4g PiBQQVNJRC4gKwo+ID4gKzo6Cj4gPiArCj4gPiArIGlvYXNpZF90IGlvYXNpZF9hbGxvYyhzdHJ1 Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBtaW4sCj4gPiBpb2FzaWRfdCBtYXgsCj4gPiAr ICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpwcml2YXRlKTsKPiA+ICsKPiA+ICsgaW50IGlv YXNpZF9nZXQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkKTsKPiA+ICsK PiA+ICsgdm9pZCBpb2FzaWRfcHV0KHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlv YXNpZCk7Cj4gPiArCj4gPiArIGludCBpb2FzaWRfZ2V0X2xvY2tlZChzdHJ1Y3QgaW9hc2lkX3Nl dCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQpOwo+ID4gKwo+ID4gKyB2b2lkIGlvYXNpZF9wdXRfbG9j a2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCk7Cj4gPiArCj4gPiAr IHZvaWQgKmlvYXNpZF9maW5kKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNp ZCwKPiA+ICsgICAgICAgICAgICAgICAgICAgYm9vbCAoKmdldHRlcikodm9pZCAqKSk7Cj4gPiAr Cj4gPiArIGlvYXNpZF90IGlvYXNpZF9maW5kX2J5X3NwaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNl dCwgaW9hc2lkX3QKPiA+IHNwaWQpICsKPiA+ICsgaW50IGlvYXNpZF9hdHRhY2hfZGF0YShzdHJ1 Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQsCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICAgdm9pZCAqZGF0YSk7Cj4gPiArIGludCBpb2FzaWRfYXR0YWNoX3NwaWQoc3RydWN0 IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkLAo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgIGlvYXNpZF90IHNzaWQpOwo+ID4gKwo+ID4gKwo+ID4gK05vdGlmaWNhdGlvbnMKPiA+ ICstLS0tLS0tLS0tLS0tCj4gPiArQW4gSU9BU0lEIG1heSBoYXZlIG11bHRpcGxlIHVzZXJzLCBl YWNoIHVzZXIgbWF5IGhhdmUgaGFyZHdhcmUKPiA+IGNvbnRleHQgK2Fzc29jaWF0ZWQgd2l0aCBh biBJT0FTSUQuIFdoZW4gdGhlIHN0YXR1cyBvZiBhbiBJT0FTSUQKPiA+IGNoYW5nZXMsICtlLmcu IGFuIElPQVNJRCBpcyBiZWluZyBmcmVlZCwgdXNlcnMgbmVlZCB0byBiZSBub3RpZmllZAo+ID4g c3VjaCB0aGF0IHRoZSArYXNzb2NpYXRlZCBoYXJkd2FyZSBjb250ZXh0IGNhbiBiZSBjbGVhcmVk LCBmbHVzaGVkLAo+ID4gYW5kIGRyYWluZWQuICsKPiA+ICs6Ogo+ID4gKwo+ID4gKyBpbnQgaW9h c2lkX3JlZ2lzdGVyX25vdGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIHN0cnVjdAo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKPiA+ICsK PiA+ICsgdm9pZCBpb2FzaWRfdW5yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3QgaW9hc2lkX3NldCAq c2V0LAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBub3RpZmll cl9ibG9jayAqbmIpCj4gPiArCj4gPiArIGludCBpb2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0o c3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKPiA+ICsKPiA+ICsgdm9pZCBpb2FzaWRfdW5y ZWdpc3Rlcl9ub3RpZmllcl9tbShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0Cj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbm90aWZpZXJfYmxvY2sgKm5iKQo+ID4g Kwo+ID4gKyBpbnQgaW9hc2lkX25vdGlmeShpb2FzaWRfdCBpb2FzaWQsIGVudW0gaW9hc2lkX25v dGlmeV92YWwgY21kLAo+ID4gKyAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgZmxhZ3Mp Cj4gPiArCj4gPiArCj4gPiArRXZlbnRzCj4gPiArfn5+fn5+Cj4gPiArTm90aWZpY2F0aW9uIGV2 ZW50cyBhcmUgcGVydGluZW50IHRvIGluZGl2aWR1YWwgSU9BU0lEcywgdGhleSBjYW4KPiA+IGJl ICtvbmUgb2YgdGhlIGZvbGxvd2luZzoKPiA+ICsKPiA+ICsgLSBBTExPQwo+ID4gKyAtIEZSRUUK PiA+ICsgLSBCSU5ECj4gPiArIC0gVU5CSU5ECj4gPiArCj4gPiArT3JkZXJpbmcKPiA+ICt+fn5+ fn5+fgo+ID4gK09yZGVyaW5nIGlzIHN1cHBvcnRlZCBieSBJT0FTSUQgbm90aWZpY2F0aW9uIHBy aW9yaXRpZXMgYXMgdGhlCj4gPiArZm9sbG93aW5nIChpbiBhc2NlbmRpbmcgb3JkZXIpOiAgCj4g Cj4gV2hhdCBkb2VzIGFzY2VuZGluZyBvcmRlciBleGFjdGx5IG1lYW4gaGVyZT8gTEFTVC0+SU9N TVUtPkRFVklDRS4uLj8KPiAKWWVzLiBDUFUgaGFzIHRoZSBoaWdoZXN0IHByaW9yaXR5IGFuZCB3 aWxsIGdldCBub3RpZmllZCBmaXJzdC4KCj4gPiArCj4gPiArOjoKPiA+ICsKPiA+ICsgZW51bSBp b2FzaWRfbm90aWZpZXJfcHJpb3Mgewo+ID4gKwlJT0FTSURfUFJJT19MQVNULAo+ID4gKwlJT0FT SURfUFJJT19JT01NVSwKPiA+ICsJSU9BU0lEX1BSSU9fREVWSUNFLAo+ID4gKwlJT0FTSURfUFJJ T19DUFUsCj4gPiArIH07Cj4gPiArCj4gPiArVGhlIHR5cGljYWwgdXNlIGNhc2UgaXMgd2hlbiBh biBJT0FTSUQgaXMgZnJlZWQgZHVlIHRvIGFuCj4gPiBleGNlcHRpb24sIERNQSArc291cmNlIHNo b3VsZCBiZSBxdWllc2NlZCBiZWZvcmUgdGVhcmluZyBkb3duIG90aGVyCj4gPiBoYXJkd2FyZSBj b250ZXh0cyAraW4gdGhlIHN5c3RlbS4gVGhpcyB3aWxsIHJlZHVjZSB0aGUgY2h1cm4gaW4KPiA+ IGhhbmRsaW5nIGZhdWx0cy4gRE1BIHdvcmsgK3N1Ym1pc3Npb24gaXMgcGVyZm9ybWVkIGJ5IHRo ZSBDUFUgd2hpY2gKPiA+IGlzIGdyYW50ZWQgaGlnaGVyIHByaW9yaXR5IHRoYW4gK2RldmljZXMu Cj4gPiArCj4gPiArCj4gPiArU2NvcGVzCj4gPiArfn5+fn5+Cj4gPiArVGhlcmUgYXJlIHR3byB0 eXBlcyBvZiBub3RpZmllcnMgaW4gSU9BU0lEIGNvcmU6IHN5c3RlbS13aWRlIGFuZAo+ID4gK2lv YXNpZF9zZXQtd2lkZS4KPiA+ICsKPiA+ICtTeXN0ZW0td2lkZSBub3RpZmllciBpcyBjYXRlcmlu ZyBmb3IgdXNlcnMgdGhhdCBuZWVkIHRvIGhhbmRsZSBhbGwKPiA+ICtJT0FTSURzIGluIHRoZSBz eXN0ZW0uIEUuZy4gVGhlIElPTU1VIGRyaXZlciBoYW5kbGVzIGFsbCBJT0FTSURzLgo+ID4gKwo+ ID4gK1BlciBpb2FzaWRfc2V0IG5vdGlmaWVyIGNhbiBiZSB1c2VkIGJ5IFZNIHNwZWNpZmljIGNv bXBvbmVudHMgc3VjaAo+ID4gYXMgK0tWTS4gQWZ0ZXIgYWxsLCBlYWNoIEtWTSBpbnN0YW5jZSBv bmx5IGNhcmVzIGFib3V0IElPQVNJRHMKPiA+IHdpdGhpbiBpdHMgK293biBzZXQuCj4gPiArCj4g PiArCj4gPiArQXRvbWljaXR5Cj4gPiArfn5+fn5+fn5+Cj4gPiArSU9BU0lEIG5vdGlmaWVycyBh cmUgYXRvbWljIGR1ZSB0byBzcGlubG9ja3MgdXNlZCBpbnNpZGUgdGhlIElPQVNJRAo+ID4gK2Nv cmUuIEZvciB0YXNrcyBjYW5ub3QgYmUgY29tcGxldGVkIGluIHRoZSBub3RpZmllciBoYW5kbGVy LCBhc3luYwo+ID4gd29yayArY2FuIGJlIHN1Ym1pdHRlZCB0byBjb21wbGV0ZSB0aGUgd29yayBs YXRlciBhcyBsb25nIGFzIHRoZXJlCj4gPiBpcyBubyArb3JkZXJpbmcgcmVxdWlyZW1lbnQuCj4g PiArCj4gPiArUmVmZXJlbmNlIGNvdW50aW5nCj4gPiArLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiAr SU9BU0lEIGxpZmVjeWNsZSBtYW5hZ2VtZW50IGlzIGJhc2VkIG9uIHJlZmVyZW5jZSBjb3VudGlu Zy4gVXNlcnMKPiA+IG9mICtJT0FTSUQgaW50ZW5kIHRvIGFsaWduIGxpZmVjeWNsZSB3aXRoIHRo ZSBJT0FTSUQgbmVlZCB0byBob2xkCj4gPiArcmVmZXJlbmNlIG9mIHRoZSBJT0FTSUQuIElPQVNJ RCB3aWxsIG5vdCBiZSByZXR1cm5lZCB0byB0aGUgcG9vbAo+ID4gZm9yICthbGxvY2F0aW9uIHVu dGlsIGFsbCByZWZlcmVuY2VzIGFyZSBkcm9wcGVkLiBDYWxsaW5nCj4gPiBpb2FzaWRfZnJlZSgp ICt3aWxsIG1hcmsgdGhlIElPQVNJRCBhcyBGUkVFX1BFTkRJTkcgaWYgdGhlIElPQVNJRAo+ID4g aGFzIG91dHN0YW5kaW5nICtyZWZlcmVuY2UuIGlvYXNpZF9nZXQoKSBpcyBub3QgYWxsb3dlZCBv bmNlIGFuCj4gPiBJT0FTSUQgaXMgaW4gdGhlICtGUkVFX1BFTkRJTkcgc3RhdGUuCj4gPiArCj4g PiArRXZlbnQgbm90aWZpY2F0aW9ucyBhcmUgdXNlZCB0byBpbmZvcm0gdXNlcnMgb2YgSU9BU0lE IHN0YXR1cwo+ID4gY2hhbmdlLiArSU9BU0lEX0ZSRUUgZXZlbnQgcHJvbXB0cyB1c2VycyB0byBk cm9wIHRoZWlyIHJlZmVyZW5jZXMKPiA+IGFmdGVyICtjbGVhcmluZyBpdHMgY29udGV4dC4KPiA+ ICsKPiA+ICtGb3IgZXhhbXBsZSwgb24gVlQtZCBwbGF0Zm9ybSB3aGVuIGFuIElPQVNJRCBpcyBm cmVlZCwgdGVhcmRvd24KPiA+ICthY3Rpb25zIGFyZSBwZXJmb3JtZWQgb24gS1ZNLCBkZXZpY2Ug ZHJpdmVyLCBhbmQgSU9NTVUgZHJpdmVyLgo+ID4gK0tWTSBzaGFsbCByZWdpc3RlciBub3RpZmll ciBibG9jayB3aXRoOjoKPiA+ICsKPiA+ICsgc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBw YXNpZF9uYl9rdm0gPSB7Cj4gPiArCS5ub3RpZmllcl9jYWxsID0gcGFzaWRfc3RhdHVzX2NoYW5n ZV9rdm0sCj4gPiArCS5wcmlvcml0eSAgICAgID0gSU9BU0lEX1BSSU9fQ1BVLAo+ID4gKyB9Owo+ ID4gKwo+ID4gK1ZEQ00gZHJpdmVyIHNoYWxsIHJlZ2lzdGVyIG5vdGlmaWVyIGJsb2NrIHdpdGg6 Ogo+ID4gKwo+ID4gKyBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBhc2lkX25iX3ZkY20g PSB7Cj4gPiArCS5ub3RpZmllcl9jYWxsID0gcGFzaWRfc3RhdHVzX2NoYW5nZV92ZGNtLAo+ID4g KwkucHJpb3JpdHkgICAgICA9IElPQVNJRF9QUklPX0RFVklDRSwKPiA+ICsgfTsKPiA+ICsKPiA+ ICtJbiBib3RoIGNhc2VzLCBub3RpZmllciBibG9ja3Mgc2hhbGwgYmUgcmVnaXN0ZXJlZCBvbiB0 aGUgSU9BU0lECj4gPiBzZXQgK3N1Y2ggdGhhdCAqb25seSogZXZlbnRzIGZyb20gdGhlIG1hdGNo aW5nIFZNIGlzIHJlY2VpdmVkLgo+ID4gKwo+ID4gK0lmIEtWTSBhdHRlbXB0cyB0byByZWdpc3Rl ciBub3RpZmllciBibG9jayBiZWZvcmUgdGhlIElPQVNJRCBzZXQgaXMKPiA+ICtjcmVhdGVkIGZv ciB0aGUgTU0gdG9rZW4sIHRoZSBub3RpZmllciBibG9jayB3aWxsIGJlIHBsYWNlZCBvbiBhCj4g PiArcGVuZGluZyBsaXN0IGluc2lkZSBJT0FTSUQgY29yZS4gT25jZSB0aGUgdG9rZW4gbWF0Y2hp bmcgSU9BU0lEIHNldAo+ID4gK2lzIGNyZWF0ZWQsIElPQVNJRCB3aWxsIHJlZ2lzdGVyIHRoZSBu b3RpZmllciBibG9jayBhdXRvbWF0aWNhbGx5Lgo+ID4gK0lPQVNJRCBjb3JlIGRvZXMgbm90IHJl cGxheSBldmVudHMgZm9yIHRoZSBleGlzdGluZyBJT0FTSURzIGluIHRoZQo+ID4gK3NldC4gRm9y IElPQVNJRCBzZXQgb2YgTU0gdHlwZSwgbm90aWZpY2F0aW9uIGJsb2NrcyBjYW4gYmUKPiA+IHJl Z2lzdGVyZWQgK29uIGVtcHR5IHNldHMgb25seS4gVGhpcyBpcyB0byBhdm9pZCBsb3N0IGV2ZW50 cy4KPiA+ICsKPiA+ICtJT01NVSBkcml2ZXIgc2hhbGwgcmVnaXN0ZXIgbm90aWZpZXIgYmxvY2sg b24gZ2xvYmFsIGNoYWluOjoKPiA+ICsKPiA+ICsgc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9j ayBwYXNpZF9uYl92dGQgPSB7Cj4gPiArCS5ub3RpZmllcl9jYWxsID0gcGFzaWRfc3RhdHVzX2No YW5nZV92dGQsCj4gPiArCS5wcmlvcml0eSAgICAgID0gSU9BU0lEX1BSSU9fSU9NTVUsCj4gPiAr IH07Cj4gPiArCj4gPiArQ3VzdG9tIGFsbG9jYXRvciBBUElzCj4gPiArLS0tLS0tLS0tLS0tLS0t LS0tLS0tCj4gPiArCj4gPiArOjoKPiA+ICsKPiA+ICsgaW50IGlvYXNpZF9yZWdpc3Rlcl9hbGxv Y2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3BzCj4gPiAqYWxsb2NhdG9yKTsgKwo+ID4g KyB2b2lkIGlvYXNpZF91bnJlZ2lzdGVyX2FsbG9jYXRvcihzdHJ1Y3QgaW9hc2lkX2FsbG9jYXRv cl9vcHMKPiA+ICphbGxvY2F0b3IpOyArCj4gPiArQWxsb2NhdG9yIENob2ljZXMKPiA+ICt+fn5+ fn5+fn5+fn5+fn5+fgo+ID4gK0lPQVNJRHMgYXJlIGFsbG9jYXRlZCBmb3IgYm90aCBob3N0IGFu ZCBndWVzdCBTVkEvSU9WQSB1c2FnZS4KPiA+IEhvd2V2ZXIsICthbGxvY2F0b3JzIGNhbiBiZSBk aWZmZXJlbnQuIEZvciBleGFtcGxlLCBvbiBWVC1kIGd1ZXN0Cj4gPiBQQVNJRCArYWxsb2NhdGlv biBtdXN0IGJlIHBlcmZvcm1lZCB2aWEgYSB2aXJ0dWFsIGNvbW1hbmQgaW50ZXJmYWNlCj4gPiB3 aGljaCBpcyArZW11bGF0ZWQgYnkgVk1NLgo+ID4gKwo+ID4gK0lPQVNJRCBjb3JlIGhhcyB0aGUg bm90aW9uIG9mICJjdXN0b20gYWxsb2NhdG9yIiBzdWNoIHRoYXQgZ3Vlc3QKPiA+IGNhbiArcmVn aXN0ZXIgdmlydHVhbCBjb21tYW5kIGFsbG9jYXRvciB0aGF0IHByZWNlZGVzIHRoZSBkZWZhdWx0 Cj4gPiBvbmUuICsKPiA+ICtOYW1lc3BhY2VzCj4gPiArfn5+fn5+fn5+fgo+ID4gK0lPQVNJRHMg YXJlIGxpbWl0ZWQgc3lzdGVtIHJlc291cmNlcyB0aGF0IGRlZmF1bHQgdG8gMjAgYml0cyBpbgo+ ID4gK3NpemUuIFNpbmNlIGVhY2ggZGV2aWNlIGhhcyBpdHMgb3duIHRhYmxlLCB0aGVvcmV0aWNh bGx5IHRoZQo+ID4gbmFtZXNwYWNlICtjYW4gYmUgcGVyIGRldmljZSBhbHNvLiBIb3dldmVyLCBm b3Igc2VjdXJpdHkgcmVhc29ucwo+ID4gc2hhcmluZyBQQVNJRCArdGFibGVzIGFtb25nIGRldmlj ZXMgYXJlIG5vdCBnb29kIGZvciBpc29sYXRpb24uCj4gPiBUaGVyZWZvcmUsIElPQVNJRCArbmFt ZXNwYWNlIGlzIHN5c3RlbS13aWRlLgo+ID4gKwo+ID4gK1RoZXJlIGFyZSBhbHNvIG90aGVyIHJl YXNvbnMgdG8gaGF2ZSB0aGlzIHNpbXBsZXIgc3lzdGVtLXdpZGUKPiA+ICtuYW1lc3BhY2UuIFRh a2UgVlQtZCBhcyBhbiBleGFtcGxlLCBWVC1kIHN1cHBvcnRzIHNoYXJlZCB3b3JrcXVldWUKPiA+ ICthbmQgRU5RQ01EWzFdIHdoZXJlIG9uZSBJT0FTSUQgY291bGQgYmUgdXNlZCB0byBzdWJtaXQg d29yayBvbgo+ID4gK211bHRpcGxlIGRldmljZXMgdGhhdCBhcmUgc2hhcmVkIHdpdGggb3RoZXIg Vk1zLiBUaGlzIHJlcXVpcmVzCj4gPiBJT0FTSUQgK3RvIGJlIHN5c3RlbS13aWRlLiBUaGlzIGlz IGFsc28gdGhlIHJlYXNvbiB3aHkgZ3Vlc3RzIG11c3QKPiA+IHVzZSBhbiArZW11bGF0ZWQgdmly dHVhbCBjb21tYW5kIGludGVyZmFjZSB0byBhbGxvY2F0ZSBJT0FTSUQgZnJvbQo+ID4gdGhlIGhv c3QuICsKPiA+ICsKPiA+ICtMaWZlIGN5Y2xlCj4gPiArPT09PT09PT09PQo+ID4gK1RoaXMgc2Vj dGlvbiBjb3ZlcnMgSU9BU0lEIGxpZmVjeWNsZSBtYW5hZ2VtZW50IGZvciBib3RoIGJhcmUtbWV0 YWwKPiA+ICthbmQgZ3Vlc3QgdXNhZ2VzLiBJbiBiYXJlLW1ldGFsIFNWQSwgTU1VIG5vdGlmaWVy IGlzIGRpcmVjdGx5Cj4gPiBob29rZWQgK3VwIHdpdGggSU9NTVUgZHJpdmVyLCB0aGVyZWZvcmUg dGhlIHByb2Nlc3MgYWRkcmVzcyBzcGFjZQo+ID4gKE1NKSArbGlmZWN5Y2xlIGlzIGFsaWduZWQg d2l0aCBJT0FTSUQuICAKPiAKPiBNTVUgbm90aWZpZXIgZm9yIFNWQSBtYWlubHkgc2VydmVzIElP TU1VIGNhY2hlIGZsdXNoZXMsIHJpZ2h0PyBUaGUKPiBJT0FTSUQgbGlmZSBjeWNsZSBmb3IgYmFy ZSBtYXRhbCBTVkEgaXMgbWFuYWdlZCBieSB0aGUgZGV2aWNlIGRyaXZlcgo+IHRocm91Z2ggdGhl IGlvbW11IHN2YSBhcGkncyBpb21tdV9zdmFfKHVuKWJpbmRfZGV2aWNlKCk/Cj4gClRydWUgdGhh dCBsaWZlY3ljbGUgYmV0d2VlbiBpb21tdSBhbmQgZGV2aWNlIGFyZSBhbGlnbmVkIGJ5IHN2YSBB UElzLgpCdXQgYmV0d2VlbiBtbS9jcHUgYW5kIGlvbW11LCBpdCBkZXBlbmRzIG9uIG1tdV9ub3Rp Zmllci5yZWxlYXNlKCkuIEluCmNhc2UgcHJvY2VzcyB0ZXJtaW5hdGVzIHVuZXhwZWN0ZWRseS4K Cj4gPiArCj4gPiArSG93ZXZlciwgZ3Vlc3QgTU1VIG5vdGlmaWVyIGlzIG5vdCBhdmFpbGFibGUg dG8gaG9zdCBJT01NVSBkcml2ZXIsCj4gPiArd2hlbiBndWVzdCBNTSB0ZXJtaW5hdGVzIHVuZXhw ZWN0ZWRseSwgdGhlIGV2ZW50cyBoYXZlIHRvIGdvCj4gPiB0aHJvdWdoICtWRklPIGFuZCBJT01N VSBVQVBJIHRvIHJlYWNoIGhvc3QgSU9NTVUgZHJpdmVyLiBUaGVyZSBhcmUKPiA+IGFsc28gbW9y ZSArcGFydGllcyBpbnZvbHZlZCBpbiBndWVzdCBTVkEsIGUuZy4gb24gSW50ZWwgVlQtZAo+ID4g cGxhdGZvcm0sIElPQVNJRHMgK2FyZSB1c2VkIGJ5IElPTU1VIGRyaXZlciwgS1ZNLCBWRENNLCBh bmQgVkZJTy4KPiA+ICsKPiA+ICtOYXRpdmUgSU9BU0lEIExpZmUgQ3ljbGUgKFZULWQgRXhhbXBs ZSkKPiA+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICsKPiA+ ICtUaGUgbm9ybWFsIGZsb3cgb2YgbmF0aXZlIFNWQSBjb2RlIHdpdGggSW50ZWwgRGF0YSBTdHJl YW1pbmcKPiA+ICtBY2NlbGVyYXRvcihEU0EpIFsyXSBhcyBleGFtcGxlOgo+ID4gKwo+ID4gKzEu IEhvc3QgdXNlciBvcGVucyBhY2NlbGVyYXRvciBGRCwgZS5nLiBEU0EgZHJpdmVyLCBvciB1YWNj ZTsKPiA+ICsyLiBEU0EgZHJpdmVyIGFsbG9jYXRlIFdRLCBkbyBzdmFfYmluZF9kZXZpY2UoKTsK PiA+ICszLiBJT01NVSBkcml2ZXIgY2FsbHMgaW9hc2lkX2FsbG9jKCksIHRoZW4gYmluZCBQQVNJ RCB3aXRoIGRldmljZSwKPiA+ICsgICBtbXVfbm90aWZpZXJfZ2V0KCkKPiA+ICs0LiBETUEgc3Rh cnRzIGJ5IERTQSBkcml2ZXIgdXNlcnNwYWNlCj4gPiArNS4gRFNBIHVzZXJzcGFjZSBjbG9zZSBG RAo+ID4gKzYuIERTQS91YWNjZSBrZXJuZWwgZHJpdmVyIGhhbmRsZXMgRkQuY2xvc2UoKQo+ID4g KzcuIERTQSBkcml2ZXIgc3RvcHMgRE1BCj4gPiArOC4gRFNBIGRyaXZlciBjYWxscyBzdmFfdW5i aW5kX2RldmljZSgpOwo+ID4gKzkuIElPTU1VIGRyaXZlciBkb2VzIHVuYmluZCwgY2xlYXJzIFBB U0lEIGNvbnRleHQgaW4gSU9NTVUsIGZsdXNoCj4gPiArICAgVExCcy4gbW11X25vdGlmaWVyX3B1 dCgpIGNhbGxlZC4KPiA+ICsxMC4gbW11X25vdGlmaWVyLnJlbGVhc2UoKSBjYWxsZWQsIElPTU1V IFNWQSBjb2RlIGNhbGxzCj4gPiBpb2FzaWRfZnJlZSgpKiArMTEuIFRoZSBJT0FTSUQgaXMgcmV0 dXJuZWQgdG8gdGhlIHBvb2wsIHJlY2xhaW1lZC4KPiA+ICsKPiA+ICs6Ogo+ID4gKwo+ID4gKyAg ICogV2l0aCBFTlFDTUQsIFBBU0lEIHVzZWQgb24gVlQtZCBpcyBub3QgcmVsZWFzZWQgaW4KPiA+ IG1tdV9ub3RpZmllcigpIGJ1dAo+ID4gKyAgICAgbW1kcm9wKCkuIG1tZHJvcCBjb21lcyBhZnRl ciBGRCBjbG9zZS4gU2hvdWxkIG5vdCBtYXR0ZXIuCj4gPiArICAgICBJZiB0aGUgdXNlciBwcm9j ZXNzIGRpZXMgdW5leHBlY3RlZGx5LCBTdGVwICMxMCBtYXkgY29tZQo+ID4gYmVmb3JlCj4gPiAr ICAgICBTdGVwICM1LCBpbiBiZXR3ZWVuLCBhbGwgRE1BIGZhdWx0cyBkaXNjYXJkZWQuIFBSUSBy ZXNwb25kZWQKPiA+IHdpdGgKPiA+ICsgICAgIGNvZGUgSU5WQUxJRCBSRVFVRVNULgo+ID4gKwo+ ID4gK0R1cmluZyB0aGUgbm9ybWFsIHRlYXJkb3duLCB0aGUgZm9sbG93aW5nIHRocmVlIHN0ZXBz IHdvdWxkIGhhcHBlbgo+ID4gaW4gK29yZGVyOgo+ID4gKwo+ID4gKzEuIERldmljZSBkcml2ZXIg c3RvcHMgRE1BIHJlcXVlc3QKPiA+ICsyLiBJT01NVSBkcml2ZXIgdW5iaW5kcyBQQVNJRCBhbmQg bW0sIGZsdXNoIGFsbCBUTEJzLCBkcmFpbgo+ID4gaW4tZmxpZ2h0Cj4gPiArICAgcmVxdWVzdHMu Cj4gPiArMy4gSU9BU0lEIGZyZWVkCj4gPiArCj4gPiArRXhjZXB0aW9uIGhhcHBlbnMgd2hlbiBw cm9jZXNzIHRlcm1pbmF0ZXMgKmJlZm9yZSogZGV2aWNlIGRyaXZlcgo+ID4gc3RvcHMgK0RNQSBh bmQgY2FsbCBJT01NVSBkcml2ZXIgdG8gdW5iaW5kLiBUaGUgZmxvdyBvZiBwcm9jZXNzCj4gPiBl eGlzdHMgYXJlIGFzICtmb2xsb3dzOgo+ID4gKwo+ID4gKzo6Cj4gPiArCj4gPiArICAgZG9fZXhp dCgpIHsKPiA+ICsJZXhpdF9tbSgpIHsKPiA+ICsJCW1tX3B1dCgpOwo+ID4gKwkJZXhpdF9tbWFw KCkgewo+ID4gKwkJCWludGVsX2ludmFsaWRhdGVfcmFuZ2UoKSAvL21tdSBub3RpZmllcgo+ID4g KwkJCXRsYl9maW5pc2hfbW11KCkKPiA+ICsJCQltbXVfbm90aWZpZXJfcmVsZWFzZShtbSkgewo+ ID4gKwkJCQlpbnRlbF9pb21tdV9yZWxlYXNlKCkgeyAgCj4gCj4gaW50ZWxfbW1fcmVsZWFzZSgp Ckdvb2QgY2F0Y2gsCgo+IAo+ID4gKyAgIFsyXQo+ID4gaW50ZWxfaW9tbXVfdGVhcmRvd25fcGFz aWQoKTsKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50ZWxf aW9tbXVfZmx1c2hfdGxicygpOwo+ID4gKwkJCQl9Cj4gPiArCQkJCS8vIHRsYl9pbnZhbGlkYXRl X3JhbmdlIGNiIHJlbW92ZWQKPiA+ICsJCQl9Cj4gPiArCQkJdW5tYXBfdm1hcygpOwo+ID4gKyAg ICAgICAgICAgICAgICAgICAgICAgIGZyZWVfcGd0YWJsZXMoKTsgLy8gSU9NTVUgY2Fubm90IHdh bGsgUEdUCj4gPiBhZnRlciB0aGlzCj4gPiArCQl9Owo+ID4gKwl9Cj4gPiArCWV4aXRfZmlsZXMo dHNrKSB7Cj4gPiArCQljbG9zZV9maWxlcygpIHsKPiA+ICsJCQlkc2FfY2xvc2UoKTsKPiA+ICsg ICBbMV0JCQlkc2Ffc3RvcF9kbWEoKTsKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICBpbnRl bF9zdm1fdW5iaW5kX3Bhc2lkKCk7IC8vbm90aGluZyB0byBkbwo+ID4gKwkJfQo+ID4gKwl9Cj4g PiArICAgfQo+ID4gKwo+ID4gKyAgIG1tZHJvcCgpIC8qIHNvbWUgcmFuZG9tIHRpbWUgbGF0ZXIs IGxhenkgbW0gdXNlciAqLyB7Cj4gPiArICAgCW1tX2ZyZWVfcGdkKCk7Cj4gPiArICAgICAgICBk ZXN0cm95X2NvbnRleHQobW0pOyB7Cj4gPiArICAgWzNdCSAgICAgICAgaW9hc2lkX2ZyZWUoKTsK PiA+ICsJfQo+ID4gKyAgIH0KPiA+ICsKPiA+ICtBcyBzaG93biBpbiB0aGUgbGlzdCBhYm92ZSwg c3RlcCAjMiBjb3VsZCBoYXBwZW4gYmVmb3JlCj4gPiArIzEuIFVucmVjb3ZlcmFibGUoVVIpIGZh dWx0cyBjb3VsZCBoYXBwZW4gYmV0d2VlbiAjMiBhbmQgIzEuICAKPiAKPiBUaGUgVlQtZCBoYXJk d2FyZSB3aWxsIGlnbm9yZSBVUiBmYXVsdHMgZHVlIHRvIHRoZSBzZXR0aW5nIG9mIEZQRCBiaXQK PiBvZiB0aGUgUEFTSUQgZW50cnkuIFRoZSBzb2Z0d2FyZSB3b24ndCBzZWUgVVIgZmF1bHRzLgo+ IApZZXMsIGhlcmUgSSBzaG91bGQgbm90ZSB0aGF0LgoiRmF1bHQgcHJvY2Vzc2luZyBpcyBkaXNh YmxlZCBieSB0aGUgSU9NTVUgZHJpdmVyIGluICMyLCB0aGVyZWZvcmUgdGhlClVSIGZhdWx0IG5l dmVyIHJlYWNoZXMgdGhlIGRyaXZlci4iCgo+ID4gKwo+ID4gK0Fsc28gbm90aWNlIHRoYXQgVExC IGludmFsaWRhdGlvbiBvY2N1cnMgYXQgbW11X25vdGlmaWVyCj4gPiAraW52YWxpZGF0ZV9yYW5n ZSBjYWxsYmFjayBhcyB3ZWxsIGFzIHRoZSByZWxlYXNlIGNhbGxiYWNrLiBUaGUKPiA+IHJlYXNv biAraXMgdGhhdCByZWxlYXNlIGNhbGxiYWNrIHdpbGwgZGVsZXRlIElPTU1VIGRyaXZlciBmcm9t IHRoZQo+ID4gbm90aWZpZXIgK2NoYWluIHdoaWNoIG1heSBza2lwIGludmFsaWRhdGVfcmFuZ2Uo KSBjYWxscyBkdXJpbmcgdGhlCj4gPiBleGl0IHBhdGguICsKPiA+ICtUbyBhdm9pZCB1bm5lY2Vz c2FyeSByZXBvcnRpbmcgb2YgVVIgZmF1bHQsIElPTU1VIGRyaXZlciBzaGFsbAo+ID4gZGlzYWJs ZSArZmF1bHQgcmVwb3J0aW5nIGFmdGVyIGZyZWUgYW5kIGJlZm9yZSB1bmJpbmQuCj4gPiArCj4g PiArR3Vlc3QgSU9BU0lEIExpZmUgQ3ljbGUgKFZULWQgRXhhbXBsZSkKPiA+ICstLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gK0d1ZXN0IElPQVNJRCBsaWZlIGN5Y2xl IHN0YXJ0cyB3aXRoIGd1ZXN0IGRyaXZlciBvcGVuKCksIHRoaXMKPiA+IGNvdWxkIGJlICt1YWNj ZSBvciBpbmRpdmlkdWFsIGFjY2VsZXJhdG9yIGRyaXZlciBzdWNoIGFzIERTQS4gQXQgRkQKPiA+ IG9wZW4sICtzdmFfYmluZF9kZXZpY2UoKSBpcyBjYWxsZWQgd2hpY2ggdHJpZ2dlcnMgYSBzZXJp ZXMgb2YKPiA+IGFjdGlvbnMuICsKPiA+ICtUaGUgZXhhbXBsZSBiZWxvdyBpcyBhbiBpbGx1c3Ry YXRpb24gb2YgKm5vcm1hbCogb3BlcmF0aW9ucyB0aGF0Cj4gPiAraW52b2x2ZXMgKmFsbCogdGhl IFNXIGNvbXBvbmVudHMgaW4gVlQtZC4gVGhlIGZsb3cgY2FuIGJlIHNpbXBsZXIKPiA+IGlmICtu byBFTlFDTUQgaXMgc3VwcG9ydGVkLgo+ID4gKwo+ID4gKzo6Cj4gPiArCj4gPiArICAgICBWRklP ICAgICAgICBJT01NVSAgICAgICAgS1ZNICAgICAgICBWRENNICAgICAgICBJT0FTSUQKPiA+IFJl Zgo+ID4gKyAgIC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLgo+ID4gKyAgIDEgICAgICAgICAgICAgaW9hc2lkX3JlZ2lzdGVy X25vdGlmaWVyL19tbSgpCj4gPiArICAgMiBpb2FzaWRfYWxsb2MoKSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMQo+ID4gKyAgIDMgYmluZF9ncGFzaWQoKQo+ ID4gKyAgIDQgICAgICAgICAgICAgaW9tbXVfYmluZCgpLT5pb2FzaWRfZ2V0KCkgICAgICAgICAg ICAgICAgICAgICAgIDIKPiA+ICsgICA1ICAgICAgICAgICAgIGlvYXNpZF9ub3RpZnkoQklORCkK PiA+ICsgICA2ICAgICAgICAgICAgICAgICAgICAgICAgICAtPiBpb2FzaWRfZ2V0KCkgICAgICAg ICAgICAgICAgICAgICAzCj4gPiArICAgNyAgICAgICAgICAgICAgICAgICAgICAgICAgLT4gdm1j c191cGRhdGVfYXRvbWljKCkKPiA+ICsgICA4IG1kZXZfd3JpdGUoZ3Bhc2lkKQo+ID4gKyAgIDkg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBocGFzaWQ9Cj4gPiArICAgMTAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZpbmRfYnlfc3BpZChncGFzaWQpICAgICAg NAo+ID4gKyAgIDExICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZGV2X3dyaXRl KGhwYXNpZCkKPiA+ICsgICAxMiAtLS0tLS0tLSBHVUVTVCBTVEFSVFMgRE1BIC0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCj4gPiArICAgMTMgLS0tLS0tLS0gR1VFU1QgU1RPUFMgRE1BIC0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiArICAgMTQgbWRldl9jbGVhcihncGFzaWQpCj4gPiAr ICAgMTUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZkZXZfY2xlYXIoaHBhc2lk KQo+ID4gKyAgIDE2ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpb2FzaWRfcHV0 KCkKPiA+IDMKPiA+ICsgICAxNyB1bmJpbmRfZ3Bhc2lkKCkKPiA+ICsgICAxOCAgICAgICAgICAg IGlvbW11X3ViaW5kKCkKPiA+ICsgICAxOSAgICAgICAgICAgIGlvYXNpZF9ub3RpZnkoVU5CSU5E KQo+ID4gKyAgIDIwICAgICAgICAgICAgICAgICAgICAgICAgICAtPiB2bWNzX3VwZGF0ZV9hdG9t aWMoKQo+ID4gKyAgIDIxICAgICAgICAgICAgICAgICAgICAgICAgICAtPiBpb2FzaWRfcHV0KCkK PiA+IDIKPiA+ICsgICAyMiBpb2FzaWRfZnJlZSgpCj4gPiAxCj4gPiArICAgMjMgICAgICAgICAg ICBpb2FzaWRfcHV0KCkKPiA+IDAKPiA+ICsgICAyNCAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBSZWNsYWltZWQKPiA+ICsgICAtLS0tLS0tLS0tLS0tLSBO ZXcgTGlmZSBDeWNsZSBCZWdpbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiArICAg MSAgaW9hc2lkX2FsbG9jKCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLT4KPiA+ IDEgKwo+ID4gKyAgIE5vdGU6IElPQVNJRCBOb3RpZmljYXRpb24gRXZlbnRzOiBGUkVFLCBCSU5E LCBVTkJJTkQKPiA+ICsKPiA+ICtFeGNlcHRpb24gY2FzZXMgYXJpc2Ugd2hlbiBhIGd1ZXN0IGNy YXNoZXMgb3IgYSBtYWxpY2lvdXMgZ3Vlc3QKPiA+ICthdHRlbXB0cyB0byBjYXVzZSBkaXNydXB0 aW9uIG9uIHRoZSBob3N0IHN5c3RlbS4gVGhlIGZhdWx0IGhhbmRsaW5nCj4gPiArcnVsZXMgYXJl Ogo+ID4gKwo+ID4gKzEuIElPQVNJRCBmcmVlIG11c3QgKmFsd2F5cyogc3VjY2VlZC4KPiA+ICsy LiBBbiBpbmFjdGl2ZSBwZXJpb2QgbWF5IGJlIHJlcXVpcmVkIGJlZm9yZSB0aGUgZnJlZWQgSU9B U0lEIGlzCj4gPiArICAgcmVjbGFpbWVkLiBEdXJpbmcgdGhpcyBwZXJpb2QsIGNvbnN1bWVycyBv ZiBJT0FTSUQgcGVyZm9ybQo+ID4gY2xlYW51cC4gKzMuIE1hbGZ1bmN0aW9uIGlzIGxpbWl0ZWQg dG8gdGhlIGd1ZXN0IG93bmVkIHJlc291cmNlcwo+ID4gZm9yIGFsbAo+ID4gKyAgIHByb2dyYW1t aW5nIGVycm9ycy4KPiA+ICsKPiA+ICtUaGUgcHJpbWFyeSBzb3VyY2Ugb2YgZXhjZXB0aW9uIGlz IHdoZW4gdGhlIGZvbGxvd2luZyBhcmUgb3V0IG9mCj4gPiArb3JkZXI6Cj4gPiArCj4gPiArMS4g U3RhcnQvU3RvcCBvZiBETUEgYWN0aXZpdHkKPiA+ICsgICAoR3Vlc3QgZGV2aWNlIGRyaXZlciwg bWRldiB2aWEgVkZJTykKPiA+ICsyLiBTZXR1cC9UZWFyZG93biBvZiBJT01NVSBQQVNJRCBjb250 ZXh0LCBJT1RMQiwgRGV2VExCIGZsdXNoZXMKPiA+ICsgICAoSG9zdCBJT01NVSBkcml2ZXIgYmlu ZC91bmJpbmQpCj4gPiArMy4gU2V0dXAvVGVhcmRvd24gb2YgVk1DUyBQQVNJRCB0cmFuc2xhdGlv biB0YWJsZSBlbnRyaWVzIChLVk0pIGluCj4gPiArICAgY2FzZSBvZiBFTlFDTUQKPiA+ICs0LiBQ cm9ncmFtbWluZy9DbGVhcmluZyBob3N0IFBBU0lEIGluIFZEQ00gKEhvc3QgVkRDTSBkcml2ZXIp Cj4gPiArNS4gSU9BU0lEIGFsbG9jL2ZyZWUgKEhvc3QgSU9BU0lEKQo+ID4gKwo+ID4gK1ZGSU8g aXMgdGhlICpvbmx5KiB1c2VyLWtlcm5lbCBpbnRlcmZhY2UsIHdoaWNoIGlzIHVsdGltYXRlbHkK PiA+ICtyZXNwb25zaWJsZSBmb3IgZXhjZXB0aW9uIGhhbmRsaW5ncy4KPiA+ICsKPiA+ICsjMSBp cyBwcm9jZXNzZWQgdGhlIHNhbWUgd2F5IGFzIHRoZSBhc3NpZ25lZCBkZXZpY2UgdG9kYXkgYmFz ZWQgb24KPiA+ICtkZXZpY2UgZmlsZSBkZXNjcmlwdG9ycyBhbmQgZXZlbnRzLiBUaGVyZSBpcyBu byBzcGVjaWFsIGhhbmRsaW5nLgo+ID4gKwo+ID4gKyMzIGlzIGJhc2VkIG9uIGJpbmQvdW5iaW5k IGV2ZW50cyBlbWl0dGVkIGJ5ICMyLgo+ID4gKwo+ID4gKyM0IGlzIG5hdHVyYWxseSBhbGlnbmVk IHdpdGggSU9BU0lEIGxpZmUgY3ljbGUgaW4gdGhhdCBhbiBpbGxlZ2FsCj4gPiArZ3Vlc3QgUEFT SUQgcHJvZ3JhbW1pbmcgd291bGQgZmFpbCBpbiBvYnRhaW5pbmcgcmVmZXJlbmNlIG9mIHRoZQo+ ID4gK21hdGNoaW5nIGhvc3QgSU9BU0lELgo+ID4gKwo+ID4gKyM1IGlzIHNpbWlsYXIgdG8gIzQu IFRoZSBmYXVsdCB3aWxsIGJlIHJlcG9ydGVkIHRvIHRoZSB1c2VyIGlmCj4gPiBQQVNJRCArdXNl ZCBpbiB0aGUgRU5RQ01EIGlzIG5vdCBzZXQgdXAgaW4gVk1DUyBQQVNJRCB0cmFuc2xhdGlvbgo+ ID4gdGFibGUuICsKPiA+ICtUaGVyZWZvcmUsIHRoZSByZW1haW5pbmcgb3V0IG9mIG9yZGVyIHBy b2JsZW0gaXMgYmV0d2VlbiAjMiBhbmQKPiA+ICsjNS4gSS5lLiB1bmJpbmQgdnMuIGZyZWUuIE1v cmUgc3BlY2lmaWNhbGx5LCBmcmVlIGJlZm9yZSB1bmJpbmQuCj4gPiArCj4gPiArSU9BU0lEIG5v dGlmaWVyIGFuZCByZWZjb3VudGluZyBhcmUgdXNlZCB0byBlbnN1cmUgb3JkZXIuIEZvbGxvd2lu Zwo+ID4gK2EgcHVibGlzaGVyLXN1YnNjcmliZXIgcGF0dGVybiB3aGVyZToKPiA+ICsKPiA+ICst IFB1Ymxpc2hlcnM6IFZGSU8gJiBJT01NVQo+ID4gKy0gU3Vic2NyaWJlcnM6IEtWTSwgVkRDTSwg SU9NTVUKPiA+ICsKPiA+ICtJT0FTSUQgbm90aWZpZXIgaXMgYXRvbWljIHdoaWNoIHJlcXVpcmVz IHN1YnNjcmliZXJzIHRvIGRvIHF1aWNrCj4gPiAraGFuZGxpbmcgb2YgdGhlIGV2ZW50IGluIHRo ZSBhdG9taWMgY29udGV4dC4gV29ya3F1ZXVlIGNhbiBiZSB1c2VkCj4gPiBmb3IgK2FueSBwcm9j ZXNzaW5nIHRoYXQgcmVxdWlyZXMgdGhyZWFkIGNvbnRleHQuIElPQVNJRCByZWZlcmVuY2UKPiA+ IG11c3QgYmUgK2FjcXVpcmVkIGJlZm9yZSByZWNlaXZpbmcgdGhlIEZSRUUgZXZlbnQuIFRoZSBy ZWZlcmVuY2UKPiA+IG11c3QgYmUgK2Ryb3BwZWQgYXQgdGhlIGVuZCBvZiB0aGUgcHJvY2Vzc2lu ZyBpbiBvcmRlciB0byByZXR1cm4KPiA+IHRoZSBJT0FTSUQgdG8gK3RoZSBwb29sLgo+ID4gKwo+ ID4gK0xldCdzIGV4YW1pbmUgdGhlIElPQVNJRCBsaWZlIGN5Y2xlIGFnYWluIHdoZW4gZnJlZSBo YXBwZW5zCj4gPiAqYmVmb3JlKiArdW5iaW5kLiBUaGlzIGNvdWxkIGJlIGEgcmVzdWx0IG9mIG1p c2JlaGF2aW5nIGd1ZXN0cyBvcgo+ID4gY3Jhc2guIEFzc3VtaW5nICtWRklPIGNhbm5vdCBlbmZv cmNlIHVuYmluZC0+ZnJlZSBvcmRlci4gTm90aWNlCj4gPiB0aGF0IHRoZSBzZXR1cCBwYXJ0IHVw ICt1bnRpbCBzdGVwICMxMiBpcyBpZGVudGljYWwgdG8gdGhlIG5vcm1hbAo+ID4gY2FzZSwgdGhl IGZsb3cgYmVsb3cgc3RhcnRzICt3aXRoIHN0ZXAgMTMuCj4gPiArCj4gPiArOjoKPiA+ICsKPiA+ ICsgICAgIFZGSU8gICAgICAgIElPTU1VICAgICAgICBLVk0gICAgICAgIFZEQ00gICAgICAgIElP QVNJRAo+ID4gUmVmCj4gPiArICAgLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uCj4gPiArICAgMTMgLS0tLS0tLS0gR1VFU1Qg U1RBUlRTIERNQSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKyAgIDE0IC0tLS0tLS0t ICpHVUVTVCBNSVNCRUhBVkVTISEhKiAtLS0tLS0tLS0tLS0tLS0tCj4gPiArICAgMTUgaW9hc2lk X2ZyZWUoKQo+ID4gKyAgIDE2Cj4gPiBpb2FzaWRfbm90aWZ5KEZSRUUpCj4gPiArICAgMTcKPiA+ IG1hcmtfaW9hc2lkX2luYWN0aXZlWzFdCj4gPiArICAgMTggICAgICAgICAgICAgICAgICAgICAg ICAgIGt2bV9uYl9oYW5kbGVyKEZSRUUpCj4gPiArICAgMTkgICAgICAgICAgICAgICAgICAgICAg ICAgIHZtY3NfdXBkYXRlX2F0b21pYygpCj4gPiArICAgMjAgICAgICAgICAgICAgICAgICAgICAg ICAgIGlvYXNpZF9wdXRfbG9ja2VkKCkgICAtPiAgICAgICAgICAgMwo+ID4gKyAgIDIxICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZGNtX25iX2hhbmRsZXIoRlJFRSkKPiA+ICsg ICAyMiAgICAgICAgICAgIGlvbW1fbmJfaGFuZGxlcihGUkVFKQo+ID4gKyAgIDIzIGlvYXNpZF9m cmVlKCkgcmV0dXJuc1syXSAgICAgICAgICBzY2hlZHVsZV93b3JrKCkgICAgICAgICAgIDIKPiA+ ICsgICAyNCAgICAgICAgICAgIHNjaGVkdWxlX3dvcmsoKSAgICAgICAgdmRldl9jbGVhcl93ayho cGFzaWQpCj4gPiArICAgMjUgICAgICAgICAgICB0ZWFyZG93bl9wYXNpZF93aygpCj4gPiArICAg MjYgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvYXNpZF9wdXQoKSAtPiAgICAg ICAgICAgMQo+ID4gKyAgIDI3ICAgICAgICAgICAgaW9hc2lkX3B1dCgpICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDAKPiA+ICsgICAyOCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBSZWNsYWltZWQKPiA+ICsgICAyOSB1bmJpbmRfZ3Bh c2lkKCkKPiA+ICsgICAzMCAgICAgICAgICAgIGlvbW11X3VuYmluZCgpLT5pb2FzaWRfZmluZCgp IEZhaWxzWzNdCj4gPiArICAgLS0tLS0tLS0tLS0tLS0gTmV3IExpZmUgQ3ljbGUgQmVnaW4gLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gKwo+ID4gK05vdGU6Cj4gPiArCj4gPiArMS4g QnkgbWFya2luZyBJT0FTSUQgaW5hY3RpdmUgYXQgc3RlcCAjMTcsIG5vIG5ldyByZWZlcmVuY2Vz IGNhbiBiZQo+ID4gKyAgIGhlbGQuIGlvYXNpZF9nZXQvZmluZCgpIHdpbGwgcmV0dXJuIC1FTk9F TlQ7Cj4gPiArMi4gQWZ0ZXIgc3RlcCAjMjMsIGFsbCBldmVudHMgY2FuIGdvIG91dCBvZiBvcmRl ci4gU2hhbGwgbm90IGFmZmVjdAo+ID4gKyAgIHRoZSBvdXRjb21lLgo+ID4gKzMuIElPTU1VIGRy aXZlciBmYWlscyB0byBmaW5kIHByaXZhdGUgZGF0YSBmb3IgdW5iaW5kaW5nLiBJZgo+ID4gdW5i aW5kIGlzCj4gPiArICAgY2FsbGVkIGFmdGVyIHRoZSBzYW1lIElPQVNJRCBpcyBhbGxvY2F0ZWQg Zm9yIHRoZSBzYW1lIGd1ZXN0Cj4gPiBhZ2FpbiwKPiA+ICsgICB0aGlzIGlzIGEgcHJvZ3JhbW1p bmcgZXJyb3IuIFRoZSBkYW1hZ2UgaXMgbGltaXRlZCB0byB0aGUgZ3Vlc3QKPiA+ICsgICBpdHNl bGYgc2luY2UgdW5iaW5kIHBlcmZvcm1zIHBlcm1pc3Npb24gY2hlY2tpbmcgYmFzZWQgb24gdGhl Cj4gPiArICAgSU9BU0lEIHNldCBhc3NvY2lhdGVkIHdpdGggdGhlIGd1ZXN0IHByb2Nlc3MuCj4g PiArCj4gPiArS1ZNIFBBU0lEIFRyYW5zbGF0aW9uIFRhYmxlIFVwZGF0ZXMKPiA+ICt+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgo+ID4gK1BlciBWTSBQQVNJRCB0cmFuc2xhdGlv biB0YWJsZSBpcyBtYWludGFpbmVkIGJ5IEtWTSBpbiBvcmRlciB0bwo+ID4gK3N1cHBvcnQgRU5R Q01EIGluIHRoZSBndWVzdC4gVGhlIHRhYmxlIGNvbnRhaW5zIGhvc3QtZ3Vlc3QgUEFTSUQKPiA+ ICt0cmFuc2xhdGlvbnMgdG8gYmUgY29uc3VtZWQgYnkgQ1BVIHVjb2RlLiBUaGUgc3luY2hyb25p emF0aW9uIG9mCj4gPiB0aGUgK1BBU0lEIHN0YXRlcyBkZXBlbmRzIG9uIFZGSU8vSU9NTVUgZHJp dmVyLCB3aGVyZSBJT0NUTCBhbmQKPiA+IGF0b21pYyArbm90aWZpZXJzIGFyZSB1c2VkLiBLVk0g bXVzdCByZWdpc3RlciBJT0FTSUQgbm90aWZpZXIgcGVyCj4gPiBWTSBpbnN0YW5jZSArZHVyaW5n IGxhdW5jaCB0aW1lLiBUaGUgZm9sbG93aW5nIGV2ZW50cyBhcmUgaGFuZGxlZDoKPiA+ICsKPiA+ ICsxLiBCSU5EL1VOQklORAo+ID4gKzIuIEZSRUUKPiA+ICsKPiA+ICtSdWxlczoKPiA+ICsKPiA+ ICsxLiBNdWx0aXBsZSBkZXZpY2VzIGNhbiBiaW5kIHdpdGggdGhlIHNhbWUgUEFTSUQsIHRoaXMg Y2FuIGJlCj4gPiBkaWZmZXJlbnQgUENJCj4gPiArICAgZGV2aWNlcyBvciBtZGV2cyB3aXRoaW4g dGhlIHNhbWUgUENJIGRldmljZS4gSG93ZXZlciwgb25seSB0aGUKPiA+ICsgICAqZmlyc3QqIEJJ TkQgYW5kICpsYXN0KiBVTkJJTkQgZW1pdCBub3RpZmljYXRpb25zLgo+ID4gKzIuIElPQVNJRCBj b2RlIGlzIHJlc3BvbnNpYmxlIGZvciBlbnN1cmluZyB0aGUgY29ycmVjdG5lc3Mgb2YgSC1HCj4g PiArICAgUEFTSUQgbWFwcGluZy4gVGhlcmUgaXMgbm8gbmVlZCBmb3IgS1ZNIHRvIHZhbGlkYXRl IHRoZQo+ID4gKyAgIG5vdGlmaWNhdGlvbiBkYXRhLgo+ID4gKzMuIFdoZW4gVU5CSU5EIGhhcHBl bnMgKmFmdGVyKiBGUkVFLCBLVk0gd2lsbCBzZWUgZXJyb3IgaW4KPiA+ICsgICBpb2FzaWRfZ2V0 KCkgZXZlbiB3aGVuIHRoZSByZWNsYWltIGlzIG5vdCBkb25lLiBJT01NVSBkcml2ZXIKPiA+IHdp bGwKPiA+ICsgICBhbHNvIGF2b2lkIHNlbmRpbmcgVU5CSU5EIGlmIHRoZSBQQVNJRCBpcyBhbHJl YWR5IEZSRUUuCj4gPiArNC4gV2hlbiBLVk0gdGVybWluYXRlcyAqYmVmb3JlKiBGUkVFICYgVU5C SU5ELCByZWZlcmVuY2VzIHdpbGwgYmUKPiA+ICsgICBkcm9wcGVkIGZvciBhbGwgaG9zdCBQQVNJ RHMuCj4gPiArCj4gPiArVkRDTSBQQVNJRCBQcm9ncmFtbWluZwo+ID4gK35+fn5+fn5+fn5+fn5+ fn5+fn5+fn4KPiA+ICtWRENNIGNvbXBvc2VzIHZpcnR1YWwgZGV2aWNlcyBhbmQgZXhwb3NlcyB0 aGVtIHRvIHRoZSBndWVzdHMuIFdoZW4KPiA+ICt0aGUgZ3Vlc3QgYWxsb2NhdGVzIGEgUEFTSUQg dGhlbiBwcm9ncmFtIGl0IHRvIHRoZSB2aXJ0dWFsIGRldmljZSwKPiA+IFZEQ00gK2ludGVyY2Vw dHMgdGhlIHByb2dyYW1taW5nIGF0dGVtcHQgdGhlbiBwcm9ncmFtIHRoZSBtYXRjaGluZwo+ID4g aG9zdCArUEFTSUQgb24gdG8gdGhlIGhhcmR3YXJlLgo+ID4gK0NvbnZlcnNlbHksIHdoZW4gYSBk ZXZpY2UgaXMgZ29pbmcgYXdheSwgVkRDTSBtdXN0IGJlIGluZm9ybWVkIHN1Y2gKPiA+ICt0aGF0 IFBBU0lEIGNvbnRleHQgb24gdGhlIGhhcmR3YXJlIGNhbiBiZSBjbGVhcmVkLiBUaGVyZSBjb3Vs ZCBiZQo+ID4gK211bHRpcGxlIG1kZXZzIGFzc2lnbmVkIHRvIGRpZmZlcmVudCBndWVzdHMgaW4g dGhlIHNhbWUgVkRDTS4gU2luY2UKPiA+ICt0aGUgUEFTSUQgdGFibGUgaXMgc2hhcmVkIGF0IFBD SSBkZXZpY2UgbGV2ZWwsIGxhenkgY2xlYXJpbmcgaXMgbm90Cj4gPiArc2VjdXJlLiBBIG1hbGlj aW91cyBndWVzdCBjYW4gYXR0YWNrIGJ5IHVzaW5nIG5ld2x5IGZyZWVkIFBBU0lEcwo+ID4gdGhh dCArYXJlIGFsbG9jYXRlZCBieSBhbm90aGVyIGd1ZXN0Lgo+ID4gKwo+ID4gK0J5IGhvbGRpbmcg YSByZWZlcmVuY2Ugb2YgdGhlIFBBU0lEIHVudGlsIFZEQ00gY2xlYW5zIHVwIHRoZSBIVwo+ID4g Y29udGV4dCwgK2l0IGlzIGd1YXJhbnRlZWQgdGhhdCBQQVNJRCBsaWZlIGN5Y2xlcyBkbyBub3Qg Y3Jvc3MKPiA+IHdpdGhpbiB0aGUgc2FtZSArZGV2aWNlLgo+ID4gKwo+ID4gKwo+ID4gK1JlZmVy ZW5jZQo+ID4gKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KPiA+ICsxLgo+ID4gaHR0cHM6Ly9zb2Z0d2FyZS5pbnRlbC5jb20vc2l0ZXMvZGVmYXVs dC9maWxlcy9tYW5hZ2VkL2M1LzE1L2FyY2hpdGVjdHVyZS1pbnN0cnVjdGlvbi1zZXQtZXh0ZW5z aW9ucy1wcm9ncmFtbWluZy1yZWZlcmVuY2UucGRmCj4gPiArICsyLgo+ID4gaHR0cHM6Ly8wMS5v cmcvYmxvZ3MvMjAxOS9pbnRyb2R1Y2luZy1pbnRlbC1kYXRhLXN0cmVhbWluZy1hY2NlbGVyYXRv cgo+ID4gKyArMy4KPiA+IGh0dHBzOi8vc29mdHdhcmUuaW50ZWwuY29tL2VuLXVzL2Rvd25sb2Fk L2ludGVsLWRhdGEtc3RyZWFtaW5nLWFjY2VsZXJhdG9yLXByZWxpbWluYXJ5LWFyY2hpdGVjdHVy ZS1zcGVjaWZpY2F0aW9uIAo+IAo+IEJlc3QgcmVnYXJkcywKPiBiYW9sdQo+IF9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4gaW9tbXUgbWFpbGluZyBsaXN0 Cj4gaW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKPiBodHRwczovL2xpc3RzLmxpbnV4 Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQpbSmFjb2IgUGFuXQpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwppb21tdSBtYWlsaW5nIGxp c3QKaW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZv dW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vaW9tbXU= 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 BEF94C433E6 for ; Fri, 28 Aug 2020 16:54:14 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8C6A420738 for ; Fri, 28 Aug 2020 16:54:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726929AbgH1QyM convert rfc822-to-8bit (ORCPT ); Fri, 28 Aug 2020 12:54:12 -0400 Received: from mga07.intel.com ([134.134.136.100]:63481 "EHLO mga07.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725814AbgH1QyF (ORCPT ); Fri, 28 Aug 2020 12:54:05 -0400 IronPort-SDR: zX33U/j8ji9khCrPGNcQC8LSvx/zWNDy4cLybBR+9PX4p1smj2tHQXaZF9fSu0MSuH823CxZ8n eUZw2t27eF1Q== X-IronPort-AV: E=McAfee;i="6000,8403,9727"; a="220947069" X-IronPort-AV: E=Sophos;i="5.76,364,1592895600"; d="scan'208";a="220947069" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 09:54:03 -0700 IronPort-SDR: tD0lLztNFbDkl9g9wSfZG83YCD/SoJKb/Als6u5szKMDiXTwtEN0Cio7W7dHfBa5DcLZiuyyOP BSa5hk+TKTlg== X-IronPort-AV: E=Sophos;i="5.76,364,1592895600"; d="scan'208";a="296177334" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga003-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Aug 2020 09:54:02 -0700 Date: Fri, 28 Aug 2020 10:01:07 -0700 From: Jacob Pan To: Lu Baolu Cc: Jacob Pan , iommu@lists.linux-foundation.org, LKML , Jean-Philippe Brucker , Joerg Roedel , David Woodhouse , "Tian, Kevin" , Raj Ashok , Wu Hao , jacob.jun.pan@linux.intel.com Subject: Re: [PATCH v2 1/9] docs: Document IO Address Space ID (IOASID) APIs Message-ID: <20200828100107.55ae32c1@jacob-builder> In-Reply-To: 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> 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 Baolu, Thanks for the review! On Sun, 23 Aug 2020 15:05:08 +0800 Lu Baolu wrote: > Hi Jacob, > > On 2020/8/22 12:35, 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 > > 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 > > +requests can target. > > + > > +The primary use cases for IOASID are Shared Virtual Address (SVA) > > and +IO Virtual Address (IOVA). However, the requirements for > > IOASID > > Can you please elaborate a bit more about how ioasid is used by IOVA? > Good point, I will add a paragraph for IOVA usage. Something like this: "For IOVA, IOASID #0 is typically used for DMA request without PASID. However, some architectures such as VT-d also offers the flexibility of using any PASID for DMA request without PASID. For example, on VT-d PASID #0 is used for PCI device RID2PASID and for SIOV each auxilary domain also allocates a non-zero default PASID for DMA request w/o PASID. PASID #0, is reserved and not allocated from any ioasid_set." > > +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) > > + > > +SVA/SVM - Shared Virtual Addressing/Memory > > + > > +ENQCMD - New Intel X86 ISA for efficient workqueue submission [1] > > + > > +DSA - Intel Data Streaming Accelerator [2] > > + > > +VDCM - Virtual device composition module [3] > > Capitalize the first letter of each word. > will do. > > + > > +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. > > + > > +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. 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. > > Is there a real IOASID set allocated in the host which represent the > SPID? > SPIDs are not allocated from the host IOASID set, but the backing host IOASID of the SPID is. So the same SPID # can belong to different IOASID set. SPIDs are allocated by VMM and given to the host, IOASID code in the host just stores it in the ioasid_set. > > + > > +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 +traffic outside its own IOASIDs, or free an active > > IOASID belong to +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); > > + > > + 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, > > + void (*fn)(ioasid_t id, void > > *data), > > + void *data) > > + > > + > > +IOASID set concept is introduced to represent such IOASID groups. > > Each +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 > > + > > +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); > > + > > + > > +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): > > What does ascending order exactly mean here? LAST->IOMMU->DEVICE...? > Yes. CPU has the highest priority and will get notified first. > > + > > +:: > > + > > + 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 +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 > > +reference of the IOASID. IOASID will not be returned to the pool > > for +allocation until all references are dropped. Calling > > ioasid_free() +will mark the IOASID as FREE_PENDING if the IOASID > > has outstanding +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. > > + > > +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 > > +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. > > MMU notifier for SVA mainly serves IOMMU cache flushes, right? The > IOASID life cycle for bare matal SVA is managed by the device driver > through the iommu sva api's iommu_sva_(un)bind_device()? > True that lifecycle between iommu and device are aligned by sva APIs. But between mm/cpu and iommu, it depends on mmu_notifier.release(). In case process terminates unexpectedly. > > + > > +However, guest MMU notifier is not available to host IOMMU driver, > > +when guest MM terminates unexpectedly, the events have to go > > through +VFIO and IOMMU UAPI to reach host IOMMU driver. There are > > also more +parties involved in guest SVA, e.g. on Intel VT-d > > platform, IOASIDs +are used by IOMMU driver, KVM, VDCM, and VFIO. > > + > > +Native IOASID Life Cycle (VT-d Example) > > +--------------------------------------- > > + > > +The normal flow of native SVA code with Intel Data Streaming > > +Accelerator(DSA) [2] as example: > > + > > +1. Host user opens accelerator FD, e.g. DSA driver, or uacce; > > +2. DSA driver allocate WQ, do sva_bind_device(); > > +3. IOMMU driver calls ioasid_alloc(), then bind PASID with device, > > + mmu_notifier_get() > > +4. DMA starts by DSA driver userspace > > +5. DSA userspace close FD > > +6. DSA/uacce kernel driver handles FD.close() > > +7. DSA driver stops DMA > > +8. DSA driver calls sva_unbind_device(); > > +9. IOMMU driver does unbind, clears PASID context in IOMMU, flush > > + TLBs. mmu_notifier_put() called. > > +10. mmu_notifier.release() called, IOMMU SVA code calls > > ioasid_free()* +11. The IOASID is returned to the pool, reclaimed. > > + > > +:: > > + > > + * With ENQCMD, PASID used on VT-d is not released in > > mmu_notifier() but > > + mmdrop(). mmdrop comes after FD close. Should not matter. > > + If the user process dies unexpectedly, Step #10 may come > > before > > + Step #5, in between, all DMA faults discarded. PRQ responded > > with > > + 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 +follows: > > + > > +:: > > + > > + do_exit() { > > + exit_mm() { > > + mm_put(); > > + exit_mmap() { > > + intel_invalidate_range() //mmu notifier > > + tlb_finish_mmu() > > + mmu_notifier_release(mm) { > > + intel_iommu_release() { > > intel_mm_release() Good catch, > > > + [2] > > intel_iommu_teardown_pasid(); > > + intel_iommu_flush_tlbs(); > > + } > > + // tlb_invalidate_range cb removed > > + } > > + unmap_vmas(); > > + free_pgtables(); // IOMMU cannot walk PGT > > after this > > + }; > > + } > > + exit_files(tsk) { > > + close_files() { > > + dsa_close(); > > + [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. > > The VT-d hardware will ignore UR faults due to the setting of FPD bit > of the PASID entry. The software won't see UR faults. > Yes, here I should note that. "Fault processing is disabled by the IOMMU driver in #2, therefore the UR fault never reaches the driver." > > + > > +Also notice that TLB invalidation occurs at mmu_notifier > > +invalidate_range callback as well as the release callback. The > > reason +is that release callback will delete IOMMU driver from the > > notifier +chain which may skip invalidate_range() calls during the > > exit path. + > > +To avoid unnecessary reporting of UR fault, IOMMU driver shall > > disable +fault reporting after free and before unbind. > > + > > +Guest IOASID Life Cycle (VT-d Example) > > +-------------------------------------- > > +Guest IOASID life cycle starts with guest driver open(), this > > could be +uacce or individual accelerator driver such as DSA. At FD > > open, +sva_bind_device() is called which triggers a series of > > actions. + > > +The example below is an illustration of *normal* operations that > > +involves *all* the SW components in VT-d. The flow can be simpler > > if +no ENQCMD is supported. > > + > > +:: > > + > > + VFIO IOMMU KVM VDCM IOASID > > Ref > > + .................................................................. > > + 1 ioasid_register_notifier/_mm() > > + 2 ioasid_alloc() 1 > > + 3 bind_gpasid() > > + 4 iommu_bind()->ioasid_get() 2 > > + 5 ioasid_notify(BIND) > > + 6 -> ioasid_get() 3 > > + 7 -> vmcs_update_atomic() > > + 8 mdev_write(gpasid) > > + 9 hpasid= > > + 10 find_by_spid(gpasid) 4 > > + 11 vdev_write(hpasid) > > + 12 -------- GUEST STARTS DMA -------------------------- > > + 13 -------- GUEST STOPS DMA -------------------------- > > + 14 mdev_clear(gpasid) > > + 15 vdev_clear(hpasid) > > + 16 ioasid_put() > > 3 > > + 17 unbind_gpasid() > > + 18 iommu_ubind() > > + 19 ioasid_notify(UNBIND) > > + 20 -> vmcs_update_atomic() > > + 21 -> ioasid_put() > > 2 > > + 22 ioasid_free() > > 1 > > + 23 ioasid_put() > > 0 > > + 24 Reclaimed > > + -------------- New Life Cycle Begin ---------------------------- > > + 1 ioasid_alloc() -> > > 1 + > > + Note: IOASID Notification Events: FREE, BIND, UNBIND > > + > > +Exception cases arise when a guest crashes or a malicious guest > > +attempts to cause disruption on the host system. The fault handling > > +rules are: > > + > > +1. IOASID free must *always* succeed. > > +2. An inactive period may be required before the freed IOASID is > > + reclaimed. During this period, consumers of IOASID perform > > cleanup. +3. Malfunction is limited to the guest owned resources > > for all > > + programming errors. > > + > > +The primary source of exception is when the following are out of > > +order: > > + > > +1. Start/Stop of DMA activity > > + (Guest device driver, mdev via VFIO) > > +2. Setup/Teardown of IOMMU PASID context, IOTLB, DevTLB flushes > > + (Host IOMMU driver bind/unbind) > > +3. Setup/Teardown of VMCS PASID translation table entries (KVM) in > > + case of ENQCMD > > +4. Programming/Clearing host PASID in VDCM (Host VDCM driver) > > +5. IOASID alloc/free (Host IOASID) > > + > > +VFIO is the *only* user-kernel interface, which is ultimately > > +responsible for exception handlings. > > + > > +#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 > > + 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 +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 > > Best regards, > baolu > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu [Jacob Pan]