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 E68623958C24 for ; Thu, 5 Aug 2021 15:30:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E68623958C24 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com IronPort-SDR: +anbCcRrywDf8J12GjF+8ZnpajjHxIkojuNsdteodgQW7Fyfi028qJFzZztZcUNks2BpEBS6Lu dmlUjuDQnbj4TYiw/gqgkJykAq6YVt56QCSMh27+Zav6h/q42N8T5zAJ8X2eBjWQUW26jS5+FX yeVA4dsMeSlMKQUqSEqyqQSKWCg61jTOmTTSy44O9Te79KExy+w+CIOSoZpHVuymz1Y13BMu3d 2VlkbZZ3v5RPMxF53vBW7NZXe5WOfu+IWstgbMoPtMXMY+cO7XZeS1fzWiJ7VQzudBy4DcSe8K 3o5E6GfKpFKsV6FDFKqxgEPy X-IronPort-AV: E=Sophos;i="5.84,296,1620720000"; d="scan'208,223";a="64515580" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa4.mentor.iphmx.com with ESMTP; 05 Aug 2021 07:30:35 -0800 IronPort-SDR: 7JhQmypSwnDCZlrPD6agW5AMECYNVLhBCDoDk5nK69v4tTZyifnZnzemhJFQ6vmB0//hNR88/2 e7NmkHIhEXHVkMNgN8Ethjm4AV3cK6vonieDQpvwL9SVB20g0L8kP2uivw6L7PrkkSrYkdK60c B0PiwPLPpKG9inj86R75743n4yIey35+wYdzk40j+Xaj7B0manFfq6MeD/XRaPyVnCDhfKYP17 NnEA9yQC2hML3jqlALmFEfM4QnlDkb8xtZdyYQhjShtHFcVWl+qD7sUX0ImYl+89Z9h6dvhWFH 9R4= Subject: [PATCH, v3, libgomp, OpenMP 5.0, committed] Implement omp_get_device_num To: Thomas Schwinge CC: Jakub Jelinek , Andrew Stubbs , , , Tom de Vries References: <32c3546a-49c1-bedf-3002-c4e7783bf312@codesourcery.com> <20210723103913.GB2380545@tucnak> <7121c061-c57c-da35-4618-94cbfe4e1bb1@codesourcery.com> <87bl6eiveg.fsf@euler.schwinge.homeip.net> From: Chung-Lin Tang Message-ID: <7462afd0-2d5c-20cc-84a5-6184039f70c5@codesourcery.com> Date: Thu, 5 Aug 2021 23:30:18 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:78.0) Gecko/20100101 Thunderbird/78.12.0 MIME-Version: 1.0 In-Reply-To: <87bl6eiveg.fsf@euler.schwinge.homeip.net> Content-Type: multipart/mixed; boundary="------------AACAFA1A8E1B393D40BF3C91" Content-Language: en-US X-ClientProxiedBy: SVR-ORW-MBX-09.mgc.mentorg.com (147.34.90.209) To svr-orw-mbx-02.mgc.mentorg.com (147.34.90.202) X-Spam-Status: No, score=-9.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, KAM_SHORT, KAM_STOCKGEN, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 05 Aug 2021 15:30:41 -0000 --------------AACAFA1A8E1B393D40BF3C91 Content-Type: text/plain; charset="utf-8"; format=flowed Content-Transfer-Encoding: 7bit On 2021/8/3 8:07 PM, Thomas Schwinge wrote: >> Really suggest to have intelmic support be re-worked as an offload plugin inside >> libgomp, rather than floating outside by itself. > Well, it is a regular libgomp plugin, just its sources are not in > 'libgomp/plugin/' and it's not built during libgomp build. Are you > suggesting just to move it into 'libgomp/plugin/'? This may need some > more complicated setup because of its 'liboffloadmic' dependency? Well it appears that liboffloadmic is layered atop of a COI API (Common Offload Interface?) that is supposed to be the true proprietary interface to Intel MIC devices. I think it is more reasonable to have each libgomp plugin to directly be built atop of the vendor-specific interface for the accelerator. Having another in-tree library serve in-between makes things a bit unnecessarily complex. (I'm not sure if I recall correctly, but did liboffloadmic have another use besides for libgomp?) >>>> --- a/libgomp/libgomp-plugin.h >>>> +++ b/libgomp/libgomp-plugin.h >>>> @@ -102,6 +102,12 @@ struct addr_pair >>>> uintptr_t end; >>>> }; >>>> >>>> +/* This symbol is to name a target side variable that holds the designated >>>> + 'device number' of the target device. The symbol needs to be available to >>>> + libgomp code and the offload plugin (which in the latter case must be >>>> + stringified). */ >>>> +#define GOMP_DEVICE_NUM_VAR __gomp_device_num >>> For a single var it is acceptable (though, please avoid the double space >>> before offload plugin in the comment), but once we have more than one >>> variable, I think we should simply have a struct which will contain all the >>> parameters that need to be copied from the host to the offloading device at >>> image load time (and have eventually another struct that holds parameters >>> that we'll need to copy to the device on each kernel launch, I bet some ICVs >>> will be one category, other ICVs another one). > ACK. Also other program state, like 'fenv' or the gfortran "state blob". > This is "Missing data/state > sharing/propagation between host and offloading devices". Okay, so we actually have a PR number for this :) >> Actually, if you look at the 5.[01] specifications, omp_get_device_num() is not >> defined in terms of an ICV. Maybe it conceptually ought to be, but the current >> description of "the device number of the device on which the calling thread is >> executing" is not one if the defined ICVs. >> >> It looks like there will eventually be some kind of ICV block handled in a similar >> way, but I think that the modifications will be straightforward then. For now, >> I think it's okay for GOMP_DEVICE_NUM_VAR to just be a normal global variable. > There is, by the way, precedent for that: > 'libgomp/config/nvptx/time.c:double __nvptx_clocktick', set up in > 'libgomp/plugin/plugin-nvptx.c:nvptx_set_clocktick' ('cuModuleGetGlobal' > to get the device address, followed by 'cuMemcpyHtoD'), invoked from > 'libgomp/plugin/plugin-nvptx.c:GOMP_OFFLOAD_load_image', quite simple. > > For the case discussed here, we're now adding more complex > 'other_count'/'other_entries'/'num_others' bookkeeping. (Great that all > of the plugins plus 'libgomp/target.c' invented their own terminology...) > ;-) Well, that is kind of what nvptx is doing by itself internally. (e.g. libgomp/config/gcn/time.c does not use such external setting by the plugin) Maybe that "last" entry handled by load_image will eventually turn into a large block struct to handle all such cases. >> --- a/libgomp/plugin/plugin-gcn.c >> +++ b/libgomp/plugin/plugin-gcn.c ... >> + if (status == HSA_STATUS_SUCCESS) >> + { >> + uint64_t device_num_varptr; >> + uint32_t device_num_varsize; >> + >> + status = hsa_fns.hsa_executable_symbol_get_info_fn >> + (var_symbol, HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_ADDRESS, >> + &device_num_varptr); >> + if (status != HSA_STATUS_SUCCESS) >> + hsa_fatal ("Could not extract a variable from its symbol", status); >> + status = hsa_fns.hsa_executable_symbol_get_info_fn >> + (var_symbol, HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_SIZE, >> + &device_num_varsize); >> + if (status != HSA_STATUS_SUCCESS) >> + hsa_fatal ("Could not extract a variable size from its symbol", status); >> + >> + pair->start = device_num_varptr; >> + pair->end = device_num_varptr + device_num_varsize; >> + } >> + else >> + pair->start = pair->end = 0; >> + > Is the 'else' branch to accomodate "old" executables running against > "new" libgomp? If yes, then please add a comment, "for compatibility > with pre-GCC 12 executables" or similar. No, it's because GOMP_DEVICE_NUM_VAR is only linked in when the program actually uses omp_get_device_num(). Even when a program does use omp_get_device_num(), only that offload image which contains that part of libgomp has the device number variable defined. So the else case should actually be quite common. > Also, add 'pair++;', to avoid future confusion? Done. >> + if (r == CUDA_SUCCESS) >> + { >> + targ_tbl->start = (uintptr_t) device_num_varptr; >> + targ_tbl->end = (uintptr_t) (device_num_varptr + device_num_varsize); >> + } >> + else >> + targ_tbl->start = targ_tbl->end = 0; >> + > Same comment for 'else', please. > > Also, 'targ_tbl++;', to avoid future confusion? Done. >> nvptx_set_clocktick (module, dev); >> >> - return fn_entries + var_entries; >> + return fn_entries + var_entries + other_entries; >> } >> >> /* Unload the program described by TARGET_DATA. DEV_DATA is the >> --- a/libgomp/target.c >> +++ b/libgomp/target.c >> @@ -1974,6 +1974,9 @@ gomp_load_image_to_device (struct gomp_device_descr *devicep, unsigned version, >> int num_funcs = host_funcs_end - host_func_table; >> int num_vars = (host_vars_end - host_var_table) / 2; >> >> + /* Others currently is only 'device_num' */ >> + int num_others = 1; >> + >> /* Load image to device and get target addresses for the image. */ >> struct addr_pair *target_table = NULL; >> int i, num_target_entries; >> @@ -1982,7 +1985,9 @@ gomp_load_image_to_device (struct gomp_device_descr *devicep, unsigned version, >> = devicep->load_image_func (devicep->target_id, version, >> target_data, &target_table); >> > Do I understand right that the special-casing here: > >> - if (num_target_entries != num_funcs + num_vars) >> + if (num_target_entries != num_funcs + num_vars >> + /* Others (device_num) are included as trailing entries in pair list. */ >> + && num_target_entries != num_funcs + num_vars + num_others) >> { >> gomp_mutex_unlock (&devicep->lock); >> if (is_register_lock) >> @@ -2054,6 +2059,31 @@ gomp_load_image_to_device (struct gomp_device_descr *devicep, unsigned version, >> array++; >> } >> >> + /* Last entry is for the on-device 'device_num' variable. Tolerate case >> + where plugin does not return this entry. */ >> + if (num_funcs + num_vars < num_target_entries) > ... and here is just for compatibility with the unmodified Intel MIC > plugin? Wouldn't it be simpler to just add a dummy value to that one, to > avoid this special-casing? Adding that "null" code to liboffloadmic is not lesser effort, and is not as robust as simply checking here in gomp_load_image_to_device. > >> + { >> + struct addr_pair *device_num_var = &target_table[num_funcs + num_vars]; >> + if (device_num_var->start != 0) > Please also here add a comment about the '0' case, for completeness. Done. >> + { >> + /* The index of the devicep within devices[] is regarded as its >> + 'device number', which is different from the per-device type >> + devicep->target_id. */ >> + int device_num_val = (int) (devicep - &devices[0]); >> + if (device_num_var->end - device_num_var->start != sizeof (int)) >> + { >> + gomp_mutex_unlock (&devicep->lock); > Add: > > if (is_register_lock) > gomp_mutex_unlock (®ister_lock); > > ..., I suppose? Done, thanks for catching this one. >> + /* Copy device_num value to place on device memory, hereby actually >> + designating its device number into effect. */ >> + gomp_copy_host2dev (devicep, NULL, (void *) device_num_var->start, >> + &device_num_val, sizeof (int), false, NULL); >> + } >> + } >> + >> free (target_table); >> } > Am I understanding this correctly that instead of handling it all inside > the plugins (like '__nvptx_clocktick'), we're here doing the > 'other_count'/'other_entries'/'num_others' bookkeeping plus > 'gomp_copy_host2dev', because we don't know 'device_num_val' inside the > plugins, and also to introduce a more generic interface for future ICVs > etc.? As mentioned above, cases like "__nvptx_clocktick" should be seen as target specific, and can be implemented entirely within nvptx's domain. It's really not a design issue, and any target can do similar device initialization if they can. > It feels to me as if this interface can be improved still. (For example, > would it make sense to pass into the plugins (via 'load_image_func') some > kind of table, containing 'device_num_val' etc., and then let each plugin > to the setup?) But I'm OK if we leave that for later, once we actually > add more ICVs etc. I thought of that when implementing the current patch too, but: 1) It would likely be yet another plugin-hook added (not undoable, but kind of superfluous IMHO). 2) It would be further exposing higher-level concepts (OpenMP or OpenACC) into the plugin, and generally speaking the plugin has a more limited view of the entire libgomp source. This means that there will be cases where putting some kind of setup/initialization in the plugin will be awkward and hard to implement (without pulling even more stuff into the plugin). Having the plugin simply do the job of finding the device location of an opaque variable with pre-arranged name and size, and return it for libgomp to do the setup work, is a better separation of interface. >> --- a/libgomp/config/gcn/icv-device.c >> +++ b/libgomp/config/gcn/icv-device.c >> @@ -70,6 +70,16 @@ omp_is_initial_device (void) >> return 0; >> } >> >> +/* This is set to the device number of current GPU during device initialization, >> + when the offload image containing this libgomp portion is loaded. */ >> +static int GOMP_DEVICE_NUM_VAR; >> + >> +int >> +omp_get_device_num (void) >> +{ >> + return GOMP_DEVICE_NUM_VAR; >> +} >> + >> ialias (omp_set_default_device) >> ialias (omp_get_default_device) >> ialias (omp_get_initial_device) > I suppose also add 'ialias (omp_get_device_num)' here, like... Done, thanks for catching. >> --- a/libgomp/testsuite/lib/libgomp.exp >> +++ b/libgomp/testsuite/lib/libgomp.exp >> +# Return 1 if compiling for offload target intelmic >> +proc check_effective_target_offload_target_intelmic { } { >> + return [libgomp_check_effective_target_offload_target "*-intelmic"] >> +} >> --- /dev/null >> +++ b/libgomp/testsuite/libgomp.c-c++-common/target-45.c >> @@ -0,0 +1,30 @@ >> +/* { dg-do run { target { ! offload_target_intelmic } } } */ > This means that the test case is skipped as soon as the compiler is > configured for Intel MIC offloading -- even if that's not used during > execution. > > From some older experiment of mine, I do have a > 'check_effective_target_offload_device_intel_mic', which I'll propose as > a follow-up, once this is in. Great. >> + if (initial_device .and. host_device_num .ne. device_num) stop 2 > That one matches 'libgomp.c-c++-common/target-45.c': > > if (initial_device && host_device_num != device_num) > abort (); > > ..., but here: > >> + if (initial_device .and. host_device_num .eq. device_num) stop 3 > ... shouldn't that be '.not.initial_device', like in: > > if (!initial_device && host_device_num == device_num) > abort (); Yeah, Tobias also caught this as well :) > > (Also, I'm not familiar with Fortran operator precedence rules, so > probably would put the individual expressions into braces.;-) -- But I > trust you know better than I do, of course.) Done. Attached is the final "v3" patch that I committed. Thanks, Chung-Lin --------------AACAFA1A8E1B393D40BF3C91 Content-Type: text/plain; charset="UTF-8"; x-mac-type=0; x-mac-creator=0; name="omp_get_device_num-v3.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="omp_get_device_num-v3.patch" RnJvbSAwYmFjNzkzZWQ2YmFkMmMwYzEzY2QxZTkzYTFhYTU4MDg0NjdhZmM4IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDaHVuZy1MaW4gVGFuZyA8Y2x0YW5nQGNvZGVzb3Vy Y2VyeS5jb20+CkRhdGU6IFRodSwgNSBBdWcgMjAyMSAyMzoyOTowMyArMDgwMApTdWJqZWN0 OiBbUEFUQ0hdIG9wZW5tcDogSW1wbGVtZW50IG9tcF9nZXRfZGV2aWNlX251bSByb3V0aW5l CgpUaGlzIHBhdGNoIGltcGxlbWVudHMgdGhlIG9tcF9nZXRfZGV2aWNlX251bSBsaWJyYXJ5 IHJvdXRpbmUsIHNwZWNpZmllZCBpbgpPcGVuTVAgNS4wLgoKR09NUF9ERVZJQ0VfTlVNX1ZB UiBpcyBhIG1hY3JvIHN5bWJvbCB3aGljaCBkZWZpbmVzIG5hbWUgb2YgYSAiZGV2aWNlIG51 bWJlciIKdmFyaWFibGUsIGlzIGRlZmluZWQgb24gdGhlIGRldmljZS1zaWRlIGxpYmdvbXAs IGhhcyBpdCdzIGFkZHJlc3MgcmV0dXJuZWQgdG8KaG9zdC1zaWRlIGxpYmdvbXAgZHVyaW5n IGRldmljZSBpbml0aWFsaXphdGlvbiwgYW5kIHRoZSBob3N0IGxpYmdvbXAgdGhlbgpzZXRz IGl0cyB2YWx1ZSB0byB0aGUgZGVzaWduYXRlZCBkZXZpY2UgbnVtYmVyLgoKbGliZ29tcC9D aGFuZ2VMb2c6CgoJKiBpY3YtZGV2aWNlLmMgKG9tcF9nZXRfZGV2aWNlX251bSk6IE5ldyBB UEkgZnVuY3Rpb24sIGhvc3Qgc2lkZS4KCSogZm9ydHJhbi5jIChvbXBfZ2V0X2RldmljZV9u dW1fKTogTmV3IGludGVyZmFjZSBmdW5jdGlvbi4KCSogbGliZ29tcC1wbHVnaW4uaCAoR09N UF9ERVZJQ0VfTlVNX1ZBUik6IERlZmluZSBtYWNybyBzeW1ib2wuCgkqIGxpYmdvbXAubWFw IChPTVBfNS4wLjIpOiBOZXcgdmVyc2lvbiBzcGFjZSB3aXRoIG9tcF9nZXRfZGV2aWNlX251 bSwKCW9tcF9nZXRfZGV2aWNlX251bV8uCgkqIGxpYmdvbXAudGV4aSAob21wX2dldF9kZXZp Y2VfbnVtKTogQWRkIGRvY3VtZW50YXRpb24gZm9yIG5ldyBBUEkKCWZ1bmN0aW9uLgoJKiBv bXAuaC5pbiAob21wX2dldF9kZXZpY2VfbnVtKTogQWRkIGRlY2xhcmF0aW9uLgoJKiBvbXBf bGliLmY5MC5pbiAob21wX2dldF9kZXZpY2VfbnVtKTogTGlrZXdpc2UuCgkqIG9tcF9saWIu aC5pbiAob21wX2dldF9kZXZpY2VfbnVtKTogTGlrZXdpc2UuCgkqIHRhcmdldC5jIChnb21w X2xvYWRfaW1hZ2VfdG9fZGV2aWNlKTogSWYgYWRkaXRpb25hbCBlbnRyeSBmb3IgZGV2aWNl CgludW1iZXIgZXhpc3RzIGF0IGVuZCBvZiByZXR1cm5lZCBlbnRyaWVzIGZyb20gJ2xvYWRf aW1hZ2VfZnVuYycgaG9vaywKCWNvcHkgdGhlIGFzc2lnbmVkIGRldmljZSBudW1iZXIgb3Zl ciB0byB0aGUgZGV2aWNlIHZhcmlhYmxlLgoKCSogY29uZmlnL2djbi9pY3YtZGV2aWNlLmMg KEdPTVBfREVWSUNFX05VTV9WQVIpOiBEZWZpbmUgc3RhdGljIGdsb2JhbC4KCShvbXBfZ2V0 X2RldmljZV9udW0pOiBOZXcgQVBJIGZ1bmN0aW9uLCBkZXZpY2Ugc2lkZS4KCSogcGx1Z2lu L3BsdWdpbi1nY24uYyAoInN5bWNhdC5oIik6IEFkZCBpbmNsdWRlLgoJKEdPTVBfT0ZGTE9B RF9sb2FkX2ltYWdlKTogQWRkIGFkZHJlc3NlcyBvZiBkZXZpY2UgR09NUF9ERVZJQ0VfTlVN X1ZBUgoJYXQgZW5kIG9mIHJldHVybmVkICd0YXJnZXRfdGFibGUnIGVudHJpZXMuCgoJKiBj b25maWcvbnZwdHgvaWN2LWRldmljZS5jIChHT01QX0RFVklDRV9OVU1fVkFSKTogRGVmaW5l IHN0YXRpYyBnbG9iYWwuCgkob21wX2dldF9kZXZpY2VfbnVtKTogTmV3IEFQSSBmdW5jdGlv biwgZGV2aWNlIHNpZGUuCgkqIHBsdWdpbi9wbHVnaW4tbnZwdHguYyAoInN5bWNhdC5oIik6 IEFkZCBpbmNsdWRlLgoJKEdPTVBfT0ZGTE9BRF9sb2FkX2ltYWdlKTogQWRkIGFkZHJlc3Nl cyBvZiBkZXZpY2UgR09NUF9ERVZJQ0VfTlVNX1ZBUgoJYXQgZW5kIG9mIHJldHVybmVkICd0 YXJnZXRfdGFibGUnIGVudHJpZXMuCgoJKiB0ZXN0c3VpdGUvbGliL2xpYmdvbXAuZXhwCgko Y2hlY2tfZWZmZWN0aXZlX3RhcmdldF9vZmZsb2FkX3RhcmdldF9pbnRlbG1pYyk6IE5ldyBm dW5jdGlvbiBmb3IKCXRlc3RpbmcgZm9yIGludGVsbWljIG9mZmxvYWRpbmcuCgkqIHRlc3Rz dWl0ZS9saWJnb21wLmMtYysrLWNvbW1vbi90YXJnZXQtNDUuYzogTmV3IHRlc3QuCgkqIHRl c3RzdWl0ZS9saWJnb21wLmZvcnRyYW4vdGFyZ2V0MTAuZjkwOiBOZXcgdGVzdC4KLS0tCiBs aWJnb21wL2NvbmZpZy9nY24vaWN2LWRldmljZS5jICAgICAgICAgICAgICAgfCAxMSArKysr KysKIGxpYmdvbXAvY29uZmlnL252cHR4L2ljdi1kZXZpY2UuYyAgICAgICAgICAgICB8IDEx ICsrKysrKwogbGliZ29tcC9mb3J0cmFuLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgIDcgKysrKwogbGliZ29tcC9pY3YtZGV2aWNlLmMgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgIDkgKysrKysKIGxpYmdvbXAvbGliZ29tcC1wbHVnaW4uaCAgICAgICAgICAgICAg ICAgICAgICB8ICA2ICsrKwogbGliZ29tcC9saWJnb21wLm1hcCAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDggKysrLQogbGliZ29tcC9saWJnb21wLnRleGkgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgMjkgKysrKysrKysrKysrKysKIGxpYmdvbXAvb21wLmguaW4gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxICsKIGxpYmdvbXAvb21wX2xpYi5mOTAu aW4gICAgICAgICAgICAgICAgICAgICAgICB8ICA2ICsrKwogbGliZ29tcC9vbXBfbGliLmgu aW4gICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDMgKysKIGxpYmdvbXAvcGx1Z2luL3Bs dWdpbi1nY24uYyAgICAgICAgICAgICAgICAgICB8IDM4ICsrKysrKysrKysrKysrKysrKy0K IGxpYmdvbXAvcGx1Z2luL3BsdWdpbi1udnB0eC5jICAgICAgICAgICAgICAgICB8IDI1ICsr KysrKysrKystLQogbGliZ29tcC90YXJnZXQuYyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgMzYgKysrKysrKysrKysrKysrKystCiBsaWJnb21wL3Rlc3RzdWl0ZS9saWIvbGli Z29tcC5leHAgICAgICAgICAgICAgfCAgNSArKysKIC4uLi9saWJnb21wLmMtYysrLWNvbW1v bi90YXJnZXQtNDUuYyAgICAgICAgICB8IDMwICsrKysrKysrKysrKysrKwogLi4uL3Rlc3Rz dWl0ZS9saWJnb21wLmZvcnRyYW4vdGFyZ2V0MTAuZjkwICAgIHwgMjAgKysrKysrKysrKwog MTYgZmlsZXMgY2hhbmdlZCwgMjM4IGluc2VydGlvbnMoKyksIDcgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgbGliZ29tcC90ZXN0c3VpdGUvbGliZ29tcC5jLWMrKy1jb21t b24vdGFyZ2V0LTQ1LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWJnb21wL3Rlc3RzdWl0ZS9s aWJnb21wLmZvcnRyYW4vdGFyZ2V0MTAuZjkwCgpkaWZmIC0tZ2l0IGEvbGliZ29tcC9jb25m aWcvZ2NuL2ljdi1kZXZpY2UuYyBiL2xpYmdvbXAvY29uZmlnL2djbi9pY3YtZGV2aWNlLmMK aW5kZXggNzJkNGY3Y2ZmNzQuLjM0ZTBmODM0NmYyIDEwMDY0NAotLS0gYS9saWJnb21wL2Nv bmZpZy9nY24vaWN2LWRldmljZS5jCisrKyBiL2xpYmdvbXAvY29uZmlnL2djbi9pY3YtZGV2 aWNlLmMKQEAgLTcwLDYgKzcwLDE2IEBAIG9tcF9pc19pbml0aWFsX2RldmljZSAodm9pZCkK ICAgcmV0dXJuIDA7CiB9CiAKKy8qIFRoaXMgaXMgc2V0IHRvIHRoZSBkZXZpY2UgbnVtYmVy IG9mIGN1cnJlbnQgR1BVIGR1cmluZyBkZXZpY2UgaW5pdGlhbGl6YXRpb24sCisgICB3aGVu IHRoZSBvZmZsb2FkIGltYWdlIGNvbnRhaW5pbmcgdGhpcyBsaWJnb21wIHBvcnRpb24gaXMg bG9hZGVkLiAgKi8KK3N0YXRpYyB2b2xhdGlsZSBpbnQgR09NUF9ERVZJQ0VfTlVNX1ZBUjsK KworaW50CitvbXBfZ2V0X2RldmljZV9udW0gKHZvaWQpCit7CisgIHJldHVybiBHT01QX0RF VklDRV9OVU1fVkFSOworfQorCiBpYWxpYXMgKG9tcF9zZXRfZGVmYXVsdF9kZXZpY2UpCiBp YWxpYXMgKG9tcF9nZXRfZGVmYXVsdF9kZXZpY2UpCiBpYWxpYXMgKG9tcF9nZXRfaW5pdGlh bF9kZXZpY2UpCkBAIC03NywzICs4Nyw0IEBAIGlhbGlhcyAob21wX2dldF9udW1fZGV2aWNl cykKIGlhbGlhcyAob21wX2dldF9udW1fdGVhbXMpCiBpYWxpYXMgKG9tcF9nZXRfdGVhbV9u dW0pCiBpYWxpYXMgKG9tcF9pc19pbml0aWFsX2RldmljZSkKK2lhbGlhcyAob21wX2dldF9k ZXZpY2VfbnVtKQpkaWZmIC0tZ2l0IGEvbGliZ29tcC9jb25maWcvbnZwdHgvaWN2LWRldmlj ZS5jIGIvbGliZ29tcC9jb25maWcvbnZwdHgvaWN2LWRldmljZS5jCmluZGV4IDNiOTY4OTBm MzM4Li5iNjMxNDlkMGMzNCAxMDA2NDQKLS0tIGEvbGliZ29tcC9jb25maWcvbnZwdHgvaWN2 LWRldmljZS5jCisrKyBiL2xpYmdvbXAvY29uZmlnL252cHR4L2ljdi1kZXZpY2UuYwpAQCAt NTgsOCArNTgsMTkgQEAgb21wX2lzX2luaXRpYWxfZGV2aWNlICh2b2lkKQogICByZXR1cm4g MDsKIH0KIAorLyogVGhpcyBpcyBzZXQgdG8gdGhlIGRldmljZSBudW1iZXIgb2YgY3VycmVu dCBHUFUgZHVyaW5nIGRldmljZSBpbml0aWFsaXphdGlvbiwKKyAgIHdoZW4gdGhlIG9mZmxv YWQgaW1hZ2UgY29udGFpbmluZyB0aGlzIGxpYmdvbXAgcG9ydGlvbiBpcyBsb2FkZWQuICAq Lworc3RhdGljIHZvbGF0aWxlIGludCBHT01QX0RFVklDRV9OVU1fVkFSOworCitpbnQKK29t cF9nZXRfZGV2aWNlX251bSAodm9pZCkKK3sKKyAgcmV0dXJuIEdPTVBfREVWSUNFX05VTV9W QVI7Cit9CisKIGlhbGlhcyAob21wX3NldF9kZWZhdWx0X2RldmljZSkKIGlhbGlhcyAob21w X2dldF9kZWZhdWx0X2RldmljZSkKIGlhbGlhcyAob21wX2dldF9pbml0aWFsX2RldmljZSkK IGlhbGlhcyAob21wX2dldF9udW1fZGV2aWNlcykKIGlhbGlhcyAob21wX2lzX2luaXRpYWxf ZGV2aWNlKQoraWFsaWFzIChvbXBfZ2V0X2RldmljZV9udW0pCmRpZmYgLS1naXQgYS9saWJn b21wL2ZvcnRyYW4uYyBiL2xpYmdvbXAvZm9ydHJhbi5jCmluZGV4IGUwNDI3MDJhYzkxLi4w N2Y5NzY1NmU1MSAxMDA2NDQKLS0tIGEvbGliZ29tcC9mb3J0cmFuLmMKKysrIGIvbGliZ29t cC9mb3J0cmFuLmMKQEAgLTgzLDYgKzgzLDcgQEAgaWFsaWFzX3JlZGlyZWN0IChvbXBfZ2V0 X3BhcnRpdGlvbl9wbGFjZV9udW1zKQogaWFsaWFzX3JlZGlyZWN0IChvbXBfc2V0X2RlZmF1 bHRfZGV2aWNlKQogaWFsaWFzX3JlZGlyZWN0IChvbXBfZ2V0X2RlZmF1bHRfZGV2aWNlKQog aWFsaWFzX3JlZGlyZWN0IChvbXBfZ2V0X251bV9kZXZpY2VzKQoraWFsaWFzX3JlZGlyZWN0 IChvbXBfZ2V0X2RldmljZV9udW0pCiBpYWxpYXNfcmVkaXJlY3QgKG9tcF9nZXRfbnVtX3Rl YW1zKQogaWFsaWFzX3JlZGlyZWN0IChvbXBfZ2V0X3RlYW1fbnVtKQogaWFsaWFzX3JlZGly ZWN0IChvbXBfaXNfaW5pdGlhbF9kZXZpY2UpCkBAIC01OTksNiArNjAwLDEyIEBAIG9tcF9n ZXRfaW5pdGlhbF9kZXZpY2VfICh2b2lkKQogICByZXR1cm4gb21wX2dldF9pbml0aWFsX2Rl dmljZSAoKTsKIH0KIAoraW50MzJfdAorb21wX2dldF9kZXZpY2VfbnVtXyAodm9pZCkKK3sK KyAgcmV0dXJuIG9tcF9nZXRfZGV2aWNlX251bSAoKTsKK30KKwogaW50MzJfdAogb21wX2dl dF9tYXhfdGFza19wcmlvcml0eV8gKHZvaWQpCiB7CmRpZmYgLS1naXQgYS9saWJnb21wL2lj di1kZXZpY2UuYyBiL2xpYmdvbXAvaWN2LWRldmljZS5jCmluZGV4IGMxYmVkZjQ2NjQ3Li5m MTFiZGZhODVjNCAxMDA2NDQKLS0tIGEvbGliZ29tcC9pY3YtZGV2aWNlLmMKKysrIGIvbGli Z29tcC9pY3YtZGV2aWNlLmMKQEAgLTYxLDggKzYxLDE3IEBAIG9tcF9pc19pbml0aWFsX2Rl dmljZSAodm9pZCkKICAgcmV0dXJuIDE7CiB9CiAKK2ludAorb21wX2dldF9kZXZpY2VfbnVt ICh2b2lkKQoreworICAvKiBCeSBzcGVjaWZpY2F0aW9uLCB0aGlzIGlzIGVxdWl2YWxlbnQg dG8gb21wX2dldF9pbml0aWFsX2RldmljZQorICAgICBvbiB0aGUgaG9zdC4gICovCisgIHJl dHVybiBvbXBfZ2V0X2luaXRpYWxfZGV2aWNlICgpOworfQorCiBpYWxpYXMgKG9tcF9zZXRf ZGVmYXVsdF9kZXZpY2UpCiBpYWxpYXMgKG9tcF9nZXRfZGVmYXVsdF9kZXZpY2UpCiBpYWxp YXMgKG9tcF9nZXRfaW5pdGlhbF9kZXZpY2UpCiBpYWxpYXMgKG9tcF9nZXRfbnVtX2Rldmlj ZXMpCiBpYWxpYXMgKG9tcF9pc19pbml0aWFsX2RldmljZSkKK2lhbGlhcyAob21wX2dldF9k ZXZpY2VfbnVtKQpkaWZmIC0tZ2l0IGEvbGliZ29tcC9saWJnb21wLXBsdWdpbi5oIGIvbGli Z29tcC9saWJnb21wLXBsdWdpbi5oCmluZGV4IDYyNjQ1Y2U5OTU0Li5jZjI0YTJiZWU0MSAx MDA2NDQKLS0tIGEvbGliZ29tcC9saWJnb21wLXBsdWdpbi5oCisrKyBiL2xpYmdvbXAvbGli Z29tcC1wbHVnaW4uaApAQCAtMTAyLDYgKzEwMiwxMiBAQCBzdHJ1Y3QgYWRkcl9wYWlyCiAg IHVpbnRwdHJfdCBlbmQ7CiB9OwogCisvKiBUaGlzIHN5bWJvbCBpcyB0byBuYW1lIGEgdGFy Z2V0IHNpZGUgdmFyaWFibGUgdGhhdCBob2xkcyB0aGUgZGVzaWduYXRlZAorICAgJ2Rldmlj ZSBudW1iZXInIG9mIHRoZSB0YXJnZXQgZGV2aWNlLiBUaGUgc3ltYm9sIG5lZWRzIHRvIGJl IGF2YWlsYWJsZSB0bworICAgbGliZ29tcCBjb2RlIGFuZCB0aGUgb2ZmbG9hZCBwbHVnaW4g KHdoaWNoIGluIHRoZSBsYXR0ZXIgY2FzZSBtdXN0IGJlCisgICBzdHJpbmdpZmllZCkuICAq LworI2RlZmluZSBHT01QX0RFVklDRV9OVU1fVkFSIF9fZ29tcF9kZXZpY2VfbnVtCisKIC8q IE1pc2NlbGxhbmVvdXMgZnVuY3Rpb25zLiAgKi8KIGV4dGVybiB2b2lkICpHT01QX1BMVUdJ Tl9tYWxsb2MgKHNpemVfdCkgX19hdHRyaWJ1dGVfXyAoKG1hbGxvYykpOwogZXh0ZXJuIHZv aWQgKkdPTVBfUExVR0lOX21hbGxvY19jbGVhcmVkIChzaXplX3QpIF9fYXR0cmlidXRlX18g KChtYWxsb2MpKTsKZGlmZiAtLWdpdCBhL2xpYmdvbXAvbGliZ29tcC5tYXAgYi9saWJnb21w L2xpYmdvbXAubWFwCmluZGV4IDY5YWE2OTU2MmI4Li5jYzQ0ODg1Y2JhOSAxMDA2NDQKLS0t IGEvbGliZ29tcC9saWJnb21wLm1hcAorKysgYi9saWJnb21wL2xpYmdvbXAubWFwCkBAIC0x OTksMTIgKzE5OSwxOCBAQCBPTVBfNS4wLjEgewogCW9tcF9mdWxmaWxsX2V2ZW50XzsKIH0g T01QXzUuMDsKIAorT01QXzUuMC4yIHsKKyAgZ2xvYmFsOgorCW9tcF9nZXRfZGV2aWNlX251 bTsKKwlvbXBfZ2V0X2RldmljZV9udW1fOworfSBPTVBfNS4wLjE7CisKIE9NUF81LjEgewog ICBnbG9iYWw6CiAJb21wX2Rpc3BsYXlfZW52OwogCW9tcF9kaXNwbGF5X2Vudl87CiAJb21w X2Rpc3BsYXlfZW52XzhfOwotfSBPTVBfNS4wLjE7Cit9IE9NUF81LjAuMjsKIAogR09NUF8x LjAgewogICBnbG9iYWw6CmRpZmYgLS1naXQgYS9saWJnb21wL2xpYmdvbXAudGV4aSBiL2xp YmdvbXAvbGliZ29tcC50ZXhpCmluZGV4IDJjMWYxYjU5NjhiLi5mYzllNzA4YThkMiAxMDA2 NDQKLS0tIGEvbGliZ29tcC9saWJnb21wLnRleGkKKysrIGIvbGliZ29tcC9saWJnb21wLnRl eGkKQEAgLTE2NSw2ICsxNjUsNyBAQCBsaW5rYWdlLCBhbmQgZG8gbm90IHRocm93IGV4Y2Vw dGlvbnMuCiAqIG9tcF9nZXRfYW5jZXN0b3JfdGhyZWFkX251bTo6IEFuY2VzdG9yIHRocmVh ZCBJRAogKiBvbXBfZ2V0X2NhbmNlbGxhdGlvbjo6ICAgICAgICBXaGV0aGVyIGNhbmNlbGxh dGlvbiBzdXBwb3J0IGlzIGVuYWJsZWQKICogb21wX2dldF9kZWZhdWx0X2RldmljZTo6ICAg ICAgR2V0IHRoZSBkZWZhdWx0IGRldmljZSBmb3IgdGFyZ2V0IHJlZ2lvbnMKKyogb21wX2dl dF9kZXZpY2VfbnVtOjogICAgICAgICAgR2V0IGRldmljZSB0aGF0IGN1cnJlbnQgdGhyZWFk IGlzIHJ1bm5pbmcgb24KICogb21wX2dldF9keW5hbWljOjogICAgICAgICAgICAgRHluYW1p YyB0ZWFtcyBzZXR0aW5nCiAqIG9tcF9nZXRfaW5pdGlhbF9kZXZpY2U6OiAgICAgIERldmlj ZSBudW1iZXIgb2YgaG9zdCBkZXZpY2UKICogb21wX2dldF9sZXZlbDo6ICAgICAgICAgICAg ICAgTnVtYmVyIG9mIHBhcmFsbGVsIHJlZ2lvbnMKQEAgLTM4NSw2ICszODYsMzQgQEAgRm9y IE9wZW5NUCA1LjEsIHRoaXMgbXVzdCBiZSBlcXVhbCB0byB0aGUgdmFsdWUgcmV0dXJuZWQg YnkgdGhlCiAKIAogCitAbm9kZSBvbXBfZ2V0X2RldmljZV9udW0KK0BzZWN0aW9uIEBjb2Rl e29tcF9nZXRfZGV2aWNlX251bX0gLS0gUmV0dXJuIGRldmljZSBudW1iZXIgb2YgY3VycmVu dCBkZXZpY2UKK0B0YWJsZSBAYXNpcworQGl0ZW0gQGVtcGh7RGVzY3JpcHRpb259OgorVGhp cyBmdW5jdGlvbiByZXR1cm5zIGEgZGV2aWNlIG51bWJlciB0aGF0IHJlcHJlc2VudHMgdGhl IGRldmljZSB0aGF0IHRoZQorY3VycmVudCB0aHJlYWQgaXMgZXhlY3V0aW5nIG9uLiBGb3Ig T3Blbk1QIDUuMCwgdGhpcyBtdXN0IGJlIGVxdWFsIHRvIHRoZQordmFsdWUgcmV0dXJuZWQg YnkgdGhlIEBjb2Rle29tcF9nZXRfaW5pdGlhbF9kZXZpY2V9IGZ1bmN0aW9uIHdoZW4gY2Fs bGVkCitmcm9tIHRoZSBob3N0LgorCitAaXRlbSBAZW1waHtDL0MrK30KK0BtdWx0aXRhYmxl IEBjb2x1bW5mcmFjdGlvbnMgLjIwIC44MAorQGl0ZW0gQGVtcGh7UHJvdG90eXBlfTogQHRh YiBAY29kZXtpbnQgb21wX2dldF9kZXZpY2VfbnVtKHZvaWQpO30KK0BlbmQgbXVsdGl0YWJs ZQorCitAaXRlbSBAZW1waHtGb3J0cmFufToKK0BtdWx0aXRhYmxlIEBjb2x1bW5mcmFjdGlv bnMgLjIwIC44MAorQGl0ZW0gQGVtcGh7SW50ZXJmYWNlfTogQHRhYiBAY29kZXtpbnRlZ2Vy IGZ1bmN0aW9uIG9tcF9nZXRfZGV2aWNlX251bSgpfQorQGVuZCBtdWx0aXRhYmxlCisKK0Bp dGVtIEBlbXBoe1NlZSBhbHNvfToKK0ByZWZ7b21wX2dldF9pbml0aWFsX2RldmljZX0KKwor QGl0ZW0gQGVtcGh7UmVmZXJlbmNlfToKK0B1cmVme2h0dHBzOi8vd3d3Lm9wZW5tcC5vcmcs IE9wZW5NUCBzcGVjaWZpY2F0aW9uIHY1LjB9LCBTZWN0aW9uIDMuMi4zNy4KK0BlbmQgdGFi bGUKKworCisKIEBub2RlIG9tcF9nZXRfbGV2ZWwKIEBzZWN0aW9uIEBjb2Rle29tcF9nZXRf bGV2ZWx9IC0tIE9idGFpbiB0aGUgY3VycmVudCBuZXN0aW5nIGxldmVsCiBAdGFibGUgQGFz aXMKZGlmZiAtLWdpdCBhL2xpYmdvbXAvb21wLmguaW4gYi9saWJnb21wL29tcC5oLmluCmlu ZGV4IGM5M2RiOTY4ZDJlLi5kYTM0YTlkOThhNiAxMDA2NDQKLS0tIGEvbGliZ29tcC9vbXAu aC5pbgorKysgYi9saWJnb21wL29tcC5oLmluCkBAIC0yNDMsNiArMjQzLDcgQEAgZXh0ZXJu IHZvaWQgb21wX2dldF9wYXJ0aXRpb25fcGxhY2VfbnVtcyAoaW50ICopIF9fR09NUF9OT1RI Uk9XOwogZXh0ZXJuIHZvaWQgb21wX3NldF9kZWZhdWx0X2RldmljZSAoaW50KSBfX0dPTVBf Tk9USFJPVzsKIGV4dGVybiBpbnQgb21wX2dldF9kZWZhdWx0X2RldmljZSAodm9pZCkgX19H T01QX05PVEhST1c7CiBleHRlcm4gaW50IG9tcF9nZXRfbnVtX2RldmljZXMgKHZvaWQpIF9f R09NUF9OT1RIUk9XOworZXh0ZXJuIGludCBvbXBfZ2V0X2RldmljZV9udW0gKHZvaWQpIF9f R09NUF9OT1RIUk9XOwogZXh0ZXJuIGludCBvbXBfZ2V0X251bV90ZWFtcyAodm9pZCkgX19H T01QX05PVEhST1c7CiBleHRlcm4gaW50IG9tcF9nZXRfdGVhbV9udW0gKHZvaWQpIF9fR09N UF9OT1RIUk9XOwogCmRpZmYgLS1naXQgYS9saWJnb21wL29tcF9saWIuZjkwLmluIGIvbGli Z29tcC9vbXBfbGliLmY5MC5pbgppbmRleCA1ZmM2NTg3ZTQ5ZS4uZDdlODA0ZjRmZDUgMTAw NjQ0Ci0tLSBhL2xpYmdvbXAvb21wX2xpYi5mOTAuaW4KKysrIGIvbGliZ29tcC9vbXBfbGli LmY5MC5pbgpAQCAtNTUwLDYgKzU1MCwxMiBAQAogICAgICAgICAgIGVuZCBmdW5jdGlvbiBv bXBfZ2V0X2luaXRpYWxfZGV2aWNlCiAgICAgICAgIGVuZCBpbnRlcmZhY2UKIAorICAgICAg ICBpbnRlcmZhY2UKKyAgICAgICAgICBmdW5jdGlvbiBvbXBfZ2V0X2RldmljZV9udW0gKCkK KyAgICAgICAgICAgIGludGVnZXIgKDQpIDo6IG9tcF9nZXRfZGV2aWNlX251bQorICAgICAg ICAgIGVuZCBmdW5jdGlvbiBvbXBfZ2V0X2RldmljZV9udW0KKyAgICAgICAgZW5kIGludGVy ZmFjZQorCiAgICAgICAgIGludGVyZmFjZQogICAgICAgICAgIGZ1bmN0aW9uIG9tcF9nZXRf bWF4X3Rhc2tfcHJpb3JpdHkgKCkKICAgICAgICAgICAgIGludGVnZXIgKDQpIDo6IG9tcF9n ZXRfbWF4X3Rhc2tfcHJpb3JpdHkKZGlmZiAtLWdpdCBhL2xpYmdvbXAvb21wX2xpYi5oLmlu IGIvbGliZ29tcC9vbXBfbGliLmguaW4KaW5kZXggOTg3M2NlYTlhYzEuLjIwYzMyNjQ1ZTNj IDEwMDY0NAotLS0gYS9saWJnb21wL29tcF9saWIuaC5pbgorKysgYi9saWJnb21wL29tcF9s aWIuaC5pbgpAQCAtMjQ0LDYgKzI0NCw5IEBACiAgICAgICBleHRlcm5hbCBvbXBfZ2V0X2lu aXRpYWxfZGV2aWNlCiAgICAgICBpbnRlZ2VyKDQpIG9tcF9nZXRfaW5pdGlhbF9kZXZpY2UK IAorICAgICAgZXh0ZXJuYWwgb21wX2dldF9kZXZpY2VfbnVtCisgICAgICBpbnRlZ2VyKDQp IG9tcF9nZXRfZGV2aWNlX251bQorCiAgICAgICBleHRlcm5hbCBvbXBfZ2V0X21heF90YXNr X3ByaW9yaXR5CiAgICAgICBpbnRlZ2VyKDQpIG9tcF9nZXRfbWF4X3Rhc2tfcHJpb3JpdHkK IApkaWZmIC0tZ2l0IGEvbGliZ29tcC9wbHVnaW4vcGx1Z2luLWdjbi5jIGIvbGliZ29tcC9w bHVnaW4vcGx1Z2luLWdjbi5jCmluZGV4IDI1NDg2MTRhMmU1Li5mMjZkNzM2MTEwNiAxMDA2 NDQKLS0tIGEvbGliZ29tcC9wbHVnaW4vcGx1Z2luLWdjbi5jCisrKyBiL2xpYmdvbXAvcGx1 Z2luL3BsdWdpbi1nY24uYwpAQCAtMjksNiArMjksNyBAQAogLyoge3t7IEluY2x1ZGVzIGFu ZCBkZWZpbmVzICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAic3ltY2F0 LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KICNpbmNsdWRlIDxzdGRsaWIuaD4KICNpbmNsdWRl IDxzdHJpbmcuaD4KQEAgLTMzMDUsNiArMzMwNiw3IEBAIEdPTVBfT0ZGTE9BRF9sb2FkX2lt YWdlIChpbnQgb3JkLCB1bnNpZ25lZCB2ZXJzaW9uLCBjb25zdCB2b2lkICp0YXJnZXRfZGF0 YSwKICAgc3RydWN0IGtlcm5lbF9pbmZvICprZXJuZWw7CiAgIGludCBrZXJuZWxfY291bnQg PSBpbWFnZV9kZXNjLT5rZXJuZWxfY291bnQ7CiAgIHVuc2lnbmVkIHZhcl9jb3VudCA9IGlt YWdlX2Rlc2MtPmdsb2JhbF92YXJpYWJsZV9jb3VudDsKKyAgaW50IG90aGVyX2NvdW50ID0g MTsKIAogICBhZ2VudCA9IGdldF9hZ2VudF9pbmZvIChvcmQpOwogICBpZiAoIWFnZW50KQpA QCAtMzMyMSw3ICszMzIzLDggQEAgR09NUF9PRkZMT0FEX2xvYWRfaW1hZ2UgKGludCBvcmQs IHVuc2lnbmVkIHZlcnNpb24sIGNvbnN0IHZvaWQgKnRhcmdldF9kYXRhLAogCiAgIEdDTl9E RUJVRyAoIkVuY291bnRlcmVkICVkIGtlcm5lbHMgaW4gYW4gaW1hZ2VcbiIsIGtlcm5lbF9j b3VudCk7CiAgIEdDTl9ERUJVRyAoIkVuY291bnRlcmVkICV1IGdsb2JhbCB2YXJpYWJsZXMg aW4gYW4gaW1hZ2VcbiIsIHZhcl9jb3VudCk7Ci0gIHBhaXIgPSBHT01QX1BMVUdJTl9tYWxs b2MgKChrZXJuZWxfY291bnQgKyB2YXJfY291bnQgLSAyKQorICBHQ05fREVCVUcgKCJFeHBl Y3QgJWQgb3RoZXIgdmFyaWFibGVzIGluIGFuIGltYWdlXG4iLCBvdGhlcl9jb3VudCk7Cisg IHBhaXIgPSBHT01QX1BMVUdJTl9tYWxsb2MgKChrZXJuZWxfY291bnQgKyB2YXJfY291bnQg KyBvdGhlcl9jb3VudCAtIDIpCiAJCQkgICAgICogc2l6ZW9mIChzdHJ1Y3QgYWRkcl9wYWly KSk7CiAgICp0YXJnZXRfdGFibGUgPSBwYWlyOwogICBtb2R1bGUgPSAoc3RydWN0IG1vZHVs ZV9pbmZvICopCkBAIC0zMzk2LDYgKzMzOTksMzcgQEAgR09NUF9PRkZMT0FEX2xvYWRfaW1h Z2UgKGludCBvcmQsIHVuc2lnbmVkIHZlcnNpb24sIGNvbnN0IHZvaWQgKnRhcmdldF9kYXRh LAogICAgICAgcGFpcisrOwogICAgIH0KIAorICBHQ05fREVCVUcgKCJMb29raW5nIGZvciB2 YXJpYWJsZSAlc1xuIiwgU1RSSU5HWCAoR09NUF9ERVZJQ0VfTlVNX1ZBUikpOworCisgIGhz YV9zdGF0dXNfdCBzdGF0dXM7CisgIGhzYV9leGVjdXRhYmxlX3N5bWJvbF90IHZhcl9zeW1i b2w7CisgIHN0YXR1cyA9IGhzYV9mbnMuaHNhX2V4ZWN1dGFibGVfZ2V0X3N5bWJvbF9mbiAo YWdlbnQtPmV4ZWN1dGFibGUsIE5VTEwsCisJCQkJCQkgU1RSSU5HWCAoR09NUF9ERVZJQ0Vf TlVNX1ZBUiksCisJCQkJCQkgYWdlbnQtPmlkLCAwLCAmdmFyX3N5bWJvbCk7CisgIGlmIChz dGF0dXMgPT0gSFNBX1NUQVRVU19TVUNDRVNTKQorICAgIHsKKyAgICAgIHVpbnQ2NF90IGRl dmljZV9udW1fdmFycHRyOworICAgICAgdWludDMyX3QgZGV2aWNlX251bV92YXJzaXplOwor CisgICAgICBzdGF0dXMgPSBoc2FfZm5zLmhzYV9leGVjdXRhYmxlX3N5bWJvbF9nZXRfaW5m b19mbgorCSh2YXJfc3ltYm9sLCBIU0FfRVhFQ1VUQUJMRV9TWU1CT0xfSU5GT19WQVJJQUJM RV9BRERSRVNTLAorCSAmZGV2aWNlX251bV92YXJwdHIpOworICAgICAgaWYgKHN0YXR1cyAh PSBIU0FfU1RBVFVTX1NVQ0NFU1MpCisJaHNhX2ZhdGFsICgiQ291bGQgbm90IGV4dHJhY3Qg YSB2YXJpYWJsZSBmcm9tIGl0cyBzeW1ib2wiLCBzdGF0dXMpOworICAgICAgc3RhdHVzID0g aHNhX2Zucy5oc2FfZXhlY3V0YWJsZV9zeW1ib2xfZ2V0X2luZm9fZm4KKwkodmFyX3N5bWJv bCwgSFNBX0VYRUNVVEFCTEVfU1lNQk9MX0lORk9fVkFSSUFCTEVfU0laRSwKKwkgJmRldmlj ZV9udW1fdmFyc2l6ZSk7CisgICAgICBpZiAoc3RhdHVzICE9IEhTQV9TVEFUVVNfU1VDQ0VT UykKKwloc2FfZmF0YWwgKCJDb3VsZCBub3QgZXh0cmFjdCBhIHZhcmlhYmxlIHNpemUgZnJv bSBpdHMgc3ltYm9sIiwgc3RhdHVzKTsKKworICAgICAgcGFpci0+c3RhcnQgPSBkZXZpY2Vf bnVtX3ZhcnB0cjsKKyAgICAgIHBhaXItPmVuZCA9IGRldmljZV9udW1fdmFycHRyICsgZGV2 aWNlX251bV92YXJzaXplOworICAgIH0KKyAgZWxzZQorICAgIC8qIFRoZSAnR09NUF9ERVZJ Q0VfTlVNX1ZBUicgdmFyaWFibGUgd2FzIG5vdCBpbiB0aGlzIGltYWdlLiAgKi8KKyAgICBw YWlyLT5zdGFydCA9IHBhaXItPmVuZCA9IDA7CisgIHBhaXIrKzsKKwogICAvKiBFbnN1cmUg dGhhdCBjb25zdHJ1Y3RvcnMgYXJlIHJ1biBmaXJzdC4gICovCiAgIHN0cnVjdCBHT01QX2tl cm5lbF9sYXVuY2hfYXR0cmlidXRlcyBrbGEgPQogICAgIHsgMywKQEAgLTM0MTgsNyArMzQ1 Miw3IEBAIEdPTVBfT0ZGTE9BRF9sb2FkX2ltYWdlIChpbnQgb3JkLCB1bnNpZ25lZCB2ZXJz aW9uLCBjb25zdCB2b2lkICp0YXJnZXRfZGF0YSwKICAgaWYgKG1vZHVsZS0+ZmluaV9hcnJh eV9mdW5jKQogICAgIGtlcm5lbF9jb3VudC0tOwogCi0gIHJldHVybiBrZXJuZWxfY291bnQg KyB2YXJfY291bnQ7CisgIHJldHVybiBrZXJuZWxfY291bnQgKyB2YXJfY291bnQgKyBvdGhl cl9jb3VudDsKIH0KIAogLyogVW5sb2FkIEdDTiBvYmplY3QtY29kZSBtb2R1bGUgZGVzY3Jp YmVkIGJ5IHN0cnVjdCBnY25faW1hZ2VfZGVzYyBpbgpkaWZmIC0tZ2l0IGEvbGliZ29tcC9w bHVnaW4vcGx1Z2luLW52cHR4LmMgYi9saWJnb21wL3BsdWdpbi9wbHVnaW4tbnZwdHguYwpp bmRleCAxMjE1MjEyZDUwMS4uMGYxNmUxY2YwMGQgMTAwNjQ0Ci0tLSBhL2xpYmdvbXAvcGx1 Z2luL3BsdWdpbi1udnB0eC5jCisrKyBiL2xpYmdvbXAvcGx1Z2luL3BsdWdpbi1udnB0eC5j CkBAIC0zNCw2ICszNCw3IEBACiAjZGVmaW5lIF9HTlVfU09VUkNFCiAjaW5jbHVkZSAib3Bl bmFjYy5oIgogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgInN5bWNhdC5oIgogI2lu Y2x1ZGUgImxpYmdvbXAtcGx1Z2luLmgiCiAjaW5jbHVkZSAib2FjYy1wbHVnaW4uaCIKICNp bmNsdWRlICJnb21wLWNvbnN0YW50cy5oIgpAQCAtMTI2NSw3ICsxMjY2LDcgQEAgR09NUF9P RkZMT0FEX2xvYWRfaW1hZ2UgKGludCBvcmQsIHVuc2lnbmVkIHZlcnNpb24sIGNvbnN0IHZv aWQgKnRhcmdldF9kYXRhLAogICBDVW1vZHVsZSBtb2R1bGU7CiAgIGNvbnN0IGNoYXIgKmNv bnN0ICp2YXJfbmFtZXM7CiAgIGNvbnN0IHN0cnVjdCB0YXJnX2ZuX2xhdW5jaCAqZm5fZGVz Y3M7Ci0gIHVuc2lnbmVkIGludCBmbl9lbnRyaWVzLCB2YXJfZW50cmllcywgaSwgajsKKyAg dW5zaWduZWQgaW50IGZuX2VudHJpZXMsIHZhcl9lbnRyaWVzLCBvdGhlcl9lbnRyaWVzLCBp LCBqOwogICBzdHJ1Y3QgdGFyZ19mbl9kZXNjcmlwdG9yICp0YXJnX2ZuczsKICAgc3RydWN0 IGFkZHJfcGFpciAqdGFyZ190Ymw7CiAgIGNvbnN0IG52cHR4X3RkYXRhX3QgKmltZ19oZWFk ZXIgPSAoY29uc3QgbnZwdHhfdGRhdGFfdCAqKSB0YXJnZXRfZGF0YTsKQEAgLTEyOTUsOCAr MTI5NiwxMSBAQCBHT01QX09GRkxPQURfbG9hZF9pbWFnZSAoaW50IG9yZCwgdW5zaWduZWQg dmVyc2lvbiwgY29uc3Qgdm9pZCAqdGFyZ2V0X2RhdGEsCiAgIGZuX2VudHJpZXMgPSBpbWdf aGVhZGVyLT5mbl9udW07CiAgIGZuX2Rlc2NzID0gaW1nX2hlYWRlci0+Zm5fZGVzY3M7CiAK KyAgLyogQ3VycmVudGx5LCB0aGUgb25seSBvdGhlciBlbnRyeSBraW5kIGlzICdkZXZpY2Ug bnVtYmVyJy4gICovCisgIG90aGVyX2VudHJpZXMgPSAxOworCiAgIHRhcmdfdGJsID0gR09N UF9QTFVHSU5fbWFsbG9jIChzaXplb2YgKHN0cnVjdCBhZGRyX3BhaXIpCi0JCQkJICogKGZu X2VudHJpZXMgKyB2YXJfZW50cmllcykpOworCQkJCSAqIChmbl9lbnRyaWVzICsgdmFyX2Vu dHJpZXMgKyBvdGhlcl9lbnRyaWVzKSk7CiAgIHRhcmdfZm5zID0gR09NUF9QTFVHSU5fbWFs bG9jIChzaXplb2YgKHN0cnVjdCB0YXJnX2ZuX2Rlc2NyaXB0b3IpCiAJCQkJICogZm5fZW50 cmllcyk7CiAKQEAgLTEzNDUsOSArMTM0OSwyNCBAQCBHT01QX09GRkxPQURfbG9hZF9pbWFn ZSAoaW50IG9yZCwgdW5zaWduZWQgdmVyc2lvbiwgY29uc3Qgdm9pZCAqdGFyZ2V0X2RhdGEs CiAgICAgICB0YXJnX3RibC0+ZW5kID0gdGFyZ190YmwtPnN0YXJ0ICsgYnl0ZXM7CiAgICAg fQogCisgIENVZGV2aWNlcHRyIGRldmljZV9udW1fdmFycHRyOworICBzaXplX3QgZGV2aWNl X251bV92YXJzaXplOworICBDVXJlc3VsdCByID0gQ1VEQV9DQUxMX05PQ0hFQ0sgKGN1TW9k dWxlR2V0R2xvYmFsLCAmZGV2aWNlX251bV92YXJwdHIsCisJCQkJICAmZGV2aWNlX251bV92 YXJzaXplLCBtb2R1bGUsCisJCQkJICBTVFJJTkdYIChHT01QX0RFVklDRV9OVU1fVkFSKSk7 CisgIGlmIChyID09IENVREFfU1VDQ0VTUykKKyAgICB7CisgICAgICB0YXJnX3RibC0+c3Rh cnQgPSAodWludHB0cl90KSBkZXZpY2VfbnVtX3ZhcnB0cjsKKyAgICAgIHRhcmdfdGJsLT5l bmQgPSAodWludHB0cl90KSAoZGV2aWNlX251bV92YXJwdHIgKyBkZXZpY2VfbnVtX3ZhcnNp emUpOworICAgIH0KKyAgZWxzZQorICAgIC8qIFRoZSAnR09NUF9ERVZJQ0VfTlVNX1ZBUicg dmFyaWFibGUgd2FzIG5vdCBpbiB0aGlzIGltYWdlLiAgKi8KKyAgICB0YXJnX3RibC0+c3Rh cnQgPSB0YXJnX3RibC0+ZW5kID0gMDsKKyAgdGFyZ190YmwrKzsKKwogICBudnB0eF9zZXRf Y2xvY2t0aWNrIChtb2R1bGUsIGRldik7CiAKLSAgcmV0dXJuIGZuX2VudHJpZXMgKyB2YXJf ZW50cmllczsKKyAgcmV0dXJuIGZuX2VudHJpZXMgKyB2YXJfZW50cmllcyArIG90aGVyX2Vu dHJpZXM7CiB9CiAKIC8qIFVubG9hZCB0aGUgcHJvZ3JhbSBkZXNjcmliZWQgYnkgVEFSR0VU X0RBVEEuICBERVZfREFUQSBpcyB0aGUKZGlmZiAtLWdpdCBhL2xpYmdvbXAvdGFyZ2V0LmMg Yi9saWJnb21wL3RhcmdldC5jCmluZGV4IDQ1M2IzMjEwZTQwLi42N2ZjZjQxY2MyZSAxMDA2 NDQKLS0tIGEvbGliZ29tcC90YXJnZXQuYworKysgYi9saWJnb21wL3RhcmdldC5jCkBAIC0x OTc0LDYgKzE5NzQsOSBAQCBnb21wX2xvYWRfaW1hZ2VfdG9fZGV2aWNlIChzdHJ1Y3QgZ29t cF9kZXZpY2VfZGVzY3IgKmRldmljZXAsIHVuc2lnbmVkIHZlcnNpb24sCiAgIGludCBudW1f ZnVuY3MgPSBob3N0X2Z1bmNzX2VuZCAtIGhvc3RfZnVuY190YWJsZTsKICAgaW50IG51bV92 YXJzICA9IChob3N0X3ZhcnNfZW5kIC0gaG9zdF92YXJfdGFibGUpIC8gMjsKIAorICAvKiBP dGhlcnMgY3VycmVudGx5IGlzIG9ubHkgJ2RldmljZV9udW0nICovCisgIGludCBudW1fb3Ro ZXJzID0gMTsKKwogICAvKiBMb2FkIGltYWdlIHRvIGRldmljZSBhbmQgZ2V0IHRhcmdldCBh ZGRyZXNzZXMgZm9yIHRoZSBpbWFnZS4gICovCiAgIHN0cnVjdCBhZGRyX3BhaXIgKnRhcmdl dF90YWJsZSA9IE5VTEw7CiAgIGludCBpLCBudW1fdGFyZ2V0X2VudHJpZXM7CkBAIC0xOTgy LDcgKzE5ODUsOSBAQCBnb21wX2xvYWRfaW1hZ2VfdG9fZGV2aWNlIChzdHJ1Y3QgZ29tcF9k ZXZpY2VfZGVzY3IgKmRldmljZXAsIHVuc2lnbmVkIHZlcnNpb24sCiAgICAgPSBkZXZpY2Vw LT5sb2FkX2ltYWdlX2Z1bmMgKGRldmljZXAtPnRhcmdldF9pZCwgdmVyc2lvbiwKIAkJCQl0 YXJnZXRfZGF0YSwgJnRhcmdldF90YWJsZSk7CiAKLSAgaWYgKG51bV90YXJnZXRfZW50cmll cyAhPSBudW1fZnVuY3MgKyBudW1fdmFycykKKyAgaWYgKG51bV90YXJnZXRfZW50cmllcyAh PSBudW1fZnVuY3MgKyBudW1fdmFycworICAgICAgLyogT3RoZXJzIChkZXZpY2VfbnVtKSBh cmUgaW5jbHVkZWQgYXMgdHJhaWxpbmcgZW50cmllcyBpbiBwYWlyIGxpc3QuICAqLworICAg ICAgJiYgbnVtX3RhcmdldF9lbnRyaWVzICE9IG51bV9mdW5jcyArIG51bV92YXJzICsgbnVt X290aGVycykKICAgICB7CiAgICAgICBnb21wX211dGV4X3VubG9jayAoJmRldmljZXAtPmxv Y2spOwogICAgICAgaWYgKGlzX3JlZ2lzdGVyX2xvY2spCkBAIC0yMDU0LDYgKzIwNTksMzUg QEAgZ29tcF9sb2FkX2ltYWdlX3RvX2RldmljZSAoc3RydWN0IGdvbXBfZGV2aWNlX2Rlc2Ny ICpkZXZpY2VwLCB1bnNpZ25lZCB2ZXJzaW9uLAogICAgICAgYXJyYXkrKzsKICAgICB9CiAK KyAgLyogTGFzdCBlbnRyeSBpcyBmb3IgdGhlIG9uLWRldmljZSAnZGV2aWNlX251bScgdmFy aWFibGUuIFRvbGVyYXRlIGNhc2UKKyAgICAgd2hlcmUgcGx1Z2luIGRvZXMgbm90IHJldHVy biB0aGlzIGVudHJ5LiAgKi8KKyAgaWYgKG51bV9mdW5jcyArIG51bV92YXJzIDwgbnVtX3Rh cmdldF9lbnRyaWVzKQorICAgIHsKKyAgICAgIHN0cnVjdCBhZGRyX3BhaXIgKmRldmljZV9u dW1fdmFyID0gJnRhcmdldF90YWJsZVtudW1fZnVuY3MgKyBudW1fdmFyc107CisgICAgICAv KiBTdGFydCBhZGRyZXNzIHdpbGwgYmUgbm9uLXplcm8gZm9yIGxhc3QgZW50cnkgaWYgR09N UF9ERVZJQ0VfTlVNX1ZBUgorCSB3YXMgZm91bmQgaW4gdGhpcyBpbWFnZS4gICovCisgICAg ICBpZiAoZGV2aWNlX251bV92YXItPnN0YXJ0ICE9IDApCisJeworCSAgLyogVGhlIGluZGV4 IG9mIHRoZSBkZXZpY2VwIHdpdGhpbiBkZXZpY2VzW10gaXMgcmVnYXJkZWQgYXMgaXRzCisJ ICAgICAnZGV2aWNlIG51bWJlcicsIHdoaWNoIGlzIGRpZmZlcmVudCBmcm9tIHRoZSBwZXIt ZGV2aWNlIHR5cGUKKwkgICAgIGRldmljZXAtPnRhcmdldF9pZC4gICovCisJICBpbnQgZGV2 aWNlX251bV92YWwgPSAoaW50KSAoZGV2aWNlcCAtICZkZXZpY2VzWzBdKTsKKwkgIGlmIChk ZXZpY2VfbnVtX3Zhci0+ZW5kIC0gZGV2aWNlX251bV92YXItPnN0YXJ0ICE9IHNpemVvZiAo aW50KSkKKwkgICAgeworCSAgICAgIGdvbXBfbXV0ZXhfdW5sb2NrICgmZGV2aWNlcC0+bG9j ayk7CisJICAgICAgaWYgKGlzX3JlZ2lzdGVyX2xvY2spCisJCWdvbXBfbXV0ZXhfdW5sb2Nr ICgmcmVnaXN0ZXJfbG9jayk7CisJICAgICAgZ29tcF9mYXRhbCAoIm9mZmxvYWQgcGx1Z2lu IG1hbmFnZWQgJ2RldmljZV9udW0nIG5vdCBvZiBleHBlY3RlZCAiCisJCQkgICJmb3JtYXQi KTsKKwkgICAgfQorCisJICAvKiBDb3B5IGRldmljZV9udW0gdmFsdWUgdG8gcGxhY2Ugb24g ZGV2aWNlIG1lbW9yeSwgaGVyZWJ5IGFjdHVhbGx5CisJICAgICBkZXNpZ25hdGluZyBpdHMg ZGV2aWNlIG51bWJlciBpbnRvIGVmZmVjdC4gICovCisJICBnb21wX2NvcHlfaG9zdDJkZXYg KGRldmljZXAsIE5VTEwsICh2b2lkICopIGRldmljZV9udW1fdmFyLT5zdGFydCwKKwkJCSAg ICAgICZkZXZpY2VfbnVtX3ZhbCwgc2l6ZW9mIChpbnQpLCBmYWxzZSwgTlVMTCk7CisJfQor ICAgIH0KKwogICBmcmVlICh0YXJnZXRfdGFibGUpOwogfQogCmRpZmYgLS1naXQgYS9saWJn b21wL3Rlc3RzdWl0ZS9saWIvbGliZ29tcC5leHAgYi9saWJnb21wL3Rlc3RzdWl0ZS9saWIv bGliZ29tcC5leHAKaW5kZXggYTIwNTAxNTFlODQuLmJhOGE3MzI3NWM1IDEwMDY0NAotLS0g YS9saWJnb21wL3Rlc3RzdWl0ZS9saWIvbGliZ29tcC5leHAKKysrIGIvbGliZ29tcC90ZXN0 c3VpdGUvbGliL2xpYmdvbXAuZXhwCkBAIC0zNzQsNiArMzc0LDExIEBAIHByb2MgY2hlY2tf ZWZmZWN0aXZlX3RhcmdldF9vZmZsb2FkX3RhcmdldF9hbWRnY24geyB9IHsKICAgICByZXR1 cm4gW2xpYmdvbXBfY2hlY2tfZWZmZWN0aXZlX3RhcmdldF9vZmZsb2FkX3RhcmdldCAiYW1k Z2NuIl0KIH0KIAorIyBSZXR1cm4gMSBpZiBjb21waWxpbmcgZm9yIG9mZmxvYWQgdGFyZ2V0 IGludGVsbWljCitwcm9jIGNoZWNrX2VmZmVjdGl2ZV90YXJnZXRfb2ZmbG9hZF90YXJnZXRf aW50ZWxtaWMgeyB9IHsKKyAgICByZXR1cm4gW2xpYmdvbXBfY2hlY2tfZWZmZWN0aXZlX3Rh cmdldF9vZmZsb2FkX3RhcmdldCAiKi1pbnRlbG1pYyJdCit9CisKICMgUmV0dXJuIDEgaWYg b2ZmbG9hZCBkZXZpY2UgaXMgYXZhaWxhYmxlLgogcHJvYyBjaGVja19lZmZlY3RpdmVfdGFy Z2V0X29mZmxvYWRfZGV2aWNlIHsgfSB7CiAgICAgcmV0dXJuIFtjaGVja19ydW50aW1lX25v Y2FjaGUgb2ZmbG9hZF9kZXZpY2VfYXZhaWxhYmxlXyB7CmRpZmYgLS1naXQgYS9saWJnb21w L3Rlc3RzdWl0ZS9saWJnb21wLmMtYysrLWNvbW1vbi90YXJnZXQtNDUuYyBiL2xpYmdvbXAv dGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL3RhcmdldC00NS5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5lYzBkMjAyZTUxYwotLS0gL2Rldi9udWxs CisrKyBiL2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL3RhcmdldC00 NS5jCkBAIC0wLDAgKzEsMzAgQEAKKy8qIHsgZGctZG8gcnVuIHsgdGFyZ2V0IHsgISBvZmZs b2FkX3RhcmdldF9pbnRlbG1pYyB9IH0gfSAqLworCisjaW5jbHVkZSA8b21wLmg+CisjaW5j bHVkZSA8c3RkbGliLmg+CisKK2ludCBtYWluICh2b2lkKQoreworCisgIGludCBob3N0X2Rl dmljZV9udW0gPSBvbXBfZ2V0X2RldmljZV9udW0gKCk7CisKKyAgaWYgKGhvc3RfZGV2aWNl X251bSAhPSBvbXBfZ2V0X2luaXRpYWxfZGV2aWNlICgpKQorICAgIGFib3J0ICgpOworCisg IGludCBkZXZpY2VfbnVtOworICBpbnQgaW5pdGlhbF9kZXZpY2U7CisKKyAgI3ByYWdtYSBv bXAgdGFyZ2V0IG1hcChmcm9tOiBkZXZpY2VfbnVtLCBpbml0aWFsX2RldmljZSkKKyAgewor ICAgIGluaXRpYWxfZGV2aWNlID0gb21wX2lzX2luaXRpYWxfZGV2aWNlICgpOworICAgIGRl dmljZV9udW0gPSBvbXBfZ2V0X2RldmljZV9udW0gKCk7CisgIH0KKworICBpZiAoaW5pdGlh bF9kZXZpY2UgJiYgaG9zdF9kZXZpY2VfbnVtICE9IGRldmljZV9udW0pCisgICAgYWJvcnQg KCk7CisKKyAgaWYgKCFpbml0aWFsX2RldmljZSAmJiBob3N0X2RldmljZV9udW0gPT0gZGV2 aWNlX251bSkKKyAgICBhYm9ydCAoKTsKKworICByZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBh L2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuZm9ydHJhbi90YXJnZXQxMC5mOTAgYi9saWJn b21wL3Rlc3RzdWl0ZS9saWJnb21wLmZvcnRyYW4vdGFyZ2V0MTAuZjkwCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4wYjkzOWFkN2EwZAotLS0gL2Rldi9udWxs CisrKyBiL2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuZm9ydHJhbi90YXJnZXQxMC5mOTAK QEAgLTAsMCArMSwyMCBAQAorISB7IGRnLWRvIHJ1biB7IHRhcmdldCB7ICEgb2ZmbG9hZF90 YXJnZXRfaW50ZWxtaWMgfSB9IH0KKworcHJvZ3JhbSBtYWluCisgIHVzZSBvbXBfbGliCisg IGltcGxpY2l0IG5vbmUKKyAgaW50ZWdlciA6OiBkZXZpY2VfbnVtLCBob3N0X2RldmljZV9u dW0KKyAgbG9naWNhbCA6OiBpbml0aWFsX2RldmljZQorCisgIGhvc3RfZGV2aWNlX251bSA9 IG9tcF9nZXRfZGV2aWNlX251bSAoKQorICBpZiAoaG9zdF9kZXZpY2VfbnVtIC5uZS4gb21w X2dldF9pbml0aWFsX2RldmljZSAoKSkgc3RvcCAxCisKKyAgISRvbXAgdGFyZ2V0IG1hcChm cm9tOiBkZXZpY2VfbnVtLCBpbml0aWFsX2RldmljZSkKKyAgaW5pdGlhbF9kZXZpY2UgPSBv bXBfaXNfaW5pdGlhbF9kZXZpY2UgKCkKKyAgZGV2aWNlX251bSA9IG9tcF9nZXRfZGV2aWNl X251bSAoKQorICAhJG9tcCBlbmQgdGFyZ2V0CisKKyAgaWYgKGluaXRpYWxfZGV2aWNlIC5h bmQuIChob3N0X2RldmljZV9udW0gLm5lLiBkZXZpY2VfbnVtKSkgc3RvcCAyCisgIGlmICgo Lm5vdC4gaW5pdGlhbF9kZXZpY2UpIC5hbmQuIChob3N0X2RldmljZV9udW0gLmVxLiBkZXZp Y2VfbnVtKSkgc3RvcCAzCisKK2VuZCBwcm9ncmFtIG1haW4KLS0gCjIuMTcuMQoK --------------AACAFA1A8E1B393D40BF3C91--