From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from esa4.mentor.iphmx.com (esa4.mentor.iphmx.com [68.232.137.252]) by sourceware.org (Postfix) with ESMTPS id 2867F385C405 for ; Tue, 13 Sep 2022 07:08:04 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 2867F385C405 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com X-IronPort-AV: E=Sophos;i="5.93,312,1654588800"; d="diff'?scan'208,217";a="82880800" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa4.mentor.iphmx.com with ESMTP; 12 Sep 2022 23:07:59 -0800 IronPort-SDR: nQfU9nKw1bggCyFjapfzdMkgj18P8zoJZTTdZPRl/HsoiANA9kObwUTdp5X+JgrYZcvG7R0++g 6fPvn4T9a9dYEg6Dmj5yoMbt+VcR178oCYlWmbYECOVGpHJzuFLu8K53U+9obmKqUezq0RLbdy dwGhL1zaf2xe13CLktcVYivo6QTknFDWk0V1jdGVxSI3yrUQOJQjQaMkHJKX/HmDuqyN3yDyuH /CvKSJBdhGxPLXrA6G5yhz6228OFrhR5evC4nyKxoA5tAay6k2QUMzhvLu1XjCdon4H6og0Lsd G58= Content-Type: multipart/mixed; boundary="------------31Sd0wZgRlLkpR6tZERA0Se7" Message-ID: <3f0fc49f-b07f-bee2-51a8-a5d03f1c33ed@codesourcery.com> Date: Tue, 13 Sep 2022 09:07:51 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.2.1 Subject: Re: [Patch] libgomp/nvptx: Prepare for reverse-offload callback handling Content-Language: en-US From: Tobias Burnus To: Jakub Jelinek , Tom de Vries , gcc-patches CC: Alexander Monakov References: <57b3ae5e-8f15-8bea-fa09-39bccbaa2414@codesourcery.com> In-Reply-To: <57b3ae5e-8f15-8bea-fa09-39bccbaa2414@codesourcery.com> X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-15.mgc.mentorg.com (139.181.222.15) To svr-ies-mbx-12.mgc.mentorg.com (139.181.222.12) X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00,GIT_PATCH_0,HEADER_FROM_DIFFERENT_DOMAINS,HTML_MESSAGE,KAM_DMARC_STATUS,KAM_SHORT,NICE_REPLY_A,SPF_HELO_PASS,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --------------31Sd0wZgRlLkpR6tZERA0Se7 Content-Type: multipart/alternative; boundary="------------dkVMQj13bfsZCWOkH37iHlrD" --------------dkVMQj13bfsZCWOkH37iHlrD Content-Type: text/plain; charset="utf-8"; format=flowed Content-Transfer-Encoding: quoted-printable @Alexander/@Tom =E2=80=93 Can you comment on both libgomp/config/nvptx + li= bgomp/plugin/plugin-nvptx.c ? (Comments on the rest are welcome, too) (Updated patch enclosed) Because Jakub asked: I'm afraid you need Alexander or Tom here, I don't feel I can review it; I could rubber stamp it if they are ok with it. Regarding: How did the standardization process for this feature look like, how did it = pass if it's not efficiently implementable for the major offloading targets? It doesn't have to be implementable on all major offloading targets, it is = enough when it can work on some. As one needs to request the reverse offloa= ding through a declarative directive, it is always possible in that case to= just pretend devices that don't support it don't exist. First, I think it is better to provide a feature even if it is slow =E2=80= =93 than not providing it at all. Secondly, as Jakub mentioned, it is not r= equired that all devices support this feature well. It is sufficient some d= o. I believe on of the main uses is debugging and for this use, the performanc= e is not critical. This patch attempts to have no overhead if the feature i= s not used (no 'omp requires reverse_offload' and no actual reverse offload= ). Additionally, for GCN, it can be implemented with almost no overhead by usi= ng the feature used for I/O. (CUDA implements 'printf' internally =E2=80=93= but does not permit to piggyback on this feature.) * * * I think in the future, we could additionally pass information to GOMP_targe= t_ext whether a target region is known not to do reverse offload =E2=80=93 = both by checking what's in the region and by utilizing an 'absent(target)' = assumption places in the outer target regsion on an '(begin) assume(s)' dir= ective. That should at least help with the common case of having no reverse= offload =E2=80=93 even if it does not for some large kernel which does use= reverse offload for non-debugging purpose (e.g. to trigger file I/O or int= er-node communication). * * * Regarding the implementation: I left in 'usleep(1)' for now =E2=80=93 1=C2= =B5s seems to be not too bad and I have no idea what's better. I also don't have any idea what's the overhead for accessing concurrently a= ccessible managed memory from the host (is it on the host until requested f= rom the device =E2=80=93 or is it always on the device and needs to be copi= ed/migrated to the host for every access). Likewise, I don't know how much = overhead it is to D2H copy the memory via the second CUDA stream. Suggestions are welcome. But as this code is strictly confined to a single = function, it can easily be modified later. Documentation: I have not mentioned caveats in https://gcc.gnu.org/onlinedo= cs/libgomp/nvptx.html as the reverse offload is not yet enabled, even with = this patch. On 26.08.22 11:07, Tobias Burnus wrote: PRE-REMARK As nvptx (and all other plugins) returns <=3D 0 for GOMP_OFFLOAD_get_num_devices if GOMP_REQUIRES_REVERSE_OFFLOAD is set. This patch is currently still a no op. The patch is almost stand alone, except that it either needs a void *rev_fn_table =3D NULL; in GOMP_OFFLOAD_load_image or the following patch: [Patch][2/3] nvptx: libgomp+mkoffload.cc: Prepare for reverse offload fn = lookup https://gcc.gnu.org/pipermail/gcc-patches/2022-August/600348.html (which in turn needs the '[1/3]' patch). Not required to be compilable, but the patch is based on the ideas/code from the reverse-offload ME patch; the latter adds calls to GOMP_target_ext (omp_initial_device, which is for host fallback code processed by the normal target_ext and for device code by the target_ext of this patch. =E2=86=92 "[Patch] OpenMP: Support reverse offload (middle end part)" https://gcc.gnu.org/pipermail/gcc-patches/2022-July/598662.html * * * This patch adds initial offloading support for nvptx. When the nvptx's device GOMP_target_ext is called - it creates a lock, fills a struct with the argument pointers (addr, kinds, sizes), its device number and the set the function pointer address. On the host side, the last address is checked - if fn_addr !=3D NULL, it passes all arguments on to the generic (target.c) gomp_target_rev to do the actual offloading. CUDA does lockup when trying to copy data from the currently running stream; hence, a new stream is generated to do the memory copying. Just having managed memory is not enough - it needs to be concurrently accessible - otherwise, it will segfault on the host when migrated to the device. OK for mainline? * * * Future work for nvptx: * Adjust 'sleep', possibly using different values with and without USM and to do shorter sleeps than usleep(1)? * Set a flag whether there is any offload function at all, avoiding to run the more expensive check if there is 'requires reverse_offload' without actual reverse-offloading functions present. (Recall that the '2/3' patch, mentioned above, only has fn !=3D NULL for reverse-offload functions.) * Document =E2=86=92 libgomp.texi that reverse offload may cause some perfo= rmance overhead for all target regions. + That reverse offload is run serialized. And obviously: submitting the missing bits to get reverse offload working, but that's mostly not an nvptx topic. ----------------- Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstra=C3=9Fe 201= , 80634 M=C3=BCnchen; Gesellschaft mit beschr=C3=A4nkter Haftung; Gesch=C3= =A4ftsf=C3=BChrer: Thomas Heurung, Frank Th=C3=BCrauf; Sitz der Gesellschaf= t: M=C3=BCnchen; Registergericht M=C3=BCnchen, HRB 106955 --------------dkVMQj13bfsZCWOkH37iHlrD-- --------------31Sd0wZgRlLkpR6tZERA0Se7 Content-Type: text/x-patch; charset="UTF-8"; name="rev-offload-run-nvptx-v2.diff" Content-Disposition: attachment; filename="rev-offload-run-nvptx-v2.diff" Content-Transfer-Encoding: base64 bGliZ29tcC9udnB0eDogUHJlcGFyZSBmb3IgcmV2ZXJzZS1vZmZsb2FkIGNh bGxiYWNrIGhhbmRsaW5nCgpUaGlzIHBhdGNoIGFkZHMgYSBzdHViICdnb21w X3RhcmdldF9yZXYnIGluIHRoZSBob3N0J3MgdGFyZ2V0LmMsIHdoaWNoIHdp bGwKbGF0ZXIgaGFuZGxlIHRoZSByZXZlcnNlIG9mZmxvYWQuCkZvciBudnB0 eCwgaXQgYWRkcyBzdXBwb3J0IGZvciBmb3J3YXJkaW5nIHRoZSBvZmZsb2Fk IGdvbXBfdGFyZ2V0X2V4dCBjYWxsCnRvIHRoZSBob3N0IGJ5IHNldHRpbmcg dmFsdWVzIGluIGEgc3RydWN0IG9uIHRoZSBkZXZpY2UgYW5kIHF1ZXJ5aW5n IGl0IG9uCnRoZSBob3N0IC0gaW52b2tpbmcgZ29tcF90YXJnZXRfcmV2IG9u IHRoZSByZXN1bHQuCgppbmNsdWRlL0NoYW5nZUxvZzoKCgkqIGN1ZGEvY3Vk YS5oIChlbnVtIENVZGV2aWNlX2F0dHJpYnV0ZSk6IEFkZAoJQ1VfREVWSUNF X0FUVFJJQlVURV9DT05DVVJSRU5UX01BTkFHRURfQUNDRVNTLgoJKGVudW0g Q1VtZW1BdHRhY2hfZmxhZ3MpOiBOZXcgc3R1YiB3aXRoIG9ubHkgbWVtYmVy CglDVV9NRU1fQVRUQUNIX0dMT0JBTC4KCShjdU1lbUFsbG9jTWFuYWdlZCk6 IEFkZCBwcm90b3R5cGUuCgpsaWJnb21wL0NoYW5nZUxvZzoKCgkqIGNvbmZp Zy9udnB0eC9pY3YtZGV2aWNlLmMgKEdPTVBfREVWSUNFX05VTV9WQVIpOiBS ZW1vdmUKCSdzdGF0aWMnIGZvciB0aGlzIHZhcmlhYmxlLgoJKiBjb25maWcv bnZwdHgvdGFyZ2V0LmMgKEdPTVBfUkVWX09GRkxPQURfVkFSKTogI2RlZmlu ZSBhcwoJdmFyaWFibGUtbmFtZSBzdHJpbmcgYW5kIHVzZSBpdCB0byBkZWZp bmUgdGhlIHZhcmlhYmxlLgoJKEdPTVBfREVWSUNFX05VTV9WQVIpOiBEZWNs YXJlIHRoaXMgZXh0ZXJuIGdsb2JhbCB2YXIuCgkoc3RydWN0IHJldl9vZmZs b2FkKTogRGVmaW5lLgoJKEdPTVBfdGFyZ2V0X2V4dCk6IEhhbmRsZSByZXZl cnNlIG9mZmxvYWQuCgkqIGxpYmdvbXAtcGx1Z2luLmggKEdPTVBfUExVR0lO X3RhcmdldF9yZXYpOiBOZXcgcHJvdG90eXBlLgoJKiBsaWJnb21wLXBsdWdp bi5jIChHT01QX1BMVUdJTl90YXJnZXRfcmV2KTogTmV3LCBjYWxsIC4uLgoJ KiB0YXJnZXQuYyAoZ29tcF90YXJnZXRfcmV2KTogLi4uIHRoaXMgbmV3IHN0 dWIgZnVuY3Rpb24uCgkqIGxpYmdvbXAuaCAoZ29tcF90YXJnZXRfcmV2KTog RGVjbGFyZS4KCSogbGliZ29tcC5tYXAgKEdPTVBfUExVR0lOXzEuNCk6IE5l dzsgYWRkIEdPTVBfUExVR0lOX3RhcmdldF9yZXYuCgkqIHBsdWdpbi9jdWRh LWxpYi5kZWYgKGN1TWVtQWxsb2NNYW5hZ2VkKTogQWRkLgoJKiBwbHVnaW4v cGx1Z2luLW52cHR4LmMgKEdPTVBfUkVWX09GRkxPQURfVkFSKTogI2RlZmlu ZSB2YXIgc3RyaW5nLgoJKHN0cnVjdCByZXZfb2ZmbG9hZCk6IE5ldy4KCShz dHJ1Y3QgcHR4X2RldmljZSk6IEFkZCBjb25jdXJyX21hbmFnZWRfYWNjZXNz LCByZXZfZGF0YQoJYW5kIHJldl9kYXRhX2Rldi4KCShudnB0eF9vcGVuX2Rl dmljZSk6IFNldCBwdHhfZGV2aWNlJ3MgY29uY3Vycl9tYW5hZ2VkX2FjY2Vz czsKCScjaWYgMCcgdW51c2VkIGFzeW5jX2VuZ2luZXMuCgkoR09NUF9PRkZM T0FEX2xvYWRfaW1hZ2UpOiBBbGxvY2F0ZSByZXZfZGF0YSB2YXJpYWJsZS4K CShyZXZfb2ZmX2Rldl90b19ob3N0X2NweSwgcmV2X29mZl9ob3N0X3RvX2Rl dl9jcHkpOiBOZXcuCgkoR09NUF9PRkZMT0FEX3J1bik6IEhhbmRsZSByZXZl cnNlIG9mZmxvYWRpbmcuCgogaW5jbHVkZS9jdWRhL2N1ZGEuaCAgICAgICAg ICAgICAgIHwgICA4ICsrLQogbGliZ29tcC9jb25maWcvbnZwdHgvaWN2LWRl dmljZS5jIHwgICAyICstCiBsaWJnb21wL2NvbmZpZy9udnB0eC90YXJnZXQu YyAgICAgfCAgNTIgKysrKysrKysrKysrLS0KIGxpYmdvbXAvbGliZ29tcC1w bHVnaW4uYyAgICAgICAgICB8ICAxMiArKysrCiBsaWJnb21wL2xpYmdvbXAt cGx1Z2luLmggICAgICAgICAgfCAgIDcgKysKIGxpYmdvbXAvbGliZ29tcC5o ICAgICAgICAgICAgICAgICB8ICAgNSArKwogbGliZ29tcC9saWJnb21wLm1h cCAgICAgICAgICAgICAgIHwgICA1ICsrCiBsaWJnb21wL3BsdWdpbi9jdWRh LWxpYi5kZWYgICAgICAgfCAgIDEgKwogbGliZ29tcC9wbHVnaW4vcGx1Z2lu LW52cHR4LmMgICAgIHwgMTQzICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKy0tCiBsaWJnb21wL3RhcmdldC5jICAgICAgICAgICAgICAg ICAgfCAgMTkgKysrKysKIDEwIGZpbGVzIGNoYW5nZWQsIDI0MSBpbnNlcnRp b25zKCspLCAxMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmNsdWRl L2N1ZGEvY3VkYS5oIGIvaW5jbHVkZS9jdWRhL2N1ZGEuaAppbmRleCAzOTM4 ZDA1Li4wOGU0OTZhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2N1ZGEvY3VkYS5o CisrKyBiL2luY2x1ZGUvY3VkYS9jdWRhLmgKQEAgLTc3LDkgKzc3LDE0IEBA IHR5cGVkZWYgZW51bSB7CiAgIENVX0RFVklDRV9BVFRSSUJVVEVfQ09OQ1VS UkVOVF9LRVJORUxTID0gMzEsCiAgIENVX0RFVklDRV9BVFRSSUJVVEVfTUFY X1RIUkVBRFNfUEVSX01VTFRJUFJPQ0VTU09SID0gMzksCiAgIENVX0RFVklD RV9BVFRSSUJVVEVfQVNZTkNfRU5HSU5FX0NPVU5UID0gNDAsCi0gIENVX0RF VklDRV9BVFRSSUJVVEVfTUFYX1JFR0lTVEVSU19QRVJfTVVMVElQUk9DRVNT T1IgPSA4MgorICBDVV9ERVZJQ0VfQVRUUklCVVRFX01BWF9SRUdJU1RFUlNf UEVSX01VTFRJUFJPQ0VTU09SID0gODIsCisgIENVX0RFVklDRV9BVFRSSUJV VEVfQ09OQ1VSUkVOVF9NQU5BR0VEX0FDQ0VTUyA9IDg5CiB9IENVZGV2aWNl X2F0dHJpYnV0ZTsKIAordHlwZWRlZiBlbnVtIHsKKyAgQ1VfTUVNX0FUVEFD SF9HTE9CQUwgPSAweDEKK30gQ1VtZW1BdHRhY2hfZmxhZ3M7CisKIGVudW0g ewogICBDVV9FVkVOVF9ERUZBVUxUID0gMCwKICAgQ1VfRVZFTlRfRElTQUJM RV9USU1JTkcgPSAyCkBAIC0xNjksNiArMTc0LDcgQEAgQ1VyZXN1bHQgY3VN ZW1HZXRJbmZvIChzaXplX3QgKiwgc2l6ZV90ICopOwogQ1VyZXN1bHQgY3VN ZW1BbGxvYyAoQ1VkZXZpY2VwdHIgKiwgc2l6ZV90KTsKICNkZWZpbmUgY3VN ZW1BbGxvY0hvc3QgY3VNZW1BbGxvY0hvc3RfdjIKIENVcmVzdWx0IGN1TWVt QWxsb2NIb3N0ICh2b2lkICoqLCBzaXplX3QpOworQ1VyZXN1bHQgY3VNZW1B bGxvY01hbmFnZWQgKENVZGV2aWNlcHRyICosIHNpemVfdCwgdW5zaWduZWQg aW50KTsKIENVcmVzdWx0IGN1TWVtY3B5IChDVWRldmljZXB0ciwgQ1VkZXZp Y2VwdHIsIHNpemVfdCk7CiAjZGVmaW5lIGN1TWVtY3B5RHRvREFzeW5jIGN1 TWVtY3B5RHRvREFzeW5jX3YyCiBDVXJlc3VsdCBjdU1lbWNweUR0b0RBc3lu YyAoQ1VkZXZpY2VwdHIsIENVZGV2aWNlcHRyLCBzaXplX3QsIENVc3RyZWFt KTsKZGlmZiAtLWdpdCBhL2xpYmdvbXAvY29uZmlnL252cHR4L2ljdi1kZXZp Y2UuYyBiL2xpYmdvbXAvY29uZmlnL252cHR4L2ljdi1kZXZpY2UuYwppbmRl eCA2Zjg2OWJlLi5lZWYxNTFjIDEwMDY0NAotLS0gYS9saWJnb21wL2NvbmZp Zy9udnB0eC9pY3YtZGV2aWNlLmMKKysrIGIvbGliZ29tcC9jb25maWcvbnZw dHgvaWN2LWRldmljZS5jCkBAIC0zMCw3ICszMCw3IEBACiAKIC8qIFRoaXMg aXMgc2V0IHRvIHRoZSBJQ1YgdmFsdWVzIG9mIGN1cnJlbnQgR1BVIGR1cmlu ZyBkZXZpY2UgaW5pdGlhbGl6YXRpb24sCiAgICB3aGVuIHRoZSBvZmZsb2Fk IGltYWdlIGNvbnRhaW5pbmcgdGhpcyBsaWJnb21wIHBvcnRpb24gaXMgbG9h ZGVkLiAgKi8KLXN0YXRpYyB2b2xhdGlsZSBzdHJ1Y3QgZ29tcF9vZmZsb2Fk X2ljdnMgR09NUF9BRERJVElPTkFMX0lDVlM7Cit2b2xhdGlsZSBzdHJ1Y3Qg Z29tcF9vZmZsb2FkX2ljdnMgR09NUF9BRERJVElPTkFMX0lDVlM7CiAKIHZv aWQKIG9tcF9zZXRfZGVmYXVsdF9kZXZpY2UgKGludCBkZXZpY2VfbnVtIF9f YXR0cmlidXRlX18oKHVudXNlZCkpKQpkaWZmIC0tZ2l0IGEvbGliZ29tcC9j b25maWcvbnZwdHgvdGFyZ2V0LmMgYi9saWJnb21wL2NvbmZpZy9udnB0eC90 YXJnZXQuYwppbmRleCAxMTEwOGQyLi4yYTNmZDhmIDEwMDY0NAotLS0gYS9s aWJnb21wL2NvbmZpZy9udnB0eC90YXJnZXQuYworKysgYi9saWJnb21wL2Nv bmZpZy9udnB0eC90YXJnZXQuYwpAQCAtMjYsNyArMjYsMjkgQEAKICNpbmNs dWRlICJsaWJnb21wLmgiCiAjaW5jbHVkZSA8bGltaXRzLmg+CiAKKyNkZWZp bmUgR09NUF9SRVZfT0ZGTE9BRF9WQVIgX19nb21wX3Jldl9vZmZsb2FkX3Zh cgorCisvKiBSZXZlcnNlIG9mZmxvYWQuIE11c3QgbWF0Y2ggdmVyc2lvbiB1 c2VkIGluIHBsdWdpbi9wbHVnaW4tbnZwdHguYy4gKi8KK3N0cnVjdCByZXZf b2ZmbG9hZCB7CisgIHVpbnQ2NF90IGZuOworICB1aW50NjRfdCBtYXBudW07 CisgIHVpbnQ2NF90IGFkZHJzOworICB1aW50NjRfdCBzaXplczsKKyAgdWlu dDY0X3Qga2luZHM7CisgIGludDMyX3QgZGV2X251bTsKKyAgdWludDMyX3Qg bG9jazsKK307CisKKyNpZiAoX19TSVpFT0ZfU0hPUlRfXyAhPSAyIFwKKyAg ICAgfHwgX19TSVpFT0ZfU0laRV9UX18gIT0gOCBcCisgICAgIHx8IF9fU0la RU9GX1BPSU5URVJfXyAhPSA4KQorI2Vycm9yICJEYXRhLXR5cGUgY29udmVy c2lvbiByZXF1aXJlZCBmb3IgcmV2X29mZmxvYWQiCisjZW5kaWYKKworCiBl eHRlcm4gaW50IF9fZ29tcF90ZWFtX251bSBfX2F0dHJpYnV0ZV9fKChzaGFy ZWQpKTsKK2V4dGVybiB2b2xhdGlsZSBzdHJ1Y3QgZ29tcF9vZmZsb2FkX2lj dnMgR09NUF9BRERJVElPTkFMX0lDVlM7Cit2b2xhdGlsZSBzdHJ1Y3QgcmV2 X29mZmxvYWQgKkdPTVBfUkVWX09GRkxPQURfVkFSOwogCiBib29sCiBHT01Q X3RlYW1zNCAodW5zaWduZWQgaW50IG51bV90ZWFtc19sb3dlciwgdW5zaWdu ZWQgaW50IG51bV90ZWFtc191cHBlciwKQEAgLTg4LDE2ICsxMTAsMzIgQEAg R09NUF90YXJnZXRfZXh0IChpbnQgZGV2aWNlLCB2b2lkICgqZm4pICh2b2lk ICopLCBzaXplX3QgbWFwbnVtLAogCQkgdm9pZCAqKmhvc3RhZGRycywgc2l6 ZV90ICpzaXplcywgdW5zaWduZWQgc2hvcnQgKmtpbmRzLAogCQkgdW5zaWdu ZWQgaW50IGZsYWdzLCB2b2lkICoqZGVwZW5kLCB2b2lkICoqYXJncykKIHsK LSAgKHZvaWQpIGRldmljZTsKLSAgKHZvaWQpIGZuOwotICAodm9pZCkgbWFw bnVtOwotICAodm9pZCkgaG9zdGFkZHJzOwotICAodm9pZCkgc2l6ZXM7Ci0g ICh2b2lkKSBraW5kczsKICAgKHZvaWQpIGZsYWdzOwogICAodm9pZCkgZGVw ZW5kOwogICAodm9pZCkgYXJnczsKLSAgX19idWlsdGluX3VucmVhY2hhYmxl ICgpOworCisgIGlmIChkZXZpY2UgIT0gR09NUF9ERVZJQ0VfSE9TVF9GQUxM QkFDSworICAgICAgfHwgZm4gPT0gTlVMTAorICAgICAgfHwgR09NUF9SRVZf T0ZGTE9BRF9WQVIgPT0gTlVMTCkKKyAgICByZXR1cm47CisKKyAgd2hpbGUg KF9fc3luY19sb2NrX3Rlc3RfYW5kX3NldCAoJkdPTVBfUkVWX09GRkxPQURf VkFSLT5sb2NrLCAodWludDhfdCkgMSkpCisgICAgOyAgLyogc3BpbiAgKi8K KworICBfX2F0b21pY19zdG9yZV9uICgmR09NUF9SRVZfT0ZGTE9BRF9WQVIt Pm1hcG51bSwgbWFwbnVtLCBfX0FUT01JQ19TRVFfQ1NUKTsKKyAgX19hdG9t aWNfc3RvcmVfbiAoJkdPTVBfUkVWX09GRkxPQURfVkFSLT5hZGRycywgaG9z dGFkZHJzLCBfX0FUT01JQ19TRVFfQ1NUKTsKKyAgX19hdG9taWNfc3RvcmVf biAoJkdPTVBfUkVWX09GRkxPQURfVkFSLT5zaXplcywgc2l6ZXMsIF9fQVRP TUlDX1NFUV9DU1QpOworICBfX2F0b21pY19zdG9yZV9uICgmR09NUF9SRVZf T0ZGTE9BRF9WQVItPmtpbmRzLCBraW5kcywgX19BVE9NSUNfU0VRX0NTVCk7 CisgIF9fYXRvbWljX3N0b3JlX24gKCZHT01QX1JFVl9PRkZMT0FEX1ZBUi0+ ZGV2X251bSwKKwkJICAgIEdPTVBfQURESVRJT05BTF9JQ1ZTLmRldmljZV9u dW0sIF9fQVRPTUlDX1NFUV9DU1QpOworCisgIC8qICdmbicgbXVzdCBiZSBs YXN0LiAgKi8KKyAgX19hdG9taWNfc3RvcmVfbiAoJkdPTVBfUkVWX09GRkxP QURfVkFSLT5mbiwgZm4sIF9fQVRPTUlDX1NFUV9DU1QpOworCisgIC8qIFBy b2Nlc3NlZCBvbiB0aGUgaG9zdCAtIHdoZW4gZG9uZSwgZm4gaXMgc2V0IHRv IE5VTEwuICAqLworICB3aGlsZSAoX19hdG9taWNfbG9hZF9uICgmR09NUF9S RVZfT0ZGTE9BRF9WQVItPmZuLCBfX0FUT01JQ19TRVFfQ1NUKSAhPSAwKQor ICAgIDsgIC8qIHNwaW4gICovCisgIF9fc3luY19sb2NrX3JlbGVhc2UgKCZH T01QX1JFVl9PRkZMT0FEX1ZBUi0+bG9jayk7CiB9CiAKIHZvaWQKZGlmZiAt LWdpdCBhL2xpYmdvbXAvbGliZ29tcC1wbHVnaW4uYyBiL2xpYmdvbXAvbGli Z29tcC1wbHVnaW4uYwppbmRleCA5ZDRjYzYyLi4zMTZkZTc0IDEwMDY0NAot LS0gYS9saWJnb21wL2xpYmdvbXAtcGx1Z2luLmMKKysrIGIvbGliZ29tcC9s aWJnb21wLXBsdWdpbi5jCkBAIC03OCwzICs3OCwxNSBAQCBHT01QX1BMVUdJ Tl9mYXRhbCAoY29uc3QgY2hhciAqbXNnLCAuLi4pCiAgIGdvbXBfdmZhdGFs IChtc2csIGFwKTsKICAgdmFfZW5kIChhcCk7CiB9CisKK3ZvaWQKK0dPTVBf UExVR0lOX3RhcmdldF9yZXYgKHVpbnQ2NF90IGZuX3B0ciwgdWludDY0X3Qg bWFwbnVtLCB1aW50NjRfdCBkZXZhZGRyc19wdHIsCisJCQl1aW50NjRfdCBz aXplc19wdHIsIHVpbnQ2NF90IGtpbmRzX3B0ciwgaW50IGRldl9udW0sCisJ CQl2b2lkICgqZGV2X3RvX2hvc3RfY3B5KSAodm9pZCAqLCBjb25zdCB2b2lk ICosIHNpemVfdCwKKwkJCQkJCSB2b2lkICopLAorCQkJdm9pZCAoKmhvc3Rf dG9fZGV2X2NweSkgKHZvaWQgKiwgY29uc3Qgdm9pZCAqLCBzaXplX3QsCisJ CQkJCQkgdm9pZCAqKSwgdm9pZCAqdG9rZW4pCit7CisgIGdvbXBfdGFyZ2V0 X3JldiAoZm5fcHRyLCBtYXBudW0sIGRldmFkZHJzX3B0ciwgc2l6ZXNfcHRy LCBraW5kc19wdHIsIGRldl9udW0sCisJCSAgIGRldl90b19ob3N0X2NweSwg aG9zdF90b19kZXZfY3B5LCB0b2tlbik7Cit9CmRpZmYgLS1naXQgYS9saWJn b21wL2xpYmdvbXAtcGx1Z2luLmggYi9saWJnb21wL2xpYmdvbXAtcGx1Z2lu LmgKaW5kZXggNmFiNWFjNi4uODc1Zjk2NyAxMDA2NDQKLS0tIGEvbGliZ29t cC9saWJnb21wLXBsdWdpbi5oCisrKyBiL2xpYmdvbXAvbGliZ29tcC1wbHVn aW4uaApAQCAtMTIxLDYgKzEyMSwxMyBAQCBleHRlcm4gdm9pZCBHT01QX1BM VUdJTl9lcnJvciAoY29uc3QgY2hhciAqLCAuLi4pCiBleHRlcm4gdm9pZCBH T01QX1BMVUdJTl9mYXRhbCAoY29uc3QgY2hhciAqLCAuLi4pCiAJX19hdHRy aWJ1dGVfXyAoKG5vcmV0dXJuLCBmb3JtYXQgKHByaW50ZiwgMSwgMikpKTsK IAorZXh0ZXJuIHZvaWQgR09NUF9QTFVHSU5fdGFyZ2V0X3JldiAodWludDY0 X3QsIHVpbnQ2NF90LCB1aW50NjRfdCwgdWludDY0X3QsCisJCQkJICAgIHVp bnQ2NF90LCBpbnQsCisJCQkJICAgIHZvaWQgKCopICh2b2lkICosIGNvbnN0 IHZvaWQgKiwgc2l6ZV90LAorCQkJCQkgICAgICB2b2lkICopLAorCQkJCSAg ICB2b2lkICgqKSAodm9pZCAqLCBjb25zdCB2b2lkICosIHNpemVfdCwKKwkJ CQkJICAgICAgdm9pZCAqKSwgdm9pZCAqKTsKKwogLyogUHJvdG90eXBlcyBm b3IgZnVuY3Rpb25zIGltcGxlbWVudGVkIGJ5IGxpYmdvbXAgcGx1Z2lucy4g ICovCiBleHRlcm4gY29uc3QgY2hhciAqR09NUF9PRkZMT0FEX2dldF9uYW1l ICh2b2lkKTsKIGV4dGVybiB1bnNpZ25lZCBpbnQgR09NUF9PRkZMT0FEX2dl dF9jYXBzICh2b2lkKTsKZGlmZiAtLWdpdCBhL2xpYmdvbXAvbGliZ29tcC5o IGIvbGliZ29tcC9saWJnb21wLmgKaW5kZXggNzUxOTI3NC4uNTgwMzY4MyAx MDA2NDQKLS0tIGEvbGliZ29tcC9saWJnb21wLmgKKysrIGIvbGliZ29tcC9s aWJnb21wLmgKQEAgLTExMjgsNiArMTEyOCwxMSBAQCBleHRlcm4gaW50IGdv bXBfcGF1c2VfaG9zdCAodm9pZCk7CiBleHRlcm4gdm9pZCBnb21wX2luaXRf dGFyZ2V0c19vbmNlICh2b2lkKTsKIGV4dGVybiBpbnQgZ29tcF9nZXRfbnVt X2RldmljZXMgKHZvaWQpOwogZXh0ZXJuIGJvb2wgZ29tcF90YXJnZXRfdGFz a19mbiAodm9pZCAqKTsKK2V4dGVybiB2b2lkIGdvbXBfdGFyZ2V0X3JldiAo dWludDY0X3QsIHVpbnQ2NF90LCB1aW50NjRfdCwgdWludDY0X3QsIHVpbnQ2 NF90LAorCQkJICAgICBpbnQsCisJCQkgICAgIHZvaWQgKCopICh2b2lkICos IGNvbnN0IHZvaWQgKiwgc2l6ZV90LCB2b2lkICopLAorCQkJICAgICB2b2lk ICgqKSAodm9pZCAqLCBjb25zdCB2b2lkICosIHNpemVfdCwgdm9pZCAqKSwK KwkJCSAgICAgdm9pZCAqKTsKIAogLyogU3BsYXkgdHJlZSBkZWZpbml0aW9u cy4gICovCiB0eXBlZGVmIHN0cnVjdCBzcGxheV90cmVlX25vZGVfcyAqc3Bs YXlfdHJlZV9ub2RlOwpkaWZmIC0tZ2l0IGEvbGliZ29tcC9saWJnb21wLm1h cCBiL2xpYmdvbXAvbGliZ29tcC5tYXAKaW5kZXggNDZkNWYxMC4uMTJmNzZm NyAxMDA2NDQKLS0tIGEvbGliZ29tcC9saWJnb21wLm1hcAorKysgYi9saWJn b21wL2xpYmdvbXAubWFwCkBAIC02MjIsMyArNjIyLDggQEAgR09NUF9QTFVH SU5fMS4zIHsKIAlHT01QX1BMVUdJTl9nb2FjY19wcm9maWxpbmdfZGlzcGF0 Y2g7CiAJR09NUF9QTFVHSU5fZ29hY2NfdGhyZWFkOwogfSBHT01QX1BMVUdJ Tl8xLjI7CisKK0dPTVBfUExVR0lOXzEuNCB7CisgIGdsb2JhbDoKKwlHT01Q X1BMVUdJTl90YXJnZXRfcmV2OworfSBHT01QX1BMVUdJTl8xLjM7CmRpZmYg LS1naXQgYS9saWJnb21wL3BsdWdpbi9jdWRhLWxpYi5kZWYgYi9saWJnb21w L3BsdWdpbi9jdWRhLWxpYi5kZWYKaW5kZXggY2Q5MWIzOS4uNjEzNTljNyAx MDA2NDQKLS0tIGEvbGliZ29tcC9wbHVnaW4vY3VkYS1saWIuZGVmCisrKyBi L2xpYmdvbXAvcGx1Z2luL2N1ZGEtbGliLmRlZgpAQCAtMjksNiArMjksNyBA QCBDVURBX09ORV9DQUxMX01BWUJFX05VTEwgKGN1TGlua0NyZWF0ZV92MikK IENVREFfT05FX0NBTEwgKGN1TGlua0Rlc3Ryb3kpCiBDVURBX09ORV9DQUxM IChjdU1lbUFsbG9jKQogQ1VEQV9PTkVfQ0FMTCAoY3VNZW1BbGxvY0hvc3Qp CitDVURBX09ORV9DQUxMIChjdU1lbUFsbG9jTWFuYWdlZCkKIENVREFfT05F X0NBTEwgKGN1TWVtY3B5KQogQ1VEQV9PTkVfQ0FMTCAoY3VNZW1jcHlEdG9E QXN5bmMpCiBDVURBX09ORV9DQUxMIChjdU1lbWNweUR0b0gpCmRpZmYgLS1n aXQgYS9saWJnb21wL3BsdWdpbi9wbHVnaW4tbnZwdHguYyBiL2xpYmdvbXAv cGx1Z2luL3BsdWdpbi1udnB0eC5jCmluZGV4IGJhNmIyMjkuLjFiZDllZTIg MTAwNjQ0Ci0tLSBhL2xpYmdvbXAvcGx1Z2luL3BsdWdpbi1udnB0eC5jCisr KyBiL2xpYmdvbXAvcGx1Z2luL3BsdWdpbi1udnB0eC5jCkBAIC01NCw2ICs1 NCw4IEBACiAjaW5jbHVkZSA8YXNzZXJ0Lmg+CiAjaW5jbHVkZSA8ZXJybm8u aD4KIAorI2RlZmluZSBHT01QX1JFVl9PRkZMT0FEX1ZBUiBfX2dvbXBfcmV2 X29mZmxvYWRfdmFyCisKIC8qIEFuIGFyYml0cmFyeSBmaXhlZCBsaW1pdCAo MTI4TUIpIGZvciB0aGUgc2l6ZSBvZiB0aGUgT3Blbk1QIHNvZnQgc3RhY2tz CiAgICBibG9jayB0byBjYWNoZSBiZXR3ZWVuIGtlcm5lbCBpbnZvY2F0aW9u cy4gIEZvciBzb2Z0LXN0YWNrcyBibG9ja3MgYmlnZ2VyCiAgICB0aGFuIHRo aXMsIHdlIHdpbGwgZnJlZSB0aGUgYmxvY2sgYmVmb3JlIGF0dGVtcHRpbmcg YW5vdGhlciBHUFUgbWVtb3J5CkBAIC0yNzQsNiArMjc2LDE3IEBAIHN0cnVj dCB0YXJnX2ZuX2Rlc2NyaXB0b3IKICAgaW50IG1heF90aHJlYWRzX3Blcl9i bG9jazsKIH07CiAKKy8qIFJldmVyc2Ugb2ZmbG9hZC4gTXVzdCBtYXRjaCB2 ZXJzaW9uIHVzZWQgaW4gY29uZmlnL252cHR4L3RhcmdldC5jLiAqLworc3Ry dWN0IHJldl9vZmZsb2FkIHsKKyAgdWludDY0X3QgZm47CisgIHVpbnQ2NF90 IG1hcG51bTsKKyAgdWludDY0X3QgYWRkcnM7CisgIHVpbnQ2NF90IHNpemVz OworICB1aW50NjRfdCBraW5kczsKKyAgaW50MzJfdCBkZXZfbnVtOworICB1 aW50MzJfdCBsb2NrOworfTsKKwogLyogQSBsb2FkZWQgUFRYIGltYWdlLiAg Ki8KIHN0cnVjdCBwdHhfaW1hZ2VfZGF0YQogewpAQCAtMzAyLDYgKzMxNSw3 IEBAIHN0cnVjdCBwdHhfZGV2aWNlCiAgIGJvb2wgbWFwOwogICBib29sIGNv bmN1cjsKICAgYm9vbCBta2VybjsKKyAgYm9vbCBjb25jdXJyX21hbmFnZWRf YWNjZXNzOwogICBpbnQgbW9kZTsKICAgaW50IGNsb2NrX2toejsKICAgaW50 IG51bV9zbXM7CkBAIC0zMjksNiArMzQzLDkgQEAgc3RydWN0IHB0eF9kZXZp Y2UKICAgICAgIHB0aHJlYWRfbXV0ZXhfdCBsb2NrOwogICAgIH0gb21wX3N0 YWNrczsKIAorICBzdHJ1Y3QgcmV2X29mZmxvYWQgKnJldl9kYXRhOworICBD VWRldmljZXB0ciByZXZfZGF0YV9kZXY7CisKICAgc3RydWN0IHB0eF9kZXZp Y2UgKm5leHQ7CiB9OwogCkBAIC00MjMsNyArNDQwLDcgQEAgbnZwdHhfb3Bl bl9kZXZpY2UgKGludCBuKQogICBzdHJ1Y3QgcHR4X2RldmljZSAqcHR4X2Rl djsKICAgQ1VkZXZpY2UgZGV2LCBjdHhfZGV2OwogICBDVXJlc3VsdCByOwot ICBpbnQgYXN5bmNfZW5naW5lcywgcGk7CisgIGludCBwaTsKIAogICBDVURB X0NBTExfRVJFVCAoTlVMTCwgY3VEZXZpY2VHZXQsICZkZXYsIG4pOwogCkBA IC01MTksMTEgKzUzNiwxNyBAQCBudnB0eF9vcGVuX2RldmljZSAoaW50IG4p CiAJCSAgQ1VfREVWSUNFX0FUVFJJQlVURV9NQVhfVEhSRUFEU19QRVJfTVVM VElQUk9DRVNTT1IsIGRldik7CiAgIHB0eF9kZXYtPm1heF90aHJlYWRzX3Bl cl9tdWx0aXByb2Nlc3NvciA9IHBpOwogCisjaWYgMAorICBpbnQgYXN5bmNf ZW5naW5lczsKICAgciA9IENVREFfQ0FMTF9OT0NIRUNLIChjdURldmljZUdl dEF0dHJpYnV0ZSwgJmFzeW5jX2VuZ2luZXMsCiAJCQkgQ1VfREVWSUNFX0FU VFJJQlVURV9BU1lOQ19FTkdJTkVfQ09VTlQsIGRldik7CiAgIGlmIChyICE9 IENVREFfU1VDQ0VTUykKICAgICBhc3luY19lbmdpbmVzID0gMTsKKyNlbmRp ZgogCisgIHIgPSBDVURBX0NBTExfTk9DSEVDSyAoY3VEZXZpY2VHZXRBdHRy aWJ1dGUsICZwaSwKKwkJCSBDVV9ERVZJQ0VfQVRUUklCVVRFX0NPTkNVUlJF TlRfTUFOQUdFRF9BQ0NFU1MsIGRldik7CisgIHB0eF9kZXYtPmNvbmN1cnJf bWFuYWdlZF9hY2Nlc3MgPSByID09IENVREFfU1VDQ0VTUyA/IHBpIDogZmFs c2U7CiAgIGZvciAoaW50IGkgPSAwOyBpICE9IEdPTVBfRElNX01BWDsgaSsr KQogICAgIHB0eF9kZXYtPmRlZmF1bHRfZGltc1tpXSA9IDA7CiAKQEAgLTEz ODAsNyArMTQwMyw3IEBAIEdPTVBfT0ZGTE9BRF9sb2FkX2ltYWdlIChpbnQg b3JkLCB1bnNpZ25lZCB2ZXJzaW9uLCBjb25zdCB2b2lkICp0YXJnZXRfZGF0 YSwKICAgZWxzZSBpZiAocmV2X2ZuX3RhYmxlKQogICAgIHsKICAgICAgIENV ZGV2aWNlcHRyIHZhcjsKLSAgICAgIHNpemVfdCBieXRlczsKKyAgICAgIHNp emVfdCBieXRlcywgaTsKICAgICAgIHIgPSBDVURBX0NBTExfTk9DSEVDSyAo Y3VNb2R1bGVHZXRHbG9iYWwsICZ2YXIsICZieXRlcywgbW9kdWxlLAogCQkJ ICAgICAiJG9mZmxvYWRfZnVuY190YWJsZSIpOwogICAgICAgaWYgKHIgIT0g Q1VEQV9TVUNDRVNTKQpAQCAtMTM5MCw2ICsxNDEzLDQ3IEBAIEdPTVBfT0ZG TE9BRF9sb2FkX2ltYWdlIChpbnQgb3JkLCB1bnNpZ25lZCB2ZXJzaW9uLCBj b25zdCB2b2lkICp0YXJnZXRfZGF0YSwKICAgICAgIHIgPSBDVURBX0NBTExf Tk9DSEVDSyAoY3VNZW1jcHlEdG9ILCAqcmV2X2ZuX3RhYmxlLCB2YXIsIGJ5 dGVzKTsKICAgICAgIGlmIChyICE9IENVREFfU1VDQ0VTUykKIAlHT01QX1BM VUdJTl9mYXRhbCAoImN1TWVtY3B5RHRvSCBlcnJvcjogJXMiLCBjdWRhX2Vy cm9yIChyKSk7CisgICAgICAvKiBGcmVlIGlmIG9ubHkgTlVMTCBlbnRyaWVz LiAgKi8KKyAgICAgIGZvciAoaSA9IDA7IGkgPCBmbl9lbnRyaWVzOyArK2kp CisJaWYgKHJldl9mbl90YWJsZVtpXSAhPSAwKQorCSAgYnJlYWs7CisgICAg ICBpZiAoaSA9PSBmbl9lbnRyaWVzKQorCXsKKwkgIGZyZWUgKCpyZXZfZm5f dGFibGUpOworCSAgKnJldl9mbl90YWJsZSA9IE5VTEw7CisJfQorICAgIH0K KworICBpZiAocmV2X2ZuX3RhYmxlICYmIGRldi0+cmV2X2RhdGEgPT0gTlVM TCkKKyAgICB7CisgICAgICBDVWRldmljZXB0ciBkcCA9IDA7CisgICAgICBp ZiAoZGV2LT5jb25jdXJyX21hbmFnZWRfYWNjZXNzICYmIENVREFfQ0FMTF9F WElTVFMgKGN1TWVtQWxsb2NNYW5hZ2VkKSkKKwl7CisJICBDVURBX0NBTExf QVNTRVJUIChjdU1lbUFsbG9jTWFuYWdlZCwgKHZvaWQgKikgJmRldi0+cmV2 X2RhdGEsCisJCQkgICAgc2l6ZW9mICgqZGV2LT5yZXZfZGF0YSksIENVX01F TV9BVFRBQ0hfR0xPQkFMKTsKKwkgIGRwID0gKENVZGV2aWNlcHRyKSBkZXYt PnJldl9kYXRhOworCX0KKyAgICAgIGVsc2UKKwl7CisJICBDVURBX0NBTExf QVNTRVJUIChjdU1lbUFsbG9jSG9zdCwgKHZvaWQgKiopICZkZXYtPnJldl9k YXRhLAorCQkJICAgIHNpemVvZiAoKmRldi0+cmV2X2RhdGEpKTsKKwkgIG1l bXNldCAoZGV2LT5yZXZfZGF0YSwgJ1wwJywgc2l6ZW9mICgqZGV2LT5yZXZf ZGF0YSkpOworCSAgQ1VEQV9DQUxMX0FTU0VSVCAoY3VNZW1BbGxvYywgJmRl di0+cmV2X2RhdGFfZGV2LAorCQkJICAgIHNpemVvZiAoKmRldi0+cmV2X2Rh dGEpKTsKKwkgIGRwID0gZGV2LT5yZXZfZGF0YV9kZXY7CisJfQorICAgICAg Q1VkZXZpY2VwdHIgZGV2aWNlX3Jldl9vZmZsb2FkX3ZhcjsKKyAgICAgIHNp emVfdCBkZXZpY2VfcmV2X29mZmxvYWRfc2l6ZTsKKyAgICAgIENVcmVzdWx0 IHIgPSBDVURBX0NBTExfTk9DSEVDSyAoY3VNb2R1bGVHZXRHbG9iYWwsCisJ CQkJICAgICAgJmRldmljZV9yZXZfb2ZmbG9hZF92YXIsCisJCQkJICAgICAg JmRldmljZV9yZXZfb2ZmbG9hZF9zaXplLCBtb2R1bGUsCisJCQkJICAgICAg WFNUUklORyAoR09NUF9SRVZfT0ZGTE9BRF9WQVIpKTsKKyAgICAgIGlmIChy ICE9IENVREFfU1VDQ0VTUykKKwlHT01QX1BMVUdJTl9mYXRhbCAoImN1TW9k dWxlR2V0R2xvYmFsIGVycm9yOiAlcyIsIGN1ZGFfZXJyb3IgKHIpKTsKKyAg ICAgIHIgPSBDVURBX0NBTExfTk9DSEVDSyAoY3VNZW1jcHlIdG9ELCBkZXZp Y2VfcmV2X29mZmxvYWRfdmFyLCAmZHAsCisJCQkgICAgIHNpemVvZiAoZHAp KTsKKyAgICAgIGlmIChyICE9IENVREFfU1VDQ0VTUykKKwlHT01QX1BMVUdJ Tl9mYXRhbCAoImN1TWVtY3B5SHRvRCBlcnJvcjogJXMiLCBjdWRhX2Vycm9y IChyKSk7CiAgICAgfQogCiAgIG52cHR4X3NldF9jbG9ja3RpY2sgKG1vZHVs ZSwgZGV2KTsKQEAgLTIwMDEsNiArMjA2NSwyMyBAQCBudnB0eF9zdGFja3Nf YWNxdWlyZSAoc3RydWN0IHB0eF9kZXZpY2UgKnB0eF9kZXYsIHNpemVfdCBz aXplLCBpbnQgbnVtKQogICByZXR1cm4gKHZvaWQgKikgcHR4X2Rldi0+b21w X3N0YWNrcy5wdHI7CiB9CiAKKwordm9pZAorcmV2X29mZl9kZXZfdG9faG9z dF9jcHkgKHZvaWQgKmRlc3QsIGNvbnN0IHZvaWQgKnNyYywgc2l6ZV90IHNp emUsCisJCQkgQ1VzdHJlYW0gc3RyZWFtKQoreworICBDVURBX0NBTExfQVNT RVJUIChjdU1lbWNweUR0b0hBc3luYywgZGVzdCwgKENVZGV2aWNlcHRyKSBz cmMsIHNpemUsIHN0cmVhbSk7CisgIENVREFfQ0FMTF9BU1NFUlQgKGN1U3Ry ZWFtU3luY2hyb25pemUsIHN0cmVhbSk7Cit9CisKK3ZvaWQKK3Jldl9vZmZf aG9zdF90b19kZXZfY3B5ICh2b2lkICpkZXN0LCBjb25zdCB2b2lkICpzcmMs IHNpemVfdCBzaXplLAorCQkJIENVc3RyZWFtIHN0cmVhbSkKK3sKKyAgQ1VE QV9DQUxMX0FTU0VSVCAoY3VNZW1jcHlIdG9EQXN5bmMsIChDVWRldmljZXB0 cikgZGVzdCwgc3JjLCBzaXplLCBzdHJlYW0pOworICBDVURBX0NBTExfQVNT RVJUIChjdVN0cmVhbVN5bmNocm9uaXplLCBzdHJlYW0pOworfQorCiB2b2lk CiBHT01QX09GRkxPQURfcnVuIChpbnQgb3JkLCB2b2lkICp0Z3RfZm4sIHZv aWQgKnRndF92YXJzLCB2b2lkICoqYXJncykKIHsKQEAgLTIwMzUsNiArMjEx NiwxMCBAQCBHT01QX09GRkxPQURfcnVuIChpbnQgb3JkLCB2b2lkICp0Z3Rf Zm4sIHZvaWQgKnRndF92YXJzLCB2b2lkICoqYXJncykKICAgbnZwdHhfYWRq dXN0X2xhdW5jaF9ib3VuZHMgKHRndF9mbiwgcHR4X2RldiwgJnRlYW1zLCAm dGhyZWFkcyk7CiAKICAgc2l6ZV90IHN0YWNrX3NpemUgPSBudnB0eF9zdGFj a3Nfc2l6ZSAoKTsKKyAgYm9vbCByZXZlcnNlX29mZiA9IHB0eF9kZXYtPnJl dl9kYXRhICE9IE5VTEw7CisgIGJvb2wgaGFzX3VzbSA9IChwdHhfZGV2LT5j b25jdXJyX21hbmFnZWRfYWNjZXNzCisJCSAgJiYgQ1VEQV9DQUxMX0VYSVNU UyAoY3VNZW1BbGxvY01hbmFnZWQpKTsKKyAgQ1VzdHJlYW0gY29weV9zdHJl YW0gPSBOVUxMOwogCiAgIHB0aHJlYWRfbXV0ZXhfbG9jayAoJnB0eF9kZXYt Pm9tcF9zdGFja3MubG9jayk7CiAgIHZvaWQgKnN0YWNrcyA9IG52cHR4X3N0 YWNrc19hY3F1aXJlIChwdHhfZGV2LCBzdGFja19zaXplLCB0ZWFtcyAqIHRo cmVhZHMpOwpAQCAtMjA0OCwxMiArMjEzMyw2MiBAQCBHT01QX09GRkxPQURf cnVuIChpbnQgb3JkLCB2b2lkICp0Z3RfZm4sIHZvaWQgKnRndF92YXJzLCB2 b2lkICoqYXJncykKICAgR09NUF9QTFVHSU5fZGVidWcgKDAsICIgICVzOiBr ZXJuZWwgJXM6IGxhdW5jaCIKIAkJICAgICAiIFsodGVhbXM6ICV1KSwgMSwg MV0gWyhsYW5lczogMzIpLCAodGhyZWFkczogJXUpLCAxXVxuIiwKIAkJICAg ICBfX0ZVTkNUSU9OX18sIGZuX25hbWUsIHRlYW1zLCB0aHJlYWRzKTsKKyAg aWYgKHJldmVyc2Vfb2ZmKQorICAgIENVREFfQ0FMTF9BU1NFUlQgKGN1U3Ry ZWFtQ3JlYXRlLCAmY29weV9zdHJlYW0sIENVX1NUUkVBTV9OT05fQkxPQ0tJ TkcpOwogICByID0gQ1VEQV9DQUxMX05PQ0hFQ0sgKGN1TGF1bmNoS2VybmVs LCBmdW5jdGlvbiwgdGVhbXMsIDEsIDEsCiAJCQkgMzIsIHRocmVhZHMsIDEs IDAsIE5VTEwsIE5VTEwsIGNvbmZpZyk7CiAgIGlmIChyICE9IENVREFfU1VD Q0VTUykKICAgICBHT01QX1BMVUdJTl9mYXRhbCAoImN1TGF1bmNoS2VybmVs IGVycm9yOiAlcyIsIGN1ZGFfZXJyb3IgKHIpKTsKLQotICByID0gQ1VEQV9D QUxMX05PQ0hFQ0sgKGN1Q3R4U3luY2hyb25pemUsICk7CisgIGlmIChyZXZl cnNlX29mZikKKyAgICB3aGlsZSAodHJ1ZSkKKyAgICAgIHsKKwlyID0gQ1VE QV9DQUxMX05PQ0hFQ0sgKGN1U3RyZWFtUXVlcnksIE5VTEwpOworCWlmIChy ID09IENVREFfU1VDQ0VTUykKKwkgIGJyZWFrOworCWlmIChyID09IENVREFf RVJST1JfTEFVTkNIX0ZBSUxFRCkKKwkgIEdPTVBfUExVR0lOX2ZhdGFsICgi Y3VTdHJlYW1RdWVyeSBlcnJvcjogJXMgJXNcbiIsIGN1ZGFfZXJyb3IgKHIp LAorCQkJICAgICBtYXliZV9hYm9ydF9tc2cpOworCWVsc2UgaWYgKHIgIT0g Q1VEQV9FUlJPUl9OT1RfUkVBRFkpCisJICBHT01QX1BMVUdJTl9mYXRhbCAo ImN1U3RyZWFtUXVlcnkgZXJyb3I6ICVzIiwgY3VkYV9lcnJvciAocikpOwor CWlmICghaGFzX3VzbSkKKwkgIHsKKwkgICAgQ1VEQV9DQUxMX0FTU0VSVCAo Y3VNZW1jcHlEdG9IQXN5bmMsIHB0eF9kZXYtPnJldl9kYXRhLAorCQkJICAg ICAgcHR4X2Rldi0+cmV2X2RhdGFfZGV2LAorCQkJICAgICAgc2l6ZW9mICgq cHR4X2Rldi0+cmV2X2RhdGEpLCBjb3B5X3N0cmVhbSk7CisJICAgIENVREFf Q0FMTF9BU1NFUlQgKGN1U3RyZWFtU3luY2hyb25pemUsIGNvcHlfc3RyZWFt KTsKKwkgIH0KKwlpZiAocHR4X2Rldi0+cmV2X2RhdGEtPmZuICE9IDApCisJ ICB7CisJICAgIHN0cnVjdCByZXZfb2ZmbG9hZCAqcmV2X2RhdGEgPSBwdHhf ZGV2LT5yZXZfZGF0YTsKKwkgICAgdWludDY0X3QgZm5fcHRyID0gcmV2X2Rh dGEtPmZuOworCSAgICB1aW50NjRfdCBtYXBudW0gPSByZXZfZGF0YS0+bWFw bnVtOworCSAgICB1aW50NjRfdCBhZGRyX3B0ciA9IHJldl9kYXRhLT5hZGRy czsKKwkgICAgdWludDY0X3Qgc2l6ZXNfcHRyID0gcmV2X2RhdGEtPnNpemVz OworCSAgICB1aW50NjRfdCBraW5kc19wdHIgPSByZXZfZGF0YS0+a2luZHM7 CisJICAgIGludCBkZXZfbnVtID0gKGludCkgcmV2X2RhdGEtPmRldl9udW07 CisJICAgIEdPTVBfUExVR0lOX3RhcmdldF9yZXYgKGZuX3B0ciwgbWFwbnVt LCBhZGRyX3B0ciwgc2l6ZXNfcHRyLAorCQkJCSAgICBraW5kc19wdHIsIGRl dl9udW0sIHJldl9vZmZfZGV2X3RvX2hvc3RfY3B5LAorCQkJCSAgICByZXZf b2ZmX2hvc3RfdG9fZGV2X2NweSwgY29weV9zdHJlYW0pOworCSAgICByZXZf ZGF0YS0+Zm4gPSAwOworCSAgICBpZiAoIWhhc191c20pCisJICAgICAgewor CQkvKiBmbiBpcyB0aGUgZmlyc3QgZWxlbWVudC4gKi8KKwkJciA9IENVREFf Q0FMTF9OT0NIRUNLIChjdU1lbWNweUh0b0RBc3luYywKKwkJCQkgICAgICAg cHR4X2Rldi0+cmV2X2RhdGFfZGV2LAorCQkJCSAgICAgICBwdHhfZGV2LT5y ZXZfZGF0YSwKKwkJCQkgICAgICAgc2l6ZW9mIChwdHhfZGV2LT5yZXZfZGF0 YS0+Zm4pLAorCQkJCSAgICAgICBjb3B5X3N0cmVhbSk7CisJCWlmIChyICE9 IENVREFfU1VDQ0VTUykKKwkJICBHT01QX1BMVUdJTl9mYXRhbCAoImN1TWVt Y3B5SHRvRCBlcnJvcjogJXMiLCBjdWRhX2Vycm9yIChyKSk7CisJCUNVREFf Q0FMTF9BU1NFUlQgKGN1U3RyZWFtU3luY2hyb25pemUsIGNvcHlfc3RyZWFt KTsKKwkgICAgICB9CisJICB9CisJdXNsZWVwICgxKTsKKyAgICAgIH0KKyAg ZWxzZQorICAgIHIgPSBDVURBX0NBTExfTk9DSEVDSyAoY3VDdHhTeW5jaHJv bml6ZSwgKTsKKyAgaWYgKHJldmVyc2Vfb2ZmKQorICAgIENVREFfQ0FMTF9B U1NFUlQgKGN1U3RyZWFtRGVzdHJveSwgY29weV9zdHJlYW0pOwogICBpZiAo ciA9PSBDVURBX0VSUk9SX0xBVU5DSF9GQUlMRUQpCiAgICAgR09NUF9QTFVH SU5fZmF0YWwgKCJjdUN0eFN5bmNocm9uaXplIGVycm9yOiAlcyAlc1xuIiwg Y3VkYV9lcnJvciAociksCiAJCSAgICAgICBtYXliZV9hYm9ydF9tc2cpOwpk aWZmIC0tZ2l0IGEvbGliZ29tcC90YXJnZXQuYyBiL2xpYmdvbXAvdGFyZ2V0 LmMKaW5kZXggNTc2MzQ4My4uOTM3N2RlMCAxMDA2NDQKLS0tIGEvbGliZ29t cC90YXJnZXQuYworKysgYi9saWJnb21wL3RhcmdldC5jCkBAIC0yOTI1LDYg KzI5MjUsMjUgQEAgR09NUF90YXJnZXRfZXh0IChpbnQgZGV2aWNlLCB2b2lk ICgqZm4pICh2b2lkICopLCBzaXplX3QgbWFwbnVtLAogICAgIGh0YWJfZnJl ZSAocmVmY291bnRfc2V0KTsKIH0KIAorLyogSGFuZGxlIHJldmVyc2Ugb2Zm bG9hZC4gVGhpcyBpcyBjYWxsZWQgYnkgdGhlIGRldmljZSBwbHVnaW5zIGZv ciBhCisgICByZXZlcnNlIG9mZmxvYWQ7IGl0IGlzIG5vdCBjYWxsZWQgaWYg dGhlIG91dGVyIHRhcmdldCBydW5zIG9uIHRoZSBob3N0LiAgKi8KKwordm9p ZAorZ29tcF90YXJnZXRfcmV2ICh1aW50NjRfdCBmbl9wdHIgX19hdHRyaWJ1 dGVfXyAoKHVudXNlZCkpLAorCQkgdWludDY0X3QgbWFwbnVtIF9fYXR0cmli dXRlX18gKCh1bnVzZWQpKSwKKwkJIHVpbnQ2NF90IGRldmFkZHJzX3B0ciBf X2F0dHJpYnV0ZV9fICgodW51c2VkKSksCisJCSB1aW50NjRfdCBzaXplc19w dHIgX19hdHRyaWJ1dGVfXyAoKHVudXNlZCkpLAorCQkgdWludDY0X3Qga2lu ZHNfcHRyIF9fYXR0cmlidXRlX18gKCh1bnVzZWQpKSwKKwkJIGludCBkZXZf bnVtIF9fYXR0cmlidXRlX18gKCh1bnVzZWQpKSwKKwkJIHZvaWQgKCpkZXZf dG9faG9zdF9jcHkpICh2b2lkICosIGNvbnN0IHZvaWQgKiwgc2l6ZV90LAor CQkJCQkgIHZvaWQgKikgX19hdHRyaWJ1dGVfXyAoKHVudXNlZCkpLAorCQkg dm9pZCAoKmhvc3RfdG9fZGV2X2NweSkgKHZvaWQgKiwgY29uc3Qgdm9pZCAq LCBzaXplX3QsCisJCQkJCSAgdm9pZCAqKSBfX2F0dHJpYnV0ZV9fICgodW51 c2VkKSksCisJCSB2b2lkICp0b2tlbiBfX2F0dHJpYnV0ZV9fICgodW51c2Vk KSkpCit7CisgIF9fYnVpbHRpbl91bnJlYWNoYWJsZSAoKTsKK30KKwogLyog SG9zdCBmYWxsYmFjayBmb3IgR09NUF90YXJnZXRfZGF0YXssX2V4dH0gcm91 dGluZXMuICAqLwogCiBzdGF0aWMgdm9pZAo= --------------31Sd0wZgRlLkpR6tZERA0Se7--