From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751633AbdG1BKi (ORCPT ); Thu, 27 Jul 2017 21:10:38 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:45920 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751568AbdG1BKh (ORCPT ); Thu, 27 Jul 2017 21:10:37 -0400 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=_8424a6a16a802fa811c3d2831f4e81aa" Date: Thu, 27 Jul 2017 18:10:34 -0700 From: Vikram Mulukutla To: qiaozhou Cc: Thomas Gleixner , John Stultz , sboyd@codeaurora.org, LKML , Wang Wilbur , Marc Zyngier , Will Deacon , Peter Zijlstra , linux-kernel-owner@vger.kernel.org, sudeep.holla@arm.com Subject: Re: [Question]: try to fix contention between expire_timers and try_to_del_timer_sync In-Reply-To: References: <3d2459c7-defd-a47e-6cea-007c10cecaac@asrmicro.com>

Message-ID: User-Agent: Roundcube Webmail/1.2.5 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --=_8424a6a16a802fa811c3d2831f4e81aa Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8; format=flowed cc: Sudeep Holla On 2017-07-26 18:29, qiaozhou wrote: > On 2017年07月26日 22:16, Thomas Gleixner wrote: >> On Wed, 26 Jul 2017, qiaozhou wrote: >> >> Cc'ed ARM folks. >> >> >> For that particular timer case we can clear base->running_timer w/o >> the >> lock held (see patch below), but this kind of >> >> lock -> test -> unlock -> retry >> >> loops are all over the place in the kernel, so this is going to hurt >> you >> sooner than later in some other place. > It's true. This is the way spinlock is used normally and widely in > kernel. I'll also ask ARM experts whether we can do something to avoid > or reduce the chance of such issue. ARMv8.1 has one single > instruction(ldadda) to replace the ldaxr/stxr loop. Hope it can > improve and reduce the chance. I think we should have this discussion now - I brought this up earlier [1] and I promised a test case that I completely forgot about - but here it is (attached). Essentially a Big CPU in an acquire-check-release loop will have an unfair advantage over a little CPU concurrently attempting to acquire the same lock, in spite of the ticket implementation. If the Big CPU needs the little CPU to make forward progress : livelock. We've run into the same loop construct in other spots in the kernel and the reason that a real symptom is so rare is that the retry-loop on the 'Big' CPU needs to be interrupted just once by say an IRQ/FIQ and the live-lock is broken. If the entire retry loop is within an interrupt-disabled critical section then the odds of live-locking are much higher. An example of the problem on a previous kernel is here [2]. Changes to the workqueue code since may have fixed this particular instance. One solution was to use udelay(1) in such loops instead of cpu_relax(), but that's not very 'relaxing'. I'm not sure if there's something we could do within the ticket spin-lock implementation to deal with this. Note that I ran my test on a 4.9 kernel so that didn't include any spinlock implementation changes since then. The test schedules two threads, one on a big CPU and one on a little CPU. The big CPU thread does the lock/unlock/retry loop for a full 1 second with interrupts disabled, while the little CPU attempts to acquire the same loop but enabling interrupts after every successful lock+unlock. With unfairness, the little CPU may take upto 1 second (or several milliseconds at the least) just to acquire the lock once. This varies depending on the IPC difference and frequencies of the big and little ARM64 CPUs: Big cpu frequency | Little cpu frequency | Max time taken by little to acquire lock 2GHz | 1.5GHz | 133 microseconds 2GHz | 300MHz | 734 milliseconds Thanks, Vikram [1] - https://lkml.org/lkml/2016/11/17/934 [2] - https://goo.gl/uneFjt -- Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project --=_8424a6a16a802fa811c3d2831f4e81aa Content-Transfer-Encoding: base64 Content-Type: text/x-diff; name=0001-measure-spinlock-fairness-across-differently-capable.patch Content-Disposition: attachment; filename=0001-measure-spinlock-fairness-across-differently-capable.patch; size=7285 RnJvbSA1MWQ2MTg2YjYyMGE5ZTM1NGEwZDQwYWYwNmFlZjFjMTI5OWNhMjIzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBWaWtyYW0gTXVsdWt1dGxhIDxtYXJraXZ4QGNvZGVhdXJvcmEu b3JnPgpEYXRlOiBUaHUsIDI3IEp1bCAyMDE3IDEyOjE0OjQ4IC0wNzAwClN1YmplY3Q6IFtQQVRD SF0gbWVhc3VyZSBzcGlubG9jayBmYWlybmVzcyBhY3Jvc3MgZGlmZmVyZW50bHkgY2FwYWJsZSBD UFVzCgpIb3cgdG8gcnVuIHRoaXMgdGVzdDoKMSkgY29tcGlsZSBhbmQgYm9vdAoyKSBlY2hvIDEg PiAvc3lzL21vZHVsZS90ZXN0L3BhcmFtZXRlcnMvcnVuX3Rlc3QKMykgc2xlZXAgNQo0KSBlY2hv IDAgPiAvc3lzL21vZHVsZS90ZXN0L3BhcmFtZXRlcnMvcnVuX3Rlc3QKClRoZSB0ZXN0IHNjaGVk dWxlcyB0d28gdGhyZWFkcyBvbiB0d28gc2VwYXJhdGUgQ1BVcwphbmQgYXR0ZW1wdHMgdG8gYWNx dWlyZSB0aGUgc2FtZSBzcGlubG9jayBmcm9tIGJvdGgKdGhyZWFkcyB3aXRoIGEgY2VydGFpbiBs b29wIGNvbnN0cnVjdC4KKGl0IGFzc3VtZXMgY3B1MCBpcyAnTGl0dGxlJyBhbmQgY3B1NCBpcyAn QmlnJy4gVGhpcwpjYW4gYmUgY2hhbmdlZCBpbiB0aGUgY29kZSkKCkFmdGVyIHJ1bm5pbmcgdGhl IHRlc3QsIGNoZWNrIHRoZXNlIGNvdW50ZXJzOgpjYXQgL3N5cy9tb2R1bGUvdGVzdC9wYXJhbWV0 ZXJzL2JpZ190aW1lX3VzCmNhdCAvc3lzL21vZHVsZS90ZXN0L3BhcmFtZXRlcnMvbGl0dGxlX3Rp bWVfdXMKCklmIHVuZmFpcm5lc3MgZXhpc3RzLCBsaXR0bGVfdGltZSBzaG91bGQgYmUgY2xvc2Ug dG8gMSBzZWNvbmQgb3IKYSBmYWlybHkgbGFyZ2UgbWlsbGlzZWNvbmQgdmFsdWUuCnRlc3QuYyBo YXMgY29tbWVudHMgdGhhdCBleHBsYWluIHdoeSB0aGlzIGlzIHNvLgoKU2lnbmVkLW9mZi1ieTog VmlrcmFtIE11bHVrdXRsYSA8bWFya2l2eEBjb2RlYXVyb3JhLm9yZz4KLS0tCiBrZXJuZWwvc2No ZWQvTWFrZWZpbGUgfCAgIDIgKy0KIGtlcm5lbC9zY2hlZC90ZXN0LmMgICB8IDIwNCArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMiBmaWxlcyBjaGFu Z2VkLCAyMDUgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGtlcm5lbC9zY2hlZC90ZXN0LmMKCmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQvTWFrZWZpbGUg Yi9rZXJuZWwvc2NoZWQvTWFrZWZpbGUKaW5kZXggZjZjY2U5NS4uNTQyYTFjNyAxMDA2NDQKLS0t IGEva2VybmVsL3NjaGVkL01ha2VmaWxlCisrKyBiL2tlcm5lbC9zY2hlZC9NYWtlZmlsZQpAQCAt MTUsNyArMTUsNyBAQCBpZm5lcSAoJChDT05GSUdfU0NIRURfT01JVF9GUkFNRV9QT0lOVEVSKSx5 KQogQ0ZMQUdTX2NvcmUubyA6PSAkKFBST0ZJTElORykgLWZuby1vbWl0LWZyYW1lLXBvaW50ZXIK IGVuZGlmCiAKLW9iai15ICs9IGNvcmUubyBsb2FkYXZnLm8gY2xvY2subyBjcHV0aW1lLm8KK29i ai15ICs9IGNvcmUubyBsb2FkYXZnLm8gY2xvY2subyBjcHV0aW1lLm8gdGVzdC5vCiBvYmoteSAr PSBpZGxlX3Rhc2subyBmYWlyLm8gcnQubyBkZWFkbGluZS5vIHN0b3BfdGFzay5vCiBvYmoteSAr PSB3YWl0Lm8gc3dhaXQubyBjb21wbGV0aW9uLm8gaWRsZS5vCiBvYmotJChDT05GSUdfU01QKSAr PSBjcHVwcmkubyBjcHVkZWFkbGluZS5vIGVuZXJneS5vIHNjaGVkX2F2Zy5vCmRpZmYgLS1naXQg YS9rZXJuZWwvc2NoZWQvdGVzdC5jIGIva2VybmVsL3NjaGVkL3Rlc3QuYwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi41ZGQzYjBkCi0tLSAvZGV2L251bGwKKysrIGIva2VybmVs L3NjaGVkL3Rlc3QuYwpAQCAtMCwwICsxLDIwNCBAQAorLyogQ29weXJpZ2h0IChjKSAyMDE0LTIw MTYsIFRoZSBMaW51eCBGb3VuZGF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIHZlcnNpb24gMiBhbmQKKyAqIG9ubHkgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogQmlnLkxpdHRsZSBzcGlubG9jayB1bmZhaXJuZXNzIHRlc3QgYnkgVmlrcmFtIE11 bHVrdXRsYQorICovCisKKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgv bm90aWZpZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9jcHUuaD4KKyNpbmNsdWRlIDxsaW51eC9jcHVt YXNrLmg+CisjaW5jbHVkZSA8bGludXgvY3B1ZnJlcS5oPgorI2luY2x1ZGUgPGxpbnV4L2t0aHJl YWQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkL3J0 Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4K Kworc3RhdGljIERFRklORV9TUElOTE9DSyhteWxvY2spOworCitzdGF0aWMgaW50IHJ1bl90ZXN0 Oworc3RhdGljIGludCBiaWdfY291bnRlciwgbGl0dGxlX2NvdW50ZXI7Cittb2R1bGVfcGFyYW0o YmlnX2NvdW50ZXIsIGludCwgMDY0NCk7Cittb2R1bGVfcGFyYW0obGl0dGxlX2NvdW50ZXIsIGlu dCwgMDY0NCk7CisKK3N0YXRpYyBpbnQgYmlnX3RpbWVfdXMsIGxpdHRsZV90aW1lX3VzOworbW9k dWxlX3BhcmFtKGJpZ190aW1lX3VzLCBpbnQsIDA2NDQpOworbW9kdWxlX3BhcmFtKGxpdHRsZV90 aW1lX3VzLCBpbnQsIDA2NDQpOworCit2b2xhdGlsZSBpbnQgc3luYyA9IDA7CisKK3N0cnVjdCB0 ZXN0ZGF0YSB7CisJaW50IGNwdTsKKwlpbnQgKmNvdW50ZXI7CisJaW50ICp0aW1lOworfTsKKwor c3RydWN0IHRlc3RkYXRhIGxpdHRsZWRhdGEgPSB7CisJLmNwdSA9IDAsCisJLmNvdW50ZXIgPSAm bGl0dGxlX2NvdW50ZXIsCisJLnRpbWUgPSAmbGl0dGxlX3RpbWVfdXMsCit9OworCitzdHJ1Y3Qg dGVzdGRhdGEgYmlnZGF0YSA9IHsKKwkuY3B1ID0gNCwKKwkuY291bnRlciA9ICZiaWdfY291bnRl ciwKKwkudGltZSA9ICZiaWdfdGltZV91cywKK307CisKKy8qCisgKiBUaGlzIGlzIHRoZSBsaXR0 bGUgQ1BVIHRocmVhZC4gSXQgYXR0ZW1wdHMgdG8gZ2V0IHRoZSBsb2NrLCBkaXNhYmxpbmcKKyAq IGFuZCBlbmFibGluZyBpbnRlcnJ1cHRzIGJlZm9yZSBhbmQgYWZ0ZXIgdGhlIGNyaXRpY2FsIHNl Y3Rpb24sIGFuZAorICogY2hlY2tzIGhvdyBsb25nIGl0IHRvb2sgdG8gZ2V0IHRoZSBsb2NrLiBJ ZGVhbGx5IHRoaXMgdGltZQorICogc2hvdWxkIGJlIHJlZmxlY3RpdmUgb2YganVzdCBvbmUgaXRl cmF0aW9uIG9mIHRoZSBjcml0aWNhbCBzZWN0aW9uIG9mIHRoZQorICogYmlnIGNwdSB0aHJlYWQg YnV0IHNpbmNlIHRoaXMgbGl0dGxlIENQVSBhbHdheXMgbG9zZXMgdGhlIHRpY2tldCBzdHJleCwK KyAqIGl0IGVuZHMgdXAgd2FpdGluZyBhIGZ1bGwgc2Vjb25kLgorICovCitzdGF0aWMgaW50IF9f cmVmIGxvY2t1bmxvY2sodm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgdGVzdGRhdGEgKnRlc3RkYXRh ID0gZGF0YTsKKwl1NjQgc3Bpbl9zdGFydF90aW1lLCBzcGluX3N0b3BfdGltZTsKKworCXNjaGVk X3NldGFmZmluaXR5KGN1cnJlbnQtPnBpZCwgY3B1bWFza19vZih0ZXN0ZGF0YS0+Y3B1KSk7CisK Kwl3aGlsZSAoIXN5bmMpOworCisJbG9jYWxfaXJxX2Rpc2FibGUoKTsKKwlzcGluX2xvY2soJm15 bG9jayk7CisJd2hpbGUgKDEpIHsKKwkJc3Bpbl91bmxvY2soJm15bG9jayk7CisJCWxvY2FsX2ly cV9lbmFibGUoKTsKKworCQljcHVfcmVsYXgoKTsKKworCQlsb2NhbF9pcnFfZGlzYWJsZSgpOwor CisJCXNwaW5fc3RhcnRfdGltZSA9IHNjaGVkX2Nsb2NrKCk7CisJCXNwaW5fbG9jaygmbXlsb2Nr KTsKKwkJc3Bpbl9zdG9wX3RpbWUgPSBzY2hlZF9jbG9jaygpOworCisJCWlmICgqdGVzdGRhdGEt PnRpbWUgPCAoKHNwaW5fc3RvcF90aW1lIC0gc3Bpbl9zdGFydF90aW1lKS9OU0VDX1BFUl9VU0VD KSkKKwkJCSp0ZXN0ZGF0YS0+dGltZSA9IChzcGluX3N0b3BfdGltZSAtIHNwaW5fc3RhcnRfdGlt ZSkvTlNFQ19QRVJfVVNFQzsKKwkJKnRlc3RkYXRhLT5jb3VudGVyID0gKnRlc3RkYXRhLT5jb3Vu dGVyICsgMTsKKwkJaWYgKCFydW5fdGVzdCkKKwkJCWJyZWFrOworCX0KKwlzcGluX3VubG9jaygm bXlsb2NrKTsKKwlsb2NhbF9pcnFfZW5hYmxlKCk7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAq IFRoaXMgaXMgdGhlIGJpZyBDUFUgdGhyZWFkLiBJZGVhbGx5IGl0IHNob3VsZCBjb250ZW5kIGFu ZCBoYXZlIGl0cyB0aWNrZXQKKyAqIGdvIGluIGFmdGVyIHRoZSBsaXR0bGUgQ1BVLiBIb3dldmVy IHdoYXQgZW5kcyB1cCBoYXBwZW5pbmcgaXMKKyAqIC0gaWYgaXQncyBydW5uaW5nIGZhc3QgZW5v dWdoIC0gdGhpcyBiaWcgQ1BVIGtlZXBzIHdpbm5pbmcgdGhlIHN0cmV4IGV2ZXJ5CisgKiB0aW1l IGFuZCBpcyBhYmxlIHRvIG9idGFpbiBhbmQgcmVsZWFzZSB0aGUgbG9jayBmb3IgYSBmdWxsIHNl Y29uZCBiZWZvcmUgaXQKKyAqIHRha2VzIGEgYnJlYWssIGF0IHdoaWNoIHBvaW50IHRoZSBsaXR0 bGUgQ1BVIHdpbnMgKGZpbmFsbHkpLgorICoKKyAqIE5vdGUgdGhhdCBpZiB0aGVyZSBleGlzdHMg YSBsb29wIGNvbnN0cnVjdCBzdWNoIGFzIHRoaXMgb25lIGluIHRoZSBrZXJuZWwsCisgKiBhbmQg dGhlcmUgaXMgbm8gJ2JyZWFrJywgdGhlbiB3ZSBoYXZlIGEgcG90ZW50aWFsIGxpdmVsb2NrIHNp dHVhdGlvbiBpZgorICogdGhpcyBiaWcgQ1BVIG5lZWRzIHRoZSBsaXR0bGUgQ1BVIHRvIG9idGFp biB0aGUgbG9jayBmb3IgdGhlIGZvcm1lciB0bworICogYnJlYWsgb3V0IG9mIHRoZSBsb29wLgor ICovCitzdGF0aWMgaW50IF9fcmVmIGxvY2t1bmxvY2tfbm9pcnEodm9pZCAqZGF0YSkKK3sKKwlz dHJ1Y3QgdGVzdGRhdGEgKnRlc3RkYXRhID0gZGF0YTsKKwl1NjQgc3Bpbl9zdGFydF90aW1lLCBz cGluX3N0b3BfdGltZSwgdGltZV9zaW5jZV9zdGFydCwgdGVzdF9zdGFydF90aW1lOworCWJvb2wg cm9sbG92ZXI7CisKKwlzY2hlZF9zZXRhZmZpbml0eShjdXJyZW50LT5waWQsIGNwdW1hc2tfb2Yo dGVzdGRhdGEtPmNwdSkpOworCisJd2hpbGUgKCFzeW5jKTsKKworCWxvY2FsX2lycV9kaXNhYmxl KCk7CisJc3Bpbl9sb2NrKCZteWxvY2spOworCXRlc3Rfc3RhcnRfdGltZSA9IHNjaGVkX2Nsb2Nr KCk7CisJd2hpbGUgKDEpIHsKKwkJc3Bpbl91bmxvY2soJm15bG9jayk7CisKKwkJdGltZV9zaW5j ZV9zdGFydCA9IHNjaGVkX2Nsb2NrKCkgLSB0ZXN0X3N0YXJ0X3RpbWU7CisJCXJvbGxvdmVyID0g dGltZV9zaW5jZV9zdGFydCA+PSBOU0VDX1BFUl9TRUM7CisKKwkJLyoKKwkJICogV2UgdGFrZSBh IGJyZWFrIGFmdGVyIDEgc2Vjb25kIHRvIGFsbG93IHdhdGNoZG9nIGV0Yy4gYW5kCisJCSAqIHBv dGVudGlhbGx5IGEgdXNlciBzaGVsbCB0byB3b3JrIQorCQkgKi8KKwkJaWYgKHJvbGxvdmVyKSB7 CisJCQlsb2NhbF9pcnFfZW5hYmxlKCk7CisJCQl0ZXN0X3N0YXJ0X3RpbWUgPSBzY2hlZF9jbG9j aygpOworCQl9CisKKwkJLyoKKwkJICogQ2hhbmdpbmcgdGhpcyBjcHVfcmVsYXggdG8gYSB1ZGVs YXkoMSkgd2lsbCBsaWtlbHkKKwkJICogYWxsb3cgdGhlIGxpdHRsZSBDUFUgZW5vdWdoIGN5Y2xl cyBzbyBpdCBmaW5hbGx5IHdpbnMKKwkJICogdGhlIHN0cmV4IGJhdHRsZS4KKwkJICovCisJCWNw dV9yZWxheCgpOworCisJCWlmIChyb2xsb3ZlcikKKwkJCWxvY2FsX2lycV9kaXNhYmxlKCk7CisK KwkJc3Bpbl9zdGFydF90aW1lID0gc2NoZWRfY2xvY2soKTsKKwkJc3Bpbl9sb2NrKCZteWxvY2sp OworCQlzcGluX3N0b3BfdGltZSA9IHNjaGVkX2Nsb2NrKCk7CisKKwkJaWYgKCp0ZXN0ZGF0YS0+ dGltZSA8ICgoc3Bpbl9zdG9wX3RpbWUgLSBzcGluX3N0YXJ0X3RpbWUpL05TRUNfUEVSX1VTRUMp KQorCQkJKnRlc3RkYXRhLT50aW1lID0gKHNwaW5fc3RvcF90aW1lIC0gc3Bpbl9zdGFydF90aW1l KS9OU0VDX1BFUl9VU0VDOworCQkqdGVzdGRhdGEtPmNvdW50ZXIgPSAqdGVzdGRhdGEtPmNvdW50 ZXIgKyAxOworCQlpZiAoIXJ1bl90ZXN0KQorCQkJYnJlYWs7CisJfQorCXNwaW5fdW5sb2NrKCZt eWxvY2spOworCWxvY2FsX2lycV9lbmFibGUoKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IHJ1bnRlc3RfcGFyYW1fc2V0KGNvbnN0IGNoYXIgKnZhbCwgc3RydWN0IGtlcm5lbF9wYXJh bSAqa3ApCit7CisJaW50IHJldDsKKwlpbnQgb2xkX3ZhbCA9IHJ1bl90ZXN0OworCisJcmV0ID0g cGFyYW1fc2V0X2ludCh2YWwsIGtwKTsKKworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwkv KiBJZiBydW5fdGVzdCBpcyBub3QgemVybyBvciBvbmUsIGlnbm9yZS4gKi8KKwlpZiAocnVuX3Rl c3QgPj4gMSkgeworCQlydW5fdGVzdCA9IG9sZF92YWw7CisJCXJldHVybiAtRUlOVkFMOworCX0K KworCWlmIChydW5fdGVzdCkgeworCQlzeW5jID0gMDsKKworCQkqbGl0dGxlZGF0YS50aW1lID0g MDsKKwkJKmxpdHRsZWRhdGEuY291bnRlciA9IDA7CisJCSpiaWdkYXRhLnRpbWUgPSAwOworCQkq YmlnZGF0YS5jb3VudGVyID0gMDsKKworCQlrdGhyZWFkX3J1bihsb2NrdW5sb2NrLCAodm9pZCAq KSAmbGl0dGxlZGF0YSwKKwkJCQkJCSJ0ZXN0LyVkIiwgbGl0dGxlZGF0YS5jcHUpOworCQlrdGhy ZWFkX3J1bihsb2NrdW5sb2NrX25vaXJxLCAodm9pZCAqKSAmYmlnZGF0YSwKKwkJCQkJCSJ0ZXN0 LyVkIiwgYmlnZGF0YS5jcHUpOworCQlzeW5jPTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK21v ZHVsZV9wYXJhbV9jYWxsKHJ1bl90ZXN0LCBydW50ZXN0X3BhcmFtX3NldCwgcGFyYW1fZ2V0X2lu dCwKKwkJICAmcnVuX3Rlc3QsIFNfSVJVR098U19JV1VTUik7CisKKworCi0tIAotLSAKUXVhbGNv bW0gSW5ub3ZhdGlvbiBDZW50ZXIsIEluYy4gaXMgYSBtZW1iZXIgb2YgQ29kZSBBdXJvcmEgRm9y dW0sCmEgTGludXggRm91bmRhdGlvbiBDb2xsYWJvcmF0aXZlIFByb2plY3QKCg== --=_8424a6a16a802fa811c3d2831f4e81aa--