From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jacob Pan Subject: [PATCH V4 01/18] docs: Document IO Address Space ID (IOASID) APIs Date: Sat, 27 Feb 2021 14:01:09 -0800 Message-ID: <1614463286-97618-2-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Sender: "iommu" To: LKML , Joerg Roedel , Lu Baolu , David Woodhouse , iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, cgroups-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Cc: "Tian, Kevin" , Dave Jiang , Raj Ashok , Jonathan Corbet , linux-doc-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Alex Williamson , Randy Dunlap , Jason Gunthorpe , Wu Hao SU9BU0lEIGlzIHVzZWQgdG8gaWRlbnRpZnkgYWRkcmVzcyBzcGFjZXMgdGhhdCBjYW4gYmUgdGFy Z2V0ZWQgYnkgZGV2aWNlCkRNQS4gSXQgaXMgYSBzeXN0ZW0td2lkZSByZXNvdXJjZSB0aGF0IGlz IGVzc2VudGlhbCB0byBpdHMgbWFueSB1c2Vycy4KVGhpcyBkb2N1bWVudCBpcyBhbiBhdHRlbXB0 IHRvIGhlbHAgZGV2ZWxvcGVycyBmcm9tIGFsbCB2ZW5kb3JzIG5hdmlnYXRlCnRoZSBBUElzLiBB dCB0aGlzIHRpbWUsIEFSTSBTTU1VIGFuZCBJbnRlbOKAmXMgU2NhbGFibGUgSU8gVmlydHVhbGl6 YXRpb24KKFNJT1YpIGVuYWJsZWQgcGxhdGZvcm1zIGFyZSB0aGUgcHJpbWFyeSB1c2VycyBvZiBJ T0FTSUQuIEV4YW1wbGVzIG9mCmhvdyBTSU9WIGNvbXBvbmVudHMgaW50ZXJhY3Qgd2l0aCB0aGUg SU9BU0lEIEFQSXMgYXJlIHByb3ZpZGVkLgoKQ2M6IEpvbmF0aGFuIENvcmJldCA8Y29yYmV0QGx3 bi5uZXQ+CkNjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCkNjOiBSYW5keSBEdW5sYXAgPHJk dW5sYXBAaW5mcmFkZWFkLm9yZz4KU2lnbmVkLW9mZi1ieTogTGl1IFlpIEwgPHlpLmwubGl1QGlu dGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogV3UgSGFvIDxoYW8ud3VAaW50ZWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBKYWNvYiBQYW4gPGphY29iLmp1bi5wYW5AbGludXguaW50ZWwuY29tPgotLS0KIERv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9pbmRleC5yc3QgIHwgICAxICsKIERvY3VtZW50YXRpb24v ZHJpdmVyLWFwaS9pb2FzaWQucnN0IHwgNTEwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysK IDIgZmlsZXMgY2hhbmdlZCwgNTExIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBE b2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJzdAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vZHJpdmVyLWFwaS9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW5k ZXgucnN0CmluZGV4IDI0NTZkMGE5N2VkOC4uYmFlZWMzMDhjZjJjIDEwMDY0NAotLS0gYS9Eb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvaW5kZXgucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVy LWFwaS9pbmRleC5yc3QKQEAgLTM3LDYgKzM3LDcgQEAgYXZhaWxhYmxlIHN1YnNlY3Rpb25zIGNh biBiZSBzZWVuIGJlbG93LgogICAgcGNpL2luZGV4CiAgICBzcGkKICAgIGkyYworICAgaW9hc2lk CiAgICBpcG1iCiAgICBpcG1pCiAgICBpM2MvaW5kZXgKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9pb2FzaWQucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2lvYXNp ZC5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mM2VkNWJmNDNm YTYKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJz dApAQCAtMCwwICsxLDUxMCBAQAorLi4gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAK Ky4uIGlvYXNpZDoKKworPT09PT09PT09PT09PT09PT09PT09CisgSU8gQWRkcmVzcyBTcGFjZSBJ RAorPT09PT09PT09PT09PT09PT09PT09CisKK0lPQVNJRHMgYXJlIHVzZWQgdG8gaWRlbnRpZnkg dmlydHVhbCBhZGRyZXNzIHNwYWNlcyB0aGF0IERNQSByZXF1ZXN0cyBjYW4KK3RhcmdldC4gSXQg aXMgYSBnZW5lcmljIG5hbWUgZm9yIFBDSWUgUHJvY2VzcyBBZGRyZXNzIElEIChQQVNJRCkgb3IK K1N1YnN0cmVhbUlEIGRlZmluZWQgYnkgQVJNJ3MgU01NVS4KKworVGhlIHByaW1hcnkgdXNlIGNh c2VzIGZvciBJT0FTSURzIGFyZSBTaGFyZWQgVmlydHVhbCBBZGRyZXNzIChTVkEpIGFuZAorSU8g VmlydHVhbCBBZGRyZXNzIChJT1ZBKSB3aGVuIG11bHRpcGxlIGFkZHJlc3Mgc3BhY2VzIHBlciBk ZXZpY2UgYXJlCitkZXNpcmVkLiBEdWUgdG8gaGFyZHdhcmUgYXJjaGl0ZWN0dXJhbCBkaWZmZXJl bmNlcyB0aGUgcmVxdWlyZW1lbnRzIGZvcgorSU9BU0lEIG1hbmFnZW1lbnQgY2FuIHZhcnkgaW4g dGVybXMgb2YgbmFtZXNwYWNlLCBzdGF0ZSBtYW5hZ2VtZW50LCBhbmQKK3ZpcnR1YWxpemF0aW9u IHVzYWdlcy4KKworVGhlIElPQVNJRCBzdWJzeXN0ZW0gY29uc2lzdHMgb2YgdGhyZWUgY29tcG9u ZW50czoKKworLSBJT0FTSUQgY29yZTogcHJvdmlkZXMgQVBJcyBmb3IgYWxsb2NhdGlvbiwgcG9v bCBtYW5hZ2VtZW50LAorICBub3RpZmljYXRpb25zIGFuZCByZWZjb3VudGluZy4KKy0gSU9BU0lE IHVzZXI6ICBwcm92aWRlcyB1c2VyIGFsbG9jYXRpb24gaW50ZXJmYWNlIHZpYSAvZGV2L2lvYXNp ZAorLSBJT0FTSUQgY2dyb3VwIGNvbnRyb2xsZXI6IG1hbmFnZSByZXNvdXJjZSBkaXN0cmlidXRp b24uCisgIChEb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2Nncm91cC12MS9pb2FzaWRzLnJzdCkK KworVGhpcyBkb2N1bWVudCBjb3ZlcnMgdGhlIGZlYXR1cmVzIHN1cHBvcnRlZCBieSB0aGUgSU9B U0lEIGNvcmUgQVBJcy4KK1ZlbmRvci1zcGVjaWZpYyB1c2UgY2FzZXMgYXJlIGFsc28gaWxsdXN0 cmF0ZWQgd2l0aCBJbnRlbCdzIFZULWQKK2Jhc2VkIHBsYXRmb3JtcyBhcyB0aGUgZmlyc3QgZXhh bXBsZS4gVGhlIHRlcm0gUEFTSUQgYW5kIElPQVNJRCBhcmUgdXNlZAoraW50ZXJjaGFuZ2VhYmx5 IHRocm91Z2hvdXQgdGhpcyBkb2N1bWVudC4KKworLi4gY29udGVudHM6OiA6bG9jYWw6CisKK0ds b3NzYXJ5Cis9PT09PT09PQorUEFTSUQgLSBQcm9jZXNzIEFkZHJlc3MgU3BhY2UgSUQKKworSU9W QSAtIElPIFZpcnR1YWwgQWRkcmVzcworCitJT0FTSUQgLSBJTyBBZGRyZXNzIFNwYWNlIElEIChn ZW5lcmljIHRlcm0gZm9yIFBDSWUgUEFTSUQgYW5kCitTdWJzdHJlYW1JRCBpbiBTTU1VKQorCitT VkEvU1ZNIC0gU2hhcmVkIFZpcnR1YWwgQWRkcmVzc2luZy9NZW1vcnkKKworZ1NWQSAtIEd1ZXN0 IFNoYXJlZCBWaXJ0dWFsIEFkZHJlc3NpbmcKKworZ0lPVkEgLSBHdWVzdCBJTyBWaXJ0dWFsIEFk ZHJlc3NpbmcKKworRU5RQ01EIC0gSW5zdHJ1Y3Rpb24gdG8gc3VibWl0IHdvcmsgdG8gc2hhcmVk IHdvcmtxdWV1ZXMuIFJlZmVyCit0byAiSW50ZWwgWDg2IElTQSBmb3IgZWZmaWNpZW50IHdvcmtx dWV1ZSBzdWJtaXNzaW9uIiBbMV0KKworRFNBIC0gSW50ZWwgRGF0YSBTdHJlYW1pbmcgQWNjZWxl cmF0b3IgWzJdCisKK1ZEQ00gLSBWaXJ0dWFsIERldmljZSBDb21wb3NpdGlvbiBNb2R1bGUgWzNd CisKK1NJT1YgLSBJbnRlbCBTY2FsYWJsZSBJTyBWaXJ0dWFsaXphdGlvbgorCitEV1EgLSBEZWRp Y2F0ZWQgV29yayBRdWV1ZQorCitTV1EgLSBTaGFyZWQgV29yayBRdWV1ZQorCisxLiBodHRwczov L3NvZnR3YXJlLmludGVsLmNvbS9zaXRlcy9kZWZhdWx0L2ZpbGVzL21hbmFnZWQvYzUvMTUvYXJj aGl0ZWN0dXJlLWluc3RydWN0aW9uLXNldC1leHRlbnNpb25zLXByb2dyYW1taW5nLXJlZmVyZW5j ZS5wZGYKKworMi4gaHR0cHM6Ly8wMS5vcmcvYmxvZ3MvMjAxOS9pbnRyb2R1Y2luZy1pbnRlbC1k YXRhLXN0cmVhbWluZy1hY2NlbGVyYXRvcgorCiszLiBodHRwczovL3NvZnR3YXJlLmludGVsLmNv bS9lbi11cy9kb3dubG9hZC9pbnRlbC1kYXRhLXN0cmVhbWluZy1hY2NlbGVyYXRvci1wcmVsaW1p bmFyeS1hcmNoaXRlY3R1cmUtc3BlY2lmaWNhdGlvbgorCisKK0tleSBDb25jZXB0cworPT09PT09 PT09PT09CisKK0lPQVNJRCBTZXQKKy0tLS0tLS0tLS0KK0FuIElPQVNJRCBzZXQgaXMgYSBncm91 cCBvZiBJT0FTSURzIGFsbG9jYXRlZCBmcm9tIHRoZSBzeXN0ZW0td2lkZQorSU9BU0lEIHBvb2wu IFJlZmVyIHRvIHNlY3Rpb24gIklPQVNJRCBTZXQgTGV2ZWwgQVBJcyIgZm9yIG1vcmUgZGV0YWls cy4KKworSU9BU0lEIHNldCBpcyBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBndWVzdCBTVkEgd2hl cmUgZWFjaCBndWVzdCBjb3VsZAoraGF2ZSBpdHMgb3duIElPQVNJRCBzZXQgZm9yIHNlY3VyaXR5 IGFuZCBlZmZpY2llbmN5IHJlYXNvbnMuCisKK0d1ZXN0IElPQVNJRAorLS0tLS0tLS0tLS0tLS0t LS0tCitJT0FTSUQgdXNlZCBieSB0aGUgZ3Vlc3QsIGlkZW50aWZpZXMgYSBndWVzdCBJT1ZBIHNw YWNlIG9yIGEgZ3Vlc3QgVkEKK3NwYWNlIHBlciBndWVzdCBwcm9jZXNzLgorCitIb3N0IElPQVNJ RAorLS0tLS0tLS0tLS0tLS0tLS0KK0lPQVNJRCB1c2VkIGJ5IHRoZSBob3N0IGVpdGhlciBmb3Ig YmFyZSBtZXRhbCBTVkEgb3IgYXMgdGhlIGJhY2tpbmcgb2YgYQorZ3Vlc3QgSU9BU0lELgorCitC aW5kL1VuYmluZAorLS0tLS0tLS0tLS0KK1JlZmVyIHRvIHRoZSBwcm9jZXNzIHdoZXJlIG1hcHBp bmdzIGFtb25nIElPQVNJRCwgcGFnZSB0YWJsZXMsIGFuZCBkZXZpY2VzCithcmUgZXN0YWJsaXNo ZWQvZGVtb2xpc2hlZC4gVGhpcyB1c3VhbGx5IGludm9sZXMgc2V0dGluZyB1cCBhbiBlbnRyeSBv ZgordGhlIElPTU1VJ3MgcGVyIGRldmljZSBQQVNJRCB0YWJsZSB3aXRoIGEgZ2l2ZW4gUEdELgor CitJT0FTSUQgU2V0IFByaXZhdGUgSUQgKFNQSUQpCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCitFYWNoIElPQVNJRCBzZXQgaGFzIGEgcHJpdmF0ZSBuYW1lc3BhY2Ugb2YgU1BJRHMuIEFu IFNQSUQgbWFwcyB0byBhCitzaW5nbGUgc3lzdGVtLXdpZGUgSU9BU0lELiBDb252ZXJzZWx5LCBl YWNoIElPQVNJRCBtYXkgYmUgYXNzb2NpYXRlZAord2l0aCBhbiBhbGlhcyBJRCwgbG9jYWwgdG8g dGhlIElPQVNJRCBzZXQsIG5hbWVkIFNQSUQuCitTUElEcyBjYW4gYmUgdXNlZCBhcyBndWVzdCBJ T0FTSURzIHdoZXJlIGVhY2ggZ3Vlc3QgY291bGQgZG8KK0lPQVNJRCBhbGxvY2F0aW9uIGZyb20g aXRzIG93biBwb29sL3NldCBhbmQgbWFwIHRoZW0gdG8gaG9zdCBwaHlzaWNhbAorSU9BU0lEcy4g U1BJRHMgYXJlIHBhcnRpY3VsYXJseSB1c2VmdWwgZm9yIHN1cHBvcnRpbmcgbGl2ZSBtaWdyYXRp b24KK3doZXJlIGRlY291cGxpbmcgZ3Vlc3QgYW5kIGhvc3QgcGh5c2ljYWwgcmVzb3VyY2VzIGFy ZSBuZWNlc3NhcnkuIEd1ZXN0Cit0byBIb3N0IFBBU0lEIG1hcHBpbmcgY2FuIGJlIHRvcm4gZG93 biBhbmQgcmUtZXN0YWJsaXNoZWQuIFN0b3JpbmcgdGhlCittYXBwaW5nIGluc2lkZSB0aGUga2Vy bmVsIGFsc28gcHJvdmlkZXMgbG9va3VwIHNlcnZpY2UuCisKK0ZvciBleGFtcGxlLCB0d28gVk1z IGNhbiBib3RoIGFsbG9jYXRlIGd1ZXN0IFBBU0lEL1NQSUQgIzEwMSBidXQgbWFwIHRvCitkaWZm ZXJlbnQgaG9zdCBQQVNJRHMgIzIwMSBhbmQgIzIwMiByZXNwZWN0aXZlbHkgYXMgc2hvd24gaW4g dGhlCitkaWFncmFtIGJlbG93LgorOjoKKworIC4tLS0tLS0tLS0tLS0tLS0tLS0uICAgIC4tLS0t LS0tLS0tLS0tLS0tLS0uCisgfCAgIFZNIDEgICAgICAgICAgIHwgICAgfCAgIFZNIDIgICAgICAg ICAgIHwKKyB8ICAgICAgICAgICAgICAgICAgfCAgICB8ICAgICAgICAgICAgICAgICAgfAorIHwt LS0tLS0tLS0tLS0tLS0tLS18ICAgIHwtLS0tLS0tLS0tLS0tLS0tLS18CisgfCBHUEFTSUQvU1BJ RCAxMDEgIHwgICAgfCBHUEFTSUQvU1BJRCAxMDEgIHwKKyAnLS0tLS0tLS0tLS0tLS0tLS0tJyAg ICAtLS0tLS0tLS0tLS0tLS0tLS0tJyAgICAgR3Vlc3QKKyBfX19fX19fX19ffF9fX19fX19fX19f X19fX19fX19fX198X19fX19fX19fX19fX19fX19fX18KKyAgICAgICAgICAgfCAgICAgICAgICAg ICAgICAgICAgICB8ICAgICAgICAgICAgICAgSG9zdAorICAgICAgICAgICB2ICAgICAgICAgICAg ICAgICAgICAgIHYKKyAuLS0tLS0tLS0tLS0tLS0tLS0tLiAgICAuLS0tLS0tLS0tLS0tLS0tLS0t LgorIHwgSG9zdCBJT0FTSUQgMjAxICB8ICAgIHwgSG9zdCBJT0FTSUQgMjAyICB8CisgJy0tLS0t LS0tLS0tLS0tLS0tLScgICAgJy0tLS0tLS0tLS0tLS0tLS0tLScKKyB8ICAgSU9BU0lEIHNldCAx ICAgfCAgICB8ICAgSU9BU0lEIHNldCAyICAgfAorICctLS0tLS0tLS0tLS0tLS0tLS0nICAgICct LS0tLS0tLS0tLS0tLS0tLS0nCisKK0d1ZXN0IFBBU0lEIGlzIHRyZWF0ZWQgYXMgSU9BU0lEIHNl dCBwcml2YXRlIElEIChTUElEKSB3aXRoaW4gYW4KK0lPQVNJRCBzZXQsIG1hcHBpbmdzIGJldHdl ZW4gZ3Vlc3QgYW5kIGhvc3QgSU9BU0lEcyBhcmUgc3RvcmVkIGluIHRoZQorc2V0IGZvciBpbnF1 aXJ5LgorCitUaGVvcnkgb2YgT3BlcmF0aW9uCis9PT09PT09PT09PT09PT09PT09CisKK1N0YXRl cworLS0tLS0tCitJT0FTSUQgaGFzIGZvdXIgc3RhdGVzIGFzIGlsbHVzdHJhdGVkIGluIHRoZSBk aWFncmFtIGJlbG93LgorOjoKKworICAgQklORC9VTkJJTkQsIFdRIFBST0cvQ0xFQVLigbQKKyAg IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLgorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8CisgICBBTExPQy9GUkVFICAgICAgICAgICAgICAgICAgIHwKKyAgIC0tLS0tLS0t LS0tLS4gICAgICAgICAgICAgICAgfAorICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICB8 CisgICArLS0tLS0tLSsgICB2ICAgICstLS0tLS0tKyAgIHYgICAgICstLS0tLS0tLS0tKworICAg fCBGUkVFICB8PD09PT09PT58IElETEXCuSB8PD09PT09PT0+fCBBQ1RJVkXCsiAgfAorICAgKy0t LS0tLS0rICAgICAgICArLS0tLS0tLSsgICAgICAgICArLS0tLS0tLS0tLSsKKyAgICAgIF4gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CisgICAgICB8ICAgICAgICAgICArLS0t LS0tLS0tLS0tLS0tKyAgICAgICAgfAorICAgICAgJz09PT09PT09PT09fCBGUkVFIFBFTkRJTkfC syB8PD09PT09PT0nCisgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tKyAgXgorICAg RlJFRSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKKyAgIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0nCisgICDCuSBBbGxvY2F0ZWQgYnV0IG5vdCB1c2VkCisgICDCsiBV c2VkIGJ5IGRldmljZSBkcml2ZXJzLCBJT01NVSwgb3IgQ1BVLCBlYWNoIHVzZXIgaG9sZHMgYSBy ZWZlcmVuY2UKKyAgIMKzIFdhaXRpbmcgZm9yIGFsbCB1c2VycyBkcm9wIHRoZWlyIHJlZmNvdW50 IGJlZm9yZSByZXR1cm5pbmcgSU9BU0lECisgICAgIGJhY2sgdG8gdGhlIHBvb2wKKyAgIOKBtCBE ZXZpY2UgZHJpdmVycyBvYnRhaW4gcmVmY291bnQgYWZ0ZXIgcHJvZ3JhbXMgd29ya3F1ZXVlIHdp dGggSU9BU0lELgorICAgICBSZWxlYXNlIHRoZSByZWZjb3VudCBhZnRlciBjbGVhcmluZyB0aGUg d29ya3F1ZXVlLgorICAgICBTaW1pbGFybHksIHRoZSBJT01NVSBkcml2ZXIgY2FuIGFsc28gZ2V0 L3B1dCBJT0FTSUQgcmVmY291bnQgZHVyaW5nCisgICAgIGJpbmQvdW5iaW5kLgorCitOb3RpZmlj YXRpb25zCistLS0tLS0tLS0tLS0tCitEZXBlbmRpbmcgb24gdGhlIGhhcmR3YXJlIGFyY2hpdGVj dHVyZSwgYW4gSU9BU0lEIGNhbiBiZSBwcm9ncmFtbWVkIGludG8KK0NQVSwgSU9NTVUsIG9yIGRl dmljZXMgZm9yIERNQSByZWxhdGVkIGFjdGl2aXR5LiBUaGUgc3luY2hyb25pemF0aW9uIGFtb25n IHRoZW0KK2lzIGJhc2VkIG9uIGV2ZW50cyBub3RpZmljYXRpb25zIHdoaWNoIGZvbGxvd3MgYSBw dWJsaXNoZXItc3Vic2NyaWJlciBwYXR0ZXJuLgorCitFdmVudHMKK35+fn5+fgorTm90aWZpY2F0 aW9uIGV2ZW50cyBhcmUgcGVydGluZW50IHRvIGluZGl2aWR1YWwgSU9BU0lEcywgdGhleSBjYW4g YmUKK29uZSBvZiB0aGUgZm9sbG93aW5nOjoKKworIC0gQUxMT0MKKyAtIEZSRUUKKyAtIEJJTkQK KyAtIFVOQklORAorCitCZXNpZGVzIGNhbGxpbmcgaW9hc2lkX25vdGlmeSgpIGRpcmVjdGx5IHdp dGggZXhwbGljaXQgZXZlbnRzLCBub3RpZmljYXRpb25zCitjYW4gYWxzbyBiZSBzZW50IGJ5IHRo ZSBJT0FTSUQgY29yZSBhcyBhIGJ5LXByb2R1Y3Qgb2YgY2FsbGluZyB0aGUgZm9sbG93aW5nCitB UElzOjoKKworIC0gaW9hc2lzZF9mcmVlKCkgICAgICAgIC8qIGVtaXRzIElPQVNJRF9GUkVFICov CisgLSBpb2FzaWRfZGV0YWNoX3NwaWQoKSAgLyogZW1pdHMgSU9BU0lEX1VOQklORCAqLworIC0g aW9hc2lkX2F0dGFjaF9zcGlkKCkgIC8qIGVtaXRzIElPQVNJRF9CSU5EICovCisKK09yZGVyaW5n Cit+fn5+fn5+fgorT3JkZXJpbmcgb2Ygbm90aWZpY2F0aW9uIGV2ZW50cyBpcyBzdXBwb3J0ZWQg YnkgdGhlIElPQVNJRCBjb3JlIGFzIHRoZQorZm9sbG93aW5nIChmcm9tIGhpZ2ggdG8gbG93KTo6 CisKKyAtIENQVQorIC0gSU9NTVUKKyAtIERFVklDRQorCitTdWJzY3JpYmVycyBvZiBJT0FTSUQg ZXZlbnRzIGFyZSByZXNwb25zaWJsZSBmb3IgcmVnaXN0ZXJpbmcgdGhlaXIKK25vdGlmaWNhdGlv biBibG9ja3MgYWNjb3JkaW5nIHRvIHRoZSBwcmlvcml0aWVzLgorCitUaGUgYWJvdmUgb3JkZXIg YXBwbGllcyB0byBhbGwgZXZlbnRzLiBGb3IgZXhhbXBsZSwgaWYgVU5CSU5EIGV2ZW50IGlzCitp c3N1ZWQgd2hlbiBhIGd1ZXN0IElPQVNJRCBpcyBmcmVlZCBkdWUgdG8gZXhjZXB0aW9ucy4gQWxs IGFjdGl2ZSBETUEKK3NvdXJjZXMgc2hvdWxkIGJlIHF1aWVzY2VkIGJlZm9yZSB0ZWFyaW5nIGRv d24gb3RoZXIgaGFyZHdhcmUgY29udGV4dHMKK2Fzc29jaWF0ZWQgd2l0aCB0aGUgSU9BU0lEIGlu IHRoZSBzeXN0ZW0uIFRoaXMgaXMgbmVjZXNzYXJ5IHRvIHJlZHVjZQordGhlIGNodXJuIGluIGhh bmRsaW5nIGZhdWx0cy4gVGhlIG5vdGlmaWNhdGlvbiBvcmRlciBlbnN1cmVzIHRoYXQgdkNQVQor aXMgc3RvcHBlZCBiZWZvcmUgSU9NTVUgYW5kIGRldmljZXMuIEtWTSB4ODYgY29kZSByZWdpc3Rl cnMgbm90aWZpY2F0aW9uCitibG9jayB3aXRoIHByaW9yaXR5IElPQVNJRF9QUklPX0NQVSBhbmQg VkRDTSBjb2RlIHJlZ2lzdGVycyBub3RpZmljYXRpb24KK2Jsb2NrIHdpdGggcHJpb3JpdHkgSU9B U0lEX1BSSU9fREVWSUNFLCBJT0FTSUQgY29yZSBlbnN1cmVzIHRoZSBDUFUKK2hhbmRsZXJzIGFy ZSBjYWxsZWQgYmVmb3JlIHRoZSBERVZJQ0UgaGFuZGxlcnMuCisKK0l0IGlzIHRoZSBjYWxsZXIn cyByZXNwb25zaWJpbGl0eSB0byBhdm9pZCBjaGFpbmVkIG5vdGlmaWNhdGlvbnMgaW4gdGhlCith dG9taWMgbm90aWZpY2F0aW9uIGhhbmRsZXJzLiBpLmUuIGlvYXNpZF9kZXRhY2hfc3BpZCgpIGNh bm5vdCBiZSBjYWxsZWQKK2luc2lkZSB0aGUgSU9BU0lEX0ZSRUUgYXRvbWljIGhhbmRsZXJzIGR1 ZSB0byBzcGlubG9ja3MgaGVsZCBieSB0aGUKK2NhbGxlciBvZiB0aGUgbm90aWZpZXIuIEhvd2V2 ZXIsIGlvYXNpZF9kZXRhY2hfc3BpZCgpIGNhbiBiZSBjYWxsZWQgZnJvbQorZGVmZXJyZWQgd29y ay4gU2VlIEF0b21pY2l0eSBzZWN0aW9uIGZvciBkZXRhaWxzLgorCitMZXZlbCBTZW5zaXRpdml0 eQorfn5+fn5+fn5+fn5+fn5+fn4KK0ZvciBlYWNoIElPQVNJRCBzdGF0ZSB0cmFuc2l0aW9uLCBJ T0FTSUQgY29yZSBlbnN1cmVzIHRoYXQgdGhlcmUgaXMKK29ubHkgb25lIG5vdGlmaWNhdGlvbiBz ZW50LiBUaGlzIHJlc2VtYmxlcyBsZXZlbCB0cmlnZ2VyZWQgaW50ZXJydXB0Cit3aGVyZSBhIHNp bmdsZSBpbnRlcnJ1cHQgaXMgcmFpc2VkIGR1cmluZyBhIHN0YXRlIHRyYW5zaXRpb24uCitGb3Ig ZXhhbXBsZSwgaWYgaW9hc2lkX2ZyZWUoKSBpcyBjYWxsZWQgdHdpY2UgYnkgYSB1c2VyIGJlZm9y ZSB0aGUKK0lPQVNJRCBpcyByZWNsYWltZWQsIElPQVNJRCBjb3JlIHdpbGwgb25seSBzZW5kIG91 dCBhIHNpbmdsZQorSU9BU0lEX05PVElGWV9GUkVFIGV2ZW50LiBTaW1pbGFybHksIGZvciBJT0FT SURfTk9USUZZX0JJTkQvVU5CSU5ECitldmVudHMsIHdoaWNoIGlzIG9ubHkgc2VudCBvdXQgb25j ZSB3aGVuIGEgU1BJRCBpcyBhdHRhY2hlZC9kZXRhY2hlZC4KKworU2NvcGVzCit+fn5+fn4KK1Ro ZXJlIGFyZSB0d28gdHlwZXMgb2Ygbm90aWZpZXJzIGluIElPQVNJRCBjb3JlOiBzeXN0ZW0td2lk ZSBhbmQKK2lvYXNpZF9zZXQtd2lkZSAob25lIG5vdGlmaWVyIGNoYWluIHBlciBpb2FzaWRfc2V0 KS4KKworU3lzdGVtLXdpZGUgbm90aWZpZXIgaXMgY2F0ZXJpbmcgZm9yIHVzZXJzIHRoYXQgbmVl ZCB0byBoYW5kbGUgYWxsIHRoZQorSU9BU0lEcyBpbiB0aGUgc3lzdGVtLiBFLmcuIFRoZSBJT01N VSBkcml2ZXIuCisKK1BlciBpb2FzaWRfc2V0IG5vdGlmaWVyIGNhbiBiZSB1c2VkIGJ5IFZNIHNw ZWNpZmljIGNvbXBvbmVudHMgc3VjaCBhcworS1ZNLiBBZnRlciBhbGwsIGVhY2ggS1ZNIGluc3Rh bmNlIG9ubHkgY2FyZXMgYWJvdXQgSU9BU0lEcyB3aXRoaW4gaXRzCitvd24gc2V0L2d1ZXN0LiBU aGUgZm9sbG93aW5nIGZsYWdzIGFyZSB1c2VkIHRvIGRpc3Rpbmd1aXNoIHRoZSBzY29wZXM6Ogor CisgI2RlZmluZSBJT0FTSURfTk9USUZZX0ZMQUdfQUxMIEJJVCgwKQorICNkZWZpbmUgSU9BU0lE X05PVElGWV9GTEFHX1NFVCBCSVQoMSkKKworRm9yIGV4YW1wbGUsIG9uIFZULWQgcGxhdGZvcm0g Ym90aCBLVk0gYW5kIFZEQ00gc2hhbGwgcmVnaXN0ZXIgbm90aWZpZXIKK2Jsb2NrIG9uIHRoZSBJ T0FTSUQgc2V0IHN1Y2ggdGhhdCAqb25seSogZXZlbnRzIGZyb20gdGhlIG1hdGNoaW5nIFZNCith cmUgcmVjZWl2ZWQuCisKK0lmIEtWTSBhdHRlbXB0cyB0byByZWdpc3RlciBhIG5vdGlmaWVyIGJs b2NrIGJlZm9yZSB0aGUgSU9BU0lEIHNldCBpcworY3JlYXRlZCB1c2luZyB0aGUgTU0gdG9rZW4s IHRoZSBub3RpZmllciBibG9jayB3aWxsIGJlIHBsYWNlZCBvbiBhCitwZW5kaW5nIGxpc3QgaW5z aWRlIElPQVNJRCBjb3JlLiBPbmNlIHRoZSB0b2tlbiBtYXRjaGluZyBJT0FTSUQgc2V0CitpcyBj cmVhdGVkLCBJT0FTSUQgd2lsbCByZWdpc3RlciB0aGUgbm90aWZpZXIgYmxvY2sgYXV0b21hdGlj YWxseS4KK0lPQVNJRCBjb3JlIGRvZXMgbm90IHJlcGxheSBldmVudHMgZm9yIHRoZSBleGlzdGlu ZyBJT0FTSURzIGluIHRoZQorc2V0LiBGb3IgSU9BU0lEIHNldCBvZiBNTSB0eXBlLCBub3RpZmlj YXRpb24gYmxvY2tzIGNhbiBiZSByZWdpc3RlcmVkCitvbiBlbXB0eSBzZXRzIG9ubHkuIFRoaXMg aXMgdG8gYXZvaWQgbG9zdCBldmVudHMuCisKK0lPTU1VIGRyaXZlciBzaGFsbCByZWdpc3RlciBu b3RpZmllciBibG9jayBvbiBnbG9iYWwgY2hhaW4sIGUuZy4gOjoKKworIHN0YXRpYyBzdHJ1Y3Qg bm90aWZpZXJfYmxvY2sgcGFzaWRfbmJfdnRkID0geworCS5ub3RpZmllcl9jYWxsID0gcGFzaWRf c3RhdHVzX2NoYW5nZV92dGQsCisJLnByaW9yaXR5ICAgICAgPSBJT0FTSURfUFJJT19JT01NVSwK KyB9OworCitBdG9taWNpdHkKK35+fn5+fn5+fgorSU9BU0lEIG5vdGlmaWVycyBhcmUgYXRvbWlj IGR1ZSB0byBzcGlubG9ja3MgdXNlZCBpbnNpZGUgdGhlIElPQVNJRAorY29yZS4gRm9yIHRhc2tz IHRoYXQgY2Fubm90IGJlIGNvbXBsZXRlZCBpbiB0aGUgbm90aWZpZXIgaGFuZGxlciwKK2FzeW5j IHdvcmsgdG8gYmUgY29tcGxldGVkIGluIG9yZGVyIG11c3QgYmUgc3VibWl0dGVkIHRvIHRoZSBv cmRlcmVkCit3b3JrcXVldWUgcHJvdmlkZWQgYnkgdGhlIElPQVNJRCBjb3JlLiBUaGlzIHdpbGwg ZW5zdXJlIHRoZSBvcmRlciB3LnIudC4KK3RoZSB3b3JrIGl0ZW1zIHN1Ym1pdHRlZCBieSBvdGhl ciB1c2VycyBvZiB0aGUgc2FtZSBldmVudC4KKworSXQgaXMgdGhlIGNhbGxlcidzIHJlc3BvbnNp YmlsaXR5IHRvIGF2b2lkIGNoYWluZWQgbm90aWZpY2F0aW9ucyBpbiB0aGUKK2F0b21pYyBub3Rp ZmljYXRpb24gaGFuZGxlcnMuIGUuZy4gaW9hc2lkX2RldGFjaF9zcGlkKCkgY2Fubm90IGJlIGNh bGxlZAoraW5zaWRlIHRoZSBJT0FTSURfRlJFRSBhdG9taWMgaGFuZGxlcnMgZHVlIHRvIHNwaW5s b2NrcyBoZWxkIGJ5IHRoZQorY2FsbGVyIG9mIHRoZSBub3RpZmllci4gSG93ZXZlciwgaW9hc2lk X2RldGFjaF9zcGlkKCkgY2FuIGJlIGNhbGxlZCBmcm9tCitkZWZlcnJlZCB3b3JrLgorCitSZWZl cmVuY2UgY291bnRpbmcKKy0tLS0tLS0tLS0tLS0tLS0tLQorSU9BU0lEIGxpZmUgY3ljbGUgbWFu YWdlbWVudCBpcyBiYXNlZCBvbiByZWZlcmVuY2UgY291bnRpbmcuIFVzZXJzIG9mCitJT0FTSUQg d2hvIGludGVuZCB0byBhbGlnbiBpdHMgY29udGV4dCB3aXRoIHRoZSBsaWZlIGN5Y2xlIG5lZWQg dG8gaG9sZAorcmVmZXJlbmNlcyBvZiB0aGUgSU9BU0lELiBBbiBJT0FTSUQgd2lsbCBub3QgYmUg cmV0dXJuZWQgdG8gdGhlIHBvb2wKK2ZvciByZS1hbGxvY2F0aW9uIHVudGlsIGFsbCBpdHMgcmVm ZXJlbmNlcyBhcmUgZHJvcHBlZC4gQ2FsbGluZyBpb2FzaWRfZnJlZSgpCit3aWxsIG1hcmsgdGhl IElPQVNJRCBhcyBGUkVFX1BFTkRJTkcgaWYgdGhlIElPQVNJRCBoYXMgb3V0c3RhbmRpbmcKK3Jl ZmVyZW5jZXMuIE5vIG5ldyByZWZlcmVuY2VzIGNhbiBiZSB0YWtlbiBieSBpb2FzaWRfZ2V0KCkg b25jZSBhbgorSU9BU0lEIGlzIGluIHRoZSBGUkVFX1BFTkRJTkcgc3RhdGUuIGlvYXNpZF9mcmVl KCkgY2FuIGJlIGNhbGxlZAorbXVsdGlwbGUgdGltZXMgd2l0aG91dCBhbiBlcnJvciB1bnRpbCBh bGwgcmVmcyBhcmUgZHJvcHBlZC4KKworaW9hc2lkX3B1dCgpIGRlY3JlbWVudHMgYW5kIHRlc3Rz IHJlZmNvdW50IG9mIHRoZSBJT0FTSUQuIElmIHJlZmNvdW50CitpcyAwLCBpb2FzaWQgd2lsbCBi ZSBmcmVlZC4gVGhlIElPQVNJRCB3aWxsIGJlIHJldHVybmVkIHRvIHRoZSBwb29sIGFuZAorYXZh aWxhYmxlIGZvciBuZXcgYWxsb2NhdGlvbnMuIE5vdGUgdGhhdCBpb2FzaWRfcHV0KCkgY2FuIGJl IGNhbGxlZCBieQordGhlIElPQVNJRF9GUkVFIGV2ZW50IGhhbmRsZXIgd2hlcmUgdGhlIHN1YnNj cmliZXIgY2FuIGRyb3AgdGhlIGxhc3QKK3JlZmNvdW50IHRoYXQgZW5kcyB0aGUgZnJlZSBwZW5k aW5nIHN0YXRlLgorCitFdmVudCBub3RpZmljYXRpb25zIGFyZSB1c2VkIHRvIGluZm9ybSB1c2Vy cyBvZiBJT0FTSUQgc3RhdHVzIGNoYW5nZS4KK0lPQVNJRF9GUkVFIG9yIFVOQklORCBldmVudHMg cHJvbXB0IHVzZXJzIHRvIGRyb3AgdGhlaXIgcmVmZXJlbmNlcyBhZnRlcgorY2xlYXJpbmcgaXRz IGNvbnRleHQuCisKK0ZvciBleGFtcGxlLCBvbiBWVC1kIHBsYXRmb3JtIHdoZW4gYW4gSU9BU0lE IGlzIGZyZWVkLCB0ZWFyZG93bgorYWN0aW9ucyBhcmUgcGVyZm9ybWVkIG9uIENQVSAoS1ZNKSwg ZGV2aWNlIGRyaXZlciAoVkRDTSksIGFuZCB0aGUgSU9NTVUKK2RyaXZlci4gVG8gcXVpZXNjZSB2 Q1BVIGZvciB3b3JrIHN1Ym1pc3Npb24sIEtWTSBub3RpZmllciBoYW5kbGVyIG11c3QKK2JlIGNh bGxlZCBiZWZvcmUgVkRDTSBoYW5kbGVyLiBUaGVyZWZvcmUsIEtWTSBhbmQgVkRDTSBzaGFsbCBt b25pdG9yCitub3RpZmljYXRpb24gZXZlbnRzIElPQVNJRF9VTkJJTkQuCisKK05hbWVzcGFjZXMK Ky0tLS0tLS0tLS0KK0lPQVNJRHMgYXJlIGxpbWl0ZWQgc3lzdGVtIHJlc291cmNlcyB0aGF0IGRl ZmF1bHQgdG8gMjAgYml0cyBpbgorc2l6ZS4gRWFjaCBkZXZpY2UgY2FuIGhhdmUgaXRzIG93biBQ QVNJRCB0YWJsZSBmb3Igc2VjdXJpdHkgcmVhc29ucy4KK1RoZW9yZXRpY2FsbHkgdGhlIG5hbWVz cGFjZSBjYW4gYmUgcGVyIGRldmljZSBhbHNvLgorCitIb3dldmVyIElPQVNJRCBuYW1lc3BhY2Ug aXMgc3lzdGVtLXdpZGUgZm9yIHR3byByZWFzb25zOgorLSBTaW1wbGljaXR5CistIFNoYXJpbmcg cmVzb3VyY2VzIG9mIGEgc2luZ2xlIGRldmljZSB0byBtdWx0aXBsZSBWTXMuCisKK1Rha2UgVlQt ZCBhcyBhbiBleGFtcGxlLCBWVC1kIHN1cHBvcnRzIHNoYXJlZCB3b3JrcXVldWUgYW5kIEVOUUNN RFsxXQord2hlcmUgb25lIElPQVNJRCBjb3VsZCBiZSB1c2VkIHRvIHN1Ym1pdCB3b3JrIG9uIG11 bHRpcGxlIGRldmljZXMgdGhhdAorYXJlIHNoYXJlZCB3aXRoIG90aGVyIFZNcy4gVGhpcyByZXF1 aXJlcyBJT0FTSUQgdG8gYmUKK3N5c3RlbS13aWRlLiBUaGlzIGlzIGFsc28gdGhlIHJlYXNvbiB3 aHkgZ3Vlc3RzIG11c3QgdXNlIGFuCitlbXVsYXRlZCB2aXJ0dWFsIGNvbW1hbmQgaW50ZXJmYWNl IHRvIGFsbG9jYXRlIElPQVNJRCBmcm9tIHRoZSBob3N0LgorCitMaWZlIGN5Y2xlCistLS0tLS0t LS0tCitUaGlzIHNlY3Rpb24gY292ZXJzIHRoZSBJT0FTSUQgbGlmZSBjeWNsZSBtYW5hZ2VtZW50 IGZvciBib3RoIGJhcmUtbWV0YWwKK2FuZCBndWVzdCB1c2FnZXMuIEluIGJhcmUtbWV0YWwgU1ZB LCBNTVUgbm90aWZpZXIgaXMgZGlyZWN0bHkgaG9va2VkCit1cCB3aXRoIHRoZSBJT01NVSBkcml2 ZXIuIEJ5IGxldmVyYWdpbmcgdGhlIC5yZWxlYXNlKCkgZnVuY3Rpb24sIHRoZQorSU9BU0lEIGxp ZmUgY3ljbGUgY2FuIGJlIG1hZGUgdG8gbWF0Y2ggdGhlIHByb2Nlc3MgYWRkcmVzcyBzcGFjZSAo TU0pCitsaWZlIGN5Y2xlLgorCitIb3dldmVyLCBndWVzdCBNTVUgbm90aWZpZXIgaXMgbm90IGF2 YWlsYWJsZSB0byB0aGUgaG9zdCBJT01NVSBkcml2ZXIsCit3aGVuIGd1ZXN0IE1NIHRlcm1pbmF0 ZXMgdW5leHBlY3RlZGx5LCB0aGUgZXZlbnRzIGhhdmUgdG8gZ28gdGhyb3VnaAorVkZJTyBhbmQg SU9NTVUgVUFQSSB0byByZWFjaCBob3N0IElPTU1VIGRyaXZlci4gVGhlcmUgYXJlIGFsc28gbW9y ZQorcGFydGllcyBpbnZvbHZlZCBpbiBndWVzdCBTVkEsIGUuZy4gb24gSW50ZWwgVlQtZCBwbGF0 Zm9ybSwgSU9BU0lEcworYXJlIHVzZWQgYnkgSU9NTVUgZHJpdmVyLCBLVk0sIFZEQ00sIGFuZCBW RklPLgorCitBdCB0aGUgaGlnaGxldmVsLCB0aGVyZSBhcmUgZm9sbG93aW5nIGZvdXIgcGF0dGVy bnM6CisKKzEuICAgQUxMT0MgLT4gRlJFRQorMi4gICBBTExPQyAtPiBCSU5EIC0+IERNQSBBY3Rp dml0eSAtPiBVTkJJTkQgLT4gRlJFRQorMy4gICBBTExPQyAtPiBCSU5EIC0+IEZSRUUKKzQuICAg QUxMT0MgLT4gQklORCAtPiBETUEgQWN0aXZpdHkgLT4gRlJFRQorCitUaGUgZmlyc3QgdHdvIGFy ZSBub3JtYWwgY2FzZXMsIDMgYW5kIDQgYXJlIGV4Y2VwdGlvbnMgZHVlIHRvIHVzZXIKK3Byb2Nl c3MgbWlzYmVoYXZpbmcuCisKK0V4Y2VwdGlvbiBoYW5kbGluZyBjYW4gYmUgY29tcGxleCB3aGVu IHRoZXJlIGFyZSBsb3RzIG9mIElPQVNJRAorY29uc3VtZXJzIGludm9sdmVkIGJ1dCB0aGUgcGF0 dGVybiBpcyBjb21tb24gYW5kIHF1aXRlIHNpbXBsZS4gV2hlbiBhbgorSU9BU0lEIGluIGFjdGl2 ZSBzdGF0ZSBpcyBiZWluZyBmcmVlZCwgSU9BU0lEIGNvcmUgd2lsbCBub3RpZnkgYWxsCit1c2Vy cyB0byBwZXJmb3JtIGNsZWFuIHVwLiBFYWNoIElPQVNJRCB1c2VyIHBlcmZvcm1zIGNsZWFudXAg YW5kIGRyb3AKK3RoZSByZWZlcmVuY2UgYXQgdGhlIGVuZC4gV2hlbiByZWZlcmVuY2UgY291bnQg ZHJvcHMgdG8gMCwgSU9BU0lEIHdpbGwKK2JlIHJlY2xhaW1lZCBhbmQgcmVhZHkgdG8gYmUgYWxs b2NhdGVkIGFnYWluLgorCitDbGVhbnVwIGNhbiBiZSBlaXRoZXIgZG9uZSBpbiB0aGUgYXRvbWlj IG5vdGlmaWVyIGhhbmRsZXIgb3IgYXMgcXVldWVkCit3b3JrIHRvIHRoZSBjb21tb24gb3JkZXJl ZCBJT0FTSUQgd29ya3F1ZXVlIHRvIGJlIHBlcmZvcm1lZCBhc3luY2hyb25vdXNseS4KK1RoZSBo aWdobGV2ZWwgZmxvdyBpcyB0aGUgZm9sbG93aW5nOjoKKworICBGcmVlIFJlccK5IC0+IE5vdGlm eSB1c2VycyAtPiBDbGVhbnVwIC0+IERyb3AgcmVmZXJlbmNlIC0+IFJlY2xhaW0KKworTm90ZXM6 CivCuSBGcmVlIG9uZSBJT0FTSUQgb3IgZnJlZSBhbGwgSU9BU0lEIHdpdGhpbiBhIHNldAorCitU aGUgZm9sbG93aW5nIHRhYmxlIHNob3dzIGhvdyBldmVudHMgYXJlIHVzZWQgb24gSW50ZWwgVlQt ZCBwbGF0Zm9ybS4KKzo6CisKKyAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgRXZlbnRzICAgICB8UHVi bGlzaGVycyAgICAgICB8IFN1YnNjcmliZXJzCisgIC0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0t LS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgIEFMTE9D ICAgICAgfC9kZXYvaW9hc2lkICAgICAgfCBOb25lCisgIC0tLS0tLS0tLS0tKy0tLS0tLS0tLS0t LS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgIEZS RUUgICAgICAgfC9kZXYvaW9hc2lkICAgICAgfCBJT01NVSAoVlQtZCBkcml2ZXIpwrkKKyAgLS0t LS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyAgQklORCAgICAgICB8SU9NTVUgICAgICAgICAgICB8IEtWTSwg VkRDTQorICAtLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICBVTkJJTkQgICAgIHxJT01NVcKyICAgICAg ICAgICB8IEtWTSwgVkRDTQorICAtLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisgIMK5IElPQVNJRCBjb3Jl IGlzc3VlcyBGUkVFIGV2ZW50cyBpZiB0aGUgSU9BU0lEIGlzIGluIHRoZSBBQ1RJVkUgc3RhdGUu IElPTU1VCisgICAgZHJpdmVyIGNhbGxzIGlvYXNpZF9kZXRhY2hfc3BpZCgpIHdoaWNoIGlzc3Vl cyBVTkJJTkQgZXZlbnQgb3V0c2lkZSBhdG9taWMKKyAgICBub3RpZmllciBoYW5kbGVyLgorICDC siBPbmx5ICpvbmUqIEJJTkQvVUJJTkQgZXZlbnQgaXMgaXNzdWVkIHBlciBiaW5kL3VuYmluZCBj eWNsZS4gRm9yIG11bHRpcGxlCisgICAgZGV2aWNlcyBib3VuZCB0byB0aGUgc2FtZSBQQVNJRCwg QklORCBldmVudCBpcyBpc3N1ZWQgZm9yIHRoZSBmaXJzdCBkZXZpY2UKKyAgICBiaW5kLCBVTkJE SU4gZXZlbnQgaXMgaXNzdWVkIGZvciB0aGUgbGFzdCBkZXZpY2UgdW5iaW5kLiBGYXVsdHMgbXVz dCBiZQorICAgIHRvbGVyYXRlZCBiZXR3ZWVuIHRoZSBmaXJzdCBhbmQgbGFzdCBkZXZpY2UgdW5i aW5kLiBVbmRlciBub3JtYWwKKyAgICBjaXJjdW1zdGFuY2VzLCBmYXVsdHMgYXJlIG5vdCBleHBl Y3RlZCBpbiB0aGF0IHRoZSB0ZWFyZG93biBwcm9jZXNzIHNoYWxsCisgICAgc3RvcCBETUEgYWN0 aXZpdGllcyBwcmlvciB0byB1bmJpbmQuCisKK1RoZSBudW1iZXIgb2YgSU9BU0lEcyBhbGxvY2F0 ZWQgaW4gdGhlIGlvYXNpZF9zZXQgc2VydmVzIGFzIHRoZSByZWZjb3VudAorb2YgdGhlIHNldCwg dGhpcyBlbnN1cmVzIHRoZSBsaWZlIGN5Y2xlIGFsaWdubWVudCBvZiB0aGUgc2V0IGFuZCBpdHMK K0lPQVNJRHMuCisKK0FQSSBJbXBsZW1lbnRhdGlvbgorPT09PT09PT09PT09PT09PT09CitUbyBn ZXQgdGhlIElPQVNJRCBBUElzLCB1c2VycyBtdXN0ICNpbmNsdWRlIDxsaW51eC9pb2FzaWQuaD4u IFRoZXNlIEFQSXMKK3NlcnZlIHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25hbGl0aWVzOgorCisgIC0g SU9BU0lEIGFsbG9jYXRpb24vZnJlZWluZworICAtIEdyb3VwIG1hbmFnZW1lbnQgaW4gdGhlIGZv cm0gb2YgaW9hc2lkX3NldAorICAtIFByaXZhdGUgZGF0YSBzdG9yYWdlIGFuZCBsb29rdXAKKyAg LSBSZWZlcmVuY2UgY291bnRpbmcKKyAgLSBFdmVudCBub3RpZmljYXRpb24gaW4gY2FzZSBvZiBh IHN0YXRlIGNoYW5nZQorCitDdXN0b20gYWxsb2NhdG9yIEFQSXMKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorCitJT0FTSURzIGFyZSBhbGxvY2F0ZWQgZm9yIGJvdGggaG9zdCBhbmQgZ3Vlc3QgU1ZB L0lPVkEgdXNhZ2UuIEhvd2V2ZXIsCithbGxvY2F0b3JzIGNhbiBiZSBkaWZmZXJlbnQuIEZvciBl eGFtcGxlLCBvbiBWVC1kIGd1ZXN0IFBBU0lECithbGxvY2F0aW9uIG11c3QgYmUgcGVyZm9ybWVk IHZpYSBhIHZpcnR1YWwgY29tbWFuZCBpbnRlcmZhY2Ugd2hpY2ggaXMKK2VtdWxhdGVkIGJ5IFZN TS4KKworSU9BU0lEIGNvcmUgaGFzIHRoZSBub3Rpb24gb2YgImN1c3RvbSBhbGxvY2F0b3IiIHN1 Y2ggdGhhdCBndWVzdCBjYW4KK3JlZ2lzdGVyIHZpcnR1YWwgY29tbWFuZCBhbGxvY2F0b3IgdGhh dCBwcmVjZWRlcyB0aGUgZGVmYXVsdCBvbmUuCis6OgorCisgaW50IGlvYXNpZF9yZWdpc3Rlcl9h bGxvY2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3BzICphbGxvY2F0b3IpOworCisgdm9p ZCBpb2FzaWRfdW5yZWdpc3Rlcl9hbGxvY2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3Bz ICphbGxvY2F0b3IpOworCitJT0FTSUQgU2V0IExldmVsIEFQSXMKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorRm9yIHVzZSBjYXNlcyBzdWNoIGFzIGd1ZXN0IFNWQSBpdCBpcyBuZWNlc3NhcnkgdG8g bWFuYWdlIElPQVNJRHMgYXQKK2lvYXNpZF9zZXQgbGV2ZWwuIEZvciBleGFtcGxlLCBWTXMgbWF5 IGFsbG9jYXRlIG11bHRpcGxlIElPQVNJRHMgZm9yCitndWVzdCBwcm9jZXNzIGFkZHJlc3Mgc2hh cmluZyAodlNWQSkuIEl0IGlzIGltcGVyYXRpdmUgdG8gZW5mb3JjZQorVk0tSU9BU0lEIG93bmVy c2hpcCBzdWNoIHRoYXQgYSBtYWxpY2lvdXMgZ3Vlc3QgY2Fubm90IHRhcmdldCBETUEKK3RyYWZm aWMgb3V0c2lkZSBpdHMgb3duIElPQVNJRHMsIG9yIGZyZWUgYW4gYWN0aXZlIElPQVNJRCB0aGF0 IGJlbG9uZ3MKK3RvIGFub3RoZXIgVk0uCisKK1RoZSBJT0FTSUQgc2V0IEFQSXMgc2VydmUgdGhl IGZvbGxvd2luZyBwdXJwb3NlczoKKworIC0gT3duZXJzaGlwL3Blcm1pc3Npb24gZW5mb3JjZW1l bnQKKyAtIFRha2UgY29sbGVjdGl2ZSBhY3Rpb25zLCBlLmcuIGZyZWUgYW4gZW50aXJlIHNldAor IC0gRXZlbnQgbm90aWZpY2F0aW9ucyB3aXRoaW4gYSBzZXQKKyAtIExvb2sgdXAgYSBzZXQgYmFz ZWQgb24gdG9rZW4KKyAtIFF1b3RhIGVuZm9yY2VtZW50IChUQkQsIGNvbnRpbmdlbnQgdXBvbiBp b2FzaWRzIGNncm91cCkKKworRWFjaCBJT0FTSUQgc2V0IGlzIGNyZWF0ZWQgd2l0aCBhIHRva2Vu LCB3aGljaCBjYW4gYmUgb25lIG9mIHRoZQorZm9sbG93aW5nIHRva2VuIHR5cGVzOjoKKworIC0g SU9BU0lEX1NFVF9UWVBFX05PTkUgKEFyYml0cmFyeSB1NjQgdmFsdWUpCisgLSBJT0FTSURfU0VU X1RZUEVfTU0gKFNldCB0b2tlbiBpcyBhIG1tX3N0cnVjdCkKKworVGhlIGV4cGxpY2l0IE1NIHRv a2VuIHR5cGUgaXMgdXNlZnVsIHdoZW4gbXVsdGlwbGUgdXNlcnMgb2YgYW4gSU9BU0lECitzZXQg dW5kZXIgdGhlIHNhbWUgcHJvY2VzcyBuZWVkIHRvIGNvbW11bmljYXRlIGFib3V0IHRoZWlyIHNo YXJlZCBJT0FTSURzLgorRS5nLiBBbiBJT0FTSUQgc2V0IGNyZWF0ZWQgYnkgVkZJTyBmb3Igb25l IGd1ZXN0IGNhbiBiZSBhc3NvY2lhdGVkCit3aXRoIHRoZSBLVk0gaW5zdGFuY2UgZm9yIHRoZSBz YW1lIGd1ZXN0IHNpbmNlIHRoZXkgc2hhcmUgYSBjb21tb24gbW1fc3RydWN0LgorQSB0b2tlbiBt dXN0IGJlIHVuaXF1ZSB3aXRoaW4gaXRzIHR5cGUuCisKKzo6CisKKyBzdHJ1Y3QgaW9hc2lkX3Nl dCAqaW9hc2lkX2FsbG9jX3NldCh2b2lkICp0b2tlbiwgaW9hc2lkX3QgcXVvdGEsIHUzMiB0eXBl KQorCisgaW50IGlvYXNpZF9zZXRfZm9yX2VhY2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRfc2V0ICpz ZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKCpmbikoaW9hc2lkX3Qg aWQsIHZvaWQgKmRhdGEpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpk YXRhKQorCisgc3RydWN0IGlvYXNpZF9zZXQgKmlvYXNpZF9maW5kX21tX3NldChzdHJ1Y3QgbW1f c3RydWN0ICp0b2tlbikKKworIHZvaWQgaW9hc2lkX2ZyZWVfYWxsX2luX3NldChzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0KQorCitJbmRpdmlkdWFsIElPQVNJRCBBUElzCistLS0tLS0tLS0tLS0tLS0t LS0tLS0tCitPbmNlIGFuIGlvYXNpZF9zZXQgaXMgY3JlYXRlZCwgSU9BU0lEcyBjYW4gYmUgYWxs b2NhdGVkIGZyb20gdGhlIHNldC4KK1dpdGhpbiB0aGUgSU9BU0lEIHNldCBuYW1lc3BhY2UsIHNl dCBwcml2YXRlIElEIChTUElEKSBpcyBzdXBwb3J0ZWQuIEluCit0aGUgVk0gdXNlIGNhc2UsIFNQ SUQgY2FuIGJlIHVzZWQgZm9yIHN0b3JpbmcgZ3Vlc3QgUEFTSUQuCisKKzo6CisKKyBpb2FzaWRf dCBpb2FzaWRfYWxsb2Moc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgbWluLCBpb2Fz aWRfdCBtYXgsCisgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKnByaXZhdGUpOworCisgaW50 IGlvYXNpZF9nZXQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkKTsKKwor IHZvaWQgaW9hc2lkX3B1dChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQp OworCisgaW50IGlvYXNpZF9nZXRfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNp ZF90IGlvYXNpZCk7CisKKyB2b2lkIGlvYXNpZF9wdXRfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0 ICpzZXQsIGlvYXNpZF90IGlvYXNpZCk7CisKKyB2b2lkICppb2FzaWRfZmluZChzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQsCisgICAgICAgICAgICAgICAgICAgYm9vbCAo KmdldHRlcikodm9pZCAqKSk7CisKKyBpb2FzaWRfdCBpb2FzaWRfZmluZF9ieV9zcGlkKHN0cnVj dCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IHNwaWQsCisgYm9vbCBnZXQpCisKKyBpbnQgaW9h c2lkX2F0dGFjaF9kYXRhKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCwK KyAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKmRhdGEpOworIGludCBpb2FzaWRfYXR0YWNo X3NwaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkLAorICAgICAgICAg ICAgICAgICAgICAgICAgaW9hc2lkX3Qgc3BpZCk7CisKKworTm90aWZpY2F0aW9uIEFQSXMKKy0t LS0tLS0tLS0tLS0tLS0tCitBbiBJT0FTSUQgbWF5IGhhdmUgbXVsdGlwbGUgdXNlcnMsIGVhY2gg dXNlciBtYXkgaGF2ZSBoYXJkd2FyZSBjb250ZXh0Cithc3NvY2lhdGVkIHdpdGggYW4gSU9BU0lE LiBXaGVuIHRoZSBzdGF0dXMgb2YgYW4gSU9BU0lEIGNoYW5nZXMsCitlLmcuIGFuIElPQVNJRCBp cyBiZWluZyBmcmVlZCwgdXNlcnMgbmVlZCB0byBiZSBub3RpZmllZCBzdWNoIHRoYXQgdGhlCith c3NvY2lhdGVkIGhhcmR3YXJlIGNvbnRleHQgY2FuIGJlIGNsZWFyZWQsIGZsdXNoZWQsIGFuZCBk cmFpbmVkLgorCis6OgorCisgaW50IGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0LCBzdHJ1Y3QKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vdGlm aWVyX2Jsb2NrICpuYikKKworIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0 IGlvYXNpZF9zZXQgKnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVj dCBub3RpZmllcl9ibG9jayAqbmIpCisKKyBpbnQgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyX21t KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKKworIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90 aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgbm90aWZpZXJfYmxvY2sgKm5iKQorCisgaW50IGlvYXNpZF9ub3Rp ZnkoaW9hc2lkX3QgaW9hc2lkLCBlbnVtIGlvYXNpZF9ub3RpZnlfdmFsIGNtZCwKKyAgICAgICAg ICAgICAgICAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpCisKKyJfbW0iIGZsYXZvciBvZiB0aGUgaW9h c2lkX3JlZ2lzdGVyX25vdGlmaWVyKCkgQVBJcyBhcmUgdXNlZCB3aGVuCithbiBJT0FTSUQgdXNl ciBuZWVkIHRvIGxpc3RlbiB0byB0aGUgSU9BU0lEIGV2ZW50cyBiZWxvbmcgdG8gYQorcHJvY2Vz cyBidXQgd2l0aG91dCB0aGUga25vd2xlZGdlIG9mIHRoZSBhc3NvY2lhdGVkIGlvYXNpZF9zZXQu Ci0tIAoyLjI1LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpo dHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ== 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=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9B928C433E0 for ; Sun, 28 Feb 2021 06:36:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4716264E21 for ; Sun, 28 Feb 2021 06:36:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230422AbhB1GgW (ORCPT ); Sun, 28 Feb 2021 01:36:22 -0500 Received: from mga09.intel.com ([134.134.136.24]:58906 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230415AbhB1GgR (ORCPT ); Sun, 28 Feb 2021 01:36:17 -0500 IronPort-SDR: Ekm0uY9IRW3tZlvAwP5aHdkycw3BNmrs4+iI/ImZ6I2hbZmeMOhIPdWGjxej7ZkF3yMifL+4x3 eBi1QttHpmEg== X-IronPort-AV: E=McAfee;i="6000,8403,9908"; a="186323892" X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="186323892" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 Feb 2021 22:33:09 -0800 IronPort-SDR: jsNOyT7QMIz0ZuXZh7tFfksP+Bp2QdUH3k8ISyKop50HKE2zIlaqHZahAwEQdW7cNI24iEUzvT Pi2CNVNUXk/A== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="517029698" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by orsmga004.jf.intel.com with ESMTP; 27 Feb 2021 22:33:09 -0800 From: Jacob Pan To: LKML , Joerg Roedel , "Lu Baolu" , David Woodhouse , iommu@lists.linux-foundation.org, cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Cc: Alex Williamson , Eric Auger , Jason Gunthorpe , Jonathan Corbet , Raj Ashok , "Tian, Kevin" , Yi Liu , Wu Hao , Dave Jiang , Jacob Pan , linux-doc@vger.kernel.org, Randy Dunlap Subject: [PATCH V4 01/18] docs: Document IO Address Space ID (IOASID) APIs Date: Sat, 27 Feb 2021 14:01:09 -0800 Message-Id: <1614463286-97618-2-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-doc@vger.kernel.org IOASID is used to identify address spaces that can be targeted by device DMA. It is a system-wide resource that is essential to its many users. This document is an attempt to help developers from all vendors navigate the APIs. At this time, ARM SMMU and Intel’s Scalable IO Virtualization (SIOV) enabled platforms are the primary users of IOASID. Examples of how SIOV components interact with the IOASID APIs are provided. Cc: Jonathan Corbet Cc: linux-doc@vger.kernel.org Cc: Randy Dunlap Signed-off-by: Liu Yi L Signed-off-by: Wu Hao Signed-off-by: Jacob Pan --- Documentation/driver-api/index.rst | 1 + Documentation/driver-api/ioasid.rst | 510 ++++++++++++++++++++++++++++ 2 files changed, 511 insertions(+) create mode 100644 Documentation/driver-api/ioasid.rst diff --git a/Documentation/driver-api/index.rst b/Documentation/driver-api/index.rst index 2456d0a97ed8..baeec308cf2c 100644 --- a/Documentation/driver-api/index.rst +++ b/Documentation/driver-api/index.rst @@ -37,6 +37,7 @@ available subsections can be seen below. pci/index spi i2c + ioasid ipmb ipmi i3c/index diff --git a/Documentation/driver-api/ioasid.rst b/Documentation/driver-api/ioasid.rst new file mode 100644 index 000000000000..f3ed5bf43fa6 --- /dev/null +++ b/Documentation/driver-api/ioasid.rst @@ -0,0 +1,510 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. ioasid: + +===================== + IO Address Space ID +===================== + +IOASIDs are used to identify virtual address spaces that DMA requests can +target. It is a generic name for PCIe Process Address ID (PASID) or +SubstreamID defined by ARM's SMMU. + +The primary use cases for IOASIDs are Shared Virtual Address (SVA) and +IO Virtual Address (IOVA) when multiple address spaces per device are +desired. Due to hardware architectural differences the requirements for +IOASID management can vary in terms of namespace, state management, and +virtualization usages. + +The IOASID subsystem consists of three components: + +- IOASID core: provides APIs for allocation, pool management, + notifications and refcounting. +- IOASID user: provides user allocation interface via /dev/ioasid +- IOASID cgroup controller: manage resource distribution. + (Documentation/admin-guide/cgroup-v1/ioasids.rst) + +This document covers the features supported by the IOASID core APIs. +Vendor-specific use cases are also illustrated with Intel's VT-d +based platforms as the first example. The term PASID and IOASID are used +interchangeably throughout this document. + +.. contents:: :local: + +Glossary +======== +PASID - Process Address Space ID + +IOVA - IO Virtual Address + +IOASID - IO Address Space ID (generic term for PCIe PASID and +SubstreamID in SMMU) + +SVA/SVM - Shared Virtual Addressing/Memory + +gSVA - Guest Shared Virtual Addressing + +gIOVA - Guest IO Virtual Addressing + +ENQCMD - Instruction to submit work to shared workqueues. Refer +to "Intel X86 ISA for efficient workqueue submission" [1] + +DSA - Intel Data Streaming Accelerator [2] + +VDCM - Virtual Device Composition Module [3] + +SIOV - Intel Scalable IO Virtualization + +DWQ - Dedicated Work Queue + +SWQ - Shared Work Queue + +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 + + +Key Concepts +============ + +IOASID Set +---------- +An IOASID set is a group of IOASIDs allocated from the system-wide +IOASID pool. Refer to section "IOASID Set Level 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. + +Guest IOASID +------------------ +IOASID used by the guest, identifies a guest IOVA space or a guest VA +space per guest process. + +Host IOASID +----------------- +IOASID used by the host either for bare metal SVA or as the backing of a +guest IOASID. + +Bind/Unbind +----------- +Refer to the process where mappings among IOASID, page tables, and devices +are established/demolished. This usually involes setting up an entry of +the IOMMU's per device PASID table with a given PGD. + +IOASID Set Private ID (SPID) +---------------------------- +Each IOASID set has a private namespace of SPIDs. An SPID maps to a +single system-wide IOASID. Conversely, each IOASID may be associated +with an alias ID, local to the IOASID set, named SPID. +SPIDs can be used as guest IOASIDs where each guest could do +IOASID allocation from its own pool/set and map them to host physical +IOASIDs. SPIDs are particularly useful for supporting live migration +where decoupling guest and host physical resources are necessary. Guest +to Host PASID mapping can be torn down and re-established. Storing the +mapping inside the kernel also provides lookup service. + +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. + +Theory of Operation +=================== + +States +------ +IOASID has four states as illustrated in the diagram below. +:: + + BIND/UNBIND, WQ PROG/CLEAR⁴ + -----------------------------. + | + ALLOC/FREE | + ------------. | + | | + +-------+ v +-------+ v +----------+ + | FREE |<======>| IDLE¹ |<=======>| ACTIVE² | + +-------+ +-------+ +----------+ + ^ | + | +---------------+ | + '===========| FREE PENDING³ |<=======' + +---------------+ ^ + FREE | + ----------------------------------' + ¹ Allocated but not used + ² Used by device drivers, IOMMU, or CPU, each user holds a reference + ³ Waiting for all users drop their refcount before returning IOASID + back to the pool + ⁴ Device drivers obtain refcount after programs workqueue with IOASID. + Release the refcount after clearing the workqueue. + Similarly, the IOMMU driver can also get/put IOASID refcount during + bind/unbind. + +Notifications +------------- +Depending on the hardware architecture, an IOASID can be programmed into +CPU, IOMMU, or devices for DMA related activity. The synchronization among them +is based on events notifications which follows a publisher-subscriber pattern. + +Events +~~~~~~ +Notification events are pertinent to individual IOASIDs, they can be +one of the following:: + + - ALLOC + - FREE + - BIND + - UNBIND + +Besides calling ioasid_notify() directly with explicit events, notifications +can also be sent by the IOASID core as a by-product of calling the following +APIs:: + + - ioasisd_free() /* emits IOASID_FREE */ + - ioasid_detach_spid() /* emits IOASID_UNBIND */ + - ioasid_attach_spid() /* emits IOASID_BIND */ + +Ordering +~~~~~~~~ +Ordering of notification events is supported by the IOASID core as the +following (from high to low):: + + - CPU + - IOMMU + - DEVICE + +Subscribers of IOASID events are responsible for registering their +notification blocks according to the priorities. + +The above order applies to all events. For example, if UNBIND event is +issued when a guest IOASID is freed due to exceptions. All active DMA +sources should be quiesced before tearing down other hardware contexts +associated with the IOASID in the system. This is necessary to reduce +the churn in handling faults. The notification order ensures that vCPU +is stopped before IOMMU and devices. KVM x86 code registers notification +block with priority IOASID_PRIO_CPU and VDCM code registers notification +block with priority IOASID_PRIO_DEVICE, IOASID core ensures the CPU +handlers are called before the DEVICE handlers. + +It is the caller's responsibility to avoid chained notifications in the +atomic notification handlers. i.e. ioasid_detach_spid() cannot be called +inside the IOASID_FREE atomic handlers due to spinlocks held by the +caller of the notifier. However, ioasid_detach_spid() can be called from +deferred work. See Atomicity section for details. + +Level Sensitivity +~~~~~~~~~~~~~~~~~ +For each IOASID state transition, IOASID core ensures that there is +only one notification sent. This resembles level triggered interrupt +where a single interrupt is raised during a state transition. +For example, if ioasid_free() is called twice by a user before the +IOASID is reclaimed, IOASID core will only send out a single +IOASID_NOTIFY_FREE event. Similarly, for IOASID_NOTIFY_BIND/UNBIND +events, which is only sent out once when a SPID is attached/detached. + +Scopes +~~~~~~ +There are two types of notifiers in IOASID core: system-wide and +ioasid_set-wide (one notifier chain per ioasid_set). + +System-wide notifier is catering for users that need to handle all the +IOASIDs in the system. E.g. The IOMMU driver. + +Per ioasid_set notifier can be used by VM specific components such as +KVM. After all, each KVM instance only cares about IOASIDs within its +own set/guest. The following flags are used to distinguish the scopes:: + + #define IOASID_NOTIFY_FLAG_ALL BIT(0) + #define IOASID_NOTIFY_FLAG_SET BIT(1) + +For example, on VT-d platform both KVM and VDCM shall register notifier +block on the IOASID set such that *only* events from the matching VM +are received. + +If KVM attempts to register a notifier block before the IOASID set is +created using the MM token, the notifier block will be placed on a +pending list inside IOASID core. Once the token matching IOASID set +is created, IOASID will register the notifier block automatically. +IOASID core does not replay events for the existing IOASIDs in the +set. For IOASID set of MM type, notification blocks can be registered +on empty sets only. This is to avoid lost events. + +IOMMU driver shall register notifier block on global chain, e.g. :: + + static struct notifier_block pasid_nb_vtd = { + .notifier_call = pasid_status_change_vtd, + .priority = IOASID_PRIO_IOMMU, + }; + +Atomicity +~~~~~~~~~ +IOASID notifiers are atomic due to spinlocks used inside the IOASID +core. For tasks that cannot be completed in the notifier handler, +async work to be completed in order must be submitted to the ordered +workqueue provided by the IOASID core. This will ensure the order w.r.t. +the work items submitted by other users of the same event. + +It is the caller's responsibility to avoid chained notifications in the +atomic notification handlers. e.g. ioasid_detach_spid() cannot be called +inside the IOASID_FREE atomic handlers due to spinlocks held by the +caller of the notifier. However, ioasid_detach_spid() can be called from +deferred work. + +Reference counting +------------------ +IOASID life cycle management is based on reference counting. Users of +IOASID who intend to align its context with the life cycle need to hold +references of the IOASID. An IOASID will not be returned to the pool +for re-allocation until all its references are dropped. Calling ioasid_free() +will mark the IOASID as FREE_PENDING if the IOASID has outstanding +references. No new references can be taken by ioasid_get() once an +IOASID is in the FREE_PENDING state. ioasid_free() can be called +multiple times without an error until all refs are dropped. + +ioasid_put() decrements and tests refcount of the IOASID. If refcount +is 0, ioasid will be freed. The IOASID will be returned to the pool and +available for new allocations. Note that ioasid_put() can be called by +the IOASID_FREE event handler where the subscriber can drop the last +refcount that ends the free pending state. + +Event notifications are used to inform users of IOASID status change. +IOASID_FREE or UNBIND events prompt 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 CPU (KVM), device driver (VDCM), and the IOMMU +driver. To quiesce vCPU for work submission, KVM notifier handler must +be called before VDCM handler. Therefore, KVM and VDCM shall monitor +notification events IOASID_UNBIND. + +Namespaces +---------- +IOASIDs are limited system resources that default to 20 bits in +size. Each device can have its own PASID table for security reasons. +Theoretically the namespace can be per device also. + +However IOASID namespace is system-wide for two reasons: +- Simplicity +- Sharing resources of a single device to multiple VMs. + +Take VT-d as an example, VT-d supports shared workqueue and ENQCMD[1] +where one IOASID could be used to submit work on multiple devices that +are shared with other VMs. This requires IOASID to be +system-wide. This is also the reason why guests must use an +emulated virtual command interface to allocate IOASID from the host. + +Life cycle +---------- +This section covers the IOASID life cycle management for both bare-metal +and guest usages. In bare-metal SVA, MMU notifier is directly hooked +up with the IOMMU driver. By leveraging the .release() function, the +IOASID life cycle can be made to match the process address space (MM) +life cycle. + +However, guest MMU notifier is not available to the 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. + +At the highlevel, there are following four patterns: + +1. ALLOC -> FREE +2. ALLOC -> BIND -> DMA Activity -> UNBIND -> FREE +3. ALLOC -> BIND -> FREE +4. ALLOC -> BIND -> DMA Activity -> FREE + +The first two are normal cases, 3 and 4 are exceptions due to user +process misbehaving. + +Exception handling can be complex when there are lots of IOASID +consumers involved but the pattern is common and quite simple. When an +IOASID in active state is being freed, IOASID core will notify all +users to perform clean up. Each IOASID user performs cleanup and drop +the reference at the end. When reference count drops to 0, IOASID will +be reclaimed and ready to be allocated again. + +Cleanup can be either done in the atomic notifier handler or as queued +work to the common ordered IOASID workqueue to be performed asynchronously. +The highlevel flow is the following:: + + Free Req¹ -> Notify users -> Cleanup -> Drop reference -> Reclaim + +Notes: +¹ Free one IOASID or free all IOASID within a set + +The following table shows how events are used on Intel VT-d platform. +:: + + -------------------------------------------------------------------------- + Events |Publishers | Subscribers + -----------+-----------------+-------------------------------------------- + ALLOC |/dev/ioasid | None + -----------+-----------------+-------------------------------------------- + FREE |/dev/ioasid | IOMMU (VT-d driver)¹ + -----------+-----------------+----------------------------------------------- + BIND |IOMMU | KVM, VDCM + -----------+-----------------+----------------------------------------------- + UNBIND |IOMMU² | KVM, VDCM + -----------+-------------------------------------------------------------- + + ¹ IOASID core issues FREE events if the IOASID is in the ACTIVE state. IOMMU + driver calls ioasid_detach_spid() which issues UNBIND event outside atomic + notifier handler. + ² Only *one* BIND/UBIND event is issued per bind/unbind cycle. For multiple + devices bound to the same PASID, BIND event is issued for the first device + bind, UNBDIN event is issued for the last device unbind. Faults must be + tolerated between the first and last device unbind. Under normal + circumstances, faults are not expected in that the teardown process shall + stop DMA activities prior to unbind. + +The number of IOASIDs allocated in the ioasid_set serves as the refcount +of the set, this ensures the life cycle alignment of the set and its +IOASIDs. + +API Implementation +================== +To get the IOASID APIs, users must #include . These APIs +serve the following functionalities: + + - IOASID allocation/freeing + - Group management in the form of ioasid_set + - Private data storage and lookup + - Reference counting + - Event notification in case of a state change + +Custom allocator APIs +--------------------- + +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. +:: + + int ioasid_register_allocator(struct ioasid_allocator_ops *allocator); + + void ioasid_unregister_allocator(struct ioasid_allocator_ops *allocator); + +IOASID Set Level APIs +--------------------- +For use cases such as guest SVA it is necessary to manage IOASIDs at +ioasid_set level. For example, VMs may allocate multiple IOASIDs for +guest process address sharing (vSVA). It is imperative to enforce +VM-IOASID ownership such that a malicious guest cannot target DMA +traffic outside its own IOASIDs, or free an active IOASID that belongs +to another VM. + +The IOASID set APIs serve the following purposes: + + - Ownership/permission enforcement + - Take collective actions, e.g. free an entire set + - Event notifications within a set + - Look up a set based on token + - Quota enforcement (TBD, contingent upon ioasids cgroup) + +Each IOASID set is created with a token, which can be one of the +following token types:: + + - IOASID_SET_TYPE_NONE (Arbitrary u64 value) + - IOASID_SET_TYPE_MM (Set token is a mm_struct) + +The explicit MM token type is useful when multiple users of an IOASID +set under the same process need to communicate about their shared IOASIDs. +E.g. An IOASID set created by VFIO for one guest can be associated +with the KVM instance for the same guest since they share a common mm_struct. +A token must be unique within its type. + +:: + + struct ioasid_set *ioasid_alloc_set(void *token, ioasid_t quota, u32 type) + + int ioasid_set_for_each_ioasid(struct ioasid_set *set, + void (*fn)(ioasid_t id, void *data), + void *data) + + struct ioasid_set *ioasid_find_mm_set(struct mm_struct *token) + + void ioasid_free_all_in_set(struct ioasid_set *set) + +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, + bool get) + + int ioasid_attach_data(struct ioasid_set *set, ioasid_t ioasid, + void *data); + int ioasid_attach_spid(struct ioasid_set *set, ioasid_t ioasid, + ioasid_t spid); + + +Notification APIs +----------------- +An IOASID may have multiple users, each user may have hardware context +associated with an IOASID. When the status of an IOASID changes, +e.g. an IOASID is being freed, users need to be notified such that the +associated hardware context can be cleared, flushed, and drained. + +:: + + int ioasid_register_notifier(struct ioasid_set *set, struct + notifier_block *nb) + + void ioasid_unregister_notifier(struct ioasid_set *set, + struct notifier_block *nb) + + int ioasid_register_notifier_mm(struct mm_struct *mm, struct + notifier_block *nb) + + void ioasid_unregister_notifier_mm(struct mm_struct *mm, struct + notifier_block *nb) + + int ioasid_notify(ioasid_t ioasid, enum ioasid_notify_val cmd, + unsigned int flags) + +"_mm" flavor of the ioasid_register_notifier() APIs are used when +an IOASID user need to listen to the IOASID events belong to a +process but without the knowledge of the associated ioasid_set. -- 2.25.1 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=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7D29DC4332E for ; Sun, 28 Feb 2021 06:33:30 +0000 (UTC) Received: from smtp3.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 3AB2764E55 for ; Sun, 28 Feb 2021 06:33:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3AB2764E55 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 smtp3.osuosl.org (Postfix) with ESMTP id 365A66F9BB; Sun, 28 Feb 2021 06:33:29 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id sQMFzRt6e5ST; Sun, 28 Feb 2021 06:33:24 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTP id 6E4E46F991; Sun, 28 Feb 2021 06:33:23 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 97F35C000B; Sun, 28 Feb 2021 06:33:22 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 47A6CC000B for ; Sun, 28 Feb 2021 06:33:16 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id 52F9E4F087 for ; Sun, 28 Feb 2021 06:33:13 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id fomKqICaG2rH for ; Sun, 28 Feb 2021 06:33:10 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by smtp4.osuosl.org (Postfix) with ESMTPS id BDCC74F062 for ; Sun, 28 Feb 2021 06:33:10 +0000 (UTC) IronPort-SDR: Ysh8TKLon9ADd6neZpXfUOd0kz0i+TOWH77nfmkq8XIUOIr+g7U9pCP/7u2PCJFYntkLKvnHal SxixsS2Kzx8g== X-IronPort-AV: E=McAfee;i="6000,8403,9908"; a="183755897" X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="183755897" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 Feb 2021 22:33:09 -0800 IronPort-SDR: jsNOyT7QMIz0ZuXZh7tFfksP+Bp2QdUH3k8ISyKop50HKE2zIlaqHZahAwEQdW7cNI24iEUzvT Pi2CNVNUXk/A== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="517029698" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by orsmga004.jf.intel.com with ESMTP; 27 Feb 2021 22:33:09 -0800 From: Jacob Pan To: LKML , Joerg Roedel , "Lu Baolu" , David Woodhouse , iommu@lists.linux-foundation.org, cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Subject: [PATCH V4 01/18] docs: Document IO Address Space ID (IOASID) APIs Date: Sat, 27 Feb 2021 14:01:09 -0800 Message-Id: <1614463286-97618-2-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Cc: "Tian, Kevin" , Dave Jiang , Raj Ashok , Jonathan Corbet , linux-doc@vger.kernel.org, Alex Williamson , Randy Dunlap , Jason Gunthorpe , Wu Hao X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" SU9BU0lEIGlzIHVzZWQgdG8gaWRlbnRpZnkgYWRkcmVzcyBzcGFjZXMgdGhhdCBjYW4gYmUgdGFy Z2V0ZWQgYnkgZGV2aWNlCkRNQS4gSXQgaXMgYSBzeXN0ZW0td2lkZSByZXNvdXJjZSB0aGF0IGlz IGVzc2VudGlhbCB0byBpdHMgbWFueSB1c2Vycy4KVGhpcyBkb2N1bWVudCBpcyBhbiBhdHRlbXB0 IHRvIGhlbHAgZGV2ZWxvcGVycyBmcm9tIGFsbCB2ZW5kb3JzIG5hdmlnYXRlCnRoZSBBUElzLiBB dCB0aGlzIHRpbWUsIEFSTSBTTU1VIGFuZCBJbnRlbOKAmXMgU2NhbGFibGUgSU8gVmlydHVhbGl6 YXRpb24KKFNJT1YpIGVuYWJsZWQgcGxhdGZvcm1zIGFyZSB0aGUgcHJpbWFyeSB1c2VycyBvZiBJ T0FTSUQuIEV4YW1wbGVzIG9mCmhvdyBTSU9WIGNvbXBvbmVudHMgaW50ZXJhY3Qgd2l0aCB0aGUg SU9BU0lEIEFQSXMgYXJlIHByb3ZpZGVkLgoKQ2M6IEpvbmF0aGFuIENvcmJldCA8Y29yYmV0QGx3 bi5uZXQ+CkNjOiBsaW51eC1kb2NAdmdlci5rZXJuZWwub3JnCkNjOiBSYW5keSBEdW5sYXAgPHJk dW5sYXBAaW5mcmFkZWFkLm9yZz4KU2lnbmVkLW9mZi1ieTogTGl1IFlpIEwgPHlpLmwubGl1QGlu dGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogV3UgSGFvIDxoYW8ud3VAaW50ZWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBKYWNvYiBQYW4gPGphY29iLmp1bi5wYW5AbGludXguaW50ZWwuY29tPgotLS0KIERv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9pbmRleC5yc3QgIHwgICAxICsKIERvY3VtZW50YXRpb24v ZHJpdmVyLWFwaS9pb2FzaWQucnN0IHwgNTEwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysK IDIgZmlsZXMgY2hhbmdlZCwgNTExIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBE b2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJzdAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vZHJpdmVyLWFwaS9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW5k ZXgucnN0CmluZGV4IDI0NTZkMGE5N2VkOC4uYmFlZWMzMDhjZjJjIDEwMDY0NAotLS0gYS9Eb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvaW5kZXgucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVy LWFwaS9pbmRleC5yc3QKQEAgLTM3LDYgKzM3LDcgQEAgYXZhaWxhYmxlIHN1YnNlY3Rpb25zIGNh biBiZSBzZWVuIGJlbG93LgogICAgcGNpL2luZGV4CiAgICBzcGkKICAgIGkyYworICAgaW9hc2lk CiAgICBpcG1iCiAgICBpcG1pCiAgICBpM2MvaW5kZXgKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9pb2FzaWQucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2lvYXNp ZC5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mM2VkNWJmNDNm YTYKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvaW9hc2lkLnJz dApAQCAtMCwwICsxLDUxMCBAQAorLi4gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAK Ky4uIGlvYXNpZDoKKworPT09PT09PT09PT09PT09PT09PT09CisgSU8gQWRkcmVzcyBTcGFjZSBJ RAorPT09PT09PT09PT09PT09PT09PT09CisKK0lPQVNJRHMgYXJlIHVzZWQgdG8gaWRlbnRpZnkg dmlydHVhbCBhZGRyZXNzIHNwYWNlcyB0aGF0IERNQSByZXF1ZXN0cyBjYW4KK3RhcmdldC4gSXQg aXMgYSBnZW5lcmljIG5hbWUgZm9yIFBDSWUgUHJvY2VzcyBBZGRyZXNzIElEIChQQVNJRCkgb3IK K1N1YnN0cmVhbUlEIGRlZmluZWQgYnkgQVJNJ3MgU01NVS4KKworVGhlIHByaW1hcnkgdXNlIGNh c2VzIGZvciBJT0FTSURzIGFyZSBTaGFyZWQgVmlydHVhbCBBZGRyZXNzIChTVkEpIGFuZAorSU8g VmlydHVhbCBBZGRyZXNzIChJT1ZBKSB3aGVuIG11bHRpcGxlIGFkZHJlc3Mgc3BhY2VzIHBlciBk ZXZpY2UgYXJlCitkZXNpcmVkLiBEdWUgdG8gaGFyZHdhcmUgYXJjaGl0ZWN0dXJhbCBkaWZmZXJl bmNlcyB0aGUgcmVxdWlyZW1lbnRzIGZvcgorSU9BU0lEIG1hbmFnZW1lbnQgY2FuIHZhcnkgaW4g dGVybXMgb2YgbmFtZXNwYWNlLCBzdGF0ZSBtYW5hZ2VtZW50LCBhbmQKK3ZpcnR1YWxpemF0aW9u IHVzYWdlcy4KKworVGhlIElPQVNJRCBzdWJzeXN0ZW0gY29uc2lzdHMgb2YgdGhyZWUgY29tcG9u ZW50czoKKworLSBJT0FTSUQgY29yZTogcHJvdmlkZXMgQVBJcyBmb3IgYWxsb2NhdGlvbiwgcG9v bCBtYW5hZ2VtZW50LAorICBub3RpZmljYXRpb25zIGFuZCByZWZjb3VudGluZy4KKy0gSU9BU0lE IHVzZXI6ICBwcm92aWRlcyB1c2VyIGFsbG9jYXRpb24gaW50ZXJmYWNlIHZpYSAvZGV2L2lvYXNp ZAorLSBJT0FTSUQgY2dyb3VwIGNvbnRyb2xsZXI6IG1hbmFnZSByZXNvdXJjZSBkaXN0cmlidXRp b24uCisgIChEb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2Nncm91cC12MS9pb2FzaWRzLnJzdCkK KworVGhpcyBkb2N1bWVudCBjb3ZlcnMgdGhlIGZlYXR1cmVzIHN1cHBvcnRlZCBieSB0aGUgSU9B U0lEIGNvcmUgQVBJcy4KK1ZlbmRvci1zcGVjaWZpYyB1c2UgY2FzZXMgYXJlIGFsc28gaWxsdXN0 cmF0ZWQgd2l0aCBJbnRlbCdzIFZULWQKK2Jhc2VkIHBsYXRmb3JtcyBhcyB0aGUgZmlyc3QgZXhh bXBsZS4gVGhlIHRlcm0gUEFTSUQgYW5kIElPQVNJRCBhcmUgdXNlZAoraW50ZXJjaGFuZ2VhYmx5 IHRocm91Z2hvdXQgdGhpcyBkb2N1bWVudC4KKworLi4gY29udGVudHM6OiA6bG9jYWw6CisKK0ds b3NzYXJ5Cis9PT09PT09PQorUEFTSUQgLSBQcm9jZXNzIEFkZHJlc3MgU3BhY2UgSUQKKworSU9W QSAtIElPIFZpcnR1YWwgQWRkcmVzcworCitJT0FTSUQgLSBJTyBBZGRyZXNzIFNwYWNlIElEIChn ZW5lcmljIHRlcm0gZm9yIFBDSWUgUEFTSUQgYW5kCitTdWJzdHJlYW1JRCBpbiBTTU1VKQorCitT VkEvU1ZNIC0gU2hhcmVkIFZpcnR1YWwgQWRkcmVzc2luZy9NZW1vcnkKKworZ1NWQSAtIEd1ZXN0 IFNoYXJlZCBWaXJ0dWFsIEFkZHJlc3NpbmcKKworZ0lPVkEgLSBHdWVzdCBJTyBWaXJ0dWFsIEFk ZHJlc3NpbmcKKworRU5RQ01EIC0gSW5zdHJ1Y3Rpb24gdG8gc3VibWl0IHdvcmsgdG8gc2hhcmVk IHdvcmtxdWV1ZXMuIFJlZmVyCit0byAiSW50ZWwgWDg2IElTQSBmb3IgZWZmaWNpZW50IHdvcmtx dWV1ZSBzdWJtaXNzaW9uIiBbMV0KKworRFNBIC0gSW50ZWwgRGF0YSBTdHJlYW1pbmcgQWNjZWxl cmF0b3IgWzJdCisKK1ZEQ00gLSBWaXJ0dWFsIERldmljZSBDb21wb3NpdGlvbiBNb2R1bGUgWzNd CisKK1NJT1YgLSBJbnRlbCBTY2FsYWJsZSBJTyBWaXJ0dWFsaXphdGlvbgorCitEV1EgLSBEZWRp Y2F0ZWQgV29yayBRdWV1ZQorCitTV1EgLSBTaGFyZWQgV29yayBRdWV1ZQorCisxLiBodHRwczov L3NvZnR3YXJlLmludGVsLmNvbS9zaXRlcy9kZWZhdWx0L2ZpbGVzL21hbmFnZWQvYzUvMTUvYXJj aGl0ZWN0dXJlLWluc3RydWN0aW9uLXNldC1leHRlbnNpb25zLXByb2dyYW1taW5nLXJlZmVyZW5j ZS5wZGYKKworMi4gaHR0cHM6Ly8wMS5vcmcvYmxvZ3MvMjAxOS9pbnRyb2R1Y2luZy1pbnRlbC1k YXRhLXN0cmVhbWluZy1hY2NlbGVyYXRvcgorCiszLiBodHRwczovL3NvZnR3YXJlLmludGVsLmNv bS9lbi11cy9kb3dubG9hZC9pbnRlbC1kYXRhLXN0cmVhbWluZy1hY2NlbGVyYXRvci1wcmVsaW1p bmFyeS1hcmNoaXRlY3R1cmUtc3BlY2lmaWNhdGlvbgorCisKK0tleSBDb25jZXB0cworPT09PT09 PT09PT09CisKK0lPQVNJRCBTZXQKKy0tLS0tLS0tLS0KK0FuIElPQVNJRCBzZXQgaXMgYSBncm91 cCBvZiBJT0FTSURzIGFsbG9jYXRlZCBmcm9tIHRoZSBzeXN0ZW0td2lkZQorSU9BU0lEIHBvb2wu IFJlZmVyIHRvIHNlY3Rpb24gIklPQVNJRCBTZXQgTGV2ZWwgQVBJcyIgZm9yIG1vcmUgZGV0YWls cy4KKworSU9BU0lEIHNldCBpcyBwYXJ0aWN1bGFybHkgdXNlZnVsIGZvciBndWVzdCBTVkEgd2hl cmUgZWFjaCBndWVzdCBjb3VsZAoraGF2ZSBpdHMgb3duIElPQVNJRCBzZXQgZm9yIHNlY3VyaXR5 IGFuZCBlZmZpY2llbmN5IHJlYXNvbnMuCisKK0d1ZXN0IElPQVNJRAorLS0tLS0tLS0tLS0tLS0t LS0tCitJT0FTSUQgdXNlZCBieSB0aGUgZ3Vlc3QsIGlkZW50aWZpZXMgYSBndWVzdCBJT1ZBIHNw YWNlIG9yIGEgZ3Vlc3QgVkEKK3NwYWNlIHBlciBndWVzdCBwcm9jZXNzLgorCitIb3N0IElPQVNJ RAorLS0tLS0tLS0tLS0tLS0tLS0KK0lPQVNJRCB1c2VkIGJ5IHRoZSBob3N0IGVpdGhlciBmb3Ig YmFyZSBtZXRhbCBTVkEgb3IgYXMgdGhlIGJhY2tpbmcgb2YgYQorZ3Vlc3QgSU9BU0lELgorCitC aW5kL1VuYmluZAorLS0tLS0tLS0tLS0KK1JlZmVyIHRvIHRoZSBwcm9jZXNzIHdoZXJlIG1hcHBp bmdzIGFtb25nIElPQVNJRCwgcGFnZSB0YWJsZXMsIGFuZCBkZXZpY2VzCithcmUgZXN0YWJsaXNo ZWQvZGVtb2xpc2hlZC4gVGhpcyB1c3VhbGx5IGludm9sZXMgc2V0dGluZyB1cCBhbiBlbnRyeSBv ZgordGhlIElPTU1VJ3MgcGVyIGRldmljZSBQQVNJRCB0YWJsZSB3aXRoIGEgZ2l2ZW4gUEdELgor CitJT0FTSUQgU2V0IFByaXZhdGUgSUQgKFNQSUQpCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCitFYWNoIElPQVNJRCBzZXQgaGFzIGEgcHJpdmF0ZSBuYW1lc3BhY2Ugb2YgU1BJRHMuIEFu IFNQSUQgbWFwcyB0byBhCitzaW5nbGUgc3lzdGVtLXdpZGUgSU9BU0lELiBDb252ZXJzZWx5LCBl YWNoIElPQVNJRCBtYXkgYmUgYXNzb2NpYXRlZAord2l0aCBhbiBhbGlhcyBJRCwgbG9jYWwgdG8g dGhlIElPQVNJRCBzZXQsIG5hbWVkIFNQSUQuCitTUElEcyBjYW4gYmUgdXNlZCBhcyBndWVzdCBJ T0FTSURzIHdoZXJlIGVhY2ggZ3Vlc3QgY291bGQgZG8KK0lPQVNJRCBhbGxvY2F0aW9uIGZyb20g aXRzIG93biBwb29sL3NldCBhbmQgbWFwIHRoZW0gdG8gaG9zdCBwaHlzaWNhbAorSU9BU0lEcy4g U1BJRHMgYXJlIHBhcnRpY3VsYXJseSB1c2VmdWwgZm9yIHN1cHBvcnRpbmcgbGl2ZSBtaWdyYXRp b24KK3doZXJlIGRlY291cGxpbmcgZ3Vlc3QgYW5kIGhvc3QgcGh5c2ljYWwgcmVzb3VyY2VzIGFy ZSBuZWNlc3NhcnkuIEd1ZXN0Cit0byBIb3N0IFBBU0lEIG1hcHBpbmcgY2FuIGJlIHRvcm4gZG93 biBhbmQgcmUtZXN0YWJsaXNoZWQuIFN0b3JpbmcgdGhlCittYXBwaW5nIGluc2lkZSB0aGUga2Vy bmVsIGFsc28gcHJvdmlkZXMgbG9va3VwIHNlcnZpY2UuCisKK0ZvciBleGFtcGxlLCB0d28gVk1z IGNhbiBib3RoIGFsbG9jYXRlIGd1ZXN0IFBBU0lEL1NQSUQgIzEwMSBidXQgbWFwIHRvCitkaWZm ZXJlbnQgaG9zdCBQQVNJRHMgIzIwMSBhbmQgIzIwMiByZXNwZWN0aXZlbHkgYXMgc2hvd24gaW4g dGhlCitkaWFncmFtIGJlbG93LgorOjoKKworIC4tLS0tLS0tLS0tLS0tLS0tLS0uICAgIC4tLS0t LS0tLS0tLS0tLS0tLS0uCisgfCAgIFZNIDEgICAgICAgICAgIHwgICAgfCAgIFZNIDIgICAgICAg ICAgIHwKKyB8ICAgICAgICAgICAgICAgICAgfCAgICB8ICAgICAgICAgICAgICAgICAgfAorIHwt LS0tLS0tLS0tLS0tLS0tLS18ICAgIHwtLS0tLS0tLS0tLS0tLS0tLS18CisgfCBHUEFTSUQvU1BJ RCAxMDEgIHwgICAgfCBHUEFTSUQvU1BJRCAxMDEgIHwKKyAnLS0tLS0tLS0tLS0tLS0tLS0tJyAg ICAtLS0tLS0tLS0tLS0tLS0tLS0tJyAgICAgR3Vlc3QKKyBfX19fX19fX19ffF9fX19fX19fX19f X19fX19fX19fX198X19fX19fX19fX19fX19fX19fX18KKyAgICAgICAgICAgfCAgICAgICAgICAg ICAgICAgICAgICB8ICAgICAgICAgICAgICAgSG9zdAorICAgICAgICAgICB2ICAgICAgICAgICAg ICAgICAgICAgIHYKKyAuLS0tLS0tLS0tLS0tLS0tLS0tLiAgICAuLS0tLS0tLS0tLS0tLS0tLS0t LgorIHwgSG9zdCBJT0FTSUQgMjAxICB8ICAgIHwgSG9zdCBJT0FTSUQgMjAyICB8CisgJy0tLS0t LS0tLS0tLS0tLS0tLScgICAgJy0tLS0tLS0tLS0tLS0tLS0tLScKKyB8ICAgSU9BU0lEIHNldCAx ICAgfCAgICB8ICAgSU9BU0lEIHNldCAyICAgfAorICctLS0tLS0tLS0tLS0tLS0tLS0nICAgICct LS0tLS0tLS0tLS0tLS0tLS0nCisKK0d1ZXN0IFBBU0lEIGlzIHRyZWF0ZWQgYXMgSU9BU0lEIHNl dCBwcml2YXRlIElEIChTUElEKSB3aXRoaW4gYW4KK0lPQVNJRCBzZXQsIG1hcHBpbmdzIGJldHdl ZW4gZ3Vlc3QgYW5kIGhvc3QgSU9BU0lEcyBhcmUgc3RvcmVkIGluIHRoZQorc2V0IGZvciBpbnF1 aXJ5LgorCitUaGVvcnkgb2YgT3BlcmF0aW9uCis9PT09PT09PT09PT09PT09PT09CisKK1N0YXRl cworLS0tLS0tCitJT0FTSUQgaGFzIGZvdXIgc3RhdGVzIGFzIGlsbHVzdHJhdGVkIGluIHRoZSBk aWFncmFtIGJlbG93LgorOjoKKworICAgQklORC9VTkJJTkQsIFdRIFBST0cvQ0xFQVLigbQKKyAg IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLgorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8CisgICBBTExPQy9GUkVFICAgICAgICAgICAgICAgICAgIHwKKyAgIC0tLS0tLS0t LS0tLS4gICAgICAgICAgICAgICAgfAorICAgICAgICAgICAgICAgfCAgICAgICAgICAgICAgICB8 CisgICArLS0tLS0tLSsgICB2ICAgICstLS0tLS0tKyAgIHYgICAgICstLS0tLS0tLS0tKworICAg fCBGUkVFICB8PD09PT09PT58IElETEXCuSB8PD09PT09PT0+fCBBQ1RJVkXCsiAgfAorICAgKy0t LS0tLS0rICAgICAgICArLS0tLS0tLSsgICAgICAgICArLS0tLS0tLS0tLSsKKyAgICAgIF4gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CisgICAgICB8ICAgICAgICAgICArLS0t LS0tLS0tLS0tLS0tKyAgICAgICAgfAorICAgICAgJz09PT09PT09PT09fCBGUkVFIFBFTkRJTkfC syB8PD09PT09PT0nCisgICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tKyAgXgorICAg RlJFRSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKKyAgIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0nCisgICDCuSBBbGxvY2F0ZWQgYnV0IG5vdCB1c2VkCisgICDCsiBV c2VkIGJ5IGRldmljZSBkcml2ZXJzLCBJT01NVSwgb3IgQ1BVLCBlYWNoIHVzZXIgaG9sZHMgYSBy ZWZlcmVuY2UKKyAgIMKzIFdhaXRpbmcgZm9yIGFsbCB1c2VycyBkcm9wIHRoZWlyIHJlZmNvdW50 IGJlZm9yZSByZXR1cm5pbmcgSU9BU0lECisgICAgIGJhY2sgdG8gdGhlIHBvb2wKKyAgIOKBtCBE ZXZpY2UgZHJpdmVycyBvYnRhaW4gcmVmY291bnQgYWZ0ZXIgcHJvZ3JhbXMgd29ya3F1ZXVlIHdp dGggSU9BU0lELgorICAgICBSZWxlYXNlIHRoZSByZWZjb3VudCBhZnRlciBjbGVhcmluZyB0aGUg d29ya3F1ZXVlLgorICAgICBTaW1pbGFybHksIHRoZSBJT01NVSBkcml2ZXIgY2FuIGFsc28gZ2V0 L3B1dCBJT0FTSUQgcmVmY291bnQgZHVyaW5nCisgICAgIGJpbmQvdW5iaW5kLgorCitOb3RpZmlj YXRpb25zCistLS0tLS0tLS0tLS0tCitEZXBlbmRpbmcgb24gdGhlIGhhcmR3YXJlIGFyY2hpdGVj dHVyZSwgYW4gSU9BU0lEIGNhbiBiZSBwcm9ncmFtbWVkIGludG8KK0NQVSwgSU9NTVUsIG9yIGRl dmljZXMgZm9yIERNQSByZWxhdGVkIGFjdGl2aXR5LiBUaGUgc3luY2hyb25pemF0aW9uIGFtb25n IHRoZW0KK2lzIGJhc2VkIG9uIGV2ZW50cyBub3RpZmljYXRpb25zIHdoaWNoIGZvbGxvd3MgYSBw dWJsaXNoZXItc3Vic2NyaWJlciBwYXR0ZXJuLgorCitFdmVudHMKK35+fn5+fgorTm90aWZpY2F0 aW9uIGV2ZW50cyBhcmUgcGVydGluZW50IHRvIGluZGl2aWR1YWwgSU9BU0lEcywgdGhleSBjYW4g YmUKK29uZSBvZiB0aGUgZm9sbG93aW5nOjoKKworIC0gQUxMT0MKKyAtIEZSRUUKKyAtIEJJTkQK KyAtIFVOQklORAorCitCZXNpZGVzIGNhbGxpbmcgaW9hc2lkX25vdGlmeSgpIGRpcmVjdGx5IHdp dGggZXhwbGljaXQgZXZlbnRzLCBub3RpZmljYXRpb25zCitjYW4gYWxzbyBiZSBzZW50IGJ5IHRo ZSBJT0FTSUQgY29yZSBhcyBhIGJ5LXByb2R1Y3Qgb2YgY2FsbGluZyB0aGUgZm9sbG93aW5nCitB UElzOjoKKworIC0gaW9hc2lzZF9mcmVlKCkgICAgICAgIC8qIGVtaXRzIElPQVNJRF9GUkVFICov CisgLSBpb2FzaWRfZGV0YWNoX3NwaWQoKSAgLyogZW1pdHMgSU9BU0lEX1VOQklORCAqLworIC0g aW9hc2lkX2F0dGFjaF9zcGlkKCkgIC8qIGVtaXRzIElPQVNJRF9CSU5EICovCisKK09yZGVyaW5n Cit+fn5+fn5+fgorT3JkZXJpbmcgb2Ygbm90aWZpY2F0aW9uIGV2ZW50cyBpcyBzdXBwb3J0ZWQg YnkgdGhlIElPQVNJRCBjb3JlIGFzIHRoZQorZm9sbG93aW5nIChmcm9tIGhpZ2ggdG8gbG93KTo6 CisKKyAtIENQVQorIC0gSU9NTVUKKyAtIERFVklDRQorCitTdWJzY3JpYmVycyBvZiBJT0FTSUQg ZXZlbnRzIGFyZSByZXNwb25zaWJsZSBmb3IgcmVnaXN0ZXJpbmcgdGhlaXIKK25vdGlmaWNhdGlv biBibG9ja3MgYWNjb3JkaW5nIHRvIHRoZSBwcmlvcml0aWVzLgorCitUaGUgYWJvdmUgb3JkZXIg YXBwbGllcyB0byBhbGwgZXZlbnRzLiBGb3IgZXhhbXBsZSwgaWYgVU5CSU5EIGV2ZW50IGlzCitp c3N1ZWQgd2hlbiBhIGd1ZXN0IElPQVNJRCBpcyBmcmVlZCBkdWUgdG8gZXhjZXB0aW9ucy4gQWxs IGFjdGl2ZSBETUEKK3NvdXJjZXMgc2hvdWxkIGJlIHF1aWVzY2VkIGJlZm9yZSB0ZWFyaW5nIGRv d24gb3RoZXIgaGFyZHdhcmUgY29udGV4dHMKK2Fzc29jaWF0ZWQgd2l0aCB0aGUgSU9BU0lEIGlu IHRoZSBzeXN0ZW0uIFRoaXMgaXMgbmVjZXNzYXJ5IHRvIHJlZHVjZQordGhlIGNodXJuIGluIGhh bmRsaW5nIGZhdWx0cy4gVGhlIG5vdGlmaWNhdGlvbiBvcmRlciBlbnN1cmVzIHRoYXQgdkNQVQor aXMgc3RvcHBlZCBiZWZvcmUgSU9NTVUgYW5kIGRldmljZXMuIEtWTSB4ODYgY29kZSByZWdpc3Rl cnMgbm90aWZpY2F0aW9uCitibG9jayB3aXRoIHByaW9yaXR5IElPQVNJRF9QUklPX0NQVSBhbmQg VkRDTSBjb2RlIHJlZ2lzdGVycyBub3RpZmljYXRpb24KK2Jsb2NrIHdpdGggcHJpb3JpdHkgSU9B U0lEX1BSSU9fREVWSUNFLCBJT0FTSUQgY29yZSBlbnN1cmVzIHRoZSBDUFUKK2hhbmRsZXJzIGFy ZSBjYWxsZWQgYmVmb3JlIHRoZSBERVZJQ0UgaGFuZGxlcnMuCisKK0l0IGlzIHRoZSBjYWxsZXIn cyByZXNwb25zaWJpbGl0eSB0byBhdm9pZCBjaGFpbmVkIG5vdGlmaWNhdGlvbnMgaW4gdGhlCith dG9taWMgbm90aWZpY2F0aW9uIGhhbmRsZXJzLiBpLmUuIGlvYXNpZF9kZXRhY2hfc3BpZCgpIGNh bm5vdCBiZSBjYWxsZWQKK2luc2lkZSB0aGUgSU9BU0lEX0ZSRUUgYXRvbWljIGhhbmRsZXJzIGR1 ZSB0byBzcGlubG9ja3MgaGVsZCBieSB0aGUKK2NhbGxlciBvZiB0aGUgbm90aWZpZXIuIEhvd2V2 ZXIsIGlvYXNpZF9kZXRhY2hfc3BpZCgpIGNhbiBiZSBjYWxsZWQgZnJvbQorZGVmZXJyZWQgd29y ay4gU2VlIEF0b21pY2l0eSBzZWN0aW9uIGZvciBkZXRhaWxzLgorCitMZXZlbCBTZW5zaXRpdml0 eQorfn5+fn5+fn5+fn5+fn5+fn4KK0ZvciBlYWNoIElPQVNJRCBzdGF0ZSB0cmFuc2l0aW9uLCBJ T0FTSUQgY29yZSBlbnN1cmVzIHRoYXQgdGhlcmUgaXMKK29ubHkgb25lIG5vdGlmaWNhdGlvbiBz ZW50LiBUaGlzIHJlc2VtYmxlcyBsZXZlbCB0cmlnZ2VyZWQgaW50ZXJydXB0Cit3aGVyZSBhIHNp bmdsZSBpbnRlcnJ1cHQgaXMgcmFpc2VkIGR1cmluZyBhIHN0YXRlIHRyYW5zaXRpb24uCitGb3Ig ZXhhbXBsZSwgaWYgaW9hc2lkX2ZyZWUoKSBpcyBjYWxsZWQgdHdpY2UgYnkgYSB1c2VyIGJlZm9y ZSB0aGUKK0lPQVNJRCBpcyByZWNsYWltZWQsIElPQVNJRCBjb3JlIHdpbGwgb25seSBzZW5kIG91 dCBhIHNpbmdsZQorSU9BU0lEX05PVElGWV9GUkVFIGV2ZW50LiBTaW1pbGFybHksIGZvciBJT0FT SURfTk9USUZZX0JJTkQvVU5CSU5ECitldmVudHMsIHdoaWNoIGlzIG9ubHkgc2VudCBvdXQgb25j ZSB3aGVuIGEgU1BJRCBpcyBhdHRhY2hlZC9kZXRhY2hlZC4KKworU2NvcGVzCit+fn5+fn4KK1Ro ZXJlIGFyZSB0d28gdHlwZXMgb2Ygbm90aWZpZXJzIGluIElPQVNJRCBjb3JlOiBzeXN0ZW0td2lk ZSBhbmQKK2lvYXNpZF9zZXQtd2lkZSAob25lIG5vdGlmaWVyIGNoYWluIHBlciBpb2FzaWRfc2V0 KS4KKworU3lzdGVtLXdpZGUgbm90aWZpZXIgaXMgY2F0ZXJpbmcgZm9yIHVzZXJzIHRoYXQgbmVl ZCB0byBoYW5kbGUgYWxsIHRoZQorSU9BU0lEcyBpbiB0aGUgc3lzdGVtLiBFLmcuIFRoZSBJT01N VSBkcml2ZXIuCisKK1BlciBpb2FzaWRfc2V0IG5vdGlmaWVyIGNhbiBiZSB1c2VkIGJ5IFZNIHNw ZWNpZmljIGNvbXBvbmVudHMgc3VjaCBhcworS1ZNLiBBZnRlciBhbGwsIGVhY2ggS1ZNIGluc3Rh bmNlIG9ubHkgY2FyZXMgYWJvdXQgSU9BU0lEcyB3aXRoaW4gaXRzCitvd24gc2V0L2d1ZXN0LiBU aGUgZm9sbG93aW5nIGZsYWdzIGFyZSB1c2VkIHRvIGRpc3Rpbmd1aXNoIHRoZSBzY29wZXM6Ogor CisgI2RlZmluZSBJT0FTSURfTk9USUZZX0ZMQUdfQUxMIEJJVCgwKQorICNkZWZpbmUgSU9BU0lE X05PVElGWV9GTEFHX1NFVCBCSVQoMSkKKworRm9yIGV4YW1wbGUsIG9uIFZULWQgcGxhdGZvcm0g Ym90aCBLVk0gYW5kIFZEQ00gc2hhbGwgcmVnaXN0ZXIgbm90aWZpZXIKK2Jsb2NrIG9uIHRoZSBJ T0FTSUQgc2V0IHN1Y2ggdGhhdCAqb25seSogZXZlbnRzIGZyb20gdGhlIG1hdGNoaW5nIFZNCith cmUgcmVjZWl2ZWQuCisKK0lmIEtWTSBhdHRlbXB0cyB0byByZWdpc3RlciBhIG5vdGlmaWVyIGJs b2NrIGJlZm9yZSB0aGUgSU9BU0lEIHNldCBpcworY3JlYXRlZCB1c2luZyB0aGUgTU0gdG9rZW4s IHRoZSBub3RpZmllciBibG9jayB3aWxsIGJlIHBsYWNlZCBvbiBhCitwZW5kaW5nIGxpc3QgaW5z aWRlIElPQVNJRCBjb3JlLiBPbmNlIHRoZSB0b2tlbiBtYXRjaGluZyBJT0FTSUQgc2V0CitpcyBj cmVhdGVkLCBJT0FTSUQgd2lsbCByZWdpc3RlciB0aGUgbm90aWZpZXIgYmxvY2sgYXV0b21hdGlj YWxseS4KK0lPQVNJRCBjb3JlIGRvZXMgbm90IHJlcGxheSBldmVudHMgZm9yIHRoZSBleGlzdGlu ZyBJT0FTSURzIGluIHRoZQorc2V0LiBGb3IgSU9BU0lEIHNldCBvZiBNTSB0eXBlLCBub3RpZmlj YXRpb24gYmxvY2tzIGNhbiBiZSByZWdpc3RlcmVkCitvbiBlbXB0eSBzZXRzIG9ubHkuIFRoaXMg aXMgdG8gYXZvaWQgbG9zdCBldmVudHMuCisKK0lPTU1VIGRyaXZlciBzaGFsbCByZWdpc3RlciBu b3RpZmllciBibG9jayBvbiBnbG9iYWwgY2hhaW4sIGUuZy4gOjoKKworIHN0YXRpYyBzdHJ1Y3Qg bm90aWZpZXJfYmxvY2sgcGFzaWRfbmJfdnRkID0geworCS5ub3RpZmllcl9jYWxsID0gcGFzaWRf c3RhdHVzX2NoYW5nZV92dGQsCisJLnByaW9yaXR5ICAgICAgPSBJT0FTSURfUFJJT19JT01NVSwK KyB9OworCitBdG9taWNpdHkKK35+fn5+fn5+fgorSU9BU0lEIG5vdGlmaWVycyBhcmUgYXRvbWlj IGR1ZSB0byBzcGlubG9ja3MgdXNlZCBpbnNpZGUgdGhlIElPQVNJRAorY29yZS4gRm9yIHRhc2tz IHRoYXQgY2Fubm90IGJlIGNvbXBsZXRlZCBpbiB0aGUgbm90aWZpZXIgaGFuZGxlciwKK2FzeW5j IHdvcmsgdG8gYmUgY29tcGxldGVkIGluIG9yZGVyIG11c3QgYmUgc3VibWl0dGVkIHRvIHRoZSBv cmRlcmVkCit3b3JrcXVldWUgcHJvdmlkZWQgYnkgdGhlIElPQVNJRCBjb3JlLiBUaGlzIHdpbGwg ZW5zdXJlIHRoZSBvcmRlciB3LnIudC4KK3RoZSB3b3JrIGl0ZW1zIHN1Ym1pdHRlZCBieSBvdGhl ciB1c2VycyBvZiB0aGUgc2FtZSBldmVudC4KKworSXQgaXMgdGhlIGNhbGxlcidzIHJlc3BvbnNp YmlsaXR5IHRvIGF2b2lkIGNoYWluZWQgbm90aWZpY2F0aW9ucyBpbiB0aGUKK2F0b21pYyBub3Rp ZmljYXRpb24gaGFuZGxlcnMuIGUuZy4gaW9hc2lkX2RldGFjaF9zcGlkKCkgY2Fubm90IGJlIGNh bGxlZAoraW5zaWRlIHRoZSBJT0FTSURfRlJFRSBhdG9taWMgaGFuZGxlcnMgZHVlIHRvIHNwaW5s b2NrcyBoZWxkIGJ5IHRoZQorY2FsbGVyIG9mIHRoZSBub3RpZmllci4gSG93ZXZlciwgaW9hc2lk X2RldGFjaF9zcGlkKCkgY2FuIGJlIGNhbGxlZCBmcm9tCitkZWZlcnJlZCB3b3JrLgorCitSZWZl cmVuY2UgY291bnRpbmcKKy0tLS0tLS0tLS0tLS0tLS0tLQorSU9BU0lEIGxpZmUgY3ljbGUgbWFu YWdlbWVudCBpcyBiYXNlZCBvbiByZWZlcmVuY2UgY291bnRpbmcuIFVzZXJzIG9mCitJT0FTSUQg d2hvIGludGVuZCB0byBhbGlnbiBpdHMgY29udGV4dCB3aXRoIHRoZSBsaWZlIGN5Y2xlIG5lZWQg dG8gaG9sZAorcmVmZXJlbmNlcyBvZiB0aGUgSU9BU0lELiBBbiBJT0FTSUQgd2lsbCBub3QgYmUg cmV0dXJuZWQgdG8gdGhlIHBvb2wKK2ZvciByZS1hbGxvY2F0aW9uIHVudGlsIGFsbCBpdHMgcmVm ZXJlbmNlcyBhcmUgZHJvcHBlZC4gQ2FsbGluZyBpb2FzaWRfZnJlZSgpCit3aWxsIG1hcmsgdGhl IElPQVNJRCBhcyBGUkVFX1BFTkRJTkcgaWYgdGhlIElPQVNJRCBoYXMgb3V0c3RhbmRpbmcKK3Jl ZmVyZW5jZXMuIE5vIG5ldyByZWZlcmVuY2VzIGNhbiBiZSB0YWtlbiBieSBpb2FzaWRfZ2V0KCkg b25jZSBhbgorSU9BU0lEIGlzIGluIHRoZSBGUkVFX1BFTkRJTkcgc3RhdGUuIGlvYXNpZF9mcmVl KCkgY2FuIGJlIGNhbGxlZAorbXVsdGlwbGUgdGltZXMgd2l0aG91dCBhbiBlcnJvciB1bnRpbCBh bGwgcmVmcyBhcmUgZHJvcHBlZC4KKworaW9hc2lkX3B1dCgpIGRlY3JlbWVudHMgYW5kIHRlc3Rz IHJlZmNvdW50IG9mIHRoZSBJT0FTSUQuIElmIHJlZmNvdW50CitpcyAwLCBpb2FzaWQgd2lsbCBi ZSBmcmVlZC4gVGhlIElPQVNJRCB3aWxsIGJlIHJldHVybmVkIHRvIHRoZSBwb29sIGFuZAorYXZh aWxhYmxlIGZvciBuZXcgYWxsb2NhdGlvbnMuIE5vdGUgdGhhdCBpb2FzaWRfcHV0KCkgY2FuIGJl IGNhbGxlZCBieQordGhlIElPQVNJRF9GUkVFIGV2ZW50IGhhbmRsZXIgd2hlcmUgdGhlIHN1YnNj cmliZXIgY2FuIGRyb3AgdGhlIGxhc3QKK3JlZmNvdW50IHRoYXQgZW5kcyB0aGUgZnJlZSBwZW5k aW5nIHN0YXRlLgorCitFdmVudCBub3RpZmljYXRpb25zIGFyZSB1c2VkIHRvIGluZm9ybSB1c2Vy cyBvZiBJT0FTSUQgc3RhdHVzIGNoYW5nZS4KK0lPQVNJRF9GUkVFIG9yIFVOQklORCBldmVudHMg cHJvbXB0IHVzZXJzIHRvIGRyb3AgdGhlaXIgcmVmZXJlbmNlcyBhZnRlcgorY2xlYXJpbmcgaXRz IGNvbnRleHQuCisKK0ZvciBleGFtcGxlLCBvbiBWVC1kIHBsYXRmb3JtIHdoZW4gYW4gSU9BU0lE IGlzIGZyZWVkLCB0ZWFyZG93bgorYWN0aW9ucyBhcmUgcGVyZm9ybWVkIG9uIENQVSAoS1ZNKSwg ZGV2aWNlIGRyaXZlciAoVkRDTSksIGFuZCB0aGUgSU9NTVUKK2RyaXZlci4gVG8gcXVpZXNjZSB2 Q1BVIGZvciB3b3JrIHN1Ym1pc3Npb24sIEtWTSBub3RpZmllciBoYW5kbGVyIG11c3QKK2JlIGNh bGxlZCBiZWZvcmUgVkRDTSBoYW5kbGVyLiBUaGVyZWZvcmUsIEtWTSBhbmQgVkRDTSBzaGFsbCBt b25pdG9yCitub3RpZmljYXRpb24gZXZlbnRzIElPQVNJRF9VTkJJTkQuCisKK05hbWVzcGFjZXMK Ky0tLS0tLS0tLS0KK0lPQVNJRHMgYXJlIGxpbWl0ZWQgc3lzdGVtIHJlc291cmNlcyB0aGF0IGRl ZmF1bHQgdG8gMjAgYml0cyBpbgorc2l6ZS4gRWFjaCBkZXZpY2UgY2FuIGhhdmUgaXRzIG93biBQ QVNJRCB0YWJsZSBmb3Igc2VjdXJpdHkgcmVhc29ucy4KK1RoZW9yZXRpY2FsbHkgdGhlIG5hbWVz cGFjZSBjYW4gYmUgcGVyIGRldmljZSBhbHNvLgorCitIb3dldmVyIElPQVNJRCBuYW1lc3BhY2Ug aXMgc3lzdGVtLXdpZGUgZm9yIHR3byByZWFzb25zOgorLSBTaW1wbGljaXR5CistIFNoYXJpbmcg cmVzb3VyY2VzIG9mIGEgc2luZ2xlIGRldmljZSB0byBtdWx0aXBsZSBWTXMuCisKK1Rha2UgVlQt ZCBhcyBhbiBleGFtcGxlLCBWVC1kIHN1cHBvcnRzIHNoYXJlZCB3b3JrcXVldWUgYW5kIEVOUUNN RFsxXQord2hlcmUgb25lIElPQVNJRCBjb3VsZCBiZSB1c2VkIHRvIHN1Ym1pdCB3b3JrIG9uIG11 bHRpcGxlIGRldmljZXMgdGhhdAorYXJlIHNoYXJlZCB3aXRoIG90aGVyIFZNcy4gVGhpcyByZXF1 aXJlcyBJT0FTSUQgdG8gYmUKK3N5c3RlbS13aWRlLiBUaGlzIGlzIGFsc28gdGhlIHJlYXNvbiB3 aHkgZ3Vlc3RzIG11c3QgdXNlIGFuCitlbXVsYXRlZCB2aXJ0dWFsIGNvbW1hbmQgaW50ZXJmYWNl IHRvIGFsbG9jYXRlIElPQVNJRCBmcm9tIHRoZSBob3N0LgorCitMaWZlIGN5Y2xlCistLS0tLS0t LS0tCitUaGlzIHNlY3Rpb24gY292ZXJzIHRoZSBJT0FTSUQgbGlmZSBjeWNsZSBtYW5hZ2VtZW50 IGZvciBib3RoIGJhcmUtbWV0YWwKK2FuZCBndWVzdCB1c2FnZXMuIEluIGJhcmUtbWV0YWwgU1ZB LCBNTVUgbm90aWZpZXIgaXMgZGlyZWN0bHkgaG9va2VkCit1cCB3aXRoIHRoZSBJT01NVSBkcml2 ZXIuIEJ5IGxldmVyYWdpbmcgdGhlIC5yZWxlYXNlKCkgZnVuY3Rpb24sIHRoZQorSU9BU0lEIGxp ZmUgY3ljbGUgY2FuIGJlIG1hZGUgdG8gbWF0Y2ggdGhlIHByb2Nlc3MgYWRkcmVzcyBzcGFjZSAo TU0pCitsaWZlIGN5Y2xlLgorCitIb3dldmVyLCBndWVzdCBNTVUgbm90aWZpZXIgaXMgbm90IGF2 YWlsYWJsZSB0byB0aGUgaG9zdCBJT01NVSBkcml2ZXIsCit3aGVuIGd1ZXN0IE1NIHRlcm1pbmF0 ZXMgdW5leHBlY3RlZGx5LCB0aGUgZXZlbnRzIGhhdmUgdG8gZ28gdGhyb3VnaAorVkZJTyBhbmQg SU9NTVUgVUFQSSB0byByZWFjaCBob3N0IElPTU1VIGRyaXZlci4gVGhlcmUgYXJlIGFsc28gbW9y ZQorcGFydGllcyBpbnZvbHZlZCBpbiBndWVzdCBTVkEsIGUuZy4gb24gSW50ZWwgVlQtZCBwbGF0 Zm9ybSwgSU9BU0lEcworYXJlIHVzZWQgYnkgSU9NTVUgZHJpdmVyLCBLVk0sIFZEQ00sIGFuZCBW RklPLgorCitBdCB0aGUgaGlnaGxldmVsLCB0aGVyZSBhcmUgZm9sbG93aW5nIGZvdXIgcGF0dGVy bnM6CisKKzEuICAgQUxMT0MgLT4gRlJFRQorMi4gICBBTExPQyAtPiBCSU5EIC0+IERNQSBBY3Rp dml0eSAtPiBVTkJJTkQgLT4gRlJFRQorMy4gICBBTExPQyAtPiBCSU5EIC0+IEZSRUUKKzQuICAg QUxMT0MgLT4gQklORCAtPiBETUEgQWN0aXZpdHkgLT4gRlJFRQorCitUaGUgZmlyc3QgdHdvIGFy ZSBub3JtYWwgY2FzZXMsIDMgYW5kIDQgYXJlIGV4Y2VwdGlvbnMgZHVlIHRvIHVzZXIKK3Byb2Nl c3MgbWlzYmVoYXZpbmcuCisKK0V4Y2VwdGlvbiBoYW5kbGluZyBjYW4gYmUgY29tcGxleCB3aGVu IHRoZXJlIGFyZSBsb3RzIG9mIElPQVNJRAorY29uc3VtZXJzIGludm9sdmVkIGJ1dCB0aGUgcGF0 dGVybiBpcyBjb21tb24gYW5kIHF1aXRlIHNpbXBsZS4gV2hlbiBhbgorSU9BU0lEIGluIGFjdGl2 ZSBzdGF0ZSBpcyBiZWluZyBmcmVlZCwgSU9BU0lEIGNvcmUgd2lsbCBub3RpZnkgYWxsCit1c2Vy cyB0byBwZXJmb3JtIGNsZWFuIHVwLiBFYWNoIElPQVNJRCB1c2VyIHBlcmZvcm1zIGNsZWFudXAg YW5kIGRyb3AKK3RoZSByZWZlcmVuY2UgYXQgdGhlIGVuZC4gV2hlbiByZWZlcmVuY2UgY291bnQg ZHJvcHMgdG8gMCwgSU9BU0lEIHdpbGwKK2JlIHJlY2xhaW1lZCBhbmQgcmVhZHkgdG8gYmUgYWxs b2NhdGVkIGFnYWluLgorCitDbGVhbnVwIGNhbiBiZSBlaXRoZXIgZG9uZSBpbiB0aGUgYXRvbWlj IG5vdGlmaWVyIGhhbmRsZXIgb3IgYXMgcXVldWVkCit3b3JrIHRvIHRoZSBjb21tb24gb3JkZXJl ZCBJT0FTSUQgd29ya3F1ZXVlIHRvIGJlIHBlcmZvcm1lZCBhc3luY2hyb25vdXNseS4KK1RoZSBo aWdobGV2ZWwgZmxvdyBpcyB0aGUgZm9sbG93aW5nOjoKKworICBGcmVlIFJlccK5IC0+IE5vdGlm eSB1c2VycyAtPiBDbGVhbnVwIC0+IERyb3AgcmVmZXJlbmNlIC0+IFJlY2xhaW0KKworTm90ZXM6 CivCuSBGcmVlIG9uZSBJT0FTSUQgb3IgZnJlZSBhbGwgSU9BU0lEIHdpdGhpbiBhIHNldAorCitU aGUgZm9sbG93aW5nIHRhYmxlIHNob3dzIGhvdyBldmVudHMgYXJlIHVzZWQgb24gSW50ZWwgVlQt ZCBwbGF0Zm9ybS4KKzo6CisKKyAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgRXZlbnRzICAgICB8UHVi bGlzaGVycyAgICAgICB8IFN1YnNjcmliZXJzCisgIC0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0t LS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgIEFMTE9D ICAgICAgfC9kZXYvaW9hc2lkICAgICAgfCBOb25lCisgIC0tLS0tLS0tLS0tKy0tLS0tLS0tLS0t LS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgIEZS RUUgICAgICAgfC9kZXYvaW9hc2lkICAgICAgfCBJT01NVSAoVlQtZCBkcml2ZXIpwrkKKyAgLS0t LS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyAgQklORCAgICAgICB8SU9NTVUgICAgICAgICAgICB8IEtWTSwg VkRDTQorICAtLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICBVTkJJTkQgICAgIHxJT01NVcKyICAgICAg ICAgICB8IEtWTSwgVkRDTQorICAtLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisgIMK5IElPQVNJRCBjb3Jl IGlzc3VlcyBGUkVFIGV2ZW50cyBpZiB0aGUgSU9BU0lEIGlzIGluIHRoZSBBQ1RJVkUgc3RhdGUu IElPTU1VCisgICAgZHJpdmVyIGNhbGxzIGlvYXNpZF9kZXRhY2hfc3BpZCgpIHdoaWNoIGlzc3Vl cyBVTkJJTkQgZXZlbnQgb3V0c2lkZSBhdG9taWMKKyAgICBub3RpZmllciBoYW5kbGVyLgorICDC siBPbmx5ICpvbmUqIEJJTkQvVUJJTkQgZXZlbnQgaXMgaXNzdWVkIHBlciBiaW5kL3VuYmluZCBj eWNsZS4gRm9yIG11bHRpcGxlCisgICAgZGV2aWNlcyBib3VuZCB0byB0aGUgc2FtZSBQQVNJRCwg QklORCBldmVudCBpcyBpc3N1ZWQgZm9yIHRoZSBmaXJzdCBkZXZpY2UKKyAgICBiaW5kLCBVTkJE SU4gZXZlbnQgaXMgaXNzdWVkIGZvciB0aGUgbGFzdCBkZXZpY2UgdW5iaW5kLiBGYXVsdHMgbXVz dCBiZQorICAgIHRvbGVyYXRlZCBiZXR3ZWVuIHRoZSBmaXJzdCBhbmQgbGFzdCBkZXZpY2UgdW5i aW5kLiBVbmRlciBub3JtYWwKKyAgICBjaXJjdW1zdGFuY2VzLCBmYXVsdHMgYXJlIG5vdCBleHBl Y3RlZCBpbiB0aGF0IHRoZSB0ZWFyZG93biBwcm9jZXNzIHNoYWxsCisgICAgc3RvcCBETUEgYWN0 aXZpdGllcyBwcmlvciB0byB1bmJpbmQuCisKK1RoZSBudW1iZXIgb2YgSU9BU0lEcyBhbGxvY2F0 ZWQgaW4gdGhlIGlvYXNpZF9zZXQgc2VydmVzIGFzIHRoZSByZWZjb3VudAorb2YgdGhlIHNldCwg dGhpcyBlbnN1cmVzIHRoZSBsaWZlIGN5Y2xlIGFsaWdubWVudCBvZiB0aGUgc2V0IGFuZCBpdHMK K0lPQVNJRHMuCisKK0FQSSBJbXBsZW1lbnRhdGlvbgorPT09PT09PT09PT09PT09PT09CitUbyBn ZXQgdGhlIElPQVNJRCBBUElzLCB1c2VycyBtdXN0ICNpbmNsdWRlIDxsaW51eC9pb2FzaWQuaD4u IFRoZXNlIEFQSXMKK3NlcnZlIHRoZSBmb2xsb3dpbmcgZnVuY3Rpb25hbGl0aWVzOgorCisgIC0g SU9BU0lEIGFsbG9jYXRpb24vZnJlZWluZworICAtIEdyb3VwIG1hbmFnZW1lbnQgaW4gdGhlIGZv cm0gb2YgaW9hc2lkX3NldAorICAtIFByaXZhdGUgZGF0YSBzdG9yYWdlIGFuZCBsb29rdXAKKyAg LSBSZWZlcmVuY2UgY291bnRpbmcKKyAgLSBFdmVudCBub3RpZmljYXRpb24gaW4gY2FzZSBvZiBh IHN0YXRlIGNoYW5nZQorCitDdXN0b20gYWxsb2NhdG9yIEFQSXMKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorCitJT0FTSURzIGFyZSBhbGxvY2F0ZWQgZm9yIGJvdGggaG9zdCBhbmQgZ3Vlc3QgU1ZB L0lPVkEgdXNhZ2UuIEhvd2V2ZXIsCithbGxvY2F0b3JzIGNhbiBiZSBkaWZmZXJlbnQuIEZvciBl eGFtcGxlLCBvbiBWVC1kIGd1ZXN0IFBBU0lECithbGxvY2F0aW9uIG11c3QgYmUgcGVyZm9ybWVk IHZpYSBhIHZpcnR1YWwgY29tbWFuZCBpbnRlcmZhY2Ugd2hpY2ggaXMKK2VtdWxhdGVkIGJ5IFZN TS4KKworSU9BU0lEIGNvcmUgaGFzIHRoZSBub3Rpb24gb2YgImN1c3RvbSBhbGxvY2F0b3IiIHN1 Y2ggdGhhdCBndWVzdCBjYW4KK3JlZ2lzdGVyIHZpcnR1YWwgY29tbWFuZCBhbGxvY2F0b3IgdGhh dCBwcmVjZWRlcyB0aGUgZGVmYXVsdCBvbmUuCis6OgorCisgaW50IGlvYXNpZF9yZWdpc3Rlcl9h bGxvY2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3BzICphbGxvY2F0b3IpOworCisgdm9p ZCBpb2FzaWRfdW5yZWdpc3Rlcl9hbGxvY2F0b3Ioc3RydWN0IGlvYXNpZF9hbGxvY2F0b3Jfb3Bz ICphbGxvY2F0b3IpOworCitJT0FTSUQgU2V0IExldmVsIEFQSXMKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorRm9yIHVzZSBjYXNlcyBzdWNoIGFzIGd1ZXN0IFNWQSBpdCBpcyBuZWNlc3NhcnkgdG8g bWFuYWdlIElPQVNJRHMgYXQKK2lvYXNpZF9zZXQgbGV2ZWwuIEZvciBleGFtcGxlLCBWTXMgbWF5 IGFsbG9jYXRlIG11bHRpcGxlIElPQVNJRHMgZm9yCitndWVzdCBwcm9jZXNzIGFkZHJlc3Mgc2hh cmluZyAodlNWQSkuIEl0IGlzIGltcGVyYXRpdmUgdG8gZW5mb3JjZQorVk0tSU9BU0lEIG93bmVy c2hpcCBzdWNoIHRoYXQgYSBtYWxpY2lvdXMgZ3Vlc3QgY2Fubm90IHRhcmdldCBETUEKK3RyYWZm aWMgb3V0c2lkZSBpdHMgb3duIElPQVNJRHMsIG9yIGZyZWUgYW4gYWN0aXZlIElPQVNJRCB0aGF0 IGJlbG9uZ3MKK3RvIGFub3RoZXIgVk0uCisKK1RoZSBJT0FTSUQgc2V0IEFQSXMgc2VydmUgdGhl IGZvbGxvd2luZyBwdXJwb3NlczoKKworIC0gT3duZXJzaGlwL3Blcm1pc3Npb24gZW5mb3JjZW1l bnQKKyAtIFRha2UgY29sbGVjdGl2ZSBhY3Rpb25zLCBlLmcuIGZyZWUgYW4gZW50aXJlIHNldAor IC0gRXZlbnQgbm90aWZpY2F0aW9ucyB3aXRoaW4gYSBzZXQKKyAtIExvb2sgdXAgYSBzZXQgYmFz ZWQgb24gdG9rZW4KKyAtIFF1b3RhIGVuZm9yY2VtZW50IChUQkQsIGNvbnRpbmdlbnQgdXBvbiBp b2FzaWRzIGNncm91cCkKKworRWFjaCBJT0FTSUQgc2V0IGlzIGNyZWF0ZWQgd2l0aCBhIHRva2Vu LCB3aGljaCBjYW4gYmUgb25lIG9mIHRoZQorZm9sbG93aW5nIHRva2VuIHR5cGVzOjoKKworIC0g SU9BU0lEX1NFVF9UWVBFX05PTkUgKEFyYml0cmFyeSB1NjQgdmFsdWUpCisgLSBJT0FTSURfU0VU X1RZUEVfTU0gKFNldCB0b2tlbiBpcyBhIG1tX3N0cnVjdCkKKworVGhlIGV4cGxpY2l0IE1NIHRv a2VuIHR5cGUgaXMgdXNlZnVsIHdoZW4gbXVsdGlwbGUgdXNlcnMgb2YgYW4gSU9BU0lECitzZXQg dW5kZXIgdGhlIHNhbWUgcHJvY2VzcyBuZWVkIHRvIGNvbW11bmljYXRlIGFib3V0IHRoZWlyIHNo YXJlZCBJT0FTSURzLgorRS5nLiBBbiBJT0FTSUQgc2V0IGNyZWF0ZWQgYnkgVkZJTyBmb3Igb25l IGd1ZXN0IGNhbiBiZSBhc3NvY2lhdGVkCit3aXRoIHRoZSBLVk0gaW5zdGFuY2UgZm9yIHRoZSBz YW1lIGd1ZXN0IHNpbmNlIHRoZXkgc2hhcmUgYSBjb21tb24gbW1fc3RydWN0LgorQSB0b2tlbiBt dXN0IGJlIHVuaXF1ZSB3aXRoaW4gaXRzIHR5cGUuCisKKzo6CisKKyBzdHJ1Y3QgaW9hc2lkX3Nl dCAqaW9hc2lkX2FsbG9jX3NldCh2b2lkICp0b2tlbiwgaW9hc2lkX3QgcXVvdGEsIHUzMiB0eXBl KQorCisgaW50IGlvYXNpZF9zZXRfZm9yX2VhY2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRfc2V0ICpz ZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKCpmbikoaW9hc2lkX3Qg aWQsIHZvaWQgKmRhdGEpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpk YXRhKQorCisgc3RydWN0IGlvYXNpZF9zZXQgKmlvYXNpZF9maW5kX21tX3NldChzdHJ1Y3QgbW1f c3RydWN0ICp0b2tlbikKKworIHZvaWQgaW9hc2lkX2ZyZWVfYWxsX2luX3NldChzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0KQorCitJbmRpdmlkdWFsIElPQVNJRCBBUElzCistLS0tLS0tLS0tLS0tLS0t LS0tLS0tCitPbmNlIGFuIGlvYXNpZF9zZXQgaXMgY3JlYXRlZCwgSU9BU0lEcyBjYW4gYmUgYWxs b2NhdGVkIGZyb20gdGhlIHNldC4KK1dpdGhpbiB0aGUgSU9BU0lEIHNldCBuYW1lc3BhY2UsIHNl dCBwcml2YXRlIElEIChTUElEKSBpcyBzdXBwb3J0ZWQuIEluCit0aGUgVk0gdXNlIGNhc2UsIFNQ SUQgY2FuIGJlIHVzZWQgZm9yIHN0b3JpbmcgZ3Vlc3QgUEFTSUQuCisKKzo6CisKKyBpb2FzaWRf dCBpb2FzaWRfYWxsb2Moc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgbWluLCBpb2Fz aWRfdCBtYXgsCisgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKnByaXZhdGUpOworCisgaW50 IGlvYXNpZF9nZXQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkKTsKKwor IHZvaWQgaW9hc2lkX3B1dChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQp OworCisgaW50IGlvYXNpZF9nZXRfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNp ZF90IGlvYXNpZCk7CisKKyB2b2lkIGlvYXNpZF9wdXRfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0 ICpzZXQsIGlvYXNpZF90IGlvYXNpZCk7CisKKyB2b2lkICppb2FzaWRfZmluZChzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0LCBpb2FzaWRfdCBpb2FzaWQsCisgICAgICAgICAgICAgICAgICAgYm9vbCAo KmdldHRlcikodm9pZCAqKSk7CisKKyBpb2FzaWRfdCBpb2FzaWRfZmluZF9ieV9zcGlkKHN0cnVj dCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IHNwaWQsCisgYm9vbCBnZXQpCisKKyBpbnQgaW9h c2lkX2F0dGFjaF9kYXRhKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsIGlvYXNpZF90IGlvYXNpZCwK KyAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKmRhdGEpOworIGludCBpb2FzaWRfYXR0YWNo X3NwaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNldCwgaW9hc2lkX3QgaW9hc2lkLAorICAgICAgICAg ICAgICAgICAgICAgICAgaW9hc2lkX3Qgc3BpZCk7CisKKworTm90aWZpY2F0aW9uIEFQSXMKKy0t LS0tLS0tLS0tLS0tLS0tCitBbiBJT0FTSUQgbWF5IGhhdmUgbXVsdGlwbGUgdXNlcnMsIGVhY2gg dXNlciBtYXkgaGF2ZSBoYXJkd2FyZSBjb250ZXh0Cithc3NvY2lhdGVkIHdpdGggYW4gSU9BU0lE LiBXaGVuIHRoZSBzdGF0dXMgb2YgYW4gSU9BU0lEIGNoYW5nZXMsCitlLmcuIGFuIElPQVNJRCBp cyBiZWluZyBmcmVlZCwgdXNlcnMgbmVlZCB0byBiZSBub3RpZmllZCBzdWNoIHRoYXQgdGhlCith c3NvY2lhdGVkIGhhcmR3YXJlIGNvbnRleHQgY2FuIGJlIGNsZWFyZWQsIGZsdXNoZWQsIGFuZCBk cmFpbmVkLgorCis6OgorCisgaW50IGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3QgaW9h c2lkX3NldCAqc2V0LCBzdHJ1Y3QKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vdGlm aWVyX2Jsb2NrICpuYikKKworIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0 IGlvYXNpZF9zZXQgKnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVj dCBub3RpZmllcl9ibG9jayAqbmIpCisKKyBpbnQgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyX21t KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG5vdGlmaWVyX2Jsb2NrICpuYikKKworIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90 aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgbm90aWZpZXJfYmxvY2sgKm5iKQorCisgaW50IGlvYXNpZF9ub3Rp ZnkoaW9hc2lkX3QgaW9hc2lkLCBlbnVtIGlvYXNpZF9ub3RpZnlfdmFsIGNtZCwKKyAgICAgICAg ICAgICAgICAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpCisKKyJfbW0iIGZsYXZvciBvZiB0aGUgaW9h c2lkX3JlZ2lzdGVyX25vdGlmaWVyKCkgQVBJcyBhcmUgdXNlZCB3aGVuCithbiBJT0FTSUQgdXNl ciBuZWVkIHRvIGxpc3RlbiB0byB0aGUgSU9BU0lEIGV2ZW50cyBiZWxvbmcgdG8gYQorcHJvY2Vz cyBidXQgd2l0aG91dCB0aGUga25vd2xlZGdlIG9mIHRoZSBhc3NvY2lhdGVkIGlvYXNpZF9zZXQu Ci0tIAoyLjI1LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpo dHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ==