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=-8.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 4DFA1C433DF for ; Fri, 12 Jun 2020 13:02:58 +0000 (UTC) Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (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 2101120792 for ; Fri, 12 Jun 2020 13:02:58 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2101120792 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 silver.osuosl.org (Postfix) with ESMTP id B892726FB0; Fri, 12 Jun 2020 13:02:57 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 9epM0T7cVk6K; Fri, 12 Jun 2020 13:02:51 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by silver.osuosl.org (Postfix) with ESMTP id 3292C203BF; Fri, 12 Jun 2020 13:02:51 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 033A0C0881; Fri, 12 Jun 2020 13:02:51 +0000 (UTC) Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 73A2BC016F for ; Fri, 12 Jun 2020 13:02:49 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id 5B2B3895AF for ; Fri, 12 Jun 2020 13:02:49 +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 sS+Vfbl6ua0f for ; Fri, 12 Jun 2020 13:02:47 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by hemlock.osuosl.org (Postfix) with ESMTPS id 2179E895AB for ; Fri, 12 Jun 2020 13:02:47 +0000 (UTC) IronPort-SDR: fXmytrUCFcyOe4+LaVe6UGyss21QpyFHWkd6mbFmnWq9IVVDjqZ+uwzc0Ubp310cijbds3K6cP K5d3ldyxsfbA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga007.jf.intel.com ([10.7.209.58]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jun 2020 06:02:46 -0700 IronPort-SDR: 37svnWUr1PnOteS0f1MOUOH6z26o/3Rk550jV+opK54qr8EzH/YjK270OEsYrJ+WTgWjfvMgCh 4GzY+8ddGWig== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.73,503,1583222400"; d="scan'208";a="260822458" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga007.jf.intel.com with ESMTP; 12 Jun 2020 06:02:46 -0700 Date: Fri, 12 Jun 2020 06:09:11 -0700 From: Jacob Pan To: "Tian, Kevin" Subject: Re: [PATCH v2 1/3] docs: IOMMU user API Message-ID: <20200612060911.29d5c3b8@jacob-builder> In-Reply-To: References: <1591848735-12447-1-git-send-email-jacob.jun.pan@linux.intel.com> <1591848735-12447-2-git-send-email-jacob.jun.pan@linux.intel.com> <20200611094741.6d118fa8@w520.home> <20200611125205.1e0280d3@jacob-builder> <20200611144047.79613c32@x1.home> <20200611172727.78dbb822@jacob-builder> Organization: OTC X-Mailer: Claws Mail 3.13.2 (GTK+ 2.24.30; x86_64-pc-linux-gnu) MIME-Version: 1.0 Cc: "Raj, Ashok" , Jonathan Corbet , Jean-Philippe Brucker , "iommu@lists.linux-foundation.org" , LKML , Christoph Hellwig , Alex Williamson , David Woodhouse 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" T24gRnJpLCAxMiBKdW4gMjAyMCAwNzozODo0NCArMDAwMAoiVGlhbiwgS2V2aW4iIDxrZXZpbi50 aWFuQGludGVsLmNvbT4gd3JvdGU6Cgo+ID4gRnJvbTogSmFjb2IgUGFuIDxqYWNvYi5qdW4ucGFu QGxpbnV4LmludGVsLmNvbT4KPiA+IFNlbnQ6IEZyaWRheSwgSnVuZSAxMiwgMjAyMCA4OjI3IEFN Cj4gPiAKPiA+IE9uIFRodSwgMTEgSnVuIDIwMjAgMTQ6NDA6NDcgLTA2MDAKPiA+IEFsZXggV2ls bGlhbXNvbiA8YWxleC53aWxsaWFtc29uQHJlZGhhdC5jb20+IHdyb3RlOgo+ID4gICAKPiA+ID4g T24gVGh1LCAxMSBKdW4gMjAyMCAxMjo1MjowNSAtMDcwMAo+ID4gPiBKYWNvYiBQYW4gPGphY29i Lmp1bi5wYW5AbGludXguaW50ZWwuY29tPiB3cm90ZToKPiA+ID4gIAo+ID4gPiA+IEhpIEFsZXgs Cj4gPiA+ID4KPiA+ID4gPiBPbiBUaHUsIDExIEp1biAyMDIwIDA5OjQ3OjQxIC0wNjAwCj4gPiA+ ID4gQWxleCBXaWxsaWFtc29uIDxhbGV4LndpbGxpYW1zb25AcmVkaGF0LmNvbT4gd3JvdGU6Cj4g PiA+ID4gIAo+ID4gPiA+ID4gT24gV2VkLCAxMCBKdW4gMjAyMCAyMToxMjoxMyAtMDcwMAo+ID4g PiA+ID4gSmFjb2IgUGFuIDxqYWNvYi5qdW4ucGFuQGxpbnV4LmludGVsLmNvbT4gd3JvdGU6Cj4g PiA+ID4gPiAgCj4gPiA+ID4gPiA+IElPTU1VIFVBUEkgaXMgbmV3bHkgaW50cm9kdWNlZCB0byBz dXBwb3J0IGNvbW11bmljYXRpb25zICAKPiA+IGJldHdlZW4gIAo+ID4gPiA+ID4gPiBndWVzdCB2 aXJ0dWFsIElPTU1VIGFuZCBob3N0IElPTU1VLiBUaGVyZSBoYXMgYmVlbiBsb3RzIG9mCj4gPiA+ ID4gPiA+IGRpc2N1c3Npb25zIG9uIGhvdyBpdCBzaG91bGQgd29yayB3aXRoIFZGSU8gVUFQSSBh bmQKPiA+ID4gPiA+ID4gdXNlcnNwYWNlIGluIGdlbmVyYWwuCj4gPiA+ID4gPiA+Cj4gPiA+ID4g PiA+IFRoaXMgZG9jdW1lbnQgaXMgaW5kZW5kZWQgdG8gY2xhcmlmeSB0aGUgVUFQSSBkZXNpZ24g YW5kCj4gPiA+ID4gPiA+IHVzYWdlLiBUaGUgbWVjaGVuaWNzIG9mIGhvdyBmdXR1cmUgZXh0ZW5z aW9ucyBzaG91bGQgYmUKPiA+ID4gPiA+ID4gYWNoaWV2ZWQgYXJlIGFsc28gY292ZXJlZCBpbiB0 aGlzIGRvY3VtZW50YXRpb24uCj4gPiA+ID4gPiA+Cj4gPiA+ID4gPiA+IFNpZ25lZC1vZmYtYnk6 IExpdSBZaSBMIDx5aS5sLmxpdUBpbnRlbC5jb20+Cj4gPiA+ID4gPiA+IFNpZ25lZC1vZmYtYnk6 IEphY29iIFBhbiA8amFjb2IuanVuLnBhbkBsaW51eC5pbnRlbC5jb20+Cj4gPiA+ID4gPiA+IC0t LQo+ID4gPiA+ID4gPiAgRG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBpL2lvbW11LnJzdCB8IDIx MAo+ID4gPiA+ID4gPiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrIDEgZmlsZSBj aGFuZ2VkLCAyMTAKPiA+ID4gPiA+ID4gaW5zZXJ0aW9ucygrKSBjcmVhdGUgbW9kZSAxMDA2NDQK PiA+ID4gPiA+ID4gRG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBpL2lvbW11LnJzdAo+ID4gPiA+ ID4gPgo+ID4gPiA+ID4gPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBp L2lvbW11LnJzdAo+ID4gPiA+ID4gPiBiL0RvY3VtZW50YXRpb24vdXNlcnNwYWNlLWFwaS9pb21t dS5yc3QgbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+ID4gPiA+ID4gaW5kZXggMDAwMDAwMDAwMDAw Li5lOTVkYzVhMDRhNDEKPiA+ID4gPiA+ID4gLS0tIC9kZXYvbnVsbAo+ID4gPiA+ID4gPiArKysg Yi9Eb2N1bWVudGF0aW9uL3VzZXJzcGFjZS1hcGkvaW9tbXUucnN0Cj4gPiA+ID4gPiA+IEBAIC0w LDAgKzEsMjEwIEBACj4gPiA+ID4gPiA+ICsuLiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMAo+ID4gPiA+ID4gPiArLi4gaW9tbXU6Cj4gPiA+ID4gPiA+ICsKPiA+ID4gPiA+ID4gKz09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPiA+ID4gPiA+ID4gK0lPTU1VIFVz ZXJzcGFjZSBBUEkKPiA+ID4gPiA+ID4gKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArSU9NTVUgVUFQSSBpcyB1c2VkIGZvciB2 aXJ0dWFsaXphdGlvbiBjYXNlcyB3aGVyZQo+ID4gPiA+ID4gPiBjb21tdW5pY2F0aW9ucyBhcmUg K25lZWRlZCBiZXR3ZWVuIHBoeXNpY2FsIGFuZCB2aXJ0dWFsCj4gPiA+ID4gPiA+IElPTU1VIGRy aXZlcnMuIEZvciBuYXRpdmUgK3VzYWdlLCBJT01NVSBpcyBhIHN5c3RlbSBkZXZpY2UKPiA+ID4g PiA+ID4gd2hpY2ggZG9lcyBub3QgbmVlZCB0byBjb21tdW5pY2F0ZSArd2l0aCB1c2VyIHNwYWNl Cj4gPiA+ID4gPiA+IGRpcmVjdGx5LiArCj4gPiA+ID4gPiA+ICtUaGUgcHJpbWFyeSB1c2UgY2Fz ZXMgYXJlIGd1ZXN0IFNoYXJlZCBWaXJ0dWFsIEFkZHJlc3MKPiA+ID4gPiA+ID4gKFNWQSkgYW5k ICtndWVzdCBJTyB2aXJ0dWFsIGFkZHJlc3MgKElPVkEpLCB3aGVyZWluIHZpcnR1YWwKPiA+ID4g PiA+ID4gSU9NTVUgKHZJT01NVSkgaXMgK3JlcXVpcmVkIHRvIGNvbW11bmljYXRlIHdpdGggdGhl Cj4gPiA+ID4gPiA+IHBoeXNpY2FsIElPTU1VIGluIHRoZSBob3N0LiArCj4gPiA+ID4gPiA+ICsu LiBjb250ZW50czo6IDpsb2NhbDoKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArRnVuY3Rpb25h bGl0aWVzCj4gPiA+ID4gPiA+ICs9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Cj4gPiA+ID4gPiA+ICtDb21tdW5pY2F0aW9ucyBvZiB1c2VyIGFuZCBr ZXJuZWwgaW52b2x2ZSBib3RoIGRpcmVjdGlvbnMuCj4gPiA+ID4gPiA+IFRoZSArc3VwcG9ydGVk IHVzZXIta2VybmVsIEFQSXMgYXJlIGFzIGZvbGxvd3M6Cj4gPiA+ID4gPiA+ICsKPiA+ID4gPiA+ ID4gKzEuIEFsbG9jL0ZyZWUgUEFTSUQKPiA+ID4gPiA+ID4gKzIuIEJpbmQvdW5iaW5kIGd1ZXN0 IFBBU0lEIChlLmcuIEludGVsIFZULWQpCj4gPiA+ID4gPiA+ICszLiBCaW5kL3VuYmluZCBndWVz dCBQQVNJRCB0YWJsZSAoZS5nLiBBUk0gc01NVSkKPiA+ID4gPiA+ID4gKzQuIEludmFsaWRhdGUg SU9NTVUgY2FjaGVzCj4gPiA+ID4gPiA+ICs1LiBTZXJ2aWNlIHBhZ2UgcmVxdWVzdAo+ID4gPiA+ ID4gPiArCj4gPiA+ID4gPiA+ICtSZXF1aXJlbWVudHMKPiA+ID4gPiA+ID4gKz09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPiA+ID4gPiA+ID4gK1Ro ZSBJT01NVSBVQVBJcyBhcmUgZ2VuZXJpYyBhbmQgZXh0ZW5zaWJsZSB0byBtZWV0IHRoZQo+ID4g PiA+ID4gPiBmb2xsb3dpbmcgK3JlcXVpcmVtZW50czoKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4g PiArMS4gRW11bGF0ZWQgYW5kIHBhcmEtdmlydHVhbGlzZWQgdklPTU1Vcwo+ID4gPiA+ID4gPiAr Mi4gTXVsdGlwbGUgdmVuZG9ycyAoSW50ZWwgVlQtZCwgQVJNIHNNTVUsIGV0Yy4pCj4gPiA+ID4g PiA+ICszLiBFeHRlbnNpb25zIHRvIHRoZSBVQVBJIHNoYWxsIG5vdCBicmVhayBleGlzdGluZyB1 c2VyCj4gPiA+ID4gPiA+IHNwYWNlICsKPiA+ID4gPiA+ID4gK0ludGVyZmFjZXMKPiA+ID4gPiA+ ID4gKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K PiA+ID4gPiA+ID4gK0FsdGhvdWdoIHRoZSBkYXRhIHN0cnVjdHVyZXMgZGVmaW5lZCBpbiBJT01N VSBVQVBJIGFyZQo+ID4gPiA+ID4gPiBzZWxmLWNvbnRhaW5lZCwgK3RoZXJlIGlzIG5vIHVzZXIg QVBJIGZ1bmN0aW9ucyBpbnRyb2R1Y2VkLgo+ID4gPiA+ID4gPiBJbnN0ZWFkLCBJT01NVSBVQVBJ IGlzICtkZXNpZ25lZCB0byB3b3JrIHdpdGggZXhpc3RpbmcgdXNlcgo+ID4gPiA+ID4gPiBkcml2 ZXIgZnJhbWV3b3JrcyBzdWNoIGFzIFZGSU8uICsKPiA+ID4gPiA+ID4gK0V4dGVuc2lvbiBSdWxl cyAmIFByZWNhdXRpb25zCj4gPiA+ID4gPiA+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQo+ID4gPiA+ID4gPiArV2hlbiBJT01NVSBVQVBJIGdldHMgZXh0ZW5kZWQsIHRoZSBkYXRhIHN0 cnVjdHVyZXMgY2FuCj4gPiA+ID4gPiA+ICpvbmx5KiBiZSArbW9kaWZpZWQgaW4gdHdvIHdheXM6 Cj4gPiA+ID4gPiA+ICsKPiA+ID4gPiA+ID4gKzEuIEFkZGluZyBuZXcgZmllbGRzIGJ5IHJlLXB1 cnBvc2luZyB0aGUgcGFkZGluZ1tdIGZpZWxkLgo+ID4gPiA+ID4gPiBObyBzaXplIGNoYW5nZS4g KzIuIEFkZGluZyBuZXcgdW5pb24gbWVtYmVycyBhdCB0aGUgZW5kLiBNYXkKPiA+ID4gPiA+ID4g aW5jcmVhc2UgaW4gc2l6ZS4gKwo+ID4gPiA+ID4gPiArTm8gbmV3IGZpZWxkcyBjYW4gYmUgYWRk ZWQgKmFmdGVyKiB0aGUgdmFyaWFibGUgc2l6ZSB1bmlvbgo+ID4gPiA+ID4gPiBpbiB0aGF0IGl0 ICt3aWxsIGJyZWFrIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2hlbiBvZmZzZXQKPiA+ID4gPiA+ ID4gbW92ZXMuIEluIGJvdGggY2FzZXMsIGEgK25ldyBmbGFnIG11c3QgYmUgYWNjb21wYW5pZWQg d2l0aAo+ID4gPiA+ID4gPiBhIG5ldyBmaWVsZCBzdWNoIHRoYXQgdGhlIElPTU1VICtkcml2ZXIg Y2FuIHByb2Nlc3MgdGhlCj4gPiA+ID4gPiA+IGRhdGEgYmFzZWQgb24gdGhlIG5ldyBmbGFnLiBW ZXJzaW9uIGZpZWxkIGlzICtvbmx5IHJlc2VydmVkCj4gPiA+ID4gPiA+IGZvciB0aGUgdW5saWtl bHkgZXZlbnQgb2YgVUFQSSB1cGdyYWRlIGF0IGl0cyBlbnRpcmV0eS4gKwo+ID4gPiA+ID4gPiAr SXQncyAqYWx3YXlzKiB0aGUgY2FsbGVyJ3MgcmVzcG9uc2liaWxpdHkgdG8gaW5kaWNhdGUgdGhl Cj4gPiA+ID4gPiA+IHNpemUgb2YgdGhlICtzdHJ1Y3R1cmUgcGFzc2VkIGJ5IHNldHRpbmcgYXJn c3oKPiA+ID4gPiA+ID4gYXBwcm9wcmlhdGVseS4gKwo+ID4gPiA+ID4gPiArV2hlbiBJT01NVSBV QVBJIGV4dGVuc2lvbiByZXN1bHRzIGluIHNpemUgaW5jcmVhc2UsIHVzZXIKPiA+ID4gPiA+ID4g c3VjaCBhcyBWRklPICtoYXMgdG8gaGFuZGxlIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW9zOgo+ID4g PiA+ID4gPiArCj4gPiA+ID4gPiA+ICsxLiBVc2VyIGFuZCBrZXJuZWwgaGFzIGV4YWN0IHNpemUg bWF0Y2gKPiA+ID4gPiA+ID4gKzIuIEFuIG9sZGVyIHVzZXIgd2l0aCBvbGRlciBrZXJuZWwgaGVh ZGVyIChzbWFsbGVyIFVBUEkKPiA+ID4gPiA+ID4gc2l6ZSkgcnVubmluZyBvbiBhCj4gPiA+ID4g PiA+ICsgICBuZXdlciBrZXJuZWwgKGxhcmdlciBVQVBJIHNpemUpCj4gPiA+ID4gPiA+ICszLiBB IG5ld2VyIHVzZXIgd2l0aCBuZXdlciBrZXJuZWwgaGVhZGVyIChsYXJnZXIgVUFQSSBzaXplKQo+ ID4gPiA+ID4gPiBydW5uaW5nCj4gPiA+ID4gPiA+ICsgICBvbiBhIG9sZGVyIGtlcm5lbC4KPiA+ ID4gPiA+ID4gKzQuIEEgbWFsaWNpb3VzL21pc2JlaGF2aW5nIHVzZXIgcGFzcyBpbGxlZ2FsL2lu dmFsaWQgc2l6ZQo+ID4gPiA+ID4gPiBidXQgd2l0aGluCj4gPiA+ID4gPiA+ICsgICByYW5nZS4g VGhlIGRhdGEgbWF5IGNvbnRhaW4gZ2FyYmFnZS4KPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiAr Cj4gPiA+ID4gPiA+ICtGZWF0dXJlIENoZWNraW5nCj4gPiA+ID4gPiA+ICstLS0tLS0tLS0tLS0t LS0tCj4gPiA+ID4gPiA+ICtXaGlsZSBsYXVuY2hpbmcgYSBndWVzdCB3aXRoIHZJT01NVSwgaXQg aXMgaW1wb3J0YW50IHRvCj4gPiA+ID4gPiA+IGVuc3VyZSB0aGF0IGhvc3QgK2NhbiBzdXBwb3J0 IHRoZSBVQVBJIGRhdGEgc3RydWN0dXJlcyB0bwo+ID4gPiA+ID4gPiBiZSB1c2VkIGZvciB2SU9N TVUtcElPTU1VICtjb21tdW5pY2F0aW9ucy4gV2l0aG91dCB0aGUKPiA+ID4gPiA+ID4gdXBmcm9u dCAgCj4gPiBjb21wYXRpYmlsaXR5ICAKPiA+ID4gPiA+ID4gY2hlY2tpbmcsIGZ1dHVyZSArZmF1 bHRzIGFyZSBkaWZmaWN1bHQgdG8gcmVwb3J0IGV2ZW4gaW4KPiA+ID4gPiA+ID4gbm9ybWFsIGNv bmRpdGlvbnMuIEZvciBleGFtcGxlLCArVExCIGludmFsaWRhdGlvbnMgc2hvdWxkCj4gPiA+ID4g PiA+IGFsd2F5cyBzdWNjZWVkIGZyb20gdklPTU1VJ3MgK3BlcnNwZWN0aXZlLiBUaGVyZSBpcyBu bwo+ID4gPiA+ID4gPiBhcmNoaXRlY3R1cmFsIHdheSB0byByZXBvcnQgYmFjayB0byB0aGUgdklP TU1VICtpZiB0aGUgVUFQSQo+ID4gPiA+ID4gPiBkYXRhIGlzIGluY29tcGF0aWJsZS4gRm9yIHRo aXMgcmVhc29uIHRoZSBmb2xsb3dpbmcgSU9NTVUKPiA+ID4gPiA+ID4gK1VBUElzIGNhbm5vdCBm YWlsOiArCj4gPiA+ID4gPiA+ICsxLiBGcmVlIFBBU0lECj4gPiA+ID4gPiA+ICsyLiBVbmJpbmQg Z3Vlc3QgUEFTSUQKPiA+ID4gPiA+ID4gKzMuIFVuYmluZCBndWVzdCBQQVNJRCB0YWJsZSAoU01N VSkKPiA+ID4gPiA+ID4gKzQuIENhY2hlIGludmFsaWRhdGUKPiA+ID4gPiA+ID4gKzUuIFBhZ2Ug cmVzcG9uc2UKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArVXNlciBhcHBsaWNhdGlvbnMgc3Vj aCBhcyBRRU1VIGlzIGV4cGVjdGVkIHRvIGltcG9ydCBrZXJuZWwKPiA+ID4gPiA+ID4gVUFQSSAr aGVhZGVycy4gT25seSBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IGlzIHN1cHBvcnRlZC4gRm9yCj4g PiA+ID4gPiA+IGV4YW1wbGUsIGFuICtvbGRlciBRRU1VICh3aXRoIG9sZGVyIGtlcm5lbCBoZWFk ZXIpIGNhbiBydW4KPiA+ID4gPiA+ID4gb24gbmV3ZXIga2VybmVsLiBOZXdlciArUUVNVSAod2l0 aCBuZXcga2VybmVsIGhlYWRlcikgbWF5Cj4gPiA+ID4gPiA+IGZhaWwgb24gb2xkZXIga2VybmVs LiAgCj4gPiA+ID4gPgo+ID4gPiA+ID4gIkJ1aWxkIHlvdXIgdXNlciBhcHBsaWNhdGlvbiBhZ2Fp bnN0IG5ld2VyIGtlcm5lbHMgYW5kIGl0IG1heQo+ID4gPiA+ID4gYnJlYWsgb24gb2xkZXIga2Vy bmVscyIgaXMgbm90IGEgZ3JlYXQgc2VsbGluZyBwb2ludCBvZiB0aGlzCj4gPiA+ID4gPiBVQVBJ LiAgQ2xlYXJseSBuZXcgZmVhdHVyZXMgbWF5IG5vdCBiZSBhdmFpbGFibGUgb24gb2xkZXIKPiA+ ID4gPiA+IGtlcm5lbHMgYW5kIGFuIGFwcGxpY2F0aW9uIHRoYXQgZGVwZW5kcyBvbiBhIG5ld2Vy IGZlYXR1cmUKPiA+ID4gPiA+IG1heSBiZSByZXN0cmljdGVkIHRvIG5ld2VyIGtlcm5lbHMuICAK PiA+ID4gPiBQZXJoYXBzICJmYWlsIG9uIG9sZGVyIGtlcm5lbCIgaXMgbm90IHRoZSByaWdodCBz dGF0ZW1lbnQuIEkKPiA+ID4gPiBtZWFudCB0byBzYXkgIk5ld2VyIFFFTVUgKHdpdGggbmV3IGtl cm5lbCBoZWFkZXIpIG1heSBmYWlsIHRoZQo+ID4gPiA+IGNvbXBhdGliaWxpdHkgY2hlY2sgb24g b2xkZXIga2VybmVsIi4gSGVyZSBjb21wYXRpYmlsaXR5IGNoZWNrCj4gPiA+ID4gaW52b2x2ZXMg YXJnc3ogY2hlY2sgYW5kIGZlYXR1cmUgY2hlY2suCj4gPiA+ID4KPiA+ID4gPiBEb2VzIGl0IHNv dW5kIHJpZ2h0PyAgCj4gPiA+Cj4gPiA+IElmIHNpbXBseSByZWNvbXBpbGluZyBRRU1VIGFnYWlu c3QgYSBuZXcga2VybmVsIGhlYWRlciBjYXVzZXMgaXQKPiA+ID4gdG8gZmFpbCBvbiBhbiBvbGQg a2VybmVsLCB3ZSd2ZSBkb25lIHNvbWV0aGluZyB2ZXJ5IHdyb25nIGluIHRoaXMKPiA+ID4gVUFQ SS4gCj4gPiAKPiA+IEkgYWdyZWUgd2Ugc2hvdWxkIG1ha2UgYmVzdCBlZmZvcnQgdG8gc3VwcG9y dCB0aGUgZmllbGRzIGluIHRoZSBuZXcKPiA+IGhlYWRlciB0aGF0IHdhcyBzdXBwb3J0ZWQgaW4g dGhlIG9sZGVyIGtlcm5lbC4KPiA+IAo+ID4gQnV0IHRoZXJlIHdpbGwgYmUgY2FzZXMgdGhhdCBu ZXcgYXBwIGZhaWxzIG9uIG9sZCBrZXJuZWwgaWYgdGhlIG5ldwo+ID4gZmllbGRzIGZyb20gdGhl IG5ldyBoZWFkZXIgYXJlIHVzZWQuIERvIHdlIGhhdmUgY29uc2Vuc3VzIG9uIHRoaXM/ICAKPiAK PiBZZXMsIEkgdGhpbmsgdGhhdCBpcyBhbHNvIHdoYXQgQWxleCBtZWFudC4gSWYgbmV3IGZlYXR1 cmUvZmllbGQgaXMKPiB0b3VjaGVkIHRoZSBhcHAgd2lsbCBmYWlsIGZvciBzdXJlIG9uIG9sZCBr ZXJuZWwuIEJ1dCBpZiBvbmx5IG9sZAo+IGZlYXR1cmVzL2ZpZWxkcyBhcmUgdG91Y2hlZCB0aGVu IHRoZSBhcHAgc2hvdWxkIHdvcmsgY29ycmVjdGx5LiBUaGlzCj4gaXMgdGhlIGNhc2UgYnkgc2lt cGx5IHJlY29tcGlsaW5nIFFlbXUgYWdhaW5zdCBhIG5ldyBrZXJuZWwgaGVhZGVyLAo+IHdoZXJl IG5vIG5ldyBmZWF0dXJlIGlzIHN1cHBvc2VkIHRvIGJlIHVzZWQuIFFlbXUgbWF5IHBhc3MgYW4g YXJnc3oKPiBiaWdnZXIgdGhhbiB3aGF0IG9sZCBrZXJuZWwgc3VwcG9ydHMsIGJ1dCBvbGQga2Vy bmVsIG9ubHkgY29waWVzIHRoZQo+IHNpemUgdGhhdCBpdCBrbm93cyBhbmQgc2VydmUgdGhlIGZl YXR1cmVzIHRoYXQgaXQgc3VwcG9ydHMgYWNjb3JkaW5nCj4gdG8gZmxhZ3MuCj4gCmdyZWF0LCB0 aGFua3MgZm9yIHRoZSBjb25maXJtYXRpb24uCgo+ID4gICAKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ ID4gPiArSU9NTVUgdmVuZG9yIGRyaXZlciBzaG91bGQgcmVwb3J0IHRoZSBiZWxvdyBmZWF0dXJl cyB0bwo+ID4gPiA+ID4gPiBJT01NVSBVQVBJICtjb25zdW1lcnMgKGUuZy4gdmlhIFZGSU8pLgo+ ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICsxLiBJT01NVV9ORVNUSU5HX0ZFQVRfU1lTV0lERV9Q QVNJRAo+ID4gPiA+ID4gPiArMi4gSU9NTVVfTkVTVElOR19GRUFUX0JJTkRfUEdUQkwKPiA+ID4g PiA+ID4gKzMuIElPTU1VX05FU1RJTkdfRkVBVF9CSU5EX1BBU0lEX1RBQkxFCj4gPiA+ID4gPiA+ ICs0LiBJT01NVV9ORVNUSU5HX0ZFQVRfQ0FDSEVfSU5WTEQKPiA+ID4gPiA+ID4gKzUuIElPTU1V X05FU1RJTkdfRkVBVF9QQUdFX1JFUVVFU1QKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArVGFr ZSBWRklPIGFzIGV4YW1wbGUsIHVwb24gcmVxdWVzdCBmcm9tIFZGSU8gdXNlciBzcGFjZQo+ID4g PiA+ID4gPiAoZS5nLiBRRU1VKSwgK1ZGSU8ga2VybmVsIGNvZGUgc2hhbGwgcXVlcnkgSU9NTVUg dmVuZG9yCj4gPiA+ID4gPiA+IGRyaXZlciBmb3IgdGhlIHN1cHBvcnQgb2YgK3RoZSBhYm92ZSBm ZWF0dXJlcy4gUXVlcnkgcmVzdWx0Cj4gPiA+ID4gPiA+IGNhbiB0aGVuIGJlIHJlcG9ydGVkIGJh Y2sgdG8gdGhlICt1c2VyLXNwYWNlIGNhbGxlci4KPiA+ID4gPiA+ID4gRGV0YWlscyBjYW4gYmUg Zm91bmQgaW4gK0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS92ZmlvLnJzdC4KPiA+ID4gPiA+ID4g Kwo+ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICtEYXRhIFBhc3NpbmcgRXhhbXBsZSB3aXRoIFZG SU8KPiA+ID4gPiA+ID4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ID4gPiA+ID4g PiArQXMgdGhlIHViaXF1aXRvdXMgdXNlcnNwYWNlIGRyaXZlciBmcmFtZXdvcmssIFZGSU8gaXMK PiA+ID4gPiA+ID4gYWxyZWFkeSBJT01NVSArYXdhcmUgYW5kIHNoYXJlIG1hbnkga2V5IGNvbmNl cHRzIHN1Y2ggYXMKPiA+ID4gPiA+ID4gZGV2aWNlIG1vZGVsLCBncm91cCwgYW5kICtwcm90ZWN0 aW9uIGRvbWFpbi4gT3RoZXIgdXNlcgo+ID4gPiA+ID4gPiBkcml2ZXIgZnJhbWV3b3JrcyBjYW4g YWxzbyBiZSBleHRlbmRlZCArdG8gc3VwcG9ydCBJT01NVQo+ID4gPiA+ID4gPiBVQVBJIGJ1dCBp dCBpcyBvdXRzaWRlIHRoZSBzY29wZSBvZiB0aGlzIGRvY3VtZW50LiArCj4gPiA+ID4gPiA+ICtJ biB0aGlzIHRpZ2h0LWtuaXQgVkZJTy1JT01NVSBpbnRlcmZhY2UsIHRoZSB1bHRpbWF0ZQo+ID4g PiA+ID4gPiBjb25zdW1lciBvZiB0aGUgK0lPTU1VIFVBUEkgZGF0YSBpcyB0aGUgaG9zdCBJT01N VSBkcml2ZXIuCj4gPiA+ID4gPiA+IFZGSU8gZmFjaWxpdGF0ZXMgdXNlci1rZXJuZWwgK3RyYW5z cG9ydCwgY2FwYWJpbGl0eQo+ID4gPiA+ID4gPiBjaGVja2luZywgc2VjdXJpdHksIGFuZCBsaWZl IGN5Y2xlIG1hbmFnZW1lbnQgb2YgK3Byb2Nlc3MKPiA+ID4gPiA+ID4gYWRkcmVzcyBzcGFjZSBJ RCAoUEFTSUQpLiArCj4gPiA+ID4gPiA+ICtVbmxpa2Ugbm9ybWFsIHVzZXIgZGF0YSBwYXNzZWQg dmlhIFZGSU8gVUFQSSBJT1RDTCwgSU9NTVUKPiA+ID4gPiA+ID4gZHJpdmVyIGlzIHRoZSArdWx0 aW1hdGUgY29uc3VtZXIgb2YgaXRzIFVBUEkgZGF0YS4gQXQgVkZJTwo+ID4gPiA+ID4gPiBsYXll ciwgdGhlIElPTU1VIFVBUEkgZGF0YSAraXMgd3JhcHBlZCBpbiBhIFZGSU8gVUFQSSBkYXRhCj4g PiA+ID4gPiA+IGZvciBzYW5pdHkgY2hlY2tpbmcuIEl0IGZvbGxvd3MgdGhlICtwYXR0ZXJuIGJl bG93Ogo+ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICs6Ogo+ID4gPiA+ID4gPiArCj4gPiA+ID4g PiA+ICsgICBzdHJ1Y3Qgewo+ID4gPiA+ID4gPiArCV9fdTMyIGFyZ3N6Owo+ID4gPiA+ID4gPiAr CV9fdTMyIGZsYWdzOwo+ID4gPiA+ID4gPiArCV9fdTggIGRhdGFbXTsKPiA+ID4gPiA+ID4gKyAg fQo+ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICtIZXJlIGRhdGFbXSBjb250YWlucyB0aGUgSU9N TVUgVUFQSSBkYXRhIHN0cnVjdHVyZXMuCj4gPiA+ID4gPiA+ICsKPiA+ID4gPiA+ID4gK0luIG9y ZGVyIHRvIGRldGVybWluZSB0aGUgc2l6ZSBhbmQgZmVhdHVyZSBzZXQgb2YgdGhlIHVzZXIKPiA+ ID4gPiA+ID4gZGF0YSwgYXJnc3ogK2FuZCBmbGFncyBhcmUgYWxzbyBlbWJlZGRlZCBpbiB0aGUg SU9NTVUgVUFQSQo+ID4gPiA+ID4gPiBkYXRhIHN0cnVjdHVyZXMuICtBICJfX3UzMiBhcmdzeiIg ZmllbGQgaXMgKmFsd2F5cyogYXQgdGhlCj4gPiA+ID4gPiA+IGJlZ2lubmluZyBvZiBlYWNoIHN0 cnVjdHVyZS4gKwo+ID4gPiA+ID4gPiArRm9yIGV4YW1wbGU6Cj4gPiA+ID4gPiA+ICs6Ogo+ID4g PiA+ID4gPiArCj4gPiA+ID4gPiA+ICsgICBzdHJ1Y3QgaW9tbXVfZ3Bhc2lkX2JpbmRfZGF0YSB7 Cj4gPiA+ID4gPiA+ICsJX191MzIgYXJnc3o7Cj4gPiA+ID4gPiA+ICsJX191MzIgdmVyc2lvbjsK PiA+ID4gPiA+ID4gKwkjZGVmaW5lIElPTU1VX1BBU0lEX0ZPUk1BVF9JTlRFTF9WVEQJMQo+ID4g PiA+ID4gPiArCV9fdTMyIGZvcm1hdDsKPiA+ID4gPiA+ID4gKwkjZGVmaW5lIElPTU1VX1NWQV9H UEFTSURfVkFMCSgxIDw8IDApCj4gPiA+ID4gPiA+ICsJX191NjQgZmxhZ3M7Cj4gPiA+ID4gPiA+ ICsJX191NjQgZ3BnZDsKPiA+ID4gPiA+ID4gKwlfX3U2NCBocGFzaWQ7Cj4gPiA+ID4gPiA+ICsJ X191NjQgZ3Bhc2lkOwo+ID4gPiA+ID4gPiArCV9fdTMyIGFkZHJfd2lkdGg7Cj4gPiA+ID4gPiA+ ICsJX191OCAgcGFkZGluZ1sxMl07Cj4gPiA+ID4gPiA+ICsJLyogVmVuZG9yIHNwZWNpZmljIGRh dGEgKi8KPiA+ID4gPiA+ID4gKwl1bmlvbiB7Cj4gPiA+ID4gPiA+ICsJCXN0cnVjdCBpb21tdV9n cGFzaWRfYmluZF9kYXRhX3Z0ZCB2dGQ7Cj4gPiA+ID4gPiA+ICsJfTsKPiA+ID4gPiA+ID4gKyAg fTsKPiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArVXNlIGJpbmQgZ3Vlc3QgUEFTSUQgYXMgYW4g ZXhhbXBsZSwgVkZJTyBjb2RlIHNoYWxsIHByb2Nlc3MKPiA+ID4gPiA+ID4gSU9NTVUgVUFQSSAr cmVxdWVzdCBhcyBmb2xsb3dzOgo+ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICs6Ogo+ID4gPiA+ ID4gPiArCj4gPiA+ID4gPiA+ICsgMSAgICAgICAgLyogTWluc3ogbXVzdCBpbmNsdWRlIElPTU1V IFVBUEkgImFyZ3N6IiBvZgo+ID4gPiA+ID4gPiBfX3UzMiAqLwo+ID4gPiA+ID4gPiArIDIgICAg ICAgIG1pbnN6ID0gb2Zmc2V0b2ZlbmQoc3RydWN0IHZmaW9faW9tbXVfdHlwZTFfYmluZCwKPiA+ ID4gPiA+ID4gZmxhZ3MpICsKPiA+ID4gPiA+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHNpemVvZih1MzIpOyAgCj4gPiA+ID4gPgo+ID4gPiA+ID4gSW4gdGhlIGV4YW1wbGUgc3Ry dWN0dXJlIGFib3ZlOgo+ID4gPiA+ID4gIAo+ID4gPiA+ID4gPiArICAgc3RydWN0IHsKPiA+ID4g PiA+ID4gKwlfX3UzMiBhcmdzejsKPiA+ID4gPiA+ID4gKwlfX3UzMiBmbGFnczsKPiA+ID4gPiA+ ID4gKwlfX3U4ICBkYXRhW107Cj4gPiA+ID4gPiA+ICsgIH0gIAo+ID4gPiA+ID4KPiA+ID4gPiA+ IFRoaXMgcHJlc3VtZXMgdGhhdCB2ZmlvIGRvZXMgbm90IHVzZSBmbGFncyB0byBpZGVudGlmeSBh Cj4gPiA+ID4gPiBkaWZmZXJlbnQgbGF5b3V0LCBmb3IgZXhhbXBsZSBhIGZpZWxkIGJlZm9yZSBk YXRhIG9yIGRlZmluaW5nCj4gPiA+ID4gPiBhIGZsYWcgdGhhdCBwcm92aWRlcyBubyBkYXRhLiAg SU9XLCB0aGUgSU9NTVUgZ3VhcmFudGVlcwo+ID4gPiA+ID4gYXJnc3ogYXQgdGhlIGJlZ2lubmlu ZyBvZiBhbGwgc3RydWN0dXJlcywgYnV0IGxldCdzIG5vdCBsaW1pdAo+ID4gPiA+ID4gaG93IHZm aW8gY2hvb3NlcyB0byBidW5kbGUgdGhhdCBzdHJ1Y3R1cmUuICBtaW5zeiBzaG91bGQgYmUKPiA+ ID4gPiA+IGJhc2VkIG9uIGZsYWdzLCB3aGljaCB3ZSdsbCBldmFsdWF0ZSB0byBkZXRlcm1pbmUg aG93IG11Y2gKPiA+ID4gPiA+IG1vcmUgdG8gY29weS4gCj4gPiA+ID4gR290IGl0LCBWRklPIG93 bnMgaXRzIGZsYWdzIHRoZXJlZm9yZSBtaW5zei4gSG93IGFib3V0IHJld29yZAo+ID4gPiA+IHRo ZSBleGFtcGxlIGRhdGEgc3RydWN0IGFzOgo+ID4gPiA+ICAgIHN0cnVjdCB7Cj4gPiA+ID4gCV9f dTMyIGFyZ3N6Owo+ID4gPiA+IAlfX3UzMiBmbGFnczsKPiA+ID4gPiAJX191OCAgZGF0YVtdOwo+ ID4gPiA+ICAgfQo+ID4gPiA+Cj4gPiA+ID4gSGVyZSBkYXRhW10gY29udGFpbnMgdGhlIElPTU1V IFVBUEkgZGF0YSBzdHJ1Y3R1cmVzLiBWRklPIGhhcwo+ID4gPiA+IHRoZSBmcmVlZG9tIHRvIGJ1 bmRsZSB0aGUgZGF0YSBhcyB3ZWxsIGFzIHBhcnNlIGRhdGEgc2l6ZSBiYXNlZAo+ID4gPiA+IG9u IGl0cyBvd24gZmxhZ3MuCj4gPiA+ID4KPiA+ID4gPiBJbiB0aGUgZXhhbXBsZSBjb2RlOgo+ID4g PiA+Cj4gPiA+ID4gIlVzZSBiaW5kIGd1ZXN0IFBBU0lEIGFzIGFuIGV4YW1wbGUsIFZGSU8gY29k ZSBzaGFsbCBmaXJzdAo+ID4gPiA+IHByb2Nlc3MgdGhlIGZsYWdzIGZpZWxkIHRvIGRldGVybWlu ZSB0aGUgc2l6ZSB0byBjb3B5IGZvciBJT01NVQo+ID4gPiA+IFVBUEkuIFRoZSBmbGFncyBjb3Vs ZCBpbmRpY2F0ZSBkaWZmZXJlbnQgbGF5b3V0IG9mIHRoZSBWRklPIGRhdGEKPiA+ID4gPiBhbmQg dGhlIHR5cGVzIG9mIElPTU1VIFVBUEkgZGF0YS4iICAKPiA+ID4KPiA+ID4gSSB0aGluayB0aGlz IHNob3VsZCBwcm9iYWJseSBnbyBubyBmdXJ0aGVyIHRoYW4gdG8gc2F5IHRoYXQgdGhlCj4gPiA+ IElPTU1VIFVBUEkgZGF0YSBzdHJ1Y3R1cmUgaXMgZXhwZWN0ZWQgdG8gYmUgZW1iZWRkZWQgb3Bh cXVlbHkKPiA+ID4gaW50byB0aGUgVkZJTyBBUEksIGZvciBleGFtcGxlLCBWRklPIG1heSB1c2Ug YSBzdHJ1Y3R1cmUgc3VjaCBhczoKPiA+ID4KPiA+ID4gICAgIHN0cnVjdCB7Cj4gPiA+ICAJX191 MzIgYXJnc3o7Cj4gPiA+ICAJX191MzIgZmxhZ3M7Cj4gPiA+ICAJX191OCAgZGF0YVtdOwo+ID4g PiAgICB9Cj4gPiA+Cj4gPiA+IHdoZXJlIGRhdGFbXSBjb250YWlucyBhbiBJT01NVSBVQVBJIHN0 cnVjdHVyZSwgaW5jbHVkaW5nIHRoZSB1c2VyCj4gPiA+IHByb3ZpZGVkIGFyZ3N6IGZpZWxkIHJl bGF0aXZlIHRvIHRoYXQgZW1iZWRkZWQgc3RydWN0dXJlLiAgVGhpcwo+ID4gPiBmb3JtYXQgYWxs b3dzIFZGSU8gdG8gbXVsdGlwbGV4IG11bHRpcGxlIElPTU1VIFVBUEkgaW50ZXJmYWNlcwo+ID4g PiB0aHJvdWdoIGEgcmVkdWNlZCBzZXQgb2YgaW9jdGxzLgo+ID4gPiAgCj4gPiBTb3VuZHMgZ29v ZCwgdGhhbmtzIGZvciB0aGUgc3VtbWFyeS4KPiA+ICAgCj4gPiA+ID4gPiA+IFVBUEkgK3JlcXVl c3QgYXMgZm9sbG93czogIAo+ID4gPiA+ICAKPiA+ID4gPiA+ID4gKyAzICAgICAgICBjb3B5X2Zy b21fdXNlcigmdmZpb19iaW5kLCAodm9pZCBfX3VzZXIgKilhcmcsCj4gPiA+ID4gPiA+IG1pbnN6 KTsKPiA+ID4gPiA+ID4gKyA0Cj4gPiA+ID4gPiA+ICsgNSAgICAgICAgLyogQ2hlY2sgVkZJTyBh cmdzeiAqLwo+ID4gPiA+ID4gPiArIDYgICAgICAgIGlmICh2ZmlvX2JpbmQuYXJnc3ogPCBtaW5z eikKPiA+ID4gPiA+ID4gKyA3ICAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwo+ID4gPiA+ ID4gPiArIDgKPiA+ID4gPiA+ID4gKyA5ICAgICAgICAvKiBWRklPIGZsYWdzIG11c3QgYmUgaW5j bHVkZWQgaW4gbWluc3ogKi8KPiA+ID4gPiA+ID4gKyAxMCAgICAgICAgc3dpdGNoICh2ZmlvX2Jp bmQuZmxhZ3MpIHsKPiA+ID4gPiA+ID4gKyAxMSAgICAgICAgY2FzZSBWRklPX0lPTU1VX0JJTkRf R1VFU1RfUEdUQkw6Cj4gPiA+ID4gPiA+ICsgMTIgICAgICAgICAgICAgICAgLyoKPiA+ID4gPiA+ ID4gKyAxMyAgICAgICAgICAgICAgICAgKiBHZXQgdGhlIGN1cnJlbnQgSU9NTVUgYmluZCBHUEFT SUQKPiA+ID4gPiA+ID4gZGF0YSBzaXplLAo+ID4gPiA+ID4gPiArIDE0ICAgICAgICAgICAgICAg ICAqIHdoaWNoIGFjY291bnRlZCBmb3IgdGhlIGxhcmdlc3QgdW5pb24KPiA+ID4gPiA+ID4gbWVt YmVyLgo+ID4gPiA+ID4gPiArIDE1ICAgICAgICAgICAgICAgICAqLwo+ID4gPiA+ID4gPiArIDE2 ICAgICAgICAgICAgICAgIGRhdGFfc2l6ZSA9IHNpemVvZihzdHJ1Y3QKPiA+ID4gPiA+ID4gaW9t bXVfZ3Bhc2lkX2JpbmRfZGF0YSk7Cj4gPiA+ID4gPiA+ICsgMTcgICAgICAgICAgICAgICAgaW9t bXVfYXJnc3ogPSB2ZmlvX2JpbmQuYXJnc3ogLSBtaW5zejsgIAo+ID4gPiA+ID4KPiA+ID4gPiA+ IE5vdGUgdGhhdCBieSBpbmNsdWRpbmcgdGhlIElPTU1VIFVBUEkgYXJnc3ogd2l0aGluIG1pbnN6 LAo+ID4gPiA+ID4gdGhpcyBpcyBpbmNvcnJlY3QuCj4gPiA+ID4gPiAgCj4gPiA+ID4gR29vZCBj YXRjaCwgc2hvdWxkIGJlOgo+ID4gPiA+IGlvbW11X2FyZ3N6ID0gdmZpb19iaW5kLmFyZ3N6IC0g bWluc3ogLSBzaXplb2YodTMyKSAgCj4gCj4gaW9tbXVfYXJnc3ogPSB2ZmlvX2JpbmQuYXJnc3og LSBtaW5zeiArIHNpemVvZih1MzIpCj4gCnlvdSBhcmUgcmlnaHQgOikKCj4gPiA+ID4gIAo+ID4g PiA+ID4gPiArIDE4ICAgICAgICAgICAgICAgIGlmIChpb21tdV9hcmdzeiA+IGRhdGFfc2l6ZSkg ewo+ID4gPiA+ID4gPiArIDE5ICAgICAgICAgICAgICAgICAgICAgICAgLyogVXNlciBkYXRhID4g Y3VycmVudCBrZXJuZWwgKi8KPiA+ID4gPiA+ID4gKyAyMCAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiAtRTJCSUc7Cj4gPiA+ID4gPiA+ICsgMjEgICAgICAgICAgICAgICAgfSAgCj4gPiA+ ID4gPgo+ID4gPiA+ID4gTm93IEkgc2VlIHdoeSB5b3UncmUgbWFraW5nIHRoZSBjbGFpbSB0aGF0 IFFFTVUgY29tcGlsZWQKPiA+ID4gPiA+IGFnYWluc3QgYW4gbmV3IGtlcm5lbCBtYXkgbm90IHdv cmsgb24gYW4gb2xkZXIga2VybmVsLiAgV2UKPiA+ID4gPiA+IGNhbiBkbyBiZXR0ZXIuICBUaGUg Y3VycmVudCBzaXplb2YgdGhlIGRhdGEgc3RydWN0dXJlIHNob3VsZAo+ID4gPiA+ID4gYmUgdGhl IG1heGltdW0gd2UnbGwgY29weSBmcm9tIHRoZSB1c2VyLCBhbmQgd2UgY2FuIHVwZGF0ZQo+ID4g PiA+ID4gdGhlIHVzZXIgcHJvdmlkZWQgSU9NTVUgVUFQSSBhcmdzeiBhcyB3ZSBwYXNzIGl0IGRv d24gZnJvbQo+ID4gPiA+ID4gdGhlIHVzZXIgdG8gYXZvaWQgZXhwb3Npbmcgb3Vyc2VsdmVzIHRv IGFuIGFyYml0cmFyaWx5IGxhcmdlCj4gPiA+ID4gPiB1c2VyIGJ1ZmZlci4gVGhlIElPTU1VIFVB UEkgaW50ZXJmYWNlcyBzaG91bGQgdGhlbiBhbHNvIHVzZQo+ID4gPiA+ID4gYXJnc3ogYW5kIGZs YWdzIHRvIGRldGVybWluZSB3aGV0aGVyIHRoZSBkYXRhIGlzIHByZXNlbnQgZm9yCj4gPiA+ID4g PiBhIHNwZWNpZmllZCBmbGFnLiBUaGF0IHNob3VsZCBhbGxvdyBhIHVzZXIgYXBwbGljYXRpb24K PiA+ID4gPiA+IGNvbXBpbGVkIGFnYWluc3QgYSBuZXdlciBrZXJuZWwgaGVhZGVyLCBidXQgb25s eSB1c2luZwo+ID4gPiA+ID4gZmVhdHVyZXMgZm91bmQgb24gb2xkZXIga2VybmVscyB0byBjb250 aW51ZSB0byB3b3JrIG9uIG9sZGVyCj4gPiA+ID4gPiBrZXJuZWxzLCB3aGljaCBzZWVtcyBsaWtl IGEgYmFzaWMgcmVxdWlyZW1lbnQgdG8gbWUuICAKPiA+ID4gPiBJIGdvdCB5b3VyIHBvaW50LiBC dXQgSSBkb24ndCB1bmRlcnN0YW5kIHdoeSBWRklPIGxheWVyIHdpbGwKPiA+ID4gPiB1cGRhdGUg SU9NTVUgYXJnc3osIElPTU1VIGxheWVyIGlzIG5vdCBleHBvc2VkIHRvIGFyYml0cmFyeQo+ID4g PiA+IGxhcmdlIHVzZXIgc2l6ZSBpbiB0aGF0IGl0IGNhbiBub3QgZXhjZWVkIHRoZSBjdXJyZW50 IFVBUEkgZGF0YQo+ID4gPiA+IHNpemUuICAKPiA+ID4KPiA+ID4gSSB3YXMgdGhpbmtpbmcgYWJv dXQgdGhlIGNhc2Ugd2hlcmUgdXNlcnNwYWNlIGlzIGNvbXBpbGVkIGFnYWluc3QKPiA+ID4gYSBu ZXdlciBrZXJuZWwgYW5kIG1pZ2h0IHByb3ZpZGUgYXJnc3ogPSBzaXplb2Yoc3RydWN0Cj4gPiA+ IGlvbW11X3VhcGlfZm9vJykgYnV0IHZmaW8gb25seSBrbm93cyBzaXplb2Yoc3RydWN0Cj4gPiA+ IGlvbW11X3VhcGlfZm9vKS4gIFdlIGRvbid0IHdhbnQgdG8gY29weSBhbiBhcmJpdHJhcnkgYW1v dW50IG9mCj4gPiA+IGRhdGEgZnJvbSB1c2Vyc3BhY2UsIHNvIHZmaW8gd291bGQgdXNlIE1JTihh cmdzeiwgc2l6ZW9mKHN0cnVjdAo+ID4gPiBpb21tdV91YXBpX2ZvbykpIGZvciB0aGUgY29weV9m cm9tX3VzZXIoKS4gVGhlIElPTU1VIFVBUEkgd291bGQKPiA+ID4gdGhlbiBuZWVkIHRvIGRlcGVu ZCBvbiB0aGUgcmVkdWNlZCBhcmdzei4KPiA+ID4KPiA+ID4gQnV0IHRoZW4gSSB0aG91Z2h0IGl0 IGV2ZW4gYmV0dGVyIGlmIFZGSU8gbGVhdmVzIHRoZSBlbnRpcmUKPiA+ID4gY29weV9mcm9tX3Vz ZXIoKSB0byB0aGUgbGF5ZXIgY29uc3VtaW5nIGl0Lgo+ID4gPiAgCj4gPiBPSy4gU291bmRzIGdv b2QsIHRoYXQgd2FzIHdoYXQgS2V2aW4gc3VnZ2VzdGVkIGFsc28uIEkganVzdCB3YXNuJ3QKPiA+ IHN1cmUgaG93IG11Y2ggVkZJTyB3YW50cyB0byBpbnNwZWN0LCBJIHRob3VnaHQgVkZJTyBsYXll ciB3YW50ZWQgdG8KPiA+IGRvIGEgc2FuaXR5IGNoZWNrLgo+ID4gCj4gPiBBbnl3YXksIEkgd2ls bCBtb3ZlIGNvcHlfZnJvbV91c2VyIHRvIGlvbW11IHVhcGkgbGF5ZXIuCj4gPiAgIAo+ID4gPiA+ IEkgYWdyZWUgd2Ugc2hvdWxkIG1ha2UgZWZmb3J0IHRvIGFsbG93IGZlYXR1cmVzIGZvdW5kIGlu IHRoZQo+ID4gPiA+IG9sZGVyIGtlcm5lbCBjb250aW51ZSB0byB3b3JrLiAgCj4gPiA+Cj4gPiA+ IFRoYXQncyBhIHJlcXVpcmVtZW50LiAgQnJlYWtpbmcgZXhpc3RpbmcgdXNlcnNwYWNlIHdpdGhv dXQKPiA+ID4gZm9sbG93aW5nIGEgZGVwcmVjYXRpb24gbW9kZWwgaXMgYSBidWcuICAKPiA+IFNv cnJ5IEkgZG9uJ3QgdW5kZXJzdGFuZCB3aHkgaXQgaXMgYnJlYWtpbmcgZXhpc3RpbmcgdXNlcnNw YWNlLiBJZiBhCj4gPiB1c2Vyc3BhY2UgaXMgcmVjb21waWxlZCB3aXRoIG5ldyBrZXJuZWwgaGVh ZGVyLCBpdCBpcyBub3QKPiA+ICpleGlzdGluZyouICAKPiAKPiBJdCBpcyBub3QgdGhlICJleGlz dGluZyBiaW5hcnkiLCBidXQgaXMgYWJvdXQgdGhlICJleGlzdGluZyBjb2RlIi4g8J+Yigo+IApy aWdodC4gSSBndWVzcyB0aGVyZSBhcmUgdHdvIHBvc3NpYmlsaXRpZXMgZm9yIGFwcHMgdG8gdXNl IGtlcm5lbApoZWFkZXIuIHdlIG5lZWQgdG8gc3VwcG9ydCBib3RoLgoxLiBzZWxlY3RpdmVseSBp bXBvcnQgcGFydCBvZiB0aGUgaGVhZGVyCjIuIGluY2x1ZGUgaGVhZGVyCgp3aWxsIGRvIGluIHRo ZSBuZXh0IHJvdW5kLgoKPiBUaGFua3MsCj4gS2V2aW4KPiAKPiA+ICAgCj4gPiA+IEJ1dCBJIHRo aW5rIHNvIHRvbyBpcyB0aGUgZmFjdCB0aGF0IHRoaXMKPiA+ID4gaW50ZXJmYWNlIGFjdHVhbGx5 IHNwZWNpZmllcyBhbmQgcHJvdmlkZXMgYW4gZXhhbXBsZSB3aGVyZSBzaW1wbHkKPiA+ID4gcmVj b21waWxpbmcgZXhpc3RpbmcgdXNlcnNwYWNlIGFnYWluc3QgYSBuZXcga2VybmVsIGhlYWRlciB3 aGVyZQo+ID4gPiB0aGUgc2l6ZSBvZiBzdHJ1Y3R1cmUgbWF5IGJlIGNoYW5nZWQgdG8gc3VwcG9y dCBhIGZlYXR1cmUgd2lsbAo+ID4gPiBjYXVzZSB0aGF0IGFwcGxpY2F0aW9uIHRvIGZhaWwgdG8g cnVuIG9uIG9sZGVyIGtlcm5lbHMuICBUaGF0J3MKPiA+ID4gbm90IGZlYXNpYmxlIGZvciBhIGRp c3RyaWJ1dGlvbiB0byBzdXBwb3J0Lgo+ID4gPiAgCj4gPiBJIHNlZSB5b3VyIHBvaW50LCBteSBh c3N1bXB0aW9uIHdhcyB0aGF0IGFwcCAoZS5nLiBRRU1VKSBpbXBvcnRzIG5ldwo+ID4gaGVhZGVy IHNlbGVjdGl2ZWx5LiBUaGUgbmV3IGhlYWRlciBtdXN0IGJlIGltcG9ydGVkIHdpdGggYW4KPiA+ IGludGVudGlvbiBvZiB1c2luZyB0aGUgbmV3IGZsYWdzL2ZpZWxkcy4gSSBndWVzcyB0aGlzIG1h eSBub3QKPiA+ICphbHdheXMqIGJlIHRydWUuIEkgd2lsbCBhZGQgdGhlIHN1cHBvcnQgZm9yIG9s ZGVyIGtlcm5lbCB0byBydW4gb24KPiA+IG5ldyBoZWFkZXIgKGlmIG5vIG5ldyBmaWVsZHMvZmxh Z3MgYXJlIHVzZWQpLgo+ID4gCj4gPiAKPiA+IFRoYW5rcyBhIGxvdCEKPiA+ICAgCj4gPiA+ID4g PiA+ICsgMjIgICAgICAgICAgICAgICAgY29weV9mcm9tX3VzZXIoJmlvbW11X2JpbmQsICh2b2lk Cj4gPiA+ID4gPiA+IF9fdXNlciAqKQo+ID4gPiA+ID4gPiArIDIzICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHZmaW9fYmluZC5kYXRhLAo+ID4gPiA+ID4gPiBpb21tdV9hcmdzeik7Cj4g PiA+ID4gPiA+ICsgMjQgICAgICAgICAgICAgICAvKgo+ID4gPiA+ID4gPiArIDI1ICAgICAgICAg ICAgICAgICogRGVhbCB3aXRoIHRyYWlsaW5nIGJ5dGVzIHRoYXQgaXMKPiA+ID4gPiA+ID4gYmln Z2VyIHRoYW4gdXNlcgo+ID4gPiA+ID4gPiArIDI2ICAgICAgICAgICAgICAgICogcHJvdmlkZWQg VUFQSSBzaXplIGJ1dCBzbWFsbGVyIHRoYW4KPiA+ID4gPiA+ID4gdGhlIGN1cnJlbnQKPiA+ID4g PiA+ID4gKyAyNyAgICAgICAgICAgICAgICAqIGtlcm5lbCBkYXRhIHNpemUuIFplcm8gZmlsbCB0 aGUKPiA+ID4gPiA+ID4gdHJhaWxpbmcgYnl0ZXMuCj4gPiA+ID4gPiA+ICsgMjggICAgICAgICAg ICAgICAgKi8KPiA+ID4gPiA+ID4gKyAyOSAgICAgICAgICAgICAgICBtZW1zZXQoaW9tbXVfYmlu ZCArIGlvbW11X2FyZ3N6LCAwLAo+ID4gPiA+ID4gPiBkYXRhX3NpemUgLQo+ID4gPiA+ID4gPiAr IDMwICAgICAgICAgICAgICAgICAgICAgICBpb21tdV9hcmdzejsgIAo+ID4gPiA+ID4KPiA+ID4g PiA+IFRoZSBJT01NVSBVQVBJIGludGVyZmFjZSBoYXZpbmcgYWNjZXNzIHRvIGFyZ3N6IHNob3Vs ZCBtYWtlCj4gPiA+ID4gPiB0aGlzIHVubmVjZXNzYXJ5LiAgUGVyZm9ybWluZyB0aGlzIG1lbXNl dCgpIHNlZW1zIGxpa2UgaXQKPiA+ID4gPiA+IHN1Z2dlc3RzIHRvIHRoZSBuZXh0IGxheWVyIHRo YXQgaXQgY2FuIHJlbHkgb24gYWxsIGZpZWxkcwo+ID4gPiA+ID4gYmVpbmcgcHJlc2VudCBhbmQg dmFsaWQsIHdoaWNoIGRlZmVhdHMgdGhlIHB1cnBvc2Ugb2YgYXJnc3ouCj4gPiA+ID4gPiAgCj4g PiA+ID4gVGhpcyBtZW1zZXQgZG9lcyBub3Qgc3VnZ2VzdCBhbGwgZmllbGRzIGFyZSBwcmVzZW50 IGFuZCB2YWxpZC4KPiA+ID4gPiBPbmx5IGZpbHRlciBvdXQgdGhlIG9idmlvdXMgaW52YWxpZCBk YXRhIGJhc2VkIG9uIGN1cnJlbnQgc2l6ZS4KPiA+ID4gPiBNeSBpbnRlbnRpb24gaXMgdG8gcmVk dWNlIHRoZSBidXJkZW4gb2YgY2hlY2tpbmcgbm90Cj4gPiA+ID4gZWxpbWluYXRlLiAgCj4gPiA+ Cj4gPiA+IEknbSBhZnJhaWQgdGhhdCByZWR1Y2luZyB0aGUgYnVyZGVuIG9uIHRoZSBJT01NVSBV QVBJIGxheWVycwo+ID4gPiBsZWFkcyB0byByZWR1Y2VkIHZpc2liaWxpdHkgd2hpY2ggbGVhZHMg dG8gbGVzcyBzdHJpbmdlbnQKPiA+ID4gdmFsaWRhdGlvbi4gIFdlJ3JlIGRlZmluaW5nIGEgVUFQ SSBsYXllciBmb3IgdGhlIGtlcm5lbCB3aGVyZQo+ID4gPiBWRklPIGp1c3QgaGFwcGVucyB0byBi ZSBhbiBpbnRlcmZhY2UgdGhyb3VnaCB0byB0aGF0IFVBUEkuICBUaGUKPiA+ID4gVUFQSSBzaG91 bGQgdGhlcmVmb3JlIGJlIHByb3ZpZGluZyB0aGUgdmFsaWRhdGlvbiwgbm90IFZGSU8uCj4gPiA+ IENyZWF0ZSBhIHdyYXBwZXIgaW4gdGhlIElPTU1VIFVBUEkgbGF5ZXIgaWYgeW91IHdhbnQgdG8g c2hhcmUKPiA+ID4gY29tbW9uIHZhbGlkYXRpb24uIAo+ID4gPiA+ID4gPiArIDMxCj4gPiA+ID4g PiA+ICsgMzIgICAgICAgICAgICAgICAgaW9tbXVfc3ZhX2JpbmRfZ3Bhc2lkKGRvbWFpbiwgZGV2 LAo+ID4gPiA+ID4gPiBpb21tdV9iaW5kX2RhdGEpOwo+ID4gPiA+ID4gPiArIDMzICAgICAgICAg ICAgICAgIGJyZWFrOwo+ID4gPiA+ID4gPiArCj4gPiA+ID4gPiA+ICsKPiA+ID4gPiA+ID4gK0Nh c2UgIzEgJiAyIGFyZSBzdXBwb3J0ZWQgcGVyIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgcnVsZS4K PiA+ID4gPiA+ID4gKwo+ID4gPiA+ID4gPiArQ2FzZSAjMyB3aWxsIGZhaWwgd2l0aCAtRTJCSUcg YXQgbGluZSAjMjAuIENhc2UgIAo+ID4gPiA+ID4KPiA+ID4gPiA+IFRoaXMgaXMgbm90IGFjY2Vw dGFibGUgSU1PLgo+ID4gPiA+ID4gIAo+ID4gPiA+IEdvdCBpdC4gV2lsbCBjb3B5IHVwIHRvIHRo ZSBjdXJyZW50IGRhdGEgc2l6ZSBhbmQgbGV0IElPTU1VCj4gPiA+ID4gZHJpdmVyIGhhbmRsZSBz dXBwb3J0ZWQgZmxhZ3MvZmVhdHVyZXMuCj4gPiA+ID4gIAo+ID4gPiA+ID4gPiArQ2FzZSAjNCBt YXkgcmVzdWx0IGluIG90aGVyIGVycm9yIHByb2Nlc3NlZCBieSBJT01NVSB2ZW5kb3IKPiA+ID4g PiA+ID4gZHJpdmVyLiBIb3dldmVyLCArdGhlIGRhbWFnZSBzaGFsbCBub3QgZXhjZWVkIHRoZSBz Y29wZSBvZgo+ID4gPiA+ID4gPiB0aGUgb2ZmZW5kaW5nIHVzZXIuICAKPiA+ID4gPiA+Cj4gPiA+ ID4gPiBUaGlzIGlzIGEgY29uY2VybiBpbiB0aGlzIGRvdWJsZSB3cmFwcGVkIGludGVyZmFjZSwg dGhlIElPTU1VCj4gPiA+ID4gPiBVQVBJIGxheWVyIG1heSBleHBlY3QgdGhlIHZmaW8gbGF5ZXIg dG8gdmFsaWRhdGUgdGhlIGRhdGEuCj4gPiA+ID4gPiBaZXJvaW5nIHRoZSByZW1haW5kZXIgb2Yg dGhlIGRhdGEgc3RydWN0dXJlIGlzIGV2aWRlbmNlCj4gPiA+ID4gPiB0b3dhcmRzIHRoYXQuICBU aGUgSU9NTVUgVUFQSSBsYXllciBuZWVkcyB0byBjb25zaWRlciBhbGwgb2YKPiA+ID4gPiA+IHRo aXMgdW50cnVzdGVkLCBzbyB3aHkgd291bGQgd2Ugbm90IHJlZmxlY3QgdGhhdCBieSBwYXNzaW5n IGEKPiA+ID4gPiA+IF9fdXNlciBwb2ludGVyIHRocm91Z2ggdG8gdGhlIElPTU1VIFVBUEkgc3Vj aCB0aGF0IGl0IGNhbgo+ID4gPiA+ID4gY29weSB0aGUgZGF0YSBmcm9tIHRoZSB1c2VyIGl0c2Vs ZiByYXRoZXIgdGhhbiBiZWluZyBtaXNsZWFkCj4gPiA+ID4gPiB0aGF0IHRoZSBjb250ZW50cyBo YXZlIGJlZW4gc29tZWhvdyB2ZXJpZmllZD8gIFRoYW5rcywgIAo+ID4gPiA+IEkgYW0gT0sgd2l0 aCBJT01NVSBsYXllciBkb2VzIHRoZSBjb3B5X2Zyb21fdXNlci4gT25lIG9mIG15Cj4gPiA+ID4g b3JpZ2luYWwgdGhpbmtpbmcgd2FzIHRoYXQgc2luY2Ugc29tZSBBUElzIChlLmcgcGFnZSByZXNw b25zZSkKPiA+ID4gPiBhbHNvIHVzZWQgYnkgaW4ta2VybmVsIGNvZGUsIEkgd291bGQgYXZvaWQg dXNlciBwb2ludGVyIG9yCj4gPiA+ID4gYW5vdGhlciB3cmFwcGVyLgo+ID4gPiA+Cj4gPiA+ID4g UGVyaGFwcyBuZWVkIHRvIGNsYXJpZnkgdGhlIHJvbGVzIG9mIGVhY2ggbGF5ZXIsIElNSE8gdGhl IHJvbGVzCj4gPiA+ID4gYXJlOgo+ID4gPiA+IC0gVkZJTwo+ID4gPiA+IAkxLiBidW5kbGUgSU9N TVUgVUFQSSBkYXRhIHdpdGggZmxhZ3MgJiBhcmdzego+ID4gPiA+IAkyLiBzYW5pdHkgY2hlY2sg YXJnc3ogPiBtaW5zego+ID4gPiA+IAkzLiBkZXRlcm1pbmUgdGhlIGNvcHlfZnJvbV91c2VyIHNp emUgYmFzZWQgb24gVkZJTwo+ID4gPiA+IGZsYWdzICYgYXJnc3oKPiA+ID4gPgo+ID4gPiA+IC0g SU9NTVUgVUFQSQo+ID4gPiA+IAkxLiBjaGVjayBhcmdzeiBhZ2FpbnN0IGN1cnJlbnQga2VybmVs IElPTU1VIFVBUEkgZGF0YQo+ID4gPiA+IHNpemUsIGl0cyBvd24gbWluc3oKPiA+ID4gPiAJMi4g cGFyc2UgZGF0YSBiYXNlZCBvbiBmZWF0dXJlL2ZsYWdzCj4gPiA+ID4KPiA+ID4gPiBTbyBpZiBW RklPIGFscmVhZHkgY2FuIGRlY2lkZSB0aGUgY29weV9mcm9tX3VzZXIgc2l6ZSBhcyBpbgo+ID4g PiA+IFZGSU8uMywgd2h5IGNhbid0IGl0IGp1c3QgZG8gdGhlIGNvcHkgYXMgd2VsbC4gVkZJTyBv bmx5IGNoZWNrcwo+ID4gPiA+IGFuZCBlbnN1cmVzIHNpemUsIG5vdGhpbmcgc3BlY2lmaWMgdG8g dGhlIGNvbnRlbnQgb2YgSU9NTVUKPiA+ID4gPiBVQVBJLiBEb2VzIHRoZSByb2xlIHBhcnRpdGlv biBzb3VuZCByaWdodD8gIAo+ID4gPgo+ID4gPiBBcyBhYm92ZSwgdGhlIG9ubHkgd2F5IHRoYXQg dGhpcyBjYW4gYmUgYSBnZW5lcmljIFVBUEkgaXMgaWYgVkZJTwo+ID4gPiBpcyBqdXN0IGEgcGFz c3Rocm91Z2gsIG90aGVyd2lzZSB0aGlzIGp1c3QgYmVjb21lcyBWRklPIEFQSSBhbmQKPiA+ID4g d2UgbWlnaHQgYXMgd2VsbCBub3QgcHJldGVuZCB3ZSdyZSBjcmVhdGluZyBhIFVBUEkgYmV0d2Vl biB0aGUKPiA+ID4gVkZJTyBhbmQgSU9NTVUuIElmIGEgc2Vjb25kIHVzZXIgb2YgdGhlIFVBUEkg d291bGQgZHVwbGljYXRlIHRoZQo+ID4gPiBjb2RlIGZyb20gVkZJTywgdGhlbiBpdCBzaG91bGRu J3QgYmUgaW4gVkZJTy4gIFRoYW5rcywKPiA+ID4KPiA+ID4gQWxleAo+ID4gPiAgCj4gPiAKPiA+ IFtKYWNvYiBQYW5dICAKCltKYWNvYiBQYW5dCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBsaXN0cy5saW51eC1m b3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9s aXN0aW5mby9pb21tdQ== 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=-8.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 269E1C433E1 for ; Fri, 12 Jun 2020 13:02:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EB3A520801 for ; Fri, 12 Jun 2020 13:02:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726310AbgFLNCz convert rfc822-to-8bit (ORCPT ); Fri, 12 Jun 2020 09:02:55 -0400 Received: from mga09.intel.com ([134.134.136.24]:6465 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726085AbgFLNCu (ORCPT ); Fri, 12 Jun 2020 09:02:50 -0400 IronPort-SDR: 9dfw7P5YIhuB08pH9/WppdMFdnCxvjN1yJhDGIly8QnKFhX4KDstlD1nspqBrfxSUX8PrpAg0E YbgMn/j8n2qg== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga007.jf.intel.com ([10.7.209.58]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jun 2020 06:02:46 -0700 IronPort-SDR: 37svnWUr1PnOteS0f1MOUOH6z26o/3Rk550jV+opK54qr8EzH/YjK270OEsYrJ+WTgWjfvMgCh 4GzY+8ddGWig== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.73,503,1583222400"; d="scan'208";a="260822458" Received: from jacob-builder.jf.intel.com (HELO jacob-builder) ([10.7.199.155]) by orsmga007.jf.intel.com with ESMTP; 12 Jun 2020 06:02:46 -0700 Date: Fri, 12 Jun 2020 06:09:11 -0700 From: Jacob Pan To: "Tian, Kevin" Cc: Alex Williamson , "iommu@lists.linux-foundation.org" , LKML , Lu Baolu , Joerg Roedel , David Woodhouse , "Liu, Yi L" , "Raj, Ashok" , "Christoph Hellwig" , Jean-Philippe Brucker , Eric Auger , "Jonathan Corbet" , jacob.jun.pan@linux.intel.com Subject: Re: [PATCH v2 1/3] docs: IOMMU user API Message-ID: <20200612060911.29d5c3b8@jacob-builder> In-Reply-To: References: <1591848735-12447-1-git-send-email-jacob.jun.pan@linux.intel.com> <1591848735-12447-2-git-send-email-jacob.jun.pan@linux.intel.com> <20200611094741.6d118fa8@w520.home> <20200611125205.1e0280d3@jacob-builder> <20200611144047.79613c32@x1.home> <20200611172727.78dbb822@jacob-builder> 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 On Fri, 12 Jun 2020 07:38:44 +0000 "Tian, Kevin" wrote: > > From: Jacob Pan > > Sent: Friday, June 12, 2020 8:27 AM > > > > On Thu, 11 Jun 2020 14:40:47 -0600 > > Alex Williamson wrote: > > > > > On Thu, 11 Jun 2020 12:52:05 -0700 > > > Jacob Pan wrote: > > > > > > > Hi Alex, > > > > > > > > On Thu, 11 Jun 2020 09:47:41 -0600 > > > > Alex Williamson wrote: > > > > > > > > > On Wed, 10 Jun 2020 21:12:13 -0700 > > > > > Jacob Pan wrote: > > > > > > > > > > > IOMMU UAPI is newly introduced to support communications > > between > > > > > > guest virtual IOMMU and host IOMMU. There has been lots of > > > > > > discussions on how it should work with VFIO UAPI and > > > > > > userspace in general. > > > > > > > > > > > > This document is indended to clarify the UAPI design and > > > > > > usage. The mechenics of how future extensions should be > > > > > > achieved are also covered in this documentation. > > > > > > > > > > > > Signed-off-by: Liu Yi L > > > > > > Signed-off-by: Jacob Pan > > > > > > --- > > > > > > Documentation/userspace-api/iommu.rst | 210 > > > > > > ++++++++++++++++++++++++++++++++++ 1 file changed, 210 > > > > > > insertions(+) create mode 100644 > > > > > > Documentation/userspace-api/iommu.rst > > > > > > > > > > > > diff --git a/Documentation/userspace-api/iommu.rst > > > > > > b/Documentation/userspace-api/iommu.rst new file mode 100644 > > > > > > index 000000000000..e95dc5a04a41 > > > > > > --- /dev/null > > > > > > +++ b/Documentation/userspace-api/iommu.rst > > > > > > @@ -0,0 +1,210 @@ > > > > > > +.. SPDX-License-Identifier: GPL-2.0 > > > > > > +.. iommu: > > > > > > + > > > > > > +===================================== > > > > > > +IOMMU Userspace API > > > > > > +===================================== > > > > > > + > > > > > > +IOMMU UAPI is used for virtualization cases where > > > > > > communications are +needed between physical and virtual > > > > > > IOMMU drivers. For native +usage, IOMMU is a system device > > > > > > which does not need to communicate +with user space > > > > > > directly. + > > > > > > +The primary use cases are guest Shared Virtual Address > > > > > > (SVA) and +guest IO virtual address (IOVA), wherein virtual > > > > > > IOMMU (vIOMMU) is +required to communicate with the > > > > > > physical IOMMU in the host. + > > > > > > +.. contents:: :local: > > > > > > + > > > > > > +Functionalities > > > > > > +==================================================== > > > > > > +Communications of user and kernel involve both directions. > > > > > > The +supported user-kernel APIs are as follows: > > > > > > + > > > > > > +1. Alloc/Free PASID > > > > > > +2. Bind/unbind guest PASID (e.g. Intel VT-d) > > > > > > +3. Bind/unbind guest PASID table (e.g. ARM sMMU) > > > > > > +4. Invalidate IOMMU caches > > > > > > +5. Service page request > > > > > > + > > > > > > +Requirements > > > > > > +==================================================== > > > > > > +The IOMMU UAPIs are generic and extensible to meet the > > > > > > following +requirements: > > > > > > + > > > > > > +1. Emulated and para-virtualised vIOMMUs > > > > > > +2. Multiple vendors (Intel VT-d, ARM sMMU, etc.) > > > > > > +3. Extensions to the UAPI shall not break existing user > > > > > > space + > > > > > > +Interfaces > > > > > > +==================================================== > > > > > > +Although the data structures defined in IOMMU UAPI are > > > > > > self-contained, +there is no user API functions introduced. > > > > > > Instead, IOMMU UAPI is +designed to work with existing user > > > > > > driver frameworks such as VFIO. + > > > > > > +Extension Rules & Precautions > > > > > > +----------------------------- > > > > > > +When IOMMU UAPI gets extended, the data structures can > > > > > > *only* be +modified in two ways: > > > > > > + > > > > > > +1. Adding new fields by re-purposing the padding[] field. > > > > > > No size change. +2. Adding new union members at the end. May > > > > > > increase in size. + > > > > > > +No new fields can be added *after* the variable size union > > > > > > in that it +will break backward compatibility when offset > > > > > > moves. In both cases, a +new flag must be accompanied with > > > > > > a new field such that the IOMMU +driver can process the > > > > > > data based on the new flag. Version field is +only reserved > > > > > > for the unlikely event of UAPI upgrade at its entirety. + > > > > > > +It's *always* the caller's responsibility to indicate the > > > > > > size of the +structure passed by setting argsz > > > > > > appropriately. + > > > > > > +When IOMMU UAPI extension results in size increase, user > > > > > > such as VFIO +has to handle the following scenarios: > > > > > > + > > > > > > +1. User and kernel has exact size match > > > > > > +2. An older user with older kernel header (smaller UAPI > > > > > > size) running on a > > > > > > + newer kernel (larger UAPI size) > > > > > > +3. A newer user with newer kernel header (larger UAPI size) > > > > > > running > > > > > > + on a older kernel. > > > > > > +4. A malicious/misbehaving user pass illegal/invalid size > > > > > > but within > > > > > > + range. The data may contain garbage. > > > > > > + > > > > > > + > > > > > > +Feature Checking > > > > > > +---------------- > > > > > > +While launching a guest with vIOMMU, it is important to > > > > > > ensure that host +can support the UAPI data structures to > > > > > > be used for vIOMMU-pIOMMU +communications. Without the > > > > > > upfront > > compatibility > > > > > > checking, future +faults are difficult to report even in > > > > > > normal conditions. For example, +TLB invalidations should > > > > > > always succeed from vIOMMU's +perspective. There is no > > > > > > architectural way to report back to the vIOMMU +if the UAPI > > > > > > data is incompatible. For this reason the following IOMMU > > > > > > +UAPIs cannot fail: + > > > > > > +1. Free PASID > > > > > > +2. Unbind guest PASID > > > > > > +3. Unbind guest PASID table (SMMU) > > > > > > +4. Cache invalidate > > > > > > +5. Page response > > > > > > + > > > > > > +User applications such as QEMU is expected to import kernel > > > > > > UAPI +headers. Only backward compatibility is supported. For > > > > > > example, an +older QEMU (with older kernel header) can run > > > > > > on newer kernel. Newer +QEMU (with new kernel header) may > > > > > > fail on older kernel. > > > > > > > > > > "Build your user application against newer kernels and it may > > > > > break on older kernels" is not a great selling point of this > > > > > UAPI. Clearly new features may not be available on older > > > > > kernels and an application that depends on a newer feature > > > > > may be restricted to newer kernels. > > > > Perhaps "fail on older kernel" is not the right statement. I > > > > meant to say "Newer QEMU (with new kernel header) may fail the > > > > compatibility check on older kernel". Here compatibility check > > > > involves argsz check and feature check. > > > > > > > > Does it sound right? > > > > > > If simply recompiling QEMU against a new kernel header causes it > > > to fail on an old kernel, we've done something very wrong in this > > > UAPI. > > > > I agree we should make best effort to support the fields in the new > > header that was supported in the older kernel. > > > > But there will be cases that new app fails on old kernel if the new > > fields from the new header are used. Do we have consensus on this? > > Yes, I think that is also what Alex meant. If new feature/field is > touched the app will fail for sure on old kernel. But if only old > features/fields are touched then the app should work correctly. This > is the case by simply recompiling Qemu against a new kernel header, > where no new feature is supposed to be used. Qemu may pass an argsz > bigger than what old kernel supports, but old kernel only copies the > size that it knows and serve the features that it supports according > to flags. > great, thanks for the confirmation. > > > > > > > > + > > > > > > +IOMMU vendor driver should report the below features to > > > > > > IOMMU UAPI +consumers (e.g. via VFIO). > > > > > > + > > > > > > +1. IOMMU_NESTING_FEAT_SYSWIDE_PASID > > > > > > +2. IOMMU_NESTING_FEAT_BIND_PGTBL > > > > > > +3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE > > > > > > +4. IOMMU_NESTING_FEAT_CACHE_INVLD > > > > > > +5. IOMMU_NESTING_FEAT_PAGE_REQUEST > > > > > > + > > > > > > +Take VFIO as example, upon request from VFIO user space > > > > > > (e.g. QEMU), +VFIO kernel code shall query IOMMU vendor > > > > > > driver for the support of +the above features. Query result > > > > > > can then be reported back to the +user-space caller. > > > > > > Details can be found in +Documentation/driver-api/vfio.rst. > > > > > > + > > > > > > + > > > > > > +Data Passing Example with VFIO > > > > > > +------------------------------ > > > > > > +As the ubiquitous userspace driver framework, VFIO is > > > > > > already IOMMU +aware and share many key concepts such as > > > > > > device model, group, and +protection domain. Other user > > > > > > driver frameworks can also be extended +to support IOMMU > > > > > > UAPI but it is outside the scope of this document. + > > > > > > +In this tight-knit VFIO-IOMMU interface, the ultimate > > > > > > consumer of the +IOMMU UAPI data is the host IOMMU driver. > > > > > > VFIO facilitates user-kernel +transport, capability > > > > > > checking, security, and life cycle management of +process > > > > > > address space ID (PASID). + > > > > > > +Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU > > > > > > driver is the +ultimate consumer of its UAPI data. At VFIO > > > > > > layer, the IOMMU UAPI data +is wrapped in a VFIO UAPI data > > > > > > for sanity checking. It follows the +pattern below: > > > > > > + > > > > > > +:: > > > > > > + > > > > > > + struct { > > > > > > + __u32 argsz; > > > > > > + __u32 flags; > > > > > > + __u8 data[]; > > > > > > + } > > > > > > + > > > > > > +Here data[] contains the IOMMU UAPI data structures. > > > > > > + > > > > > > +In order to determine the size and feature set of the user > > > > > > data, argsz +and flags are also embedded in the IOMMU UAPI > > > > > > data structures. +A "__u32 argsz" field is *always* at the > > > > > > beginning of each structure. + > > > > > > +For example: > > > > > > +:: > > > > > > + > > > > > > + struct iommu_gpasid_bind_data { > > > > > > + __u32 argsz; > > > > > > + __u32 version; > > > > > > + #define IOMMU_PASID_FORMAT_INTEL_VTD 1 > > > > > > + __u32 format; > > > > > > + #define IOMMU_SVA_GPASID_VAL (1 << 0) > > > > > > + __u64 flags; > > > > > > + __u64 gpgd; > > > > > > + __u64 hpasid; > > > > > > + __u64 gpasid; > > > > > > + __u32 addr_width; > > > > > > + __u8 padding[12]; > > > > > > + /* Vendor specific data */ > > > > > > + union { > > > > > > + struct iommu_gpasid_bind_data_vtd vtd; > > > > > > + }; > > > > > > + }; > > > > > > + > > > > > > +Use bind guest PASID as an example, VFIO code shall process > > > > > > IOMMU UAPI +request as follows: > > > > > > + > > > > > > +:: > > > > > > + > > > > > > + 1 /* Minsz must include IOMMU UAPI "argsz" of > > > > > > __u32 */ > > > > > > + 2 minsz = offsetofend(struct vfio_iommu_type1_bind, > > > > > > flags) + > > > > > > + sizeof(u32); > > > > > > > > > > In the example structure above: > > > > > > > > > > > + struct { > > > > > > + __u32 argsz; > > > > > > + __u32 flags; > > > > > > + __u8 data[]; > > > > > > + } > > > > > > > > > > This presumes that vfio does not use flags to identify a > > > > > different layout, for example a field before data or defining > > > > > a flag that provides no data. IOW, the IOMMU guarantees > > > > > argsz at the beginning of all structures, but let's not limit > > > > > how vfio chooses to bundle that structure. minsz should be > > > > > based on flags, which we'll evaluate to determine how much > > > > > more to copy. > > > > Got it, VFIO owns its flags therefore minsz. How about reword > > > > the example data struct as: > > > > struct { > > > > __u32 argsz; > > > > __u32 flags; > > > > __u8 data[]; > > > > } > > > > > > > > Here data[] contains the IOMMU UAPI data structures. VFIO has > > > > the freedom to bundle the data as well as parse data size based > > > > on its own flags. > > > > > > > > In the example code: > > > > > > > > "Use bind guest PASID as an example, VFIO code shall first > > > > process the flags field to determine the size to copy for IOMMU > > > > UAPI. The flags could indicate different layout of the VFIO data > > > > and the types of IOMMU UAPI data." > > > > > > I think this should probably go no further than to say that the > > > IOMMU UAPI data structure is expected to be embedded opaquely > > > into the VFIO API, for example, VFIO may use a structure such as: > > > > > > struct { > > > __u32 argsz; > > > __u32 flags; > > > __u8 data[]; > > > } > > > > > > where data[] contains an IOMMU UAPI structure, including the user > > > provided argsz field relative to that embedded structure. This > > > format allows VFIO to multiplex multiple IOMMU UAPI interfaces > > > through a reduced set of ioctls. > > > > > Sounds good, thanks for the summary. > > > > > > > > UAPI +request as follows: > > > > > > > > > > + 3 copy_from_user(&vfio_bind, (void __user *)arg, > > > > > > minsz); > > > > > > + 4 > > > > > > + 5 /* Check VFIO argsz */ > > > > > > + 6 if (vfio_bind.argsz < minsz) > > > > > > + 7 return -EINVAL; > > > > > > + 8 > > > > > > + 9 /* VFIO flags must be included in minsz */ > > > > > > + 10 switch (vfio_bind.flags) { > > > > > > + 11 case VFIO_IOMMU_BIND_GUEST_PGTBL: > > > > > > + 12 /* > > > > > > + 13 * Get the current IOMMU bind GPASID > > > > > > data size, > > > > > > + 14 * which accounted for the largest union > > > > > > member. > > > > > > + 15 */ > > > > > > + 16 data_size = sizeof(struct > > > > > > iommu_gpasid_bind_data); > > > > > > + 17 iommu_argsz = vfio_bind.argsz - minsz; > > > > > > > > > > Note that by including the IOMMU UAPI argsz within minsz, > > > > > this is incorrect. > > > > > > > > > Good catch, should be: > > > > iommu_argsz = vfio_bind.argsz - minsz - sizeof(u32) > > iommu_argsz = vfio_bind.argsz - minsz + sizeof(u32) > you are right :) > > > > > > > > > > + 18 if (iommu_argsz > data_size) { > > > > > > + 19 /* User data > current kernel */ > > > > > > + 20 return -E2BIG; > > > > > > + 21 } > > > > > > > > > > Now I see why you're making the claim that QEMU compiled > > > > > against an new kernel may not work on an older kernel. We > > > > > can do better. The current sizeof the data structure should > > > > > be the maximum we'll copy from the user, and we can update > > > > > the user provided IOMMU UAPI argsz as we pass it down from > > > > > the user to avoid exposing ourselves to an arbitrarily large > > > > > user buffer. The IOMMU UAPI interfaces should then also use > > > > > argsz and flags to determine whether the data is present for > > > > > a specified flag. That should allow a user application > > > > > compiled against a newer kernel header, but only using > > > > > features found on older kernels to continue to work on older > > > > > kernels, which seems like a basic requirement to me. > > > > I got your point. But I don't understand why VFIO layer will > > > > update IOMMU argsz, IOMMU layer is not exposed to arbitrary > > > > large user size in that it can not exceed the current UAPI data > > > > size. > > > > > > I was thinking about the case where userspace is compiled against > > > a newer kernel and might provide argsz = sizeof(struct > > > iommu_uapi_foo') but vfio only knows sizeof(struct > > > iommu_uapi_foo). We don't want to copy an arbitrary amount of > > > data from userspace, so vfio would use MIN(argsz, sizeof(struct > > > iommu_uapi_foo)) for the copy_from_user(). The IOMMU UAPI would > > > then need to depend on the reduced argsz. > > > > > > But then I thought it even better if VFIO leaves the entire > > > copy_from_user() to the layer consuming it. > > > > > OK. Sounds good, that was what Kevin suggested also. I just wasn't > > sure how much VFIO wants to inspect, I thought VFIO layer wanted to > > do a sanity check. > > > > Anyway, I will move copy_from_user to iommu uapi layer. > > > > > > I agree we should make effort to allow features found in the > > > > older kernel continue to work. > > > > > > That's a requirement. Breaking existing userspace without > > > following a deprecation model is a bug. > > Sorry I don't understand why it is breaking existing userspace. If a > > userspace is recompiled with new kernel header, it is not > > *existing*. > > It is not the "existing binary", but is about the "existing code". 😊 > right. I guess there are two possibilities for apps to use kernel header. we need to support both. 1. selectively import part of the header 2. include header will do in the next round. > Thanks, > Kevin > > > > > > But I think so too is the fact that this > > > interface actually specifies and provides an example where simply > > > recompiling existing userspace against a new kernel header where > > > the size of structure may be changed to support a feature will > > > cause that application to fail to run on older kernels. That's > > > not feasible for a distribution to support. > > > > > I see your point, my assumption was that app (e.g. QEMU) imports new > > header selectively. The new header must be imported with an > > intention of using the new flags/fields. I guess this may not > > *always* be true. I will add the support for older kernel to run on > > new header (if no new fields/flags are used). > > > > > > Thanks a lot! > > > > > > > > + 22 copy_from_user(&iommu_bind, (void > > > > > > __user *) > > > > > > + 23 vfio_bind.data, > > > > > > iommu_argsz); > > > > > > + 24 /* > > > > > > + 25 * Deal with trailing bytes that is > > > > > > bigger than user > > > > > > + 26 * provided UAPI size but smaller than > > > > > > the current > > > > > > + 27 * kernel data size. Zero fill the > > > > > > trailing bytes. > > > > > > + 28 */ > > > > > > + 29 memset(iommu_bind + iommu_argsz, 0, > > > > > > data_size - > > > > > > + 30 iommu_argsz; > > > > > > > > > > The IOMMU UAPI interface having access to argsz should make > > > > > this unnecessary. Performing this memset() seems like it > > > > > suggests to the next layer that it can rely on all fields > > > > > being present and valid, which defeats the purpose of argsz. > > > > > > > > > This memset does not suggest all fields are present and valid. > > > > Only filter out the obvious invalid data based on current size. > > > > My intention is to reduce the burden of checking not > > > > eliminate. > > > > > > I'm afraid that reducing the burden on the IOMMU UAPI layers > > > leads to reduced visibility which leads to less stringent > > > validation. We're defining a UAPI layer for the kernel where > > > VFIO just happens to be an interface through to that UAPI. The > > > UAPI should therefore be providing the validation, not VFIO. > > > Create a wrapper in the IOMMU UAPI layer if you want to share > > > common validation. > > > > > > + 31 > > > > > > + 32 iommu_sva_bind_gpasid(domain, dev, > > > > > > iommu_bind_data); > > > > > > + 33 break; > > > > > > + > > > > > > + > > > > > > +Case #1 & 2 are supported per backward compatibility rule. > > > > > > + > > > > > > +Case #3 will fail with -E2BIG at line #20. Case > > > > > > > > > > This is not acceptable IMO. > > > > > > > > > Got it. Will copy up to the current data size and let IOMMU > > > > driver handle supported flags/features. > > > > > > > > > > +Case #4 may result in other error processed by IOMMU vendor > > > > > > driver. However, +the damage shall not exceed the scope of > > > > > > the offending user. > > > > > > > > > > This is a concern in this double wrapped interface, the IOMMU > > > > > UAPI layer may expect the vfio layer to validate the data. > > > > > Zeroing the remainder of the data structure is evidence > > > > > towards that. The IOMMU UAPI layer needs to consider all of > > > > > this untrusted, so why would we not reflect that by passing a > > > > > __user pointer through to the IOMMU UAPI such that it can > > > > > copy the data from the user itself rather than being mislead > > > > > that the contents have been somehow verified? Thanks, > > > > I am OK with IOMMU layer does the copy_from_user. One of my > > > > original thinking was that since some APIs (e.g page response) > > > > also used by in-kernel code, I would avoid user pointer or > > > > another wrapper. > > > > > > > > Perhaps need to clarify the roles of each layer, IMHO the roles > > > > are: > > > > - VFIO > > > > 1. bundle IOMMU UAPI data with flags & argsz > > > > 2. sanity check argsz > minsz > > > > 3. determine the copy_from_user size based on VFIO > > > > flags & argsz > > > > > > > > - IOMMU UAPI > > > > 1. check argsz against current kernel IOMMU UAPI data > > > > size, its own minsz > > > > 2. parse data based on feature/flags > > > > > > > > So if VFIO already can decide the copy_from_user size as in > > > > VFIO.3, why can't it just do the copy as well. VFIO only checks > > > > and ensures size, nothing specific to the content of IOMMU > > > > UAPI. Does the role partition sound right? > > > > > > As above, the only way that this can be a generic UAPI is if VFIO > > > is just a passthrough, otherwise this just becomes VFIO API and > > > we might as well not pretend we're creating a UAPI between the > > > VFIO and IOMMU. If a second user of the UAPI would duplicate the > > > code from VFIO, then it shouldn't be in VFIO. Thanks, > > > > > > Alex > > > > > > > [Jacob Pan] [Jacob Pan]