From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from esa2.mentor.iphmx.com (esa2.mentor.iphmx.com [68.232.141.98]) by sourceware.org (Postfix) with ESMTPS id 6C2683858D28 for ; Fri, 5 Nov 2021 16:52:11 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 6C2683858D28 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: 6GYO6dNiK21fqjRWK5PNRFaFxveCvsTlNFBInX4muVTSZFwyVPhogCIVlXMHi52jizvjKKXMxS pRcHqV2PnVnpZ9CyWpezQqJnURMZ1toU9tlNuBaqEMn8sGpZr9UdZdxo+lgVCAq5rr/W8A5Dny SBUaDXeX9/yQmFryc+GXyc/uPwWDZTP/NAHRiSa1yLkbbupQgNsjZAQw1sKgG01GK+CFPH2MK7 g3ZtjuPLXPjow4n+kw8v9yRqJy1v7cIN2D/LtQa2rWtZo3ZjIcaWpBjV5N/UW6w5dF6/SVf1jg ziUcCLBCQjqGPj4vCTW8B4Ki X-IronPort-AV: E=Sophos;i="5.87,212,1631606400"; d="scan'208";a="68104600" Received: from orw-gwy-01-in.mentorg.com ([192.94.38.165]) by esa2.mentor.iphmx.com with ESMTP; 05 Nov 2021 08:52:10 -0800 IronPort-SDR: UUumlPyKe+nplTCE1LmlHmygsXpDzyJpn2mlH/wbEJkZgXw18zlI/3V3ZZCbtOnseUByW3NRYx Hh37FQBxHuzJGJ1+hTFz5MZ2ZDrHl6dgVO9nRxSxieIRxH7d2foXCaRngQpwne7WTFp+XqObvY QsAVhVXgdOvZqs6smWxgxH2hKsfEGNqBwSAmWqp2WVAr/WvcmXHFKlyjSThmiNdIcuQHex5Koy 5SojgCAOH6gAp+6njhui42CxYiEidftMOrqTs4nwXQkW1q6wFmSSLZXuT7ygpu9VqdH72vKx45 AAo= Content-Type: multipart/mixed; boundary="------------N9nfDeaDBICyjpmzMWlqutY9" Message-ID: Date: Sat, 6 Nov 2021 00:51:59 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0) Gecko/20100101 Thunderbird/91.3.0 Subject: [PATCH, v2, OpenMP 5.0] Implement relaxation of implicit map vs. existing device mappings (for mainline trunk) Content-Language: en-US To: Jakub Jelinek CC: gcc-patches , Catherine Moore , Tobias Burnus , Thomas Schwinge References: <20210624155513.GW7746@tucnak> From: Chung-Lin Tang In-Reply-To: <20210624155513.GW7746@tucnak> X-ClientProxiedBy: SVR-ORW-MBX-07.mgc.mentorg.com (147.34.90.207) To svr-orw-mbx-02.mgc.mentorg.com (147.34.90.202) X-Spam-Status: No, score=-10.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, KAM_SHORT, 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: Fri, 05 Nov 2021 16:52:15 -0000 --------------N9nfDeaDBICyjpmzMWlqutY9 Content-Type: text/plain; charset="UTF-8"; format=flowed Content-Transfer-Encoding: 7bit Hi Jakub, On 2021/6/24 11:55 PM, Jakub Jelinek wrote: > On Fri, May 14, 2021 at 09:20:25PM +0800, Chung-Lin Tang wrote: >> diff --git a/gcc/gimplify.c b/gcc/gimplify.c >> index e790f08b23f..69c4a8e0a0a 100644 >> --- a/gcc/gimplify.c >> +++ b/gcc/gimplify.c >> @@ -10374,6 +10374,7 @@ gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data) >> gcc_unreachable (); >> } >> OMP_CLAUSE_SET_MAP_KIND (clause, kind); >> + OMP_CLAUSE_MAP_IMPLICIT_P (clause) = 1; >> if (DECL_SIZE (decl) >> && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) >> { > > As Thomas mentioned, there is now also OMP_CLAUSE_MAP_IMPLICIT that means > something different: > /* Nonzero on map clauses added implicitly for reduction clauses on combined > or composite constructs. They shall be removed if there is an explicit > map clause. */ > Having OMP_CLAUSE_MAP_IMPLICIT and OMP_CLAUSE_MAP_IMPLICIT_P would be too > confusing. So either we need to use just one flag for both purposes or > have two different flags and find a better name for one of them. > The former would be possible if no OMP_CLAUSE_MAP clauses added by the FEs > are implicit - then you could clear OMP_CLAUSE_MAP_IMPLICIT in > gimplify_scan_omp_clauses. I wonder if it is the case though, e.g. doesn't > your "Improve OpenMP target support for C++ [PR92120 v4]" patch add a lot of > such implicit map clauses (e.g. the this[:1] and various others)? I have changed the name to OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P, to signal that this bit is to be passed to the runtime. Right now its intended to be used by clauses created by the middle-end, but front-end uses like that for C++ could be clarified later. > Also, gimplify_adjust_omp_clauses_1 sometimes doesn't add just one map > clause, but several, shouldn't those be marked implicit too? And similarly > it calls lang_hooks.decls.omp_finish_clause which can add even further map > clauses implicitly, shouldn't those be implicit too (in that case copy > the flag from the clause it is called on to the extra clauses it adds)? > > Also as Thomas mentioned, it should be restricted to non-OpenACC, > it can check gimplify_omp_ctxp->region_type if it is OpenMP or OpenACC. Agreed, I've adjusted the patch to only to this implicit setting for OpenMP. This reduces a lot of the originally needed scan test adjustment for existing OpenACC testcases. >> @@ -10971,9 +10972,15 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p, >> list_p = &OMP_CLAUSE_CHAIN (c); >> } >> >> - /* Add in any implicit data sharing. */ >> + /* Add in any implicit data sharing. Implicit clauses are added at the start > > Two spaces after dot in comments. Done. >> + of the clause list, but after any non-map clauses. */ >> struct gimplify_adjust_omp_clauses_data data; >> - data.list_p = list_p; >> + tree *implicit_add_list_p = orig_list_p; >> + while (*implicit_add_list_p >> + && OMP_CLAUSE_CODE (*implicit_add_list_p) != OMP_CLAUSE_MAP) >> + implicit_add_list_p = &OMP_CLAUSE_CHAIN (*implicit_add_list_p); > > Why are the implicit map clauses added first and not last? As I also explained in the first submission email, due to the processing order, if implicit classes are added last (and processed last), for example: #pragma omp target map(tofrom: var.ptr[:N]) map(tofrom: var[implicit]) { // access of var.ptr[] } The explicit var.ptr[:N] will not find anything to map, because the (implicit) map(var) has not been seen yet, and the assumed array section attachment behavior will fail. Only an order like: map(tofrom: var[implicit]) map(tofrom: var.ptr[:N]) will the usual assumed behavior show. And yes, this depends on the new behavior implemented by patch [1], which I still need you to review. e.g. for map(var.ptr[:N]), the proper behavior should *only* map the array section but NOT the base-pointer. [1] https://gcc.gnu.org/pipermail/gcc-patches/2021-May/571195.html > There is also the OpenMP 5.1 [352:17-22] case which basically says that the > implicit mappings should be ignored if there are explicit ones on the same > construct (though, do we really create implicit clauses in that case?). Implicit clauses do not appear to be created if there's an explicit clause already existing. >> +#define GOMP_MAP_IMPLICIT (GOMP_MAP_FLAG_SPECIAL_3 \ >> + | GOMP_MAP_FLAG_SPECIAL_4) >> +/* Mask for entire set of special map kind bits. */ >> +#define GOMP_MAP_FLAG_SPECIAL_BITS (GOMP_MAP_FLAG_SPECIAL_0 \ >> + | GOMP_MAP_FLAG_SPECIAL_1 \ >> + | GOMP_MAP_FLAG_SPECIAL_2 \ >> + | GOMP_MAP_FLAG_SPECIAL_3 \ >> + | GOMP_MAP_FLAG_SPECIAL_4) ... >> +#define GOMP_MAP_IMPLICIT_P(X) \ >> + (((X) & GOMP_MAP_FLAG_SPECIAL_BITS) == GOMP_MAP_IMPLICIT) > > I think here we need to decide with which GOMP_MAP* kinds the implicit > bit will need to be combined with, with looking forward into what features > we still need to implement for OpenMP 5.0/5.1 (not aware of anything in 5.2 > that would need special care but perhaps I've missed it). > > E.g. for declare mapper those single OMP_CLAUSE_MAPs with the implicit > bit might need to be split into various smaller ones, map this FIELD_DECL, > map that other FIELD_DECL, what it points to, etc. Even without declare > mapper, the spec now says that mapping a structure is as if each member is > mapped separately and 5.2 is going to say there is a predefined declare > mapper that does that (which is of course something we don't want under the > hood, we don't want thousands of maps, but virtually split it on a field by > field basis, do all the special stuff - e.g. how pointers are to be mapped > as zero array sections with pointer attachment, how C++ references are to be > handled etc. and then virtually coalesce all the adjacent fields that have > the same treatment back). I think that actually means we should defer most > of the map struct etc. handling we do in gimplify_scan_omp_clauses, instead > note the explicit map clauses and what they refer to, add implicit ones (and > set implicit bit on those), then go over all clauses (explicit and > implicit), do the declare mapper processing, do the sorting of what that > produces based on base expressions/pointers etc. > At this point, I'm not sure if GOMP_MAP_IMPLICIT can or can't appear > together e.g. with GOMP_MAP_STRUCT. Currently with the place of setting OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P in gimplify_adjust_omp_clauses_1, only things like GOMP_MAP_TO/FROM/FORCE_PRESENT/etc. be set. I already had some trouble designating how GOMP_MAP_IMPLICIT would be encoded within the current bits. My guess is that with more sophisticated features like declare mappers, the whole interface probably needs to be extended somewhat. >> @@ -405,8 +422,24 @@ gomp_map_vars_existing (struct gomp_device_descr *devicep, >> static int >> get_kind (bool short_mapkind, void *kinds, int idx) >> { >> - return short_mapkind ? ((unsigned short *) kinds)[idx] >> - : ((unsigned char *) kinds)[idx]; >> + int val = (short_mapkind >> + ? ((unsigned short *) kinds)[idx] >> + : ((unsigned char *) kinds)[idx]); >> + >> + if (GOMP_MAP_IMPLICIT_P (val)) >> + val &= ~GOMP_MAP_IMPLICIT; > > As the particular bit isn't used for anything right now, > perhaps just do val &= ~GOMP_MAP_IMPLICIT unconditionally? GOMP_MAP_IMPLICIT is (GOMP_MAP_FLAG_SPECIAL_3 | GOMP_MAP_FLAG_SPECIAL_4), and those two bits are also partially used for some other things. So an specific check should be needed. > But, on the other side, for !short_mapkind you do not want > to mask that bit out, only the low 3 bits are the mapping > type and the upper bits are log2 of alignment, so the > above for !short_mapkind would in weird way change some > alignments. I see, I've added a short_mapkind check in get_kind. >> + return val; >> +} >> + >> + >> +static bool >> +get_implicit (bool short_mapkind, void *kinds, int idx) >> +{ >> + int val = (short_mapkind >> + ? ((unsigned short *) kinds)[idx] >> + : ((unsigned char *) kinds)[idx]); >> + >> + return GOMP_MAP_IMPLICIT_P (val); > > Similarly can return 0 for !short_mapkind, the compatibility GOMP_target etc. > APIs will never have those in. This too added. Re-tested for trunk without regressions, is this okay now? Thanks, Chung-Lin 2021-11-05 Chung-Lin Tang include/ChangeLog: * gomp-constants.h (GOMP_MAP_FLAG_SPECIAL_3): Define special bit macro. (GOMP_MAP_IMPLICIT): New special map kind bits value. (GOMP_MAP_FLAG_SPECIAL_BITS): Define helper mask for whole set of special map kind bits. (GOMP_MAP_IMPLICIT_P): New predicate macro for implicit map kinds. gcc/ChangeLog: * tree.h (OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P): New access macro for 'implicit' bit, using 'base.deprecated_flag' field of tree_node. * tree-pretty-print.c (dump_omp_clause): Add support for printing implicit attribute in tree dumping. * gimplify.c (gimplify_adjust_omp_clauses_1): Set OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P to 1 if map clause is implicitly created. (gimplify_adjust_omp_clauses): Adjust place of adding implicitly created clauses, from simple append, to starting of list, after non-map clauses. * omp-low.c (lower_omp_target): Add GOMP_MAP_IMPLICIT bits into kind values passed to libgomp for implicit maps. gcc/testsuite/ChangeLog: * c-c++-common/gomp/target-implicit-map-1.c: New test. * c-c++-common/goacc/combined-reduction.c: Adjust scan test pattern. * c-c++-common/goacc/firstprivate-mappings-1.c: Likewise. * c-c++-common/goacc/mdc-1.c: Likewise. * g++.dg/goacc/firstprivate-mappings-1.C: Likewise. libgomp/ChangeLog: * target.c (gomp_map_vars_existing): Add 'bool implicit' parameter, add implicit map handling to allow a "superset" existing map as valid case. (get_kind): Adjust to filter out GOMP_MAP_IMPLICIT bits in return value. (get_implicit): New function to extract implicit status. (gomp_map_fields_existing): Adjust arguments in calls to gomp_map_vars_existing, and add uses of get_implicit. (gomp_map_vars_internal): Likewise. * testsuite/libgomp.c-c++-common/target-implicit-map-1.c: New test. --------------N9nfDeaDBICyjpmzMWlqutY9 Content-Type: text/plain; charset="UTF-8"; name="implicit-20211105.patch" Content-Disposition: attachment; filename="implicit-20211105.patch" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy9naW1wbGlmeS5jIGIvZ2NjL2dpbXBsaWZ5LmMKaW5kZXggZDhl NGIxMzkzNDkuLjU5ZTQ3YmYyYWRlIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxpZnkuYworKysg Yi9nY2MvZ2ltcGxpZnkuYwpAQCAtMTA4NjEsNiArMTA4NjEsMTAgQEAgZ2ltcGxpZnlfYWRq dXN0X29tcF9jbGF1c2VzXzEgKHNwbGF5X3RyZWVfbm9kZSBuLCB2b2lkICpkYXRhKQogCSAg Z2NjX3VucmVhY2hhYmxlICgpOwogCX0KICAgICAgIE9NUF9DTEFVU0VfU0VUX01BUF9LSU5E IChjbGF1c2UsIGtpbmQpOworICAgICAgLyogU2V0dGluZyBvZiB0aGUgaW1wbGljaXQgZmxh ZyBmb3IgdGhlIHJ1bnRpbWUgaXMgY3VycmVudGx5IGRpc2FibGVkIGZvcgorCSBPcGVuQUND LiAgKi8KKyAgICAgIGlmICgoZ2ltcGxpZnlfb21wX2N0eHAtPnJlZ2lvbl90eXBlICYgT1JU X0FDQykgPT0gMCkKKwlPTVBfQ0xBVVNFX01BUF9SVU5USU1FX0lNUExJQ0lUX1AgKGNsYXVz ZSkgPSAxOwogICAgICAgaWYgKERFQ0xfU0laRSAoZGVjbCkKIAkgICYmIFRSRUVfQ09ERSAo REVDTF9TSVpFIChkZWNsKSkgIT0gSU5URUdFUl9DU1QpCiAJewpAQCAtMTE0NzYsOSArMTE0 ODAsMTUgQEAgZ2ltcGxpZnlfYWRqdXN0X29tcF9jbGF1c2VzIChnaW1wbGVfc2VxICpwcmVf cCwgZ2ltcGxlX3NlcSBib2R5LCB0cmVlICpsaXN0X3AsCiAJbGlzdF9wID0gJk9NUF9DTEFV U0VfQ0hBSU4gKGMpOwogICAgIH0KIAotICAvKiBBZGQgaW4gYW55IGltcGxpY2l0IGRhdGEg c2hhcmluZy4gICovCisgIC8qIEFkZCBpbiBhbnkgaW1wbGljaXQgZGF0YSBzaGFyaW5nLiAg SW1wbGljaXQgY2xhdXNlcyBhcmUgYWRkZWQgYXQgdGhlIHN0YXJ0CisgICAgIG9mIHRoZSBj bGF1c2UgbGlzdCwgYnV0IGFmdGVyIGFueSBub24tbWFwIGNsYXVzZXMuICAqLwogICBzdHJ1 Y3QgZ2ltcGxpZnlfYWRqdXN0X29tcF9jbGF1c2VzX2RhdGEgZGF0YTsKLSAgZGF0YS5saXN0 X3AgPSBsaXN0X3A7CisgIHRyZWUgKmltcGxpY2l0X2FkZF9saXN0X3AgPSBvcmlnX2xpc3Rf cDsKKyAgd2hpbGUgKCppbXBsaWNpdF9hZGRfbGlzdF9wCisJICYmIE9NUF9DTEFVU0VfQ09E RSAoKmltcGxpY2l0X2FkZF9saXN0X3ApICE9IE9NUF9DTEFVU0VfTUFQKQorICAgIGltcGxp Y2l0X2FkZF9saXN0X3AgPSAmT01QX0NMQVVTRV9DSEFJTiAoKmltcGxpY2l0X2FkZF9saXN0 X3ApOworCisgIGRhdGEubGlzdF9wID0gaW1wbGljaXRfYWRkX2xpc3RfcDsKICAgZGF0YS5w cmVfcCA9IHByZV9wOwogICBzcGxheV90cmVlX2ZvcmVhY2ggKGN0eC0+dmFyaWFibGVzLCBn aW1wbGlmeV9hZGp1c3Rfb21wX2NsYXVzZXNfMSwgJmRhdGEpOwogCmRpZmYgLS1naXQgYS9n Y2Mvb21wLWxvdy5jIGIvZ2NjL29tcC1sb3cuYwppbmRleCAxNWU0NDI0YjBiYy4uM2Q1OGE2 ZDM1ZTYgMTAwNjQ0Ci0tLSBhL2djYy9vbXAtbG93LmMKKysrIGIvZ2NjL29tcC1sb3cuYwpA QCAtMTMxNTMsNiArMTMxNTMsMTkgQEAgbG93ZXJfb21wX3RhcmdldCAoZ2ltcGxlX3N0bXRf aXRlcmF0b3IgKmdzaV9wLCBvbXBfY29udGV4dCAqY3R4KQogCQkgICAgZWxzZSBpZiAoaW50 ZWdlcl9ub256ZXJvcCAocykpCiAJCSAgICAgIHRraW5kX3plcm8gPSB0a2luZDsKIAkJICB9 CisJCWlmICh0a2luZF96ZXJvID09IHRraW5kCisJCSAgICAmJiBPTVBfQ0xBVVNFX01BUF9S VU5USU1FX0lNUExJQ0lUX1AgKGMpCisJCSAgICAmJiAoKCh0a2luZCAmIEdPTVBfTUFQX0ZM QUdfU1BFQ0lBTF9CSVRTKQorCQkJICYgfkdPTVBfTUFQX0lNUExJQ0lUKQorCQkJPT0gMCkp CisJCSAgeworCQkgICAgLyogSWYgdGhpcyBpcyBhbiBpbXBsaWNpdCBtYXAsIGFuZCB0aGUg R09NUF9NQVBfSU1QTElDSVQKKwkJICAgICAgIGJpdHMgYXJlIG5vdCBpbnRlcmZlcmVkIGJ5 IG90aGVyIHNwZWNpYWwgYml0IGVuY29kaW5ncywKKwkJICAgICAgIHRoZW4gdHVybiB0aGUg R09NUF9JTVBMSUNJVF9CSVQgZmxhZyBvbiBmb3IgdGhlIHJ1bnRpbWUKKwkJICAgICAgIHRv IHNlZS4gICovCisJCSAgICB0a2luZCB8PSBHT01QX01BUF9JTVBMSUNJVDsKKwkJICAgIHRr aW5kX3plcm8gPSB0a2luZDsKKwkJICB9CiAJCWJyZWFrOwogCSAgICAgIGNhc2UgT01QX0NM QVVTRV9GSVJTVFBSSVZBVEU6CiAJCWdjY19jaGVja2luZ19hc3NlcnQgKGlzX2dpbXBsZV9v bXBfb2FjYyAoY3R4LT5zdG10KSk7CmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2MtYysr LWNvbW1vbi9nb2FjYy9jb21iaW5lZC1yZWR1Y3Rpb24uYyBiL2djYy90ZXN0c3VpdGUvYy1j KystY29tbW9uL2dvYWNjL2NvbWJpbmVkLXJlZHVjdGlvbi5jCmluZGV4IGVjZjIzZjU5ZDY2 Li43NGFiMDViYzg1NiAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9jLWMrKy1jb21tb24v Z29hY2MvY29tYmluZWQtcmVkdWN0aW9uLmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9jLWMrKy1j b21tb24vZ29hY2MvY29tYmluZWQtcmVkdWN0aW9uLmMKQEAgLTIzLDcgKzIzLDcgQEAgbWFp biAoKQogICByZXR1cm4gMDsKIH0KIAotLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1w LXRpbWVzICJvbXAgdGFyZ2V0IG9hY2NfcGFyYWxsZWwgcmVkdWN0aW9uLis6djEuIG1hcC50 b2Zyb206djEiIDEgImdpbXBsZSIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAtdGltZXMgIm9tcCB0YXJnZXQgb2FjY19wYXJhbGxlbCByZWR1Y3Rpb24uKzp2MS4g Zmlyc3Rwcml2YXRlLm4uIG1hcC50b2Zyb206djEiIDEgImdpbXBsZSIgfSB9ICovCiAvKiB7 IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtdGltZXMgImFjYyBsb29wIHJlZHVjdGlvbi4r OnYxLiBwcml2YXRlLmkuIiAxICJnaW1wbGUiIH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNj YW4tdHJlZS1kdW1wLXRpbWVzICJvbXAgdGFyZ2V0IG9hY2Nfa2VybmVscyBtYXAuZm9yY2Vf dG9mcm9tOm4gLmxlbjogNC4uIG1hcC5mb3JjZV90b2Zyb206djEgLmxlbjogNC4uIiAxICJn aW1wbGUiIH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVzICJh Y2MgbG9vcCByZWR1Y3Rpb24uKzp2MS4gcHJpdmF0ZS5pLiIgMSAiZ2ltcGxlIiB9IH0gKi8K ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvYy1jKystY29tbW9uL2dvYWNjL2ZpcnN0cHJp dmF0ZS1tYXBwaW5ncy0xLmMgYi9nY2MvdGVzdHN1aXRlL2MtYysrLWNvbW1vbi9nb2FjYy9m aXJzdHByaXZhdGUtbWFwcGluZ3MtMS5jCmluZGV4IDc5ODdiZWFlZDlhLi41MTM0ZWY2ZWQ2 YyAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9jLWMrKy1jb21tb24vZ29hY2MvZmlyc3Rw cml2YXRlLW1hcHBpbmdzLTEuYworKysgYi9nY2MvdGVzdHN1aXRlL2MtYysrLWNvbW1vbi9n b2FjYy9maXJzdHByaXZhdGUtbWFwcGluZ3MtMS5jCkBAIC00MTksMTIgKzQxOSw3IEBAIHZs YSAoaW50IGFycmF5X2xpKQogICBjb3B5b3V0IChhcnJheV9zbykKICAgLyogVGhlIGdpbXBs aWZpZXIgaGFzIGNyZWF0ZWQgYW4gaW1wbGljaXQgJ2ZpcnN0cHJpdmF0ZScgY2xhdXNlIGZv ciB0aGUgYXJyYXkKICAgICAgbGVuZ3RoLgotICAgICB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgeyg/bikjcHJhZ21hIG9tcCB0YXJnZXQgb2FjY19wYXJhbGxlbCBtYXBcKGZyb206 YXJyYXlfc28gXFtsZW46IDRcXVwpIGZpcnN0cHJpdmF0ZVwoYXJyYXlfbGkuWzAtOV0rXCl9 IG9tcGxvd2VyIHsgdGFyZ2V0IHsgISBjKysgfSB9IH0gfQotICAgICB7IGRnLWZpbmFsIHsg c2Nhbi10cmVlLWR1bXAgeyg/bikjcHJhZ21hIG9tcCB0YXJnZXQgb2FjY19wYXJhbGxlbCBt YXBcKGZyb206YXJyYXlfc28gXFtsZW46IDRcXVwpIGZpcnN0cHJpdmF0ZVwofSBvbXBsb3dl ciB7IHRhcmdldCB7IGMrKyB9IH0gfSB9Ci0gICAgIChDKysgY29tcHV0ZXMgYW4gaW50ZXJt ZWRpYXRlIHZhbHVlLCBzbyBjYW4ndCBzY2FuIGZvciAnZmlyc3Rwcml2YXRlKGFycmF5X2xp KScuKSAgKi8KLSAgLyogRm9yIEMsIG5vbi1MUDY0LCB0aGUgZ2ltcGxpZmllciBoYXMgYWxz byBjcmVhdGVkIGEgbWFwcGluZyBmb3IgdGhlIGFycmF5Ci0gICAgIGl0c2VsZjsgUFI5MDg1 OS4KLSAgICAgeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wIHsoP24pI3ByYWdtYSBvbXAg dGFyZ2V0IG9hY2NfcGFyYWxsZWwgbWFwXChmcm9tOmFycmF5X3NvIFxbbGVuOiA0XF1cKSBm aXJzdHByaXZhdGVcKGFycmF5X2xpLlswLTldK1wpIG1hcFwodG9mcm9tOlwoXCphcnJheS5b MC05XStcKSBcW2xlbjogRFwuWzAtOV0rXF1cKSBtYXBcKGZpcnN0cHJpdmF0ZTphcnJheSBc W3BvaW50ZXIgYXNzaWduLCBiaWFzOiAwXF1cKSBcW30gb21wbG93ZXIgeyB0YXJnZXQgeyBj ICYmIHsgISBscDY0IH0gfSB9IH0gfSAqLworICAgICB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgeyg/bikjcHJhZ21hIG9tcCB0YXJnZXQgb2FjY19wYXJhbGxlbCBmaXJzdHByaXZh dGVcKGFycmF5X2xpLlswLTldK1wpIG1hcFwoZnJvbTphcnJheV9zbyBcW2xlbjogNFxdXCkg XFt9IG9tcGxvd2VyIH0gfSAqLwogICB7CiAgICAgYXJyYXlfc28gPSBzaXplb2YgYXJyYXk7 CiAgIH0KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvYy1jKystY29tbW9uL2dvYWNjL21k Yy0xLmMgYi9nY2MvdGVzdHN1aXRlL2MtYysrLWNvbW1vbi9nb2FjYy9tZGMtMS5jCmluZGV4 IGMyYjhkYzZjODgwLi4wYTEyM2JlYzU4ZiAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9j LWMrKy1jb21tb24vZ29hY2MvbWRjLTEuYworKysgYi9nY2MvdGVzdHN1aXRlL2MtYysrLWNv bW1vbi9nb2FjYy9tZGMtMS5jCkBAIC00NSw3ICs0NSw3IEBAIHQxICgpCiAKIC8qIHsgZGct ZmluYWwgeyBzY2FuLXRyZWUtZHVtcC10aW1lcyAicHJhZ21hIG9tcCB0YXJnZXQgb2FjY19l bnRlcl9kYXRhIG1hcC50bzpzIC5sZW46IDMyLi4iIDEgIm9tcGxvd2VyIiB9IH0gKi8KIC8q IHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcC10aW1lcyAicHJhZ21hIG9tcCB0YXJnZXQg b2FjY19kYXRhIG1hcC50b2Zyb206LnogLmxlbjogNDAuLiBtYXAuc3RydWN0OnMgLmxlbjog MS4uIG1hcC5hbGxvYzpzLmEgLmxlbjogOC4uIG1hcC50b2Zyb206Ll8xIC5sZW46IDQwLi4g bWFwLmF0dGFjaDpzLmEgLmJpYXM6IDAuLiIgMSAib21wbG93ZXIiIH0gfSAqLwotLyogeyBk Zy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVzICJwcmFnbWEgb21wIHRhcmdldCBvYWNj X3BhcmFsbGVsIG1hcC5hdHRhY2g6cy5lIC5iaWFzOiAwLi4gbWFwLnRvZnJvbTpzIC5sZW46 IDMyIiAxICJvbXBsb3dlciIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1 bXAtdGltZXMgInByYWdtYSBvbXAgdGFyZ2V0IG9hY2NfcGFyYWxsZWwgbWFwLnRvZnJvbTpz IC5sZW46IDMyLi4gbWFwLmF0dGFjaDpzLmUgLmJpYXM6IDAuLiIgMSAib21wbG93ZXIiIH0g fSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVzICJwcmFnbWEgb21w IHRhcmdldCBvYWNjX2VudGVyX2RhdGEgbWFwLmF0dGFjaDphIC5iaWFzOiAwLi4iIDEgIm9t cGxvd2VyIiB9IH0gKi8KIC8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcC10aW1lcyAi cHJhZ21hIG9tcCB0YXJnZXQgb2FjY19leGl0X2RhdGEgbWFwLmRldGFjaDphIC5iaWFzOiAw Li4iIDEgIm9tcGxvd2VyIiB9IH0gKi8KIC8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVt cC10aW1lcyAicHJhZ21hIG9tcCB0YXJnZXQgb2FjY19lbnRlcl9kYXRhIG1hcC50bzphIC5s ZW46IDguLiIgMSAib21wbG93ZXIiIH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0 ZS9jLWMrKy1jb21tb24vZ29tcC90YXJnZXQtaW1wbGljaXQtbWFwLTEuYyBiL2djYy90ZXN0 c3VpdGUvYy1jKystY29tbW9uL2dvbXAvdGFyZ2V0LWltcGxpY2l0LW1hcC0xLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjUyOTQ0ZmRjNjVhCi0tLSAvZGV2 L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9jLWMrKy1jb21tb24vZ29tcC90YXJnZXQtaW1w bGljaXQtbWFwLTEuYwpAQCAtMCwwICsxLDM5IEBACisvKiB7IGRnLWRvIGNvbXBpbGUgfSAq LworLyogeyBkZy1hZGRpdGlvbmFsLW9wdGlvbnMgIi1mZHVtcC10cmVlLWdpbXBsZSIgfSAq LworI2lmZGVmIF9fY3BsdXNwbHVzCitleHRlcm4gIkMiCisjZWxzZQorZXh0ZXJuCisjZW5k aWYKK3ZvaWQgYWJvcnQgKHZvaWQpOworCitpbnQKK21haW4gKHZvaWQpCit7CisgICNkZWZp bmUgTiA1CisgIGludCBhcnJheVtOXVtOXTsKKworICBmb3IgKGludCBpID0gMDsgaSA8IE47 IGkrKykKKyAgICB7CisgICAgICAjcHJhZ21hIG9tcCB0YXJnZXQgZW50ZXIgZGF0YSBtYXAo YWxsb2M6IGFycmF5W2k6MV1bMDpOXSkKKworICAgICAgI3ByYWdtYSBvbXAgdGFyZ2V0Cisg ICAgICBmb3IgKGludCBqID0gMDsgaiA8IE47IGorKykKKwlhcnJheVtpXVtqXSA9IGkgKiAx MCArIGo7CisKKyAgICAgICNwcmFnbWEgb21wIHRhcmdldCBleGl0IGRhdGEgbWFwKGZyb206 IGFycmF5W2k6MV1bMDpOXSkKKyAgICB9CisKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBOOyBp KyspCisgICAgZm9yIChpbnQgaiA9IDA7IGogPCBOOyBqKyspCisgICAgICBpZiAoYXJyYXlb aV1bal0gIT0gaSArIGopCisJYWJvcnQgKCk7CisKKyAgcmV0dXJuIDA7Cit9CisKKy8qIHsg ZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcCB7I3ByYWdtYSBvbXAgdGFyZ2V0IGVudGVyIGRh dGEgbWFwXChhbGxvYzphcnJheVxbW15dXStcXVxbMFxdIFxbbGVuOiBbMC05XStcXVwpfSAi Z2ltcGxlIiB9IH0gKi8KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wIHsjcHJh Z21hIG9tcCB0YXJnZXQgbnVtX3RlYW1zLiogZmlyc3Rwcml2YXRlXChpXCkgbWFwXCh0b2Zy b206YXJyYXkgXFtsZW46IFswLTldK1xdXFtpbXBsaWNpdFxdXCl9ICJnaW1wbGUiIH0gfSAq LworCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgeyNwcmFnbWEgb21wIHRhcmdl dCBleGl0IGRhdGEgbWFwXChmcm9tOmFycmF5XFtbXl1dK1xdXFswXF0gXFtsZW46IFswLTld K1xdXCl9ICJnaW1wbGUiIH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nKysu ZGcvZ29hY2MvZmlyc3Rwcml2YXRlLW1hcHBpbmdzLTEuQyBiL2djYy90ZXN0c3VpdGUvZysr LmRnL2dvYWNjL2ZpcnN0cHJpdmF0ZS1tYXBwaW5ncy0xLkMKaW5kZXggMWIxYmFkYjFhOTAu Ljk5YTNiZDQ3MmY3IDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2crKy5kZy9nb2FjYy9m aXJzdHByaXZhdGUtbWFwcGluZ3MtMS5DCisrKyBiL2djYy90ZXN0c3VpdGUvZysrLmRnL2dv YWNjL2ZpcnN0cHJpdmF0ZS1tYXBwaW5ncy0xLkMKQEAgLTQxNiw3ICs0MTYsNyBAQCB2bGEg KGludCAmYXJyYXlfbGkpCiAgIGNvcHlvdXQgKGFycmF5X3NvKQogICAvKiBUaGUgZ2ltcGxp ZmllciBoYXMgY3JlYXRlZCBhbiBpbXBsaWNpdCAnZmlyc3Rwcml2YXRlJyBjbGF1c2UgZm9y IHRoZSBhcnJheQogICAgICBsZW5ndGguCi0gICAgIHsgZGctZmluYWwgeyBzY2FuLXRyZWUt ZHVtcCB7KD9uKSNwcmFnbWEgb21wIHRhcmdldCBvYWNjX3BhcmFsbGVsIG1hcFwoZnJvbTph cnJheV9zbyBcW2xlbjogNFxdXCkgZmlyc3Rwcml2YXRlXCh9IG9tcGxvd2VyIH0gfQorICAg ICB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgeyg/bikjcHJhZ21hIG9tcCB0YXJnZXQg b2FjY19wYXJhbGxlbCBmaXJzdHByaXZhdGVcKFteKV0rXCkgbWFwXChmcm9tOmFycmF5X3Nv IFxbbGVuOiA0XF1cKX0gb21wbG93ZXIgfSB9CiAgICAgIChDKysgY29tcHV0ZXMgYW4gaW50 ZXJtZWRpYXRlIHZhbHVlLCBzbyBjYW4ndCBzY2FuIGZvciAnZmlyc3Rwcml2YXRlKGFycmF5 X2xpKScuKSAgKi8KICAgewogICAgIGFycmF5X3NvID0gc2l6ZW9mIGFycmF5OwpkaWZmIC0t Z2l0IGEvZ2NjL3RyZWUtcHJldHR5LXByaW50LmMgYi9nY2MvdHJlZS1wcmV0dHktcHJpbnQu YwppbmRleCAyNzVkYzdkOGFmNy4uMGRhODVlZmMxMDQgMTAwNjQ0Ci0tLSBhL2djYy90cmVl LXByZXR0eS1wcmludC5jCisrKyBiL2djYy90cmVlLXByZXR0eS1wcmludC5jCkBAIC05NzEs NiArOTcxLDkgQEAgZHVtcF9vbXBfY2xhdXNlIChwcmV0dHlfcHJpbnRlciAqcHAsIHRyZWUg Y2xhdXNlLCBpbnQgc3BjLCBkdW1wX2ZsYWdzX3QgZmxhZ3MpCiAJCQkgICAgIHNwYywgZmxh Z3MsIGZhbHNlKTsKIAkgIHBwX3JpZ2h0X2JyYWNrZXQgKHBwKTsKIAl9CisgICAgICBpZiAo T01QX0NMQVVTRV9DT0RFIChjbGF1c2UpID09IE9NUF9DTEFVU0VfTUFQCisJICAmJiBPTVBf Q0xBVVNFX01BUF9SVU5USU1FX0lNUExJQ0lUX1AgKGNsYXVzZSkpCisJcHBfc3RyaW5nIChw cCwgIltpbXBsaWNpdF0iKTsKICAgICAgIHBwX3JpZ2h0X3BhcmVuIChwcCk7CiAgICAgICBi cmVhazsKIApkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUuaCBiL2djYy90cmVlLmgKaW5kZXggNzU0 MmQ5N2NlMTIuLmJhOTc0NDcxMzM5IDEwMDY0NAotLS0gYS9nY2MvdHJlZS5oCisrKyBiL2dj Yy90cmVlLmgKQEAgLTE2ODksNiArMTY4OSwxMSBAQCBjbGFzcyBhdXRvX3N1cHByZXNzX2xv Y2F0aW9uX3dyYXBwZXJzCiAgICBtYXAgY2xhdXNlLiAgKi8KICNkZWZpbmUgT01QX0NMQVVT RV9NQVBfSU1QTElDSVQoTk9ERSkgXAogICAoT01QX0NMQVVTRV9TVUJDT0RFX0NIRUNLIChO T0RFLCBPTVBfQ0xBVVNFX01BUCktPmJhc2UuZGVmYXVsdF9kZWZfZmxhZykKKy8qIE5vbnpl cm8gaWYgdGhpcyBtYXAgY2xhdXNlIGlzIHRvIGJlIGluZGljYXRlZCB0byB0aGUgcnVudGlt ZSBhcyAnaW1wbGljaXQnLAorICAgZHVlIHRvIGJlaW5nIGNyZWF0ZWQgdGhyb3VnaCBpbXBs aWNpdCBkYXRhLW1hcHBpbmcgcnVsZXMgaW4gdGhlIG1pZGRsZS1lbmQuCisgICBOT1RFOiB0 aGlzIGlzIGRpZmZlcmVudCB0aGFuIE9NUF9DTEFVU0VfTUFQX0lNUExJQ0lULiAgKi8KKyNk ZWZpbmUgT01QX0NMQVVTRV9NQVBfUlVOVElNRV9JTVBMSUNJVF9QKE5PREUpIFwKKyAgKE9N UF9DTEFVU0VfU1VCQ09ERV9DSEVDSyAoTk9ERSwgT01QX0NMQVVTRV9NQVApLT5iYXNlLmRl cHJlY2F0ZWRfZmxhZykKIAogLyogVHJ1ZSBvbiBhbiBPTVBfQ0xBVVNFX1VTRV9ERVZJQ0Vf UFRSIHdpdGggYW4gT3BlbkFDQyAnaWZfcHJlc2VudCcKICAgIGNsYXVzZS4gICovCmRpZmYg LS1naXQgYS9pbmNsdWRlL2dvbXAtY29uc3RhbnRzLmggYi9pbmNsdWRlL2dvbXAtY29uc3Rh bnRzLmgKaW5kZXggZWJkMDgwMTM0MzAuLjNlNDJkNzEyM2FlIDEwMDY0NAotLS0gYS9pbmNs dWRlL2dvbXAtY29uc3RhbnRzLmgKKysrIGIvaW5jbHVkZS9nb21wLWNvbnN0YW50cy5oCkBA IC00MCwxMSArNDAsMjIgQEAKICNkZWZpbmUgR09NUF9NQVBfRkxBR19TUEVDSUFMXzAJCSgx IDw8IDIpCiAjZGVmaW5lIEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF8xCQkoMSA8PCAzKQogI2Rl ZmluZSBHT01QX01BUF9GTEFHX1NQRUNJQUxfMgkJKDEgPDwgNCkKKyNkZWZpbmUgR09NUF9N QVBfRkxBR19TUEVDSUFMXzMJCSgxIDw8IDUpCiAjZGVmaW5lIEdPTVBfTUFQX0ZMQUdfU1BF Q0lBTF80CQkoMSA8PCA2KQogI2RlZmluZSBHT01QX01BUF9GTEFHX1NQRUNJQUwJCShHT01Q X01BUF9GTEFHX1NQRUNJQUxfMSBcCiAJCQkJCSB8IEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF8w KQogI2RlZmluZSBHT01QX01BUF9ERUVQX0NPUFkJCShHT01QX01BUF9GTEFHX1NQRUNJQUxf NCBcCiAJCQkJCSB8IEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF8yKQorLyogVGhpcyB2YWx1ZSBp bmRpY2F0ZXMgdGhlIG1hcCB3YXMgY3JlYXRlZCBpbXBsaWNpdGx5IGFjY29yZGluZyB0bwor ICAgT3Blbk1QIHJ1bGVzLiAgKi8KKyNkZWZpbmUgR09NUF9NQVBfSU1QTElDSVQJCShHT01Q X01BUF9GTEFHX1NQRUNJQUxfMyBcCisJCQkJCSB8IEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF80 KQorLyogTWFzayBmb3IgZW50aXJlIHNldCBvZiBzcGVjaWFsIG1hcCBraW5kIGJpdHMuICAq LworI2RlZmluZSBHT01QX01BUF9GTEFHX1NQRUNJQUxfQklUUwkoR09NUF9NQVBfRkxBR19T UEVDSUFMXzAgXAorCQkJCQkgfCBHT01QX01BUF9GTEFHX1NQRUNJQUxfMSBcCisJCQkJCSB8 IEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF8yIFwKKwkJCQkJIHwgR09NUF9NQVBfRkxBR19TUEVD SUFMXzMgXAorCQkJCQkgfCBHT01QX01BUF9GTEFHX1NQRUNJQUxfNCkKIC8qIEZsYWcgdG8g Zm9yY2UgYSBzcGVjaWZpYyBiZWhhdmlvciAob3IgZWxzZSwgdHJpZ2dlciBhIHJ1bi10aW1l IGVycm9yKS4gICovCiAjZGVmaW5lIEdPTVBfTUFQX0ZMQUdfRk9SQ0UJCSgxIDw8IDcpCiAK QEAgLTE4Niw2ICsxOTcsOSBAQCBlbnVtIGdvbXBfbWFwX2tpbmQKICNkZWZpbmUgR09NUF9N QVBfQUxXQVlTX1AoWCkgXAogICAoR09NUF9NQVBfQUxXQVlTX1RPX1AgKFgpIHx8ICgoWCkg PT0gR09NUF9NQVBfQUxXQVlTX0ZST00pKQogCisjZGVmaW5lIEdPTVBfTUFQX0lNUExJQ0lU X1AoWCkgXAorICAoKChYKSAmIEdPTVBfTUFQX0ZMQUdfU1BFQ0lBTF9CSVRTKSA9PSBHT01Q X01BUF9JTVBMSUNJVCkKKwogCiAvKiBBc3luY2hyb25vdXMgYmVoYXZpb3IuICBLZWVwIGlu IHN5bmMgd2l0aAogICAgbGliZ29tcC97b3BlbmFjYy5oLG9wZW5hY2MuZjkwLG9wZW5hY2Nf bGliLmh9OmFjY19hc3luY190LiAgKi8KZGlmZiAtLWdpdCBhL2xpYmdvbXAvdGFyZ2V0LmMg Yi9saWJnb21wL3RhcmdldC5jCmluZGV4IDE5NmRiYTRmMDhjLi5kZDdmNTczZmVhOCAxMDA2 NDQKLS0tIGEvbGliZ29tcC90YXJnZXQuYworKysgYi9saWJnb21wL3RhcmdldC5jCkBAIC01 MzksNyArNTM5LDcgQEAgc3RhdGljIGlubGluZSB2b2lkCiBnb21wX21hcF92YXJzX2V4aXN0 aW5nIChzdHJ1Y3QgZ29tcF9kZXZpY2VfZGVzY3IgKmRldmljZXAsCiAJCQlzdHJ1Y3QgZ29h Y2NfYXN5bmNxdWV1ZSAqYXEsIHNwbGF5X3RyZWVfa2V5IG9sZG4sCiAJCQlzcGxheV90cmVl X2tleSBuZXduLCBzdHJ1Y3QgdGFyZ2V0X3Zhcl9kZXNjICp0Z3RfdmFyLAotCQkJdW5zaWdu ZWQgY2hhciBraW5kLCBib29sIGFsd2F5c190b19mbGFnLAorCQkJdW5zaWduZWQgY2hhciBr aW5kLCBib29sIGFsd2F5c190b19mbGFnLCBib29sIGltcGxpY2l0LAogCQkJc3RydWN0IGdv bXBfY29hbGVzY2VfYnVmICpjYnVmLAogCQkJaHRhYl90ICpyZWZjb3VudF9zZXQpCiB7CkBA IC01NTAsMTEgKzU1MCwyMiBAQCBnb21wX21hcF92YXJzX2V4aXN0aW5nIChzdHJ1Y3QgZ29t cF9kZXZpY2VfZGVzY3IgKmRldmljZXAsCiAgIHRndF92YXItPmFsd2F5c19jb3B5X2Zyb20g PSBHT01QX01BUF9BTFdBWVNfRlJPTV9QIChraW5kKTsKICAgdGd0X3Zhci0+aXNfYXR0YWNo ID0gZmFsc2U7CiAgIHRndF92YXItPm9mZnNldCA9IG5ld24tPmhvc3Rfc3RhcnQgLSBvbGRu LT5ob3N0X3N0YXJ0OwotICB0Z3RfdmFyLT5sZW5ndGggPSBuZXduLT5ob3N0X2VuZCAtIG5l d24tPmhvc3Rfc3RhcnQ7CisKKyAgLyogRm9yIGltcGxpY2l0IG1hcHMsIG9sZCBjb250YWlu ZWQgaW4gbmV3IGlzIHZhbGlkLiAgKi8KKyAgYm9vbCBpbXBsaWNpdF9zdWJzZXQgPSAoaW1w bGljaXQKKwkJCSAgJiYgbmV3bi0+aG9zdF9zdGFydCA8PSBvbGRuLT5ob3N0X3N0YXJ0CisJ CQkgICYmIG9sZG4tPmhvc3RfZW5kIDw9IG5ld24tPmhvc3RfZW5kKTsKKyAgaWYgKGltcGxp Y2l0X3N1YnNldCkKKyAgICB0Z3RfdmFyLT5sZW5ndGggPSBvbGRuLT5ob3N0X2VuZCAtIG9s ZG4tPmhvc3Rfc3RhcnQ7CisgIGVsc2UKKyAgICB0Z3RfdmFyLT5sZW5ndGggPSBuZXduLT5o b3N0X2VuZCAtIG5ld24tPmhvc3Rfc3RhcnQ7CiAKICAgaWYgKChraW5kICYgR09NUF9NQVBf RkxBR19GT1JDRSkKLSAgICAgIHx8IG9sZG4tPmhvc3Rfc3RhcnQgPiBuZXduLT5ob3N0X3N0 YXJ0Ci0gICAgICB8fCBvbGRuLT5ob3N0X2VuZCA8IG5ld24tPmhvc3RfZW5kKQorICAgICAg LyogRm9yIGltcGxpY2l0IG1hcHMsIG9sZCBjb250YWluZWQgaW4gbmV3IGlzIHZhbGlkLiAg Ki8KKyAgICAgIHx8ICEoaW1wbGljaXRfc3Vic2V0CisJICAgLyogT3RoZXJ3aXNlLCBuZXcg Y29udGFpbmVkIGluc2lkZSBvbGQgaXMgY29uc2lkZXJlZCB2YWxpZC4gICovCisJICAgfHwg KG9sZG4tPmhvc3Rfc3RhcnQgPD0gbmV3bi0+aG9zdF9zdGFydAorCSAgICAgICAmJiBuZXdu LT5ob3N0X2VuZCA8PSBvbGRuLT5ob3N0X2VuZCkpKQogICAgIHsKICAgICAgIGdvbXBfbXV0 ZXhfdW5sb2NrICgmZGV2aWNlcC0+bG9jayk7CiAgICAgICBnb21wX2ZhdGFsICgiVHJ5aW5n IHRvIG1hcCBpbnRvIGRldmljZSBbJXAuLiVwKSBvYmplY3Qgd2hlbiAiCkBAIC01NjQsMTEg KzU3NSwxNyBAQCBnb21wX21hcF92YXJzX2V4aXN0aW5nIChzdHJ1Y3QgZ29tcF9kZXZpY2Vf ZGVzY3IgKmRldmljZXAsCiAgICAgfQogCiAgIGlmIChHT01QX01BUF9BTFdBWVNfVE9fUCAo a2luZCkgfHwgYWx3YXlzX3RvX2ZsYWcpCi0gICAgZ29tcF9jb3B5X2hvc3QyZGV2IChkZXZp Y2VwLCBhcSwKLQkJCSh2b2lkICopIChvbGRuLT50Z3QtPnRndF9zdGFydCArIG9sZG4tPnRn dF9vZmZzZXQKLQkJCQkgICsgbmV3bi0+aG9zdF9zdGFydCAtIG9sZG4tPmhvc3Rfc3RhcnQp LAotCQkJKHZvaWQgKikgbmV3bi0+aG9zdF9zdGFydCwKLQkJCW5ld24tPmhvc3RfZW5kIC0g bmV3bi0+aG9zdF9zdGFydCwgZmFsc2UsIGNidWYpOworICAgIHsKKyAgICAgIC8qIEltcGxp Y2l0ICsgYWx3YXlzIHNob3VsZCBub3QgaGFwcGVuLiBJZiB0aGlzIGRvZXMgb2NjdXIsIGJl bG93CisJIGFkZHJlc3MvbGVuZ3RoIGFkanVzdG1lbnQgaXMgYSBUT0RPLiAgKi8KKyAgICAg IGFzc2VydCAoIWltcGxpY2l0X3N1YnNldCk7CisKKyAgICAgIGdvbXBfY29weV9ob3N0MmRl diAoZGV2aWNlcCwgYXEsCisJCQkgICh2b2lkICopIChvbGRuLT50Z3QtPnRndF9zdGFydCAr IG9sZG4tPnRndF9vZmZzZXQKKwkJCQkgICAgKyBuZXduLT5ob3N0X3N0YXJ0IC0gb2xkbi0+ aG9zdF9zdGFydCksCisJCQkgICh2b2lkICopIG5ld24tPmhvc3Rfc3RhcnQsCisJCQkgIG5l d24tPmhvc3RfZW5kIC0gbmV3bi0+aG9zdF9zdGFydCwgZmFsc2UsIGNidWYpOworICAgIH0K IAogICBnb21wX2luY3JlbWVudF9yZWZjb3VudCAob2xkbiwgcmVmY291bnRfc2V0KTsKIH0K QEAgLTU3Niw4ICs1OTMsMjQgQEAgZ29tcF9tYXBfdmFyc19leGlzdGluZyAoc3RydWN0IGdv bXBfZGV2aWNlX2Rlc2NyICpkZXZpY2VwLAogc3RhdGljIGludAogZ2V0X2tpbmQgKGJvb2wg c2hvcnRfbWFwa2luZCwgdm9pZCAqa2luZHMsIGludCBpZHgpCiB7Ci0gIHJldHVybiBzaG9y dF9tYXBraW5kID8gKCh1bnNpZ25lZCBzaG9ydCAqKSBraW5kcylbaWR4XQotCQkgICAgICAg OiAoKHVuc2lnbmVkIGNoYXIgKikga2luZHMpW2lkeF07CisgIGludCB2YWwgPSAoc2hvcnRf bWFwa2luZAorCSAgICAgPyAoKHVuc2lnbmVkIHNob3J0ICopIGtpbmRzKVtpZHhdCisJICAg ICA6ICgodW5zaWduZWQgY2hhciAqKSBraW5kcylbaWR4XSk7CisKKyAgaWYgKHNob3J0X21h cGtpbmQgJiYgR09NUF9NQVBfSU1QTElDSVRfUCAodmFsKSkKKyAgICB2YWwgJj0gfkdPTVBf TUFQX0lNUExJQ0lUOworICByZXR1cm4gdmFsOworfQorCisKK3N0YXRpYyBib29sCitnZXRf aW1wbGljaXQgKGJvb2wgc2hvcnRfbWFwa2luZCwgdm9pZCAqa2luZHMsIGludCBpZHgpCit7 CisgIGludCB2YWwgPSAoc2hvcnRfbWFwa2luZAorCSAgICAgPyAoKHVuc2lnbmVkIHNob3J0 ICopIGtpbmRzKVtpZHhdCisJICAgICA6ICgodW5zaWduZWQgY2hhciAqKSBraW5kcylbaWR4 XSk7CisKKyAgcmV0dXJuIHNob3J0X21hcGtpbmQgJiYgR09NUF9NQVBfSU1QTElDSVRfUCAo dmFsKTsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTYzMSw2ICs2NjQsNyBAQCBnb21wX21hcF9m aWVsZHNfZXhpc3RpbmcgKHN0cnVjdCB0YXJnZXRfbWVtX2Rlc2MgKnRndCwKICAgc3RydWN0 IHNwbGF5X3RyZWVfcyAqbWVtX21hcCA9ICZkZXZpY2VwLT5tZW1fbWFwOwogICBzdHJ1Y3Qg c3BsYXlfdHJlZV9rZXlfcyBjdXJfbm9kZTsKICAgaW50IGtpbmQ7CisgIGJvb2wgaW1wbGlj aXQ7CiAgIGNvbnN0IGJvb2wgc2hvcnRfbWFwa2luZCA9IHRydWU7CiAgIGNvbnN0IGludCB0 eXBlbWFzayA9IHNob3J0X21hcGtpbmQgPyAweGZmIDogMHg3OwogCkBAIC02MzgsMTIgKzY3 MiwxNCBAQCBnb21wX21hcF9maWVsZHNfZXhpc3RpbmcgKHN0cnVjdCB0YXJnZXRfbWVtX2Rl c2MgKnRndCwKICAgY3VyX25vZGUuaG9zdF9lbmQgPSBjdXJfbm9kZS5ob3N0X3N0YXJ0ICsg c2l6ZXNbaV07CiAgIHNwbGF5X3RyZWVfa2V5IG4yID0gc3BsYXlfdHJlZV9sb29rdXAgKG1l bV9tYXAsICZjdXJfbm9kZSk7CiAgIGtpbmQgPSBnZXRfa2luZCAoc2hvcnRfbWFwa2luZCwg a2luZHMsIGkpOworICBpbXBsaWNpdCA9IGdldF9pbXBsaWNpdCAoc2hvcnRfbWFwa2luZCwg a2luZHMsIGkpOwogICBpZiAobjIKICAgICAgICYmIG4yLT50Z3QgPT0gbi0+dGd0CiAgICAg ICAmJiBuMi0+aG9zdF9zdGFydCAtIG4tPmhvc3Rfc3RhcnQgPT0gbjItPnRndF9vZmZzZXQg LSBuLT50Z3Rfb2Zmc2V0KQogICAgIHsKICAgICAgIGdvbXBfbWFwX3ZhcnNfZXhpc3Rpbmcg KGRldmljZXAsIGFxLCBuMiwgJmN1cl9ub2RlLCAmdGd0LT5saXN0W2ldLAotCQkJICAgICAg a2luZCAmIHR5cGVtYXNrLCBmYWxzZSwgY2J1ZiwgcmVmY291bnRfc2V0KTsKKwkJCSAgICAg IGtpbmQgJiB0eXBlbWFzaywgZmFsc2UsIGltcGxpY2l0LCBjYnVmLAorCQkJICAgICAgcmVm Y291bnRfc2V0KTsKICAgICAgIHJldHVybjsKICAgICB9CiAgIGlmIChzaXplc1tpXSA9PSAw KQpAQCAtNjU5LDcgKzY5NSw4IEBAIGdvbXBfbWFwX2ZpZWxkc19leGlzdGluZyAoc3RydWN0 IHRhcmdldF9tZW1fZGVzYyAqdGd0LAogCQkgPT0gbjItPnRndF9vZmZzZXQgLSBuLT50Z3Rf b2Zmc2V0KQogCSAgICB7CiAJICAgICAgZ29tcF9tYXBfdmFyc19leGlzdGluZyAoZGV2aWNl cCwgYXEsIG4yLCAmY3VyX25vZGUsICZ0Z3QtPmxpc3RbaV0sCi0JCQkJICAgICAga2luZCAm IHR5cGVtYXNrLCBmYWxzZSwgY2J1ZiwgcmVmY291bnRfc2V0KTsKKwkJCQkgICAgICBraW5k ICYgdHlwZW1hc2ssIGZhbHNlLCBpbXBsaWNpdCwgY2J1ZiwKKwkJCQkgICAgICByZWZjb3Vu dF9zZXQpOwogCSAgICAgIHJldHVybjsKIAkgICAgfQogCX0KQEAgLTY3MSw3ICs3MDgsOCBA QCBnb21wX21hcF9maWVsZHNfZXhpc3RpbmcgKHN0cnVjdCB0YXJnZXRfbWVtX2Rlc2MgKnRn dCwKIAkgICYmIG4yLT5ob3N0X3N0YXJ0IC0gbi0+aG9zdF9zdGFydCA9PSBuMi0+dGd0X29m ZnNldCAtIG4tPnRndF9vZmZzZXQpCiAJewogCSAgZ29tcF9tYXBfdmFyc19leGlzdGluZyAo ZGV2aWNlcCwgYXEsIG4yLCAmY3VyX25vZGUsICZ0Z3QtPmxpc3RbaV0sCi0JCQkJICBraW5k ICYgdHlwZW1hc2ssIGZhbHNlLCBjYnVmLCByZWZjb3VudF9zZXQpOworCQkJCSAga2luZCAm IHR5cGVtYXNrLCBmYWxzZSwgaW1wbGljaXQsIGNidWYsCisJCQkJICByZWZjb3VudF9zZXQp OwogCSAgcmV0dXJuOwogCX0KICAgICB9CkBAIC05MDMsNiArOTQxLDcgQEAgZ29tcF9tYXBf dmFyc19pbnRlcm5hbCAoc3RydWN0IGdvbXBfZGV2aWNlX2Rlc2NyICpkZXZpY2VwLAogICBm b3IgKGkgPSAwOyBpIDwgbWFwbnVtOyBpKyspCiAgICAgewogICAgICAgaW50IGtpbmQgPSBn ZXRfa2luZCAoc2hvcnRfbWFwa2luZCwga2luZHMsIGkpOworICAgICAgYm9vbCBpbXBsaWNp dCA9IGdldF9pbXBsaWNpdCAoc2hvcnRfbWFwa2luZCwga2luZHMsIGkpOwogICAgICAgaWYg KGhvc3RhZGRyc1tpXSA9PSBOVUxMCiAJICB8fCAoa2luZCAmIHR5cGVtYXNrKSA9PSBHT01Q X01BUF9GSVJTVFBSSVZBVEVfSU5UKQogCXsKQEAgLTEwODUsOCArMTEyNCw4IEBAIGdvbXBf bWFwX3ZhcnNfaW50ZXJuYWwgKHN0cnVjdCBnb21wX2RldmljZV9kZXNjciAqZGV2aWNlcCwK IAkJfQogCSAgICB9CiAJICBnb21wX21hcF92YXJzX2V4aXN0aW5nIChkZXZpY2VwLCBhcSwg biwgJmN1cl9ub2RlLCAmdGd0LT5saXN0W2ldLAotCQkJCSAga2luZCAmIHR5cGVtYXNrLCBh bHdheXNfdG9fY250ID4gMCwgTlVMTCwKLQkJCQkgIHJlZmNvdW50X3NldCk7CisJCQkJICBr aW5kICYgdHlwZW1hc2ssIGFsd2F5c190b19jbnQgPiAwLCBpbXBsaWNpdCwKKwkJCQkgIE5V TEwsIHJlZmNvdW50X3NldCk7CiAJICBpICs9IGFsd2F5c190b19jbnQ7CiAJfQogICAgICAg ZWxzZQpAQCAtMTI1Niw2ICsxMjk1LDcgQEAgZ29tcF9tYXBfdmFyc19pbnRlcm5hbCAoc3Ry dWN0IGdvbXBfZGV2aWNlX2Rlc2NyICpkZXZpY2VwLAogCWVsc2UgaWYgKHRndC0+bGlzdFtp XS5rZXkgPT0gTlVMTCkKIAkgIHsKIAkgICAgaW50IGtpbmQgPSBnZXRfa2luZCAoc2hvcnRf bWFwa2luZCwga2luZHMsIGkpOworCSAgICBib29sIGltcGxpY2l0ID0gZ2V0X2ltcGxpY2l0 IChzaG9ydF9tYXBraW5kLCBraW5kcywgaSk7CiAJICAgIGlmIChob3N0YWRkcnNbaV0gPT0g TlVMTCkKIAkgICAgICBjb250aW51ZTsKIAkgICAgc3dpdGNoIChraW5kICYgdHlwZW1hc2sp CkBAIC0xNDE1LDcgKzE0NTUsNyBAQCBnb21wX21hcF92YXJzX2ludGVybmFsIChzdHJ1Y3Qg Z29tcF9kZXZpY2VfZGVzY3IgKmRldmljZXAsCiAJICAgIHNwbGF5X3RyZWVfa2V5IG4gPSBz cGxheV90cmVlX2xvb2t1cCAobWVtX21hcCwgayk7CiAJICAgIGlmIChuICYmIG4tPnJlZmNv dW50ICE9IFJFRkNPVU5UX0xJTkspCiAJICAgICAgZ29tcF9tYXBfdmFyc19leGlzdGluZyAo ZGV2aWNlcCwgYXEsIG4sIGssICZ0Z3QtPmxpc3RbaV0sCi0JCQkJICAgICAga2luZCAmIHR5 cGVtYXNrLCBmYWxzZSwgY2J1ZnAsCisJCQkJICAgICAga2luZCAmIHR5cGVtYXNrLCBmYWxz ZSwgaW1wbGljaXQsIGNidWZwLAogCQkJCSAgICAgIHJlZmNvdW50X3NldCk7CiAJICAgIGVs c2UKIAkgICAgICB7CmRpZmYgLS1naXQgYS9saWJnb21wL3Rlc3RzdWl0ZS9saWJnb21wLmMt YysrLWNvbW1vbi90YXJnZXQtaW1wbGljaXQtbWFwLTEuYyBiL2xpYmdvbXAvdGVzdHN1aXRl L2xpYmdvbXAuYy1jKystY29tbW9uL3RhcmdldC1pbXBsaWNpdC1tYXAtMS5jCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5mMmU3MjkzNjg2MgotLS0gL2Rldi9u dWxsCisrKyBiL2xpYmdvbXAvdGVzdHN1aXRlL2xpYmdvbXAuYy1jKystY29tbW9uL3Rhcmdl dC1pbXBsaWNpdC1tYXAtMS5jCkBAIC0wLDAgKzEsMzEgQEAKKyNpZmRlZiBfX2NwbHVzcGx1 cworZXh0ZXJuICJDIgorI2Vsc2UKK2V4dGVybgorI2VuZGlmCit2b2lkIGFib3J0ICh2b2lk KTsKKworaW50CittYWluICh2b2lkKQoreworICAjZGVmaW5lIE4gNQorICBpbnQgYXJyYXlb Tl1bTl07CisKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBOOyBpKyspCisgICAgeworICAgICAg I3ByYWdtYSBvbXAgdGFyZ2V0IGVudGVyIGRhdGEgbWFwKGFsbG9jOiBhcnJheVtpOjFdWzA6 Tl0pCisKKyAgICAgICNwcmFnbWEgb21wIHRhcmdldAorICAgICAgZm9yIChpbnQgaiA9IDA7 IGogPCBOOyBqKyspCisJYXJyYXlbaV1bal0gPSBpICsgajsKKworICAgICAgI3ByYWdtYSBv bXAgdGFyZ2V0IGV4aXQgZGF0YSBtYXAoZnJvbTogYXJyYXlbaToxXVswOk5dKQorICAgIH0K KworICBmb3IgKGludCBpID0gMDsgaSA8IE47IGkrKykKKyAgICBmb3IgKGludCBqID0gMDsg aiA8IE47IGorKykKKyAgICAgIGlmIChhcnJheVtpXVtqXSAhPSBpICsgaikKKwlhYm9ydCAo KTsKKworICByZXR1cm4gMDsKK30K --------------N9nfDeaDBICyjpmzMWlqutY9--