From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 65135 invoked by alias); 21 Dec 2018 16:05:11 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 65123 invoked by uid 89); 21 Dec 2018 16:05:10 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: =?ISO-8859-1?Q?No, score=-11.9 required=5.0 tests=BAYES_00,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=Gr, Gr=c3=bc=c3, one-time, onetime?= X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 21 Dec 2018 16:05:06 +0000 Received: from svr-orw-mbx-02.mgc.mentorg.com ([147.34.90.202]) by relay1.mentorg.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-SHA384:256) id 1gaNIO-00069a-CH from ChungLin_Tang@mentor.com for gcc-patches@gcc.gnu.org; Fri, 21 Dec 2018 08:05:04 -0800 Received: from [0.0.0.0] (147.34.91.1) by svr-orw-mbx-02.mgc.mentorg.com (147.34.90.202) with Microsoft SMTP Server (TLS) id 15.0.1320.4; Fri, 21 Dec 2018 08:05:01 -0800 Reply-To: Subject: Re: [PATCH 2/6, OpenACC, libgomp] Async re-work, oacc-* parts (revised, v3) To: Thomas Schwinge , Chung-Lin Tang CC: References: <12319572-dd02-c946-f2b9-9d047be9c707@mentor.com> <34db59a1-0446-1720-9a2e-b6e54f52edb2@mentor.com> From: Chung-Lin Tang Message-ID: <9d8a319f-1955-3c1d-74b2-75c3815943ba@mentor.com> Date: Fri, 21 Dec 2018 16:25:00 -0000 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:60.0) Gecko/20100101 Thunderbird/60.3.3 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------BF2F656A2E4C90A6D3A97AC0" X-SW-Source: 2018-12/txt/msg01579.txt.bz2 --------------BF2F656A2E4C90A6D3A97AC0 Content-Type: text/plain; charset="utf-8"; format=flowed Content-Transfer-Encoding: 8bit Content-length: 5372 On 2018/12/19 5:03 AM, Thomas Schwinge wrote: > Hi Chung-Lin! > > On Tue, 18 Dec 2018 23:06:38 +0800, Chung-Lin Tang wrote: >> this part includes some of the lookup_goacc_asyncqueue fixes we talked about. >> I am still thinking about how the queue lock problem should really be solved, so regard >> this patch as just fixing some of the problems. Hi Thomas, This is my solution to the queue lock stuff we talked about. I've only attached a diff to be applied atop of the existing changes, though that may actually be easier to review. Note that this is still in testing, which means it hasn't been tested :P, but I'm posting to see if you have time to give it a look before the holidays. Having the need for a lock on the async queues is quite irritating, especially when the structure needed for managing them is quite simple. Therefore, lets do away the need for locks entirely. This patch makes the asyncqueue part of the device->openacc.async managed by lock-free atomic operations; almost all of the complexity is contained in lookup_goacc_asyncqueue(), so it should be not too complex. A descriptor and the queue array is allocated/exchanged atomically when more storage is required, while in the common case a simple lookup is enough. The fact that we manage asyncqueues by only expanding and never destroying asyncqueues during the device lifetime also simplifies many things. The current implementation may be not that optimized and clunky in some cases, but I think this should be the way to implement what should be a fairly simple asyncqueue array and active list. I'll update more on the status as testing proceeds. (and about the other corners you noticed in the last mail, I'll get to that later...) Thanks, Chung-Lin > Sure, thanks. > > Two comments, though: > >> --- libgomp/oacc-async.c (revision 267226) >> +++ libgomp/oacc-async.c (working copy) > >> +attribute_hidden struct goacc_asyncqueue * >> +lookup_goacc_asyncqueue (struct goacc_thread *thr, bool create, int async) >> +{ >> + /* The special value acc_async_noval (-1) maps to the thread-specific >> + default async stream. */ >> + if (async == acc_async_noval) >> + async = thr->default_async; >> + >> + if (async == acc_async_sync) >> + return NULL; >> + >> + if (async < 0) >> + gomp_fatal ("bad async %d", async); >> + >> + struct gomp_device_descr *dev = thr->dev; >> + >> + gomp_mutex_lock (&dev->openacc.async.lock); >> + >> + if (!create >> + && (async >= dev->openacc.async.nasyncqueue >> + || !dev->openacc.async.asyncqueue[async])) >> + { >> + gomp_mutex_unlock (&dev->openacc.async.lock); >> + return NULL; >> + } >> + >> + if (async >= dev->openacc.async.nasyncqueue) >> + { >> + int diff = async + 1 - dev->openacc.async.nasyncqueue; >> + dev->openacc.async.asyncqueue >> + = gomp_realloc (dev->openacc.async.asyncqueue, >> + sizeof (goacc_aq) * (async + 1)); >> + memset (dev->openacc.async.asyncqueue + dev->openacc.async.nasyncqueue, >> + 0, sizeof (goacc_aq) * diff); >> + dev->openacc.async.nasyncqueue = async + 1; >> + } >> + >> + if (!dev->openacc.async.asyncqueue[async]) >> + { >> + dev->openacc.async.asyncqueue[async] = dev->openacc.async.construct_func (); >> + >> + if (!dev->openacc.async.asyncqueue[async]) >> + { >> + gomp_mutex_unlock (&dev->openacc.async.lock); >> + gomp_fatal ("async %d creation failed", async); >> + } > > That will now always fail for host fallback, where > "host_openacc_async_construct" just always does "return NULL". > > Actually, if the device doesn't support asyncqueues, this whole function > should turn into some kind of no-op, so that we don't again and again try > to create a new one for every call to "lookup_goacc_asyncqueue". > > I'm attaching one possible solution. I think it's fine to assume that > the majority of devices will support asyncqueues, and for those that > don't, this is just a one-time overhead per async-argument. So, no > special handling required in "lookup_goacc_asyncqueue". > >> + /* Link new async queue into active list. */ >> + goacc_aq_list n = gomp_malloc (sizeof (struct goacc_asyncqueue_list)); >> + n->aq = dev->openacc.async.asyncqueue[async]; >> + n->next = dev->openacc.async.active; >> + dev->openacc.async.active = n; >> + } >> + gomp_mutex_unlock (&dev->openacc.async.lock); > > You still need to keep "async" locked during... > >> + return dev->openacc.async.asyncqueue[async]; > > ... this dereference. > >> +} > > > Oh, and: > >> --- libgomp/oacc-plugin.c (revision 267226) >> +++ libgomp/oacc-plugin.c (working copy) >> @@ -31,14 +31,10 @@ >> #include "oacc-int.h" >> >> void >> -GOMP_PLUGIN_async_unmap_vars (void *ptr, int async) >> +GOMP_PLUGIN_async_unmap_vars (void *ptr __attribute__((unused)), >> + int async __attribute__((unused))) >> { >> - struct target_mem_desc *tgt = ptr; >> - struct gomp_device_descr *devicep = tgt->device_descr; >> - >> - devicep->openacc.async_set_async_func (async); >> - gomp_unmap_vars (tgt, true); >> - devicep->openacc.async_set_async_func (acc_async_sync); >> + gomp_fatal ("invalid plugin function"); >> } > > Please add a comment here, something like: "Obsolete entry point, no > longer used." > > > Grüße > Thomas > > --------------BF2F656A2E4C90A6D3A97AC0 Content-Type: text/plain; charset="UTF-8"; x-mac-type=0; x-mac-creator=0; name="async-02.oacc-parts.v2-v3.diff" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="async-02.oacc-parts.v2-v3.diff" Content-length: 11623 ZGlmZiAtcnUgdHJ1bmstb3JpZy9saWJnb21wL2xpYmdvbXAuaCB0cnVuay13 b3JrL2xpYmdvbXAvbGliZ29tcC5oCi0tLSB0cnVuay1vcmlnL2xpYmdvbXAv bGliZ29tcC5oCTIwMTgtMTItMjAgMjM6MjQ6MjAuMDQwMzc1NzI0ICswODAw CisrKyB0cnVuay13b3JrL2xpYmdvbXAvbGliZ29tcC5oCTIwMTgtMTItMjEg MjM6MzI6NDcuOTM4NjI4OTU0ICswODAwCkBAIC05MzcsNiArOTM3LDEzIEBA CiAKICNpbmNsdWRlICJzcGxheS10cmVlLmgiCiAKK3N0cnVjdCBnb2FjY19h c3luY3F1ZXVlX2Rlc2MKK3sKKyAgaW50IG5hc3luY3F1ZXVlOworICBzdHJ1 Y3QgZ29hY2NfYXN5bmNxdWV1ZSAqKmFzeW5jcXVldWU7CisgIHN0cnVjdCBn b2FjY19hc3luY3F1ZXVlX2xpc3QgKmFjdGl2ZTsKK307CisKIHR5cGVkZWYg c3RydWN0IGFjY19kaXNwYXRjaF90CiB7CiAgIC8qIFRoaXMgaXMgYSBsaW5r ZWQgbGlzdCBvZiBkYXRhIG1hcHBlZCB1c2luZyB0aGUKQEAgLTk1NSwxMCAr OTYyLDcgQEAKICAgICAqZGVzdHJveV90aHJlYWRfZGF0YV9mdW5jOwogICAK ICAgc3RydWN0IHsKLSAgICBnb21wX211dGV4X3QgbG9jazsKLSAgICBpbnQg bmFzeW5jcXVldWU7Ci0gICAgc3RydWN0IGdvYWNjX2FzeW5jcXVldWUgKiph c3luY3F1ZXVlOwotICAgIHN0cnVjdCBnb2FjY19hc3luY3F1ZXVlX2xpc3Qg KmFjdGl2ZTsKKyAgICBzdHJ1Y3QgZ29hY2NfYXN5bmNxdWV1ZV9kZXNjICph cWRlc2M7CiAKICAgICBfX3R5cGVvZiAoR09NUF9PRkZMT0FEX29wZW5hY2Nf YXN5bmNfY29uc3RydWN0KSAqY29uc3RydWN0X2Z1bmM7CiAgICAgX190eXBl b2YgKEdPTVBfT0ZGTE9BRF9vcGVuYWNjX2FzeW5jX2Rlc3RydWN0KSAqZGVz dHJ1Y3RfZnVuYzsKZGlmZiAtcnUgdHJ1bmstb3JpZy9saWJnb21wL29hY2Mt YXN5bmMuYyB0cnVuay13b3JrL2xpYmdvbXAvb2FjYy1hc3luYy5jCi0tLSB0 cnVuay1vcmlnL2xpYmdvbXAvb2FjYy1hc3luYy5jCTIwMTgtMTItMTggMjI6 MTk6NTEuOTIzMTAyOTM4ICswODAwCisrKyB0cnVuay13b3JrL2xpYmdvbXAv b2FjYy1hc3luYy5jCTIwMTgtMTItMjEgMjM6NDA6MzYuMDg4NTI4ODkwICsw ODAwCkBAIC03MCw0NSArNzAsODQgQEAKIAogICBzdHJ1Y3QgZ29tcF9kZXZp Y2VfZGVzY3IgKmRldiA9IHRoci0+ZGV2OwogCi0gIGdvbXBfbXV0ZXhfbG9j ayAoJmRldi0+b3BlbmFjYy5hc3luYy5sb2NrKTsKKyAgc3RydWN0IGdvYWNj X2FzeW5jcXVldWVfZGVzYyAqYXFkZXNjID0gZGV2LT5vcGVuYWNjLmFzeW5j LmFxZGVzYzsKIAotICBpZiAoIWNyZWF0ZQotICAgICAgJiYgKGFzeW5jID49 IGRldi0+b3BlbmFjYy5hc3luYy5uYXN5bmNxdWV1ZQotCSAgfHwgIWRldi0+ b3BlbmFjYy5hc3luYy5hc3luY3F1ZXVlW2FzeW5jXSkpCi0gICAgewotICAg ICAgZ29tcF9tdXRleF91bmxvY2sgKCZkZXYtPm9wZW5hY2MuYXN5bmMubG9j ayk7Ci0gICAgICByZXR1cm4gTlVMTDsKLSAgICB9CisgIGlmICghY3JlYXRl KQorICAgIHJldHVybiBhc3luYyA8IGFxZGVzYy0+bmFzeW5jcXVldWUgPyBh cWRlc2MtPmFzeW5jcXVldWVbYXN5bmNdIDogTlVMTDsKIAotICBpZiAoYXN5 bmMgPj0gZGV2LT5vcGVuYWNjLmFzeW5jLm5hc3luY3F1ZXVlKQotICAgIHsK LSAgICAgIGludCBkaWZmID0gYXN5bmMgKyAxIC0gZGV2LT5vcGVuYWNjLmFz eW5jLm5hc3luY3F1ZXVlOwotICAgICAgZGV2LT5vcGVuYWNjLmFzeW5jLmFz eW5jcXVldWUKLQk9IGdvbXBfcmVhbGxvYyAoZGV2LT5vcGVuYWNjLmFzeW5j LmFzeW5jcXVldWUsCi0JCQlzaXplb2YgKGdvYWNjX2FxKSAqIChhc3luYyAr IDEpKTsKLSAgICAgIG1lbXNldCAoZGV2LT5vcGVuYWNjLmFzeW5jLmFzeW5j cXVldWUgKyBkZXYtPm9wZW5hY2MuYXN5bmMubmFzeW5jcXVldWUsCi0JICAg ICAgMCwgc2l6ZW9mIChnb2FjY19hcSkgKiBkaWZmKTsKLSAgICAgIGRldi0+ b3BlbmFjYy5hc3luYy5uYXN5bmNxdWV1ZSA9IGFzeW5jICsgMTsKLSAgICB9 CisgIGlmIChhc3luYyA8IGFxZGVzYy0+bmFzeW5jcXVldWUgJiYgYXFkZXNj LT5hc3luY3F1ZXVlW2FzeW5jXSkKKyAgICByZXR1cm4gYXFkZXNjLT5hc3lu Y3F1ZXVlW2FzeW5jXTsKIAotICBpZiAoIWRldi0+b3BlbmFjYy5hc3luYy5h c3luY3F1ZXVlW2FzeW5jXSkKLSAgICB7Ci0gICAgICBkZXYtPm9wZW5hY2Mu YXN5bmMuYXN5bmNxdWV1ZVthc3luY10gPSBkZXYtPm9wZW5hY2MuYXN5bmMu Y29uc3RydWN0X2Z1bmMgKCk7CisgIHN0cnVjdCBnb2FjY19hc3luY3F1ZXVl ICpuZXdfYXEgPSBkZXYtPm9wZW5hY2MuYXN5bmMuY29uc3RydWN0X2Z1bmMg KCk7CisgIGNvbnN0IGludCBpbmNfc2l6ZSA9IDg7CisgIGludCBuZXdfc3og PSBhc3luYyArIDEgKyBpbmNfc2l6ZTsKKyAgbmV3X3N6ID0gKG5ld19zeiAr IGluY19zaXplIC0gMSkgJiB+KGluY19zaXplIC0gMSk7CisKKyAgc3RydWN0 IGdvYWNjX2FzeW5jcXVldWUgKipuZXdfYXF2ZWMgPQorICAgIGdvbXBfbWFs bG9jX2NsZWFyZWQgKHNpemVvZiAoZ29hY2NfYXEpICogbmV3X3N6KTsKKyAg bmV3X2FxdmVjW2FzeW5jXSA9IG5ld19hcTsKKworICBzdHJ1Y3QgZ29hY2Nf YXN5bmNxdWV1ZV9kZXNjICpuZGVzYyA9CisgICAgZ29tcF9tYWxsb2MgKHNp emVvZiAoc3RydWN0IGdvYWNjX2FzeW5jcXVldWVfZGVzYykpOworICBuZGVz Yy0+YXN5bmNxdWV1ZSA9IG5ld19hcXZlYzsKKyAgbmRlc2MtPm5hc3luY3F1 ZXVlID0gbmV3X3N6OworCisgIGdvYWNjX2FxX2xpc3QgbmwgPSBnb21wX21h bGxvYyAoc2l6ZW9mIChzdHJ1Y3QgZ29hY2NfYXN5bmNxdWV1ZV9saXN0KSk7 CisgIG5sLT5hcSA9IG5ld19hcTsKKyAgbmRlc2MtPmFjdGl2ZSA9IG5sOwor CisgIC8qIExvb3AgdG8gYXRvbWljYWxseSBjcmVhdGUgYW5kIGFkZCBhIG5l dyBhc3luYyBxdWV1ZSwgd2l0aG91dCB1c2luZyBhIGxvY2ssCisgICAgIHRo b3VnaCBtYXkgcG9zc2libHkgcmVxdWlyaW5nIGNyZWF0aW5nIGFuZCByZXBs YWNpbmcgd2l0aCBhIG5ldyBkZXNjcmlwdG9yLgorICAgICBUaGlzIG1heSBs aWtlbHkgbm90IGJlIGFzIG9wdGltaXplZCBhcyBpdCBjYW4gYmUsIGFsdGhv dWdoIHNpbXBsaWZpZXMKKyAgICAgb3RoZXIgaGFuZGxpbmcgb2YgYXN5bmMg cXVldWVzLiAgKi8KKyAgZG8geworICAgIGludCBjdXJyX251bV9hcXMgPSBh cWRlc2MtPm5hc3luY3F1ZXVlOworICAgIAorICAgIGlmIChhc3luYyA8IGN1 cnJfbnVtX2FxcykKKyAgICAgIHsKKwkvKiBTb21lb25lIGVsc2UgZXhwYW5k ZWQgdGhlIGFzeW5jcWV1ZSBhcnJheSB0byBlbm91Z2ggc2l6ZSwgZnJlZSB0 aGUKKwkgICBhbGxvY2F0ZWQgcmVzb3VyY2VzLiAgKi8KKwlmcmVlIChuZGVz Yy0+YXN5bmNxdWV1ZSk7CisJZnJlZSAobmRlc2MpOworCisJLyogVHJ5IHRv IHNldCB0aGUgbmV3IGFxIHRvIHRoZSByaWdodCBwbGFjZSBhZ2Fpbi4gICov CisJc3RydWN0IGdvYWNjX2FzeW5jcXVldWVfZGVzYyAqbnVsbHEgPSBOVUxM OworCWlmIChfX2F0b21pY19jb21wYXJlX2V4Y2hhbmdlICgmYXFkZXNjLT5h c3luY3F1ZXVlW2FzeW5jXSwKKwkJCQkgICAgICAgJm51bGxxLCAmbmV3X2Fx LCBmYWxzZSwKKwkJCQkgICAgICAgX19BVE9NSUNfQUNRX1JFTCwgX19BVE9N SUNfQUNRVUlSRSkpCisJICB7CisJICAgIC8qIFB1c2ggbmV3IGFzeW5jcXVl dWUgdG8gZnJvbnQgb2YgYWN0aXZlIGxpc3QuICAqLworCSAgICBubC0+bmV4 dCA9IGFxZGVzYy0+YWN0aXZlOworCSAgICB3aGlsZSAoIV9fYXRvbWljX2Nv bXBhcmVfZXhjaGFuZ2UgKCZhcWRlc2MtPmFjdGl2ZSwgJm5sLT5uZXh0LCAm bmwsCisJCQkJCSAgICAgICB0cnVlLCBfX0FUT01JQ19BQ1FfUkVMLAorCQkJ CQkgICAgICAgX19BVE9NSUNfQUNRVUlSRSkpCisJICAgICAgOworCSAgfQor CWVsc2UKKwkgIHsKKwkgICAgLyogT2theSwgc29tZW9uZSBlbHNlIGFscmVh ZHkgY3JlYXRlZCAnYXN5bmMnLCBmcmVlL2Rlc3Ryb3kKKwkgICAgICAgZXZl cnl0aGluZyBhbGxvY2F0ZWQgYW5kIHJldHVybiBleGlzdGluZyBxdWV1ZSBk aXJlY3RseS4gICovCisJICAgIGlmICghZGV2LT5vcGVuYWNjLmFzeW5jLmRl c3RydWN0X2Z1bmMgKG5ld19hcSkpCisJICAgICAgZ29tcF9mYXRhbCAoImVy cm9yIGluIGFzeW5jIHF1ZXVlIGNyZWF0aW9uIik7CisJICAgIGZyZWUgKG5s KTsKKwkgIH0KKwlyZXR1cm4gYXFkZXNjLT5hc3luY3F1ZXVlW2FzeW5jXTsK KyAgICAgIH0KIAotICAgICAgaWYgKCFkZXYtPm9wZW5hY2MuYXN5bmMuYXN5 bmNxdWV1ZVthc3luY10pCi0JewotCSAgZ29tcF9tdXRleF91bmxvY2sgKCZk ZXYtPm9wZW5hY2MuYXN5bmMubG9jayk7Ci0JICBnb21wX2ZhdGFsICgiYXN5 bmMgJWQgY3JlYXRpb24gZmFpbGVkIiwgYXN5bmMpOwotCX0KLSAgICAgIAot ICAgICAgLyogTGluayBuZXcgYXN5bmMgcXVldWUgaW50byBhY3RpdmUgbGlz dC4gICovCi0gICAgICBnb2FjY19hcV9saXN0IG4gPSBnb21wX21hbGxvYyAo c2l6ZW9mIChzdHJ1Y3QgZ29hY2NfYXN5bmNxdWV1ZV9saXN0KSk7Ci0gICAg ICBuLT5hcSA9IGRldi0+b3BlbmFjYy5hc3luYy5hc3luY3F1ZXVlW2FzeW5j XTsKLSAgICAgIG4tPm5leHQgPSBkZXYtPm9wZW5hY2MuYXN5bmMuYWN0aXZl OwotICAgICAgZGV2LT5vcGVuYWNjLmFzeW5jLmFjdGl2ZSA9IG47Ci0gICAg fQotICBnb21wX211dGV4X3VubG9jayAoJmRldi0+b3BlbmFjYy5hc3luYy5s b2NrKTsKLSAgcmV0dXJuIGRldi0+b3BlbmFjYy5hc3luYy5hc3luY3F1ZXVl W2FzeW5jXTsKKyAgICAvKiBDb3B5IGN1cnJlbnQgYXN5bmNxdWV1ZSBjb250 ZW50cyovCisgICAgbWVtY3B5IChuZGVzYy0+YXN5bmNxdWV1ZSwgYXFkZXNj LT5hc3luY3F1ZXVlLAorCSAgICBzaXplb2YgKHN0cnVjdCBnb2FjY19hc3lu Y3F1ZXVlICopICogY3Vycl9udW1fYXFzKTsKKyAgICBuZGVzYy0+YWN0aXZl LT5uZXh0ID0gYXFkZXNjLT5hY3RpdmU7CisKKyAgfSB3aGlsZSAoIV9fYXRv bWljX2NvbXBhcmVfZXhjaGFuZ2UgKCZkZXYtPm9wZW5hY2MuYXN5bmMuYXFk ZXNjLAorCQkJCSAgICAgICAmYXFkZXNjLCAmbmRlc2MsIGZhbHNlLAorCQkJ CSAgICAgICBfX0FUT01JQ19BQ1FfUkVMLCBfX0FUT01JQ19BQ1FVSVJFKSk7 CisKKyAgLyogRnJlZSB0aGUgb2xkIHN0YWxlIGRlc2NyaXB0b3IgYW5kIHJl c291cmNlcyBpbiBhcWRlc2MuICAqLworICBmcmVlIChhcWRlc2MtPmFzeW5j cXVldWUpOworICBmcmVlIChhcWRlc2MpOworCisgIHJldHVybiBkZXYtPm9w ZW5hY2MuYXN5bmMuYXFkZXNjLT5hc3luY3F1ZXVlW2FzeW5jXTsKIH0KIAog YXR0cmlidXRlX2hpZGRlbiBzdHJ1Y3QgZ29hY2NfYXN5bmNxdWV1ZSAqCkBA IC0xMzksMTQgKzE3OCwxMiBAQAogICBzdHJ1Y3QgZ29hY2NfdGhyZWFkICp0 aHIgPSBnZXRfZ29hY2NfdGhyZWFkICgpOwogCiAgIGludCByZXQgPSAxOwot ICBnb21wX211dGV4X2xvY2sgKCZ0aHItPmRldi0+b3BlbmFjYy5hc3luYy5s b2NrKTsKLSAgZm9yIChnb2FjY19hcV9saXN0IGwgPSB0aHItPmRldi0+b3Bl bmFjYy5hc3luYy5hY3RpdmU7IGw7IGwgPSBsLT5uZXh0KQorICBmb3IgKGdv YWNjX2FxX2xpc3QgbCA9IHRoci0+ZGV2LT5vcGVuYWNjLmFzeW5jLmFxZGVz Yy0+YWN0aXZlOyBsOyBsID0gbC0+bmV4dCkKICAgICBpZiAoIXRoci0+ZGV2 LT5vcGVuYWNjLmFzeW5jLnRlc3RfZnVuYyAobC0+YXEpKQogICAgICAgewog CXJldCA9IDA7CiAJYnJlYWs7CiAgICAgICB9Ci0gIGdvbXBfbXV0ZXhfdW5s b2NrICgmdGhyLT5kZXYtPm9wZW5hY2MuYXN5bmMubG9jayk7CiAgIHJldHVy biByZXQ7CiB9CiAKQEAgLTE5NCwxMCArMjMxLDggQEAKIHsKICAgc3RydWN0 IGdvbXBfZGV2aWNlX2Rlc2NyICpkZXYgPSBnZXRfZ29hY2NfdGhyZWFkX2Rl dmljZSAoKTsKIAotICBnb21wX211dGV4X2xvY2sgKCZkZXYtPm9wZW5hY2Mu YXN5bmMubG9jayk7Ci0gIGZvciAoZ29hY2NfYXFfbGlzdCBsID0gZGV2LT5v cGVuYWNjLmFzeW5jLmFjdGl2ZTsgbDsgbCA9IGwtPm5leHQpCisgIGZvciAo Z29hY2NfYXFfbGlzdCBsID0gZGV2LT5vcGVuYWNjLmFzeW5jLmFxZGVzYy0+ YWN0aXZlOyBsOyBsID0gbC0+bmV4dCkKICAgICBkZXYtPm9wZW5hY2MuYXN5 bmMuc3luY2hyb25pemVfZnVuYyAobC0+YXEpOwotICBnb21wX211dGV4X3Vu bG9jayAoJmRldi0+b3BlbmFjYy5hc3luYy5sb2NrKTsKIH0KIAogLyogYWNj X2FzeW5jX3dhaXRfYWxsIGlzIGFuIE9wZW5BQ0MgMS4wIGNvbXBhdGliaWxp dHkgbmFtZSBmb3IgYWNjX3dhaXRfYWxsLiAgKi8KQEAgLTIyMSwxNCArMjU2 LDEyIEBACiAKICAgZ29hY2NfYXEgd2FpdGluZ19xdWV1ZSA9IGxvb2t1cF9n b2FjY19hc3luY3F1ZXVlICh0aHIsIHRydWUsIGFzeW5jKTsKIAotICBnb21w X211dGV4X2xvY2sgKCZ0aHItPmRldi0+b3BlbmFjYy5hc3luYy5sb2NrKTsK LSAgZm9yIChnb2FjY19hcV9saXN0IGwgPSB0aHItPmRldi0+b3BlbmFjYy5h c3luYy5hY3RpdmU7IGw7IGwgPSBsLT5uZXh0KQorICBmb3IgKGdvYWNjX2Fx X2xpc3QgbCA9IHRoci0+ZGV2LT5vcGVuYWNjLmFzeW5jLmFxZGVzYy0+YWN0 aXZlOyBsOyBsID0gbC0+bmV4dCkKICAgICB7CiAgICAgICB0aHItPmRldi0+ b3BlbmFjYy5hc3luYy5zeW5jaHJvbml6ZV9mdW5jIChsLT5hcSk7CiAgICAg ICBpZiAod2FpdGluZ19xdWV1ZSkKIAl0aHItPmRldi0+b3BlbmFjYy5hc3lu Yy5zZXJpYWxpemVfZnVuYyAobC0+YXEsIHdhaXRpbmdfcXVldWUpOwogICAg IH0KLSAgZ29tcF9tdXRleF91bmxvY2sgKCZ0aHItPmRldi0+b3BlbmFjYy5h c3luYy5sb2NrKTsKIH0KIAogaW50CkBAIC0yNjEsMzAgKzI5NCwyNyBAQAog YXR0cmlidXRlX2hpZGRlbiB2b2lkCiBnb2FjY19pbml0X2FzeW5jcXVldWVz IChzdHJ1Y3QgZ29tcF9kZXZpY2VfZGVzY3IgKmRldmljZXApCiB7Ci0gIGdv bXBfbXV0ZXhfaW5pdCAoJmRldmljZXAtPm9wZW5hY2MuYXN5bmMubG9jayk7 Ci0gIGRldmljZXAtPm9wZW5hY2MuYXN5bmMubmFzeW5jcXVldWUgPSAwOwot ICBkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLmFzeW5jcXVldWUgPSBOVUxMOwot ICBkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLmFjdGl2ZSA9IE5VTEw7CisgIGRl dmljZXAtPm9wZW5hY2MuYXN5bmMuYXFkZXNjID0KKyAgICBnb21wX21hbGxv Y19jbGVhcmVkIChzaXplb2YgKHN0cnVjdCBnb2FjY19hc3luY3F1ZXVlX2Rl c2MpKTsKIH0KIAogYXR0cmlidXRlX2hpZGRlbiBib29sCiBnb2FjY19maW5p X2FzeW5jcXVldWVzIChzdHJ1Y3QgZ29tcF9kZXZpY2VfZGVzY3IgKmRldmlj ZXApCiB7CisgIHN0cnVjdCBnb2FjY19hc3luY3F1ZXVlX2Rlc2MgKmFxZGVz YyA9IGRldmljZXAtPm9wZW5hY2MuYXN5bmMuYXFkZXNjOwogICBib29sIHJl dCA9IHRydWU7Ci0gIGlmIChkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLm5hc3lu Y3F1ZXVlID4gMCkKKworICBpZiAoYXFkZXNjLT5uYXN5bmNxdWV1ZSA+IDAp CiAgICAgewogICAgICAgZ29hY2NfYXFfbGlzdCBuZXh0OwotICAgICAgZm9y IChnb2FjY19hcV9saXN0IGwgPSBkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLmFj dGl2ZTsgbDsgbCA9IG5leHQpCisgICAgICBmb3IgKGdvYWNjX2FxX2xpc3Qg bCA9IGFxZGVzYy0+YWN0aXZlOyBsOyBsID0gbmV4dCkKIAl7CiAJICByZXQg Jj0gZGV2aWNlcC0+b3BlbmFjYy5hc3luYy5kZXN0cnVjdF9mdW5jIChsLT5h cSk7CiAJICBuZXh0ID0gbC0+bmV4dDsKIAkgIGZyZWUgKGwpOwogCX0KLSAg ICAgIGZyZWUgKGRldmljZXAtPm9wZW5hY2MuYXN5bmMuYXN5bmNxdWV1ZSk7 Ci0gICAgICBkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLm5hc3luY3F1ZXVlID0g MDsKLSAgICAgIGRldmljZXAtPm9wZW5hY2MuYXN5bmMuYXN5bmNxdWV1ZSA9 IE5VTEw7Ci0gICAgICBkZXZpY2VwLT5vcGVuYWNjLmFzeW5jLmFjdGl2ZSA9 IE5VTEw7CisgICAgICBmcmVlIChhcWRlc2MtPmFzeW5jcXVldWUpOwogICAg IH0KLSAgZ29tcF9tdXRleF9kZXN0cm95ICgmZGV2aWNlcC0+b3BlbmFjYy5h c3luYy5sb2NrKTsKKyAgZnJlZSAoYXFkZXNjKTsKICAgcmV0dXJuIHJldDsK IH0KZGlmZiAtcnUgdHJ1bmstb3JpZy9saWJnb21wL29hY2MtY3VkYS5jIHRy dW5rLXdvcmsvbGliZ29tcC9vYWNjLWN1ZGEuYwotLS0gdHJ1bmstb3JpZy9s aWJnb21wL29hY2MtY3VkYS5jCTIwMTgtMTItMTggMTg6MDk6MDguNjAxOTEz NTA3ICswODAwCisrKyB0cnVuay13b3JrL2xpYmdvbXAvb2FjYy1jdWRhLmMJ MjAxOC0xMi0yMSAyMzozNDoxMC4wMjQ3Mzg4MzQgKzA4MDAKQEAgLTg3LDkg Kzg3LDcgQEAKICAgaWYgKHRociAmJiB0aHItPmRldiAmJiB0aHItPmRldi0+ b3BlbmFjYy5jdWRhLnNldF9zdHJlYW1fZnVuYykKICAgICB7CiAgICAgICBn b2FjY19hcSBhcSA9IGdldF9nb2FjY19hc3luY3F1ZXVlIChhc3luYyk7Ci0g ICAgICBnb21wX211dGV4X2xvY2sgKCZ0aHItPmRldi0+b3BlbmFjYy5hc3lu Yy5sb2NrKTsKICAgICAgIHJldCA9IHRoci0+ZGV2LT5vcGVuYWNjLmN1ZGEu c2V0X3N0cmVhbV9mdW5jIChhcSwgc3RyZWFtKTsKLSAgICAgIGdvbXBfbXV0 ZXhfdW5sb2NrICgmdGhyLT5kZXYtPm9wZW5hY2MuYXN5bmMubG9jayk7CiAg ICAgfQogCiAgIHJldHVybiByZXQ7Cg== --------------BF2F656A2E4C90A6D3A97AC0--