27236 2009-07-13 13:48:22 -0700 Memory is not released back to the system from TCMalloc on Windows 2009-07-28 18:11:47 -0700 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) PC All RESOLVED FIXED InRadar P2 Normal --- 1 adachan adachan alice.barraclough aroben ggaren mrowe slewis oldest_to_newest 131403 0 adachan 2009-07-13 13:48:22 -0700 Right now TCMalloc_SystemRelease() is not implemented on Windows, which means we are not releasing memory back to the system. 131404 1 32677 adachan 2009-07-13 13:57:34 -0700 Created attachment 32677 This patch implements TCMalloc_SystemRelease() on windows and adds a new mechanism to release memory back to the system via a background thread. This patch implements TCMalloc_SystemRelease() on windows and adds a new mechanism to release memory back to the system via a background thread. That new mechanism is turned on by default. Every 5 seconds, the background thread wakes up and does the following: - Check if the number of pages allocated in the last 5 seconds is greater than 1/3 of the free committed pages. If so, skip this scavenge because it's a sign that there is a lot of activity going on right now and thrashing may happen if we release memory back to the system now. - Otherwise, go through the list of free spans (from largest to smallest) and release up to 1/3 of the free committed pages back to the system. We can release more if there's absolutely no activity going on in the last 5 seconds. - If the number of free committed pages reaches kMinimumFreeCommittedPageCount, we can stop the scavenging and block the scavenging thread until the number of free committed pages goes above kMinimumFreeCommittedPageCount. 131407 2 adachan 2009-07-13 14:01:28 -0700 <rdar://problem/5649058> 131409 3 32677 mrowe 2009-07-13 14:19:31 -0700 Comment on attachment 32677 This patch implements TCMalloc_SystemRelease() on windows and adds a new mechanism to release memory back to the system via a background thread. In theory our changes to TCMalloc should be wrapped in "#ifdef WTF_CHANGES". > +#if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY > +#if PLATFORM(WIN) > + static void* runScavengerThread(void*); > + > + void scavengerThread(); > +#else > + static NO_RETURN void* runScavengerThread(void*); > + > + NO_RETURN void scavengerThread(); > +#endif Why does this need to be #if'd for PLATFORM(WIN)? NO_RETURN should expand away to nothing for non-GCC compilers already. > +#if TCMALLOC_TRACK_DECOMMITED_SPANS > + inline bool shouldContinueScavenging() const { return free_committed_pages_ > kMinimumFreeCommittedPageCount; } > +#else > + inline bool shouldContinueScavenging() const { return true; } > +#endif It seems that this will lead to Tiger and Leopard to continue waking up and attempting to scavenge even when there's nothing left for it to do. Have we tested the performance and memory use impact of this patch Tiger or Leopard, where we don't track decommitted spans? > Index: wtf/TCSpinLock.h > =================================================================== > --- wtf/TCSpinLock.h (revision 45828) > +++ wtf/TCSpinLock.h (working copy) > @@ -209,6 +209,12 @@ struct TCMalloc_SpinLock { > inline void Unlock() { > if (pthread_mutex_unlock(&private_lock_) != 0) CRASH(); > } > + inline bool IsHeld() { > + if (pthread_mutex_trylock(&private_lock_)) > + return true; > + pthread_mutex_unlock(&private_lock_); > + return false; > + } > }; This change seems unrelated to the rest of the patch. 131419 4 adachan 2009-07-13 15:08:26 -0700 I'll remove the #if PLATFORM(WIN) around the declarations for runScavengerThread() and scavengerThread(). I'll make a separate patch later to define NO_RETURN for Windows. I'll remove the changes in TCSpinLock.h. What do you recommend we do for Tiger and Leopard that don't track decommitted spans? 131420 5 adachan 2009-07-13 15:14:02 -0700 Mark, regarding your suggestion about wrapping the changes with "#ifdef WTF_CHANGES": since all the changes in FastMalloc.cpp are wrapped with USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY, can I just wrap the #define for USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY with "#ifdef WTF_CHANGES"? Do I need wrap changes in TCSystemAlloc.cpp with "#ifdef WTF_CHANGES" also? They are already wrapped with #if HAVE(VIRTUALALLOC). 131472 6 mrowe 2009-07-13 19:10:38 -0700 (In reply to comment #5) > Mark, regarding your suggestion about wrapping the changes with "#ifdef > WTF_CHANGES": since all the changes in FastMalloc.cpp are wrapped with > USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY, can I just wrap the #define for > USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY with "#ifdef WTF_CHANGES"? > > Do I need wrap changes in TCSystemAlloc.cpp with "#ifdef WTF_CHANGES" also? > They are already wrapped with #if HAVE(VIRTUALALLOC). Yeah, I guess it's not really worth the hassle. 131473 7 mrowe 2009-07-13 19:15:06 -0700 (In reply to comment #3) > It seems that this will lead to Tiger and Leopard to continue waking up and > attempting to scavenge even when there's nothing left for it to do. > > Have we tested the performance and memory use impact of this patch Tiger or > Leopard, where we don't track decommitted spans? Another thing to consider would be always enabling the tracking of decommitted spans, even on Tiger or Leopard. This would simplify a bunch of the #ifdefs that this patch introduces. I initially added the #ifdef because the code was a slight performance regression on Leopard. We could re-measure the impact that this code has and if it's small enough remove the #ifdefs. 131482 8 adachan 2009-07-13 21:15:38 -0700 (In reply to comment #7) > Another thing to consider would be always enabling the tracking of decommitted > spans, even on Tiger or Leopard. This would simplify a bunch of the #ifdefs > that this patch introduces. I initially added the #ifdef because the code was > a slight performance regression on Leopard. We could re-measure the impact > that this code has and if it's small enough remove the #ifdefs. I've asked Stephanie to measure the impact of always enabling the tracking of decommitted spans on Leopard. 131628 9 32677 darin 2009-07-14 12:06:54 -0700 Comment on attachment 32677 This patch implements TCMalloc_SystemRelease() on windows and adds a new mechanism to release memory back to the system via a background thread. This patch has a lot of uses of reinterpret_cast in cases where static_cast can be used. To convert from void* to a specific type, static_cast works and is preferred. > +#if PLATFORM(WIN) > + static void* runScavengerThread(void*); > + > + void scavengerThread(); > +#else > + static NO_RETURN void* runScavengerThread(void*); > + > + NO_RETURN void scavengerThread(); > +#endif Can we just use the return 0 all the time and avoid the conditional code here and in the definition of the function? Or does GCC give us a warning about NO_RETURN if we don't specify it? > +#if TCMALLOC_TRACK_DECOMMITED_SPANS > + inline bool shouldContinueScavenging() const { return free_committed_pages_ > kMinimumFreeCommittedPageCount; } > +#else > + inline bool shouldContinueScavenging() const { return true; } > +#endif I'd prefer to have the function declaration be outside an ifdef, and have the implementation be ifdef'd. Also, the "inline" here is not needed. If you define a function inside a class definition then it's automatically treated as if "inline" was specified. > +void TCMalloc_PageHeap::scavenge() { Since this is new code, you could follow the normal WebKit style of putting the brace on a new line. > +#if PLATFORM(WIN) > + ::Sleep(kScavengeTimerDelayInSeconds * 1000); > +#else > + sleep(kScavengeTimerDelayInSeconds); > +#endif Can we make a helper function for this so we don't have to have the #if right in the middle of the code's logic? Maybe even define a sleep function for Windows, or if not, just define a function that has the call to either sleep or Sleep in it. > + void* end = (char*)start + length; This should be static_cast, not a C-style cast. > + size_t resultSize = VirtualQuery(ptr, &info, sizeof(info)); > + UNUSED_PARAM(resultSize); > + ASSERT(resultSize == sizeof(info)); You should use ASSERT_UNUSED here, not UNUSED_PARAM. For one thing, this is not a parameter! > + BOOL success = VirtualFree(ptr, length < info.RegionSize ? length : info.RegionSize, MEM_DECOMMIT); > + UNUSED_PARAM(success); > + ASSERT(success); Ditto. > + void* end = (char*)start + length; Ditto. > + size_t resultSize = VirtualQuery(ptr, &info, sizeof(info)); > + UNUSED_PARAM(resultSize); > + ASSERT(resultSize == sizeof(info)); Ditto. > + UNUSED_PARAM(newAddress); > + ASSERT(newAddress == ptr); Ditto. r=me 131710 10 adachan 2009-07-14 15:35:34 -0700 (In reply to comment #9) > (From update of attachment 32677 [details]) > This patch has a lot of uses of reinterpret_cast in cases where static_cast can > be used. To convert from void* to a specific type, static_cast works and is > preferred. > > > +#if PLATFORM(WIN) > > + static void* runScavengerThread(void*); > > + > > + void scavengerThread(); > > +#else > > + static NO_RETURN void* runScavengerThread(void*); > > + > > + NO_RETURN void scavengerThread(); > > +#endif > > Can we just use the return 0 all the time and avoid the conditional code here > and in the definition of the function? Or does GCC give us a warning about > NO_RETURN if we don't specify it? If I always return 0 in runScavengerThread(), the release build in Visual Studio will fail complaining about unreachable code. I've talked to Mark about this and we've decided to just always have: static NO_RETURN void* runScavengerThread(void*); NO_RETURN void scavengerThread(); This should compile as is because this code is turned off in the debug build anyway. Later on, we'll have a separate patch to define NO_RETURN appropriately on windows. > > > +#if TCMALLOC_TRACK_DECOMMITED_SPANS > > + inline bool shouldContinueScavenging() const { return free_committed_pages_ > kMinimumFreeCommittedPageCount; } > > +#else > > + inline bool shouldContinueScavenging() const { return true; } > > +#endif > > I'd prefer to have the function declaration be outside an ifdef, and have the > implementation be ifdef'd. > > Also, the "inline" here is not needed. If you define a function inside a class > definition then it's automatically treated as if "inline" was specified. OK. Mark also pointed out that we should test this code on Leopard/Tiger because apparently TCMALLOC_TRACK_DECOMMITTED_SPANS is not defined for those cases. We may end up turning that on for those platforms if it no longer hurts performance. > > +void TCMalloc_PageHeap::scavenge() { > > Since this is new code, you could follow the normal WebKit style of putting the > brace on a new line. Done. > > > +#if PLATFORM(WIN) > > + ::Sleep(kScavengeTimerDelayInSeconds * 1000); > > +#else > > + sleep(kScavengeTimerDelayInSeconds); > > +#endif > > Can we make a helper function for this so we don't have to have the #if right > in the middle of the code's logic? Maybe even define a sleep function for > Windows, or if not, just define a function that has the call to either sleep or > Sleep in it. I can define a sleep function on windows. Should I define it locally in FastMalloc.cpp or do you recommend a better place for it? > > > + void* end = (char*)start + length; > > This should be static_cast, not a C-style cast. Done. > > > + size_t resultSize = VirtualQuery(ptr, &info, sizeof(info)); > > + UNUSED_PARAM(resultSize); > > + ASSERT(resultSize == sizeof(info)); > > You should use ASSERT_UNUSED here, not UNUSED_PARAM. For one thing, this is not > a parameter! Done. And I'll fix the other instances. Thanks for the review! I'm waiting for results from Stephanie in testing this patch on Leopard. 132126 11 slewis 2009-07-15 20:24:51 -0700 I test the patch and tested tracking decommitted regions on Leopard. Neither were a regression on SunSpider. Tracking decommitted regions is a .4% PLT regression on Leopard (i.e. just big enough to tell that we are slower) The patch was a .6% PLT regression on Leopard. 132335 12 adachan 2009-07-16 13:59:55 -0700 (In reply to comment #11) > I test the patch and tested tracking decommitted regions on Leopard. Neither > were a regression on SunSpider. > > Tracking decommitted regions is a .4% PLT regression on Leopard (i.e. just big > enough to tell that we are slower) > > The patch was a .6% PLT regression on Leopard. Stephanie, have you tried the patch + turning on tracking decommitted regions on Leopard? 134703 13 33482 adachan 2009-07-24 18:34:28 -0700 Created attachment 33482 Patch to remove TCMALLOC_TRACK_DECOMMITED_SPANS 134704 14 33482 mrowe 2009-07-24 18:39:32 -0700 Comment on attachment 33482 Patch to remove TCMALLOC_TRACK_DECOMMITED_SPANS > Index: JavaScriptCore/ChangeLog > =================================================================== > --- JavaScriptCore/ChangeLog (revision 46386) > +++ JavaScriptCore/ChangeLog (working copy) > @@ -1,3 +1,18 @@ > +2009-07-24 Ada Chan <adachan@apple.com> > + > + In preparation for https://bugs.webkit.org/show_bug.cgi?id=27236: > + Remove TCMALLOC_TRACK_DECOMMITED_SPANS. We'll always track decommitted spans. It's probably worth mentioning that this was performance tested and had little impact. r=me 135063 15 33581 adachan 2009-07-27 16:56:47 -0700 Created attachment 33581 Revised patch to use a background thread to release memory back to the system. This patch has been revised from the previous version. The condition of whether we should hold off on the scavenge has changed. We'll check whether we need to commit any memory in the last 5 seconds. If so, it's a sign that there are not enough free committed pages around for the amount of allocations that we have done recently, so we should hold off on releasing memory. 135384 16 33581 darin 2009-07-28 15:06:23 -0700 Comment on attachment 33581 Revised patch to use a background thread to release memory back to the system. > + if (!s->decommitted) > + pagesDecommitted += s->length; > + s->decommitted = true; Since you already have the if statement, you could move the assignment into it. > +#if PLATFORM(WIN) > +static void sleep(unsigned seconds) > +{ > + ::Sleep(seconds * 1000); > +} > +#endif I usually prefer to put these platform-specific hacks into WTF headers. This is OK for now but I'd like to consider later having this be in some header with other <unistd.h> implementations for non-Unix platforms. Or a thread helper function header. > + BOOL success = VirtualFree(ptr, length < info.RegionSize ? length : info.RegionSize, MEM_DECOMMIT); > + ASSERT_UNUSED(success, success); > + length -= info.RegionSize; > + ptr = static_cast<char*>(ptr) + info.RegionSize; I think the way the code modifies length here is a little confusing and unnecessary. Instead I would write something like this: size_t decommitSize = min(info.RegionSize, end - ptr); And use that instead of the ?: and not change length each time through the loop. > + return; > +} You don't need a return here. > + void *newAddress = VirtualAlloc(ptr, length < info.RegionSize ? length : info.RegionSize, MEM_COMMIT, PAGE_READWRITE); > + ASSERT_UNUSED(newAddress, newAddress == ptr); > + length -= info.RegionSize; > + ptr = static_cast<char*>(ptr) + info.RegionSize; > + } > + return; > } Same comments as above. r=me, but please consider the tweaks I mentioned. 135445 17 adachan 2009-07-28 18:11:47 -0700 Fixed in r46511. 32677 2009-07-13 13:57:34 -0700 2009-07-14 12:06:53 -0700 This patch implements TCMalloc_SystemRelease() on windows and adds a new mechanism to release memory back to the system via a background thread. 27236.patch.txt text/plain 17964 adachan SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDQ1ODM3 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjkgQEAKKzIwMDktMDct MTMgIEFkYSBDaGFuICA8YWRhY2hhbkBhcHBsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisgICAgICAgIAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjcyMzYKKyAgICAgICAgCisgICAgICAgIEltcGxlbWVudCBUQ01h bGxvY19TeXN0ZW1SZWxlYXNlKCkgb24gd2luZG93cy4KKyAgICAgICAgCisgICAgICAgIEltcGxl bWVudCBhIG5ldyBtZWNoYW5pc20gdG8gcmVsZWFzZSBtZW1vcnkgYmFjayB0byB0aGUgc3lzdGVt IHBlcmlvZGljYWxseSB2aWEgYSBiYWNrZ3JvdW5kIHRocmVhZC4KKworICAgICAgICAqIHd0Zi9G YXN0TWFsbG9jLmNwcDoKKyAgICAgICAgKFdURjo6VENNYWxsb2NfUGFnZUhlYXA6OnNob3VsZENv bnRpbnVlU2NhdmVuZ2luZyk6CisgICAgICAgIChXVEY6OlRDTWFsbG9jX1BhZ2VIZWFwOjppbml0 KToKKyAgICAgICAgKFdURjo6VENNYWxsb2NfUGFnZUhlYXA6OnJ1blNjYXZlbmdlclRocmVhZCk6 CisgICAgICAgIChXVEY6OlRDTWFsbG9jX1BhZ2VIZWFwOjpzY2F2ZW5nZSk6CisgICAgICAgIChX VEY6OlRDTWFsbG9jX1BhZ2VIZWFwOjpOZXcpOgorICAgICAgICAoV1RGOjpUQ01hbGxvY19QYWdl SGVhcDo6QWxsb2NMYXJnZSk6CisgICAgICAgIChXVEY6OlRDTWFsbG9jX1BhZ2VIZWFwOjpEZWxl dGUpOgorICAgICAgICAoV1RGOjpUQ01hbGxvY19QYWdlSGVhcDo6c2NhdmVuZ2VyVGhyZWFkKToK KyAgICAgICAgKiB3dGYvVENTcGluTG9jay5oOgorICAgICAgICAoVENNYWxsb2NfU3BpbkxvY2s6 OklzSGVsZCk6CisgICAgICAgICogd3RmL1RDU3lzdGVtQWxsb2MuY3BwOgorICAgICAgICAoVENN YWxsb2NfU3lzdGVtUmVsZWFzZSk6CisgICAgICAgIChUQ01hbGxvY19TeXN0ZW1Db21taXQpOgor ICAgICAgICAqIHd0Zi9UQ1N5c3RlbUFsbG9jLmg6CisKIDIwMDktMDctMTMgIEd1c3Rhdm8gTm9y b25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAg VW5yZXZpZXdlZCBtYWtlIGRpc3QgYnVpbGQgZml4LgpJbmRleDogd3RmL0Zhc3RNYWxsb2MuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHd0Zi9GYXN0TWFsbG9jLmNwcAkocmV2aXNpb24gNDU4MjgpCisrKyB3 dGYvRmFzdE1hbGxvYy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTk3LDYgKzk3LDkgQEAKIAogI2Rl ZmluZSBUQ01BTExPQ19UUkFDS19ERUNPTU1JVEVEX1NQQU5TIChIQVZFKFZJUlRVQUxBTExPQykg fHwgSEFWRShNQURWX0ZSRUVfUkVVU0UpKQogCisvLyBVc2UgYSBiYWNrZ3JvdW5kIHRocmVhZCB0 byBwZXJpb2RpY2FsbHkgc2NhdmVuZ2UgbWVtb3J5IHRvIHJlbGVhc2UgYmFjayB0byB0aGUgc3lz dGVtCisjZGVmaW5lIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkgMQor CiAjaWZuZGVmIE5ERUJVRwogbmFtZXNwYWNlIFdURiB7CiAKQEAgLTExOTMsNiArMTE5NiwyNCBA QCB0ZW1wbGF0ZSA8PiBjbGFzcyBNYXBTZWxlY3RvcjwzMj4gewogLy8gY29udGlndW91cyBydW5z IG9mIHBhZ2VzIChjYWxsZWQgYSAic3BhbiIpLgogLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCisjaWYg VVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorLy8gVGhlIGNlbnRyYWwg cGFnZSBoZWFwIGNvbGxlY3RzIHNwYW5zIG9mIG1lbW9yeSB0aGF0IGhhdmUgYmVlbiBkZWxldGVk IGJ1dCBhcmUgc3RpbGwgY29tbWl0dGVkIHVudGlsIHRoZXkgYXJlIHJlbGVhc2VkCisvLyBiYWNr IHRvIHRoZSBzeXN0ZW0uICBXZSB1c2UgYSBiYWNrZ3JvdW5kIHRocmVhZCB0byBwZXJpb2RpY2Fs bHkgc2NhbiB0aGUgbGlzdCBvZiBmcmVlIHNwYW5zIGFuZCByZWxlYXNlIHNvbWUgYmFjayB0byB0 aGUKKy8vIHN5c3RlbS4gIEV2ZXJ5IDUgc2Vjb25kcywgdGhlIGJhY2tncm91bmQgdGhyZWFkIHdh a2VzIHVwIGFuZCBkb2VzIHRoZSBmb2xsb3dpbmc6CisvLyAtIENoZWNrIGlmIHRoZSBudW1iZXIg b2YgcGFnZXMgYWxsb2NhdGVkIGluIHRoZSBsYXN0IDUgc2Vjb25kcyBpcyBncmVhdGVyIHRoYW4g MS8zIG9mIHRoZSBmcmVlIGNvbW1pdHRlZCBwYWdlcy4gIElmIHNvLCAKKy8vIHNraXAgdGhpcyBz Y2F2ZW5nZSBiZWNhdXNlIGl0J3MgYSBzaWduIHRoYXQgdGhlcmUgaXMgYSBsb3Qgb2YgYWN0aXZp dHkgZ29pbmcgb24gcmlnaHQgbm93IGFuZCB0aHJhc2hpbmcgbWF5IGhhcHBlbiBpZiAKKy8vIHdl IHJlbGVhc2UgbWVtb3J5IGJhY2sgdG8gdGhlIHN5c3RlbSBub3cuCisvLyAtIE90aGVyd2lzZSwg Z28gdGhyb3VnaCB0aGUgbGlzdCBvZiBmcmVlIHNwYW5zIChmcm9tIGxhcmdlc3QgdG8gc21hbGxl c3QpIGFuZCByZWxlYXNlIHVwIHRvIDEvMyBvZiB0aGUgZnJlZSBjb21taXR0ZWQgcGFnZXMKKy8v IGJhY2sgdG8gdGhlIHN5c3RlbS4gIFdlIGNhbiByZWxlYXNlIG1vcmUgaWYgdGhlcmUncyBhYnNv bHV0ZWx5IG5vIGFjdGl2aXR5IGdvaW5nIG9uIGluIHRoZSBsYXN0IDUgc2Vjb25kcy4KKy8vIC0g SWYgdGhlIG51bWJlciBvZiBmcmVlIGNvbW1pdHRlZCBwYWdlcyByZWFjaGVzIGtNaW5pbXVtRnJl ZUNvbW1pdHRlZFBhZ2VDb3VudCwgd2UgY2FuIHN0b3AgdGhlIHNjYXZlbmdpbmcgYW5kIGJsb2Nr IHRoZQorLy8gc2NhdmVuZ2luZyB0aHJlYWQgdW50aWwgdGhlIG51bWJlciBvZiBmcmVlIGNvbW1p dHRlZCBwYWdlcyBnb2VzIGFib3ZlIGtNaW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudC4KKwor Ly8gQmFja2dyb3VuZCB0aHJlYWQgd2FrZXMgdXAgZXZlcnkgNSBzZWNvbmRzIHRvIHNjYXZlbmdl IGFzIGxvbmcgYXMgdGhlcmUgaXMgbWVtb3J5IGF2YWlsYWJsZSB0byByZXR1cm4gdG8gdGhlIHN5 c3RlbS4KK3N0YXRpYyBjb25zdCBpbnQga1NjYXZlbmdlVGltZXJEZWxheUluU2Vjb25kcyA9IDU7 CisvLyBOdW1iZXIgb2YgZnJlZSBjb21taXR0ZWQgcGFnZXMgdGhhdCB3ZSB3YW50IHRvIGtlZXAg YXJvdW5kLgorc3RhdGljIGNvbnN0IHNpemVfdCBrTWluaW11bUZyZWVDb21taXR0ZWRQYWdlQ291 bnQgPSA1MTI7CisjZW5kaWYKKwogY2xhc3MgVENNYWxsb2NfUGFnZUhlYXAgewogIHB1YmxpYzoK ICAgdm9pZCBpbml0KCk7CkBAIC0xMjkyLDYgKzEzMTMsMTYgQEAgY2xhc3MgVENNYWxsb2NfUGFn ZUhlYXAgewogICAvLyBCeXRlcyBhbGxvY2F0ZWQgZnJvbSBzeXN0ZW0KICAgdWludDY0X3Qgc3lz dGVtX2J5dGVzXzsKIAorI2lmIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1P UlkKKyNpZiBUQ01BTExPQ19UUkFDS19ERUNPTU1JVEVEX1NQQU5TCisgIC8vIE51bWJlciBvZiBw YWdlcyBrZXB0IGluIGZyZWUgbGlzdHMgdGhhdCBhcmUgc3RpbGwgY29tbWl0dGVkLgorICBMZW5n dGggZnJlZV9jb21taXR0ZWRfcGFnZXNfOworI2VuZGlmCisKKyAgLy8gTnVtYmVyIG9mIHBhZ2Vz IHRoYXQgd2UgYWxsb2NhdGVkIGluIHRoZSBsYXN0IHNjYXZlbmdlIHdhaXQgaW50ZXJ2YWwuCisg IExlbmd0aCBwYWdlc19hbGxvY2F0ZWRfc2luY2VfbGFzdF9zY2F2ZW5nZV87CisjZW5kaWYKKwog ICBib29sIEdyb3dIZWFwKExlbmd0aCBuKTsKIAogICAvLyBSRVFVSVJFUyAgIHNwYW4tPmxlbmd0 aCA+PSBuCkBAIC0xMzE0LDkgKzEzNDUsMTEgQEAgY2xhc3MgVENNYWxsb2NfUGFnZUhlYXAgewog ICAvLyBzcGFuIG9mIGV4YWN0bHkgdGhlIHNwZWNpZmllZCBsZW5ndGguICBFbHNlLCByZXR1cm5z IE5VTEwuCiAgIFNwYW4qIEFsbG9jTGFyZ2UoTGVuZ3RoIG4pOwogCisjaWYgIVVTRV9CQUNLR1JP VU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKICAgLy8gSW5jcmVtZW50YWxseSByZWxlYXNl IHNvbWUgbWVtb3J5IHRvIHRoZSBzeXN0ZW0uCiAgIC8vIEluY3JlbWVudGFsU2NhdmVuZ2Uobikg aXMgY2FsbGVkIHdoZW5ldmVyIG4gcGFnZXMgYXJlIGZyZWVkLgogICB2b2lkIEluY3JlbWVudGFs U2NhdmVuZ2UoTGVuZ3RoIG4pOworI2VuZGlmCiAKICAgLy8gTnVtYmVyIG9mIHBhZ2VzIHRvIGRl YWxsb2NhdGUgYmVmb3JlIGRvaW5nIG1vcmUgc2NhdmVuZ2luZwogICBpbnQ2NF90IHNjYXZlbmdl X2NvdW50ZXJfOwpAQCAtMTMyNyw2ICsxMzYwLDM0IEBAIGNsYXNzIFRDTWFsbG9jX1BhZ2VIZWFw IHsKICNpZiBkZWZpbmVkKFdURl9DSEFOR0VTKSAmJiBQTEFURk9STShEQVJXSU4pCiAgIGZyaWVu ZCBjbGFzcyBGYXN0TWFsbG9jWm9uZTsKICNlbmRpZgorCisjaWYgVVNFX0JBQ0tHUk9VTkRfVEhS RUFEX1RPX1NDQVZFTkdFX01FTU9SWQorI2lmIFBMQVRGT1JNKFdJTikKKyAgc3RhdGljIHZvaWQq IHJ1blNjYXZlbmdlclRocmVhZCh2b2lkKik7CisKKyAgdm9pZCBzY2F2ZW5nZXJUaHJlYWQoKTsK KyNlbHNlCisgIHN0YXRpYyBOT19SRVRVUk4gdm9pZCogcnVuU2NhdmVuZ2VyVGhyZWFkKHZvaWQq KTsKKworICBOT19SRVRVUk4gdm9pZCBzY2F2ZW5nZXJUaHJlYWQoKTsKKyNlbmRpZgorCisgIHZv aWQgc2NhdmVuZ2UoKTsKKworI2lmIFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMKKyAg aW5saW5lIGJvb2wgc2hvdWxkQ29udGludWVTY2F2ZW5naW5nKCkgY29uc3QgeyByZXR1cm4gZnJl ZV9jb21taXR0ZWRfcGFnZXNfID4ga01pbmltdW1GcmVlQ29tbWl0dGVkUGFnZUNvdW50OyB9Cisj ZWxzZQorICBpbmxpbmUgYm9vbCBzaG91bGRDb250aW51ZVNjYXZlbmdpbmcoKSBjb25zdCB7IHJl dHVybiB0cnVlOyB9CisjZW5kaWYKKworICBwdGhyZWFkX211dGV4X3QgbV9zY2F2ZW5nZU11dGV4 OworCisgIHB0aHJlYWRfY29uZF90IG1fc2NhdmVuZ2VDb25kaXRpb247CisKKyAgLy8gS2VlcHMg dHJhY2sgb2Ygd2hldGhlciB0aGUgYmFja2dyb3VuZCB0aHJlYWQgaXMgYWN0aXZlbHkgc2NhdmVu Z2luZyBtZW1vcnkgZXZlcnkga1NjYXZlbmdlVGltZXJEZWxheUluU2Vjb25kcywgb3IKKyAgLy8g aXQncyBibG9ja2VkIHdhaXRpbmcgZm9yIG1vcmUgcGFnZXMgdG8gYmUgZGVsZXRlZC4KKyAgYm9v bCBtX3NjYXZlbmdlVGhyZWFkQWN0aXZlOworI2VuZGlmICAvLyBVU0VfQkFDS0dST1VORF9USFJF QURfVE9fU0NBVkVOR0VfTUVNT1JZCiB9OwogCiB2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjppbml0 KCkKQEAgLTEzMzUsNiArMTM5NiwxNCBAQCB2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjppbml0KCkK ICAgcGFnZW1hcF9jYWNoZV8gPSBQYWdlTWFwQ2FjaGUoMCk7CiAgIGZyZWVfcGFnZXNfID0gMDsK ICAgc3lzdGVtX2J5dGVzXyA9IDA7CisKKyNpZiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NB VkVOR0VfTUVNT1JZCisjaWYgVENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUworICBmcmVl X2NvbW1pdHRlZF9wYWdlc18gPSAwOworI2VuZGlmCisgIHBhZ2VzX2FsbG9jYXRlZF9zaW5jZV9s YXN0X3NjYXZlbmdlXyA9IDA7CisjZW5kaWYgIC8vIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19T Q0FWRU5HRV9NRU1PUlkKKwogICBzY2F2ZW5nZV9jb3VudGVyXyA9IDA7CiAgIC8vIFN0YXJ0IHNj YXZlbmdpbmcgYXQga01heFBhZ2VzIGxpc3QKICAgc2NhdmVuZ2VfaW5kZXhfID0ga01heFBhZ2Vz LTE7CkBAIC0xMzQ1LDEyICsxNDE0LDgwIEBAIHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OmluaXQo KQogICAgIERMTF9Jbml0KCZmcmVlX1tpXS5ub3JtYWwpOwogICAgIERMTF9Jbml0KCZmcmVlX1tp XS5yZXR1cm5lZCk7CiAgIH0KKworI2lmIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5H RV9NRU1PUlkKKyAgcHRocmVhZF9tdXRleF9pbml0KCZtX3NjYXZlbmdlTXV0ZXgsIDApOworICBw dGhyZWFkX2NvbmRfaW5pdCgmbV9zY2F2ZW5nZUNvbmRpdGlvbiwgMCk7CisgIG1fc2NhdmVuZ2VU aHJlYWRBY3RpdmUgPSB0cnVlOworICBwdGhyZWFkX3QgdGhyZWFkOworICBwdGhyZWFkX2NyZWF0 ZSgmdGhyZWFkLCAwLCBydW5TY2F2ZW5nZXJUaHJlYWQsIHRoaXMpOworI2VuZGlmICAvLyBVU0Vf QkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCit9CisKKyNpZiBVU0VfQkFDS0dS T1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCit2b2lkKiBUQ01hbGxvY19QYWdlSGVhcDo6 cnVuU2NhdmVuZ2VyVGhyZWFkKHZvaWQqIGNvbnRleHQpCit7CisgIHJlaW50ZXJwcmV0X2Nhc3Q8 VENNYWxsb2NfUGFnZUhlYXAqPihjb250ZXh0KS0+c2NhdmVuZ2VyVGhyZWFkKCk7CisjaWYgUExB VEZPUk0oV0lOKSAmJiAhZGVmaW5lZChOREVCVUcpCisgIC8vIERlYnVnIHdpbmRvd3MgYnVpbGQg ZW5mb3JjZXMgdGhpcyBtZXRob2QgdG8gcmV0dXJuIGEgdmFsdWUuCisgIHJldHVybiAwOworI2Vu ZGlmCit9CisKK3ZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OnNjYXZlbmdlKCkgeworICAgIC8vIElm IHRoZSBudW1iZXIgb2YgcGFnZXMgYWxsb2NhdGVkIGluIHRoZSBsYXN0IDUgc2Vjb25kcyBpcyBt b3JlIHRoYW4gMS8zIG9mIHRoZSBmcmVlIGNvbW1pdHRlZCBwYWdlcywKKyAgICAvLyBza2lwIHRo aXMgc2NhdmVuZ2Ugc2luY2UgaXQncyBhIHNpZ24gdGhhdCB0aGVyZSB3aWxsIGJlIG1vcmUgYWxs b2NhdGlvbnMgbGF0ZXIgYW5kIHdlIGRvbid0IHdhbnQgdG8KKyAgICAvLyBkZWNvbW1pdCBwYWdl cyBub3cgYnV0IG9ubHkgdG8gcmVjb21taXQgdGhlbSBpbW1lZGlhdGVseSBhZnRlci4KKyNpZiBU Q01BTExPQ19UUkFDS19ERUNPTU1JVEVEX1NQQU5TCisgICAgaWYgKHBhZ2VzX2FsbG9jYXRlZF9z aW5jZV9sYXN0X3NjYXZlbmdlXyAqIDMgPiBmcmVlX2NvbW1pdHRlZF9wYWdlc18pIHsKKyAgICAg ICAgcGFnZXNfYWxsb2NhdGVkX3NpbmNlX2xhc3Rfc2NhdmVuZ2VfID0gMDsKKyAgICAgICAgcmV0 dXJuOworICAgIH0KKyAgICBMZW5ndGggcGFnZXNEZWNvbW1pdHRlZCA9IDA7CisjZW5kaWYKKyAg ICBmb3IgKGludCBpID0ga01heFBhZ2VzOyBpID49IDA7IGktLSkgeworICAgICAgICBTcGFuTGlz dCogc2xpc3QgPSAoc3RhdGljX2Nhc3Q8c2l6ZV90PihpKSA9PSBrTWF4UGFnZXMpID8gJmxhcmdl XyA6ICZmcmVlX1tpXTsKKyAgICAgICAgaWYgKCFETExfSXNFbXB0eSgmc2xpc3QtPm5vcm1hbCkp IHsKKyAgICAgICAgICAgIC8vIFJlbGVhc2UgdGhlIGxhc3Qgc3BhbiBvbiB0aGUgbm9ybWFsIHBv cnRpb24gb2YgdGhpcyBsaXN0CisgICAgICAgICAgICBTcGFuKiBzID0gc2xpc3QtPm5vcm1hbC5w cmV2OyAKKyNpZiBUQ01BTExPQ19UUkFDS19ERUNPTU1JVEVEX1NQQU5TCisgICAgICAgICAgICAv LyBPbmx5IGRlY29tbWl0IHVwIHRvIDEvMyBvZiB0aGUgZnJlZSBjb21taXR0ZWQgcGFnZXMgaWYg cGFnZXNfYWxsb2NhdGVkX3NpbmNlX2xhc3Rfc2NhdmVuZ2VfID4gMC4KKyAgICAgICAgICAgIGlm IChwYWdlc19hbGxvY2F0ZWRfc2luY2VfbGFzdF9zY2F2ZW5nZV8gJiYgKHBhZ2VzRGVjb21taXR0 ZWQgKyBzLT5sZW5ndGgpICogMyA+IGZyZWVfY29tbWl0dGVkX3BhZ2VzXykKKyAgICAgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIERMTF9SZW1vdmUocyk7CisgICAgICAgICAgICBU Q01hbGxvY19TeXN0ZW1SZWxlYXNlKHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHMtPnN0YXJ0IDw8 IGtQYWdlU2hpZnQpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGF0aWNf Y2FzdDxzaXplX3Q+KHMtPmxlbmd0aCA8PCBrUGFnZVNoaWZ0KSk7CisgICAgICAgICAgICBpZiAo IXMtPmRlY29tbWl0dGVkKQorICAgICAgICAgICAgICAgIHBhZ2VzRGVjb21taXR0ZWQgKz0gcy0+ bGVuZ3RoOworICAgICAgICAgICAgcy0+ZGVjb21taXR0ZWQgPSB0cnVlOworICAgICAgICAgICAg RExMX1ByZXBlbmQoJnNsaXN0LT5yZXR1cm5lZCwgcyk7CisgICAgICAgICAgICAvLyBXZSBjYW4g c3RvcCBzY2F2ZW5naW5nIGlmIHRoZSBudW1iZXIgb2YgZnJlZSBjb21taXR0ZWQgcGFnZXMgbGVm dCBpcyBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gdGhlIG1pbmltdW0gbnVtYmVyIHdlIHdhbnQgdG8g a2VlcCBhcm91bmQuCisgICAgICAgICAgICBpZiAoZnJlZV9jb21taXR0ZWRfcGFnZXNfIDw9IGtN aW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudCArIHBhZ2VzRGVjb21taXR0ZWQpCisgICAgICAg ICAgICAgICAgYnJlYWs7CisjZWxzZQorICAgICAgICAgICAgRExMX1JlbW92ZShzKTsKKyAgICAg ICAgICAgIFRDTWFsbG9jX1N5c3RlbVJlbGVhc2UocmVpbnRlcnByZXRfY2FzdDx2b2lkKj4ocy0+ c3RhcnQgPDwga1BhZ2VTaGlmdCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHN0YXRpY19jYXN0PHNpemVfdD4ocy0+bGVuZ3RoIDw8IGtQYWdlU2hpZnQpKTsKKyAgICAgICAg ICAgIERMTF9QcmVwZW5kKCZzbGlzdC0+cmV0dXJuZWQsIHMpOworI2VuZGlmCisgICAgICAgIH0K KyAgICB9CisjaWYgVENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUworICAgIHBhZ2VzX2Fs bG9jYXRlZF9zaW5jZV9sYXN0X3NjYXZlbmdlXyA9IDA7CisgICAgQVNTRVJUKGZyZWVfY29tbWl0 dGVkX3BhZ2VzXyA+PSBwYWdlc0RlY29tbWl0dGVkKTsKKyAgICBmcmVlX2NvbW1pdHRlZF9wYWdl c18gLT0gcGFnZXNEZWNvbW1pdHRlZDsKKyNlbmRpZgogfQorI2VuZGlmICAvLyBVU0VfQkFDS0dS T1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCiAKIGlubGluZSBTcGFuKiBUQ01hbGxvY19Q YWdlSGVhcDo6TmV3KExlbmd0aCBuKSB7CiAgIEFTU0VSVChDaGVjaygpKTsKICAgQVNTRVJUKG4g PiAwKTsKIAorI2lmIFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMgJiYgVVNFX0JBQ0tH Uk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorICBwYWdlc19hbGxvY2F0ZWRfc2luY2Vf bGFzdF9zY2F2ZW5nZV8gKz0gbjsKKyNlbmRpZgorCiAgIC8vIEZpbmQgZmlyc3Qgc2l6ZSA+PSBu IHRoYXQgaGFzIGEgbm9uLWVtcHR5IGxpc3QKICAgZm9yIChMZW5ndGggcyA9IG47IHMgPCBrTWF4 UGFnZXM7IHMrKykgewogICAgIFNwYW4qIGxsID0gTlVMTDsKQEAgLTEzNzQsNiArMTUxMSwxNCBA QCBpbmxpbmUgU3BhbiogVENNYWxsb2NfUGFnZUhlYXA6Ok5ldyhMZW5nCiAgICAgICAgIFRDTWFs bG9jX1N5c3RlbUNvbW1pdChyZWludGVycHJldF9jYXN0PHZvaWQqPihyZXN1bHQtPnN0YXJ0IDw8 IGtQYWdlU2hpZnQpLCBzdGF0aWNfY2FzdDxzaXplX3Q+KG4gPDwga1BhZ2VTaGlmdCkpOwogICAg ICAgICByZXN1bHQtPmRlY29tbWl0dGVkID0gZmFsc2U7CiAgICAgfQorI2lmIFVTRV9CQUNLR1JP VU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKKyAgICBlbHNlIHsKKyAgICAgICAgLy8gVGhl IG5ld2x5IGFsbG9jYXRlZCBtZW1vcnkgaXMgZnJvbSBhIHNwYW4gdGhhdCdzIGluIHRoZSBub3Jt YWwgc3BhbiBsaXN0IChhbHJlYWR5IGNvbW1pdHRlZCkuICBVcGRhdGUgdGhlCisgICAgICAgIC8v IGZyZWUgY29tbWl0dGVkIHBhZ2VzIGNvdW50LgorICAgICAgICBBU1NFUlQoZnJlZV9jb21taXR0 ZWRfcGFnZXNfID49IG4pOworICAgICAgICBmcmVlX2NvbW1pdHRlZF9wYWdlc18gLT0gbjsKKyAg ICB9CisjZW5kaWYgIC8vIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkK ICNlbmRpZgogICAgIEFTU0VSVChDaGVjaygpKTsKICAgICBmcmVlX3BhZ2VzXyAtPSBuOwpAQCAt MTQzNiw2ICsxNTgxLDE0IEBAIFNwYW4qIFRDTWFsbG9jX1BhZ2VIZWFwOjpBbGxvY0xhcmdlKExl bmcKICAgICAgICAgVENNYWxsb2NfU3lzdGVtQ29tbWl0KHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+ KGJlc3QtPnN0YXJ0IDw8IGtQYWdlU2hpZnQpLCBzdGF0aWNfY2FzdDxzaXplX3Q+KG4gPDwga1Bh Z2VTaGlmdCkpOwogICAgICAgICBiZXN0LT5kZWNvbW1pdHRlZCA9IGZhbHNlOwogICAgIH0KKyNp ZiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgZWxzZSB7Cisg ICAgICAgIC8vIFRoZSBuZXdseSBhbGxvY2F0ZWQgbWVtb3J5IGlzIGZyb20gYSBzcGFuIHRoYXQn cyBpbiB0aGUgbm9ybWFsIHNwYW4gbGlzdCAoYWxyZWFkeSBjb21taXR0ZWQpLiAgVXBkYXRlIHRo ZQorICAgICAgICAvLyBmcmVlIGNvbW1pdHRlZCBwYWdlcyBjb3VudC4KKyAgICAgICAgQVNTRVJU KGZyZWVfY29tbWl0dGVkX3BhZ2VzXyA+PSBuKTsKKyAgICAgICAgZnJlZV9jb21taXR0ZWRfcGFn ZXNfIC09IG47CisgICAgfQorI2VuZGlmICAvLyBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NB VkVOR0VfTUVNT1JZCiAjZW5kaWYKICAgICBBU1NFUlQoQ2hlY2soKSk7CiAgICAgZnJlZV9wYWdl c18gLT0gbjsKQEAgLTE1MjYsNiArMTY3OSwxMCBAQCBpbmxpbmUgdm9pZCBUQ01hbGxvY19QYWdl SGVhcDo6RGVsZXRlKFNwCiAgIC8vIG5lY2Vzc2FyeS4gIFdlIGRvIG5vdCBib3RoZXIgcmVzZXR0 aW5nIHRoZSBzdGFsZSBwYWdlbWFwCiAgIC8vIGVudHJpZXMgZm9yIHRoZSBwaWVjZXMgd2UgYXJl IG1lcmdpbmcgdG9nZXRoZXIgYmVjYXVzZSB3ZSBvbmx5CiAgIC8vIGNhcmUgYWJvdXQgdGhlIHBh Z2VtYXAgZW50cmllcyBmb3IgdGhlIGJvdW5kYXJpZXMuCisjaWYgVENNQUxMT0NfVFJBQ0tfREVD T01NSVRFRF9TUEFOUyAmJiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZ CisgIC8vIFRyYWNrIHRoZSB0b3RhbCBzaXplIG9mIHRoZSBuZWlnaGJvcmluZyBmcmVlIHNwYW5z IHRoYXQgYXJlIGNvbW1pdHRlZC4KKyAgTGVuZ3RoIG5laWdoYm9yaW5nQ29tbWl0dGVkU3BhbnNM ZW5ndGggPSAwOworI2VuZGlmCiAgIGNvbnN0IFBhZ2VJRCBwID0gc3Bhbi0+c3RhcnQ7CiAgIGNv bnN0IExlbmd0aCBuID0gc3Bhbi0+bGVuZ3RoOwogICBTcGFuKiBwcmV2ID0gR2V0RGVzY3JpcHRv cihwLTEpOwpAQCAtMTUzMyw2ICsxNjkwLDEwIEBAIGlubGluZSB2b2lkIFRDTWFsbG9jX1BhZ2VI ZWFwOjpEZWxldGUoU3AKICAgICAvLyBNZXJnZSBwcmVjZWRpbmcgc3BhbiBpbnRvIHRoaXMgc3Bh bgogICAgIEFTU0VSVChwcmV2LT5zdGFydCArIHByZXYtPmxlbmd0aCA9PSBwKTsKICAgICBjb25z dCBMZW5ndGggbGVuID0gcHJldi0+bGVuZ3RoOworI2lmIFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlU RURfU1BBTlMgJiYgVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorICAg IGlmICghcHJldi0+ZGVjb21taXR0ZWQpCisgICAgICAgIG5laWdoYm9yaW5nQ29tbWl0dGVkU3Bh bnNMZW5ndGggKz0gbGVuOworI2VuZGlmCiAgICAgbWVyZ2VEZWNvbW1pdHRlZFN0YXRlcyhzcGFu LCBwcmV2KTsKICAgICBETExfUmVtb3ZlKHByZXYpOwogICAgIERlbGV0ZVNwYW4ocHJldik7CkBA IC0xNTQ2LDYgKzE3MDcsMTAgQEAgaW5saW5lIHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OkRlbGV0 ZShTcAogICAgIC8vIE1lcmdlIG5leHQgc3BhbiBpbnRvIHRoaXMgc3BhbgogICAgIEFTU0VSVChu ZXh0LT5zdGFydCA9PSBwK24pOwogICAgIGNvbnN0IExlbmd0aCBsZW4gPSBuZXh0LT5sZW5ndGg7 CisjaWYgVENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUyAmJiBVU0VfQkFDS0dST1VORF9U SFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgaWYgKCFuZXh0LT5kZWNvbW1pdHRlZCkKKyAg ICAgICAgbmVpZ2hib3JpbmdDb21taXR0ZWRTcGFuc0xlbmd0aCArPSBsZW47CisjZW5kaWYKICAg ICBtZXJnZURlY29tbWl0dGVkU3RhdGVzKHNwYW4sIG5leHQpOwogICAgIERMTF9SZW1vdmUobmV4 dCk7CiAgICAgRGVsZXRlU3BhbihuZXh0KTsKQEAgLTE1NzIsMTAgKzE3MzcsMjkgQEAgaW5saW5l IHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OkRlbGV0ZShTcAogICB9CiAgIGZyZWVfcGFnZXNfICs9 IG47CiAKKyNpZiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisjaWYg VENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUworICBpZiAoc3Bhbi0+ZGVjb21taXR0ZWQp IHsKKyAgICAgIC8vIElmIHRoZSBtZXJnZWQgc3BhbiBpcyBkZWNvbW1pdHRlZCwgdGhhdCBtZWFu cyB3ZSBkZWNvbW1pdHRlZCBhbnkgbmVpZ2hib3Jpbmcgc3BhbnMgdGhhdCB3ZXJlCisgICAgICAv LyBjb21taXR0ZWQuICBVcGRhdGUgdGhlIGZyZWUgY29tbWl0dGVkIHBhZ2VzIGNvdW50LgorICAg ICAgZnJlZV9jb21taXR0ZWRfcGFnZXNfIC09IG5laWdoYm9yaW5nQ29tbWl0dGVkU3BhbnNMZW5n dGg7CisgIH0gZWxzZSB7CisgICAgICAvLyBJZiB0aGUgbWVyZ2VkIHNwYW4gcmVtYWlucyBjb21t aXR0ZWQsIGFkZCB0aGUgZGVsZXRlZCBzcGFuJ3Mgc2l6ZSB0byB0aGUgZnJlZSBjb21taXR0ZWQg cGFnZXMgY291bnQuCisgICAgICBmcmVlX2NvbW1pdHRlZF9wYWdlc18gKz0gbjsKKyAgfQorI2Vu ZGlmCisKKyAgLy8gTWFrZSBzdXJlIHRoZSBzY2F2ZW5nZSB0aHJlYWQgYmVjb21lcyBhY3RpdmUg aWYgd2UgaGF2ZSBlbm91Z2ggZnJlZWQgcGFnZXMgdG8gcmVsZWFzZSBzb21lIGJhY2sgdG8gdGhl IHN5c3RlbS4KKyAgaWYgKCFtX3NjYXZlbmdlVGhyZWFkQWN0aXZlICYmIHNob3VsZENvbnRpbnVl U2NhdmVuZ2luZygpKQorICAgICAgcHRocmVhZF9jb25kX3NpZ25hbCgmbV9zY2F2ZW5nZUNvbmRp dGlvbik7CisjZWxzZQogICBJbmNyZW1lbnRhbFNjYXZlbmdlKG4pOworI2VuZGlmCisKICAgQVNT RVJUKENoZWNrKCkpOwogfQogCisjaWYgIVVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5H RV9NRU1PUlkKIHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OkluY3JlbWVudGFsU2NhdmVuZ2UoTGVu Z3RoIG4pIHsKICAgLy8gRmFzdCBwYXRoOyBub3QgeWV0IHRpbWUgdG8gcmVsZWFzZSBtZW1vcnkK ICAgc2NhdmVuZ2VfY291bnRlcl8gLT0gbjsKQEAgLTE2MTUsNiArMTc5OSw3IEBAIHZvaWQgVENN YWxsb2NfUGFnZUhlYXA6OkluY3JlbWVudGFsU2NhdmUKICAgLy8gTm90aGluZyB0byBzY2F2ZW5n ZSwgZGVsYXkgZm9yIGEgd2hpbGUKICAgc2NhdmVuZ2VfY291bnRlcl8gPSBrRGVmYXVsdFJlbGVh c2VEZWxheTsKIH0KKyNlbmRpZgogCiB2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjpSZWdpc3RlclNp emVDbGFzcyhTcGFuKiBzcGFuLCBzaXplX3Qgc2MpIHsKICAgLy8gQXNzb2NpYXRlIHNwYW4gb2Jq ZWN0IHdpdGggYWxsIGludGVyaW9yIHBhZ2VzIGFzIHdlbGwKQEAgLTIxMDYsNiArMjI5MSwzMSBA QCBzdGF0aWMgaW5saW5lIFRDTWFsbG9jX1BhZ2VIZWFwKiBnZXRQYWdlCiAKICNkZWZpbmUgcGFn ZWhlYXAgZ2V0UGFnZUhlYXAoKQogCisjaWYgVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZF TkdFX01FTU9SWQordm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6c2NhdmVuZ2VyVGhyZWFkKCkKK3sK KyAgd2hpbGUgKDEpIHsKKyAgICAgIGlmICghc2hvdWxkQ29udGludWVTY2F2ZW5naW5nKCkpIHsK KyAgICAgICAgICBwdGhyZWFkX211dGV4X2xvY2soJm1fc2NhdmVuZ2VNdXRleCk7CisgICAgICAg ICAgbV9zY2F2ZW5nZVRocmVhZEFjdGl2ZSA9IGZhbHNlOworICAgICAgICAgIC8vIEJsb2NrIHVu dGlsIHRoZXJlIGFyZSBlbm91Z2ggZnJlZWQgcGFnZXMgdG8gcmVsZWFzZSBiYWNrIHRvIHRoZSBz eXN0ZW0uCisgICAgICAgICAgcHRocmVhZF9jb25kX3dhaXQoJm1fc2NhdmVuZ2VDb25kaXRpb24s ICZtX3NjYXZlbmdlTXV0ZXgpOworICAgICAgICAgIG1fc2NhdmVuZ2VUaHJlYWRBY3RpdmUgPSB0 cnVlOworICAgICAgICAgIHB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZtX3NjYXZlbmdlTXV0ZXgpOwor ICAgICAgfQorI2lmIFBMQVRGT1JNKFdJTikKKyAgICAgIDo6U2xlZXAoa1NjYXZlbmdlVGltZXJE ZWxheUluU2Vjb25kcyAqIDEwMDApOworI2Vsc2UKKyAgICAgIHNsZWVwKGtTY2F2ZW5nZVRpbWVy RGVsYXlJblNlY29uZHMpOworI2VuZGlmCisgICAgICB7CisgICAgICAgICAgU3BpbkxvY2tIb2xk ZXIgaCgmcGFnZWhlYXBfbG9jayk7CisgICAgICAgICAgcGFnZWhlYXAtPnNjYXZlbmdlKCk7Cisg ICAgICB9CisgIH0KK30KKyNlbmRpZgorCiAvLyBJZiBUTFMgaXMgYXZhaWxhYmxlLCB3ZSBhbHNv IHN0b3JlIGEgY29weQogLy8gb2YgdGhlIHBlci10aHJlYWQgb2JqZWN0IGluIGEgX190aHJlYWQg dmFyaWFibGUKIC8vIHNpbmNlIF9fdGhyZWFkIHZhcmlhYmxlcyBhcmUgZmFzdGVyIHRvIHJlYWQK SW5kZXg6IHd0Zi9UQ1NwaW5Mb2NrLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gd3RmL1RDU3BpbkxvY2suaAko cmV2aXNpb24gNDU4MjgpCisrKyB3dGYvVENTcGluTG9jay5oCSh3b3JraW5nIGNvcHkpCkBAIC0y MDksNiArMjA5LDEyIEBAIHN0cnVjdCBUQ01hbGxvY19TcGluTG9jayB7CiAgIGlubGluZSB2b2lk IFVubG9jaygpIHsKICAgICBpZiAocHRocmVhZF9tdXRleF91bmxvY2soJnByaXZhdGVfbG9ja18p ICE9IDApIENSQVNIKCk7CiAgIH0KKyAgaW5saW5lIGJvb2wgSXNIZWxkKCkgeworICAgIGlmIChw dGhyZWFkX211dGV4X3RyeWxvY2soJnByaXZhdGVfbG9ja18pKQorICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICBwdGhyZWFkX211dGV4X3VubG9jaygmcHJpdmF0ZV9sb2NrXyk7CisgICAgcmV0dXJu IGZhbHNlOworICB9CiB9OwogCiAjZGVmaW5lIFNQSU5MT0NLX0lOSVRJQUxJWkVSIHsgUFRIUkVB RF9NVVRFWF9JTklUSUFMSVpFUiB9CkluZGV4OiB3dGYvVENTeXN0ZW1BbGxvYy5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gd3RmL1RDU3lzdGVtQWxsb2MuY3BwCShyZXZpc2lvbiA0NTgyOCkKKysrIHd0Zi9U Q1N5c3RlbUFsbG9jLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDQxLDYgKzQ0MSwzNSBAQCB2b2lk IFRDTWFsbG9jX1N5c3RlbVJlbGVhc2Uodm9pZCogc3RhcnQsCiAgIEFTU0VSVF9VTlVTRUQobmV3 QWRkcmVzcywgbmV3QWRkcmVzcyA9PSBzdGFydCB8fCBuZXdBZGRyZXNzID09IHJlaW50ZXJwcmV0 X2Nhc3Q8dm9pZCo+KE1BUF9GQUlMRUQpKTsKIH0KIAorI2VsaWYgSEFWRShWSVJUVUFMQUxMT0Mp CisKK3ZvaWQgVENNYWxsb2NfU3lzdGVtUmVsZWFzZSh2b2lkKiBzdGFydCwgc2l6ZV90IGxlbmd0 aCkKK3sKKyAgICBpZiAoVmlydHVhbEZyZWUoc3RhcnQsIGxlbmd0aCwgTUVNX0RFQ09NTUlUKSkK KyAgICAgICAgcmV0dXJuOworCisgICAgLy8gVGhlIGRlY29tbWl0IG1heSBmYWlsIGlmIHRoZSBt ZW1vcnkgcmVnaW9uIGNvbnNpc3RzIG9mIGFsbG9jYXRpb25zCisgICAgLy8gZnJvbSBtb3JlIHRo YW4gb25lIGNhbGwgdG8gVmlydHVhbEFsbG9jLiAgSW4gdGhpcyBjYXNlLCBmYWxsIGJhY2sgdG8K KyAgICAvLyB1c2luZyBWaXJ0dWFsUXVlcnkgdG8gcmV0cmlldmUgdGhlIGFsbG9jYXRpb24gYm91 bmRhcmllcyBhbmQgZGVjb21taXQKKyAgICAvLyB0aGVtIGVhY2ggaW5kaXZpZHVhbGx5LgorCisg ICAgdm9pZCogcHRyID0gc3RhcnQ7CisgICAgdm9pZCogZW5kID0gKGNoYXIqKXN0YXJ0ICsgbGVu Z3RoOworICAgIE1FTU9SWV9CQVNJQ19JTkZPUk1BVElPTiBpbmZvOworICAgIHdoaWxlIChwdHIg PCBlbmQpIHsKKyAgICAgICAgc2l6ZV90IHJlc3VsdFNpemUgPSBWaXJ0dWFsUXVlcnkocHRyLCAm aW5mbywgc2l6ZW9mKGluZm8pKTsKKyAgICAgICAgVU5VU0VEX1BBUkFNKHJlc3VsdFNpemUpOwor ICAgICAgICBBU1NFUlQocmVzdWx0U2l6ZSA9PSBzaXplb2YoaW5mbykpOworCisgICAgICAgIEJP T0wgc3VjY2VzcyA9IFZpcnR1YWxGcmVlKHB0ciwgbGVuZ3RoIDwgaW5mby5SZWdpb25TaXplID8g bGVuZ3RoIDogaW5mby5SZWdpb25TaXplLCBNRU1fREVDT01NSVQpOworICAgICAgICBVTlVTRURf UEFSQU0oc3VjY2Vzcyk7CisgICAgICAgIEFTU0VSVChzdWNjZXNzKTsKKyAgICAgICAgbGVuZ3Ro IC09IGluZm8uUmVnaW9uU2l6ZTsKKyAgICAgICAgcHRyID0gc3RhdGljX2Nhc3Q8Y2hhcio+KHB0 cikgKyBpbmZvLlJlZ2lvblNpemU7CisgICAgfQorICAgIHJldHVybjsKK30KKwogI2Vsc2UKIAog Ly8gUGxhdGZvcm1zIHRoYXQgZG9uJ3Qgc3VwcG9ydCByZXR1cm5pbmcgbWVtb3J5IHVzZSBhbiBl bXB0eSBpbmxpbmUgdmVyc2lvbiBvZiBUQ01hbGxvY19TeXN0ZW1SZWxlYXNlCkBAIC00NTcsOCAr NDg2LDMxIEBAIHZvaWQgVENNYWxsb2NfU3lzdGVtQ29tbWl0KHZvaWQqIHN0YXJ0LCAKIAogI2Vs aWYgSEFWRShWSVJUVUFMQUxMT0MpCiAKLXZvaWQgVENNYWxsb2NfU3lzdGVtQ29tbWl0KHZvaWQq LCBzaXplX3QpCit2b2lkIFRDTWFsbG9jX1N5c3RlbUNvbW1pdCh2b2lkKiBzdGFydCwgc2l6ZV90 IGxlbmd0aCkKIHsKKyAgICBpZiAoVmlydHVhbEFsbG9jKHN0YXJ0LCBsZW5ndGgsIE1FTV9DT01N SVQsIFBBR0VfUkVBRFdSSVRFKSA9PSBzdGFydCkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8g VGhlIGNvbW1pdCBtYXkgZmFpbCBpZiB0aGUgbWVtb3J5IHJlZ2lvbiBjb25zaXN0cyBvZiBhbGxv Y2F0aW9ucworICAgIC8vIGZyb20gbW9yZSB0aGFuIG9uZSBjYWxsIHRvIFZpcnR1YWxBbGxvYy4g IEluIHRoaXMgY2FzZSwgZmFsbCBiYWNrIHRvCisgICAgLy8gdXNpbmcgVmlydHVhbFF1ZXJ5IHRv IHJldHJpZXZlIHRoZSBhbGxvY2F0aW9uIGJvdW5kYXJpZXMgYW5kIGNvbW1pdCB0aGVtCisgICAg Ly8gZWFjaCBpbmRpdmlkdWFsbHkuCisKKyAgICB2b2lkKiBwdHIgPSBzdGFydDsKKyAgICB2b2lk KiBlbmQgPSAoY2hhciopc3RhcnQgKyBsZW5ndGg7CisgICAgTUVNT1JZX0JBU0lDX0lORk9STUFU SU9OIGluZm87CisgICAgd2hpbGUgKHB0ciA8IGVuZCkgeworICAgICAgICBzaXplX3QgcmVzdWx0 U2l6ZSA9IFZpcnR1YWxRdWVyeShwdHIsICZpbmZvLCBzaXplb2YoaW5mbykpOworICAgICAgICBV TlVTRURfUEFSQU0ocmVzdWx0U2l6ZSk7CisgICAgICAgIEFTU0VSVChyZXN1bHRTaXplID09IHNp emVvZihpbmZvKSk7CisKKyAgICAgICAgdm9pZCAqbmV3QWRkcmVzcyA9IFZpcnR1YWxBbGxvYyhw dHIsIGxlbmd0aCA8IGluZm8uUmVnaW9uU2l6ZSA/IGxlbmd0aCA6IGluZm8uUmVnaW9uU2l6ZSwg TUVNX0NPTU1JVCwgUEFHRV9SRUFEV1JJVEUpOworICAgICAgICBVTlVTRURfUEFSQU0obmV3QWRk cmVzcyk7CisgICAgICAgIEFTU0VSVChuZXdBZGRyZXNzID09IHB0cik7CisgICAgICAgIGxlbmd0 aCAtPSBpbmZvLlJlZ2lvblNpemU7CisgICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PGNoYXIqPihw dHIpICsgaW5mby5SZWdpb25TaXplOworICAgIH0KKyAgICByZXR1cm47CiB9CiAKICNlbHNlCklu ZGV4OiB3dGYvVENTeXN0ZW1BbGxvYy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHd0Zi9UQ1N5c3RlbUFsbG9j LmgJKHJldmlzaW9uIDQ1ODI4KQorKysgd3RmL1RDU3lzdGVtQWxsb2MuaAkod29ya2luZyBjb3B5 KQpAQCAtNjQsNyArNjQsNyBAQCBleHRlcm4gdm9pZCBUQ01hbGxvY19TeXN0ZW1SZWxlYXNlKHZv aWQqCiAKIGV4dGVybiB2b2lkIFRDTWFsbG9jX1N5c3RlbUNvbW1pdCh2b2lkKiBzdGFydCwgc2l6 ZV90IGxlbmd0aCk7CiAKLSNpZiAhSEFWRShNQURWX0ZSRUVfUkVVU0UpICYmICFIQVZFKE1BRFZf RE9OVE5FRUQpICYmICFIQVZFKE1NQVApCisjaWYgIUhBVkUoTUFEVl9GUkVFX1JFVVNFKSAmJiAh SEFWRShNQURWX0RPTlRORUVEKSAmJiAhSEFWRShNTUFQKSAmJiAhSEFWRShWSVJUVUFMQUxMT0Mp CiBpbmxpbmUgdm9pZCBUQ01hbGxvY19TeXN0ZW1SZWxlYXNlKHZvaWQqLCBzaXplX3QpIHsgfQog I2VuZGlmCiAK 33482 2009-07-24 18:34:28 -0700 2009-07-24 18:39:32 -0700 Patch to remove TCMALLOC_TRACK_DECOMMITED_SPANS 20090724-removeflag.patch.txt text/plain 4370 adachan SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDQ2Mzg2KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTggQEAKKzIwMDktMDctMjQgIEFkYSBDaGFu ICA8YWRhY2hhbkBhcHBsZS5jb20+CisKKyAgICAgICAgSW4gcHJlcGFyYXRpb24gZm9yIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzIzNjoKKyAgICAgICAgUmVtb3Zl IFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMuICBXZSdsbCBhbHdheXMgdHJhY2sgZGVj b21taXR0ZWQgc3BhbnMuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiB3dGYvRmFzdE1hbGxvYy5jcHA6CisgICAgICAgIChXVEY6OlRDTWFsbG9jX1Bh Z2VIZWFwOjpOZXcpOgorICAgICAgICAoV1RGOjpUQ01hbGxvY19QYWdlSGVhcDo6QWxsb2NMYXJn ZSk6CisgICAgICAgIChXVEY6OnByb3BhZ2F0ZURlY29tbWl0dGVkU3RhdGUpOgorICAgICAgICAo V1RGOjptZXJnZURlY29tbWl0dGVkU3RhdGVzKToKKyAgICAgICAgKFdURjo6VENNYWxsb2NfUGFn ZUhlYXA6OkRlbGV0ZSk6CisgICAgICAgIChXVEY6OlRDTWFsbG9jX1BhZ2VIZWFwOjpJbmNyZW1l bnRhbFNjYXZlbmdlKToKKwogMjAwOS0wNy0yNCAgQ3NhYmEgT3N6dHJvZ29uYWMgIDxvc3ppQGlu Zi51LXN6ZWdlZC5odT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlciBhbmQgQWRh bSBCYXJ0aC4KSW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9GYXN0TWFsbG9jLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBKYXZhU2NyaXB0Q29yZS93dGYvRmFzdE1hbGxvYy5jcHAJKHJldmlzaW9uIDQ2Mzg1 KQorKysgSmF2YVNjcmlwdENvcmUvd3RmL0Zhc3RNYWxsb2MuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC05NSw4ICs5NSw2IEBACiAjZGVmaW5lIEZPUkNFX1NZU1RFTV9NQUxMT0MgMQogI2VuZGlmCiAK LSNkZWZpbmUgVENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUyAoSEFWRShWSVJUVUFMQUxM T0MpIHx8IEhBVkUoTUFEVl9GUkVFX1JFVVNFKSkKLQogI2lmbmRlZiBOREVCVUcKIG5hbWVzcGFj ZSBXVEYgewogCkBAIC0xMDQzLDExICsxMDQxLDcgQEAgc3RydWN0IFNwYW4gewogI2VuZGlmCiB9 OwogCi0jaWYgVENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUwogI2RlZmluZSBBU1NFUlRf U1BBTl9DT01NSVRURUQoc3BhbikgQVNTRVJUKCFzcGFuLT5kZWNvbW1pdHRlZCkKLSNlbHNlCi0j ZGVmaW5lIEFTU0VSVF9TUEFOX0NPTU1JVFRFRChzcGFuKQotI2VuZGlmCiAKICNpZmRlZiBTUEFO X0hJU1RPUlkKIHZvaWQgRXZlbnQoU3Bhbiogc3BhbiwgY2hhciBvcCwgaW50IHYgPSAwKSB7CkBA IC0xMzY5LDEyICsxMzYzLDEwIEBAIGlubGluZSBTcGFuKiBUQ01hbGxvY19QYWdlSGVhcDo6TmV3 KExlbmcKIAogICAgIFNwYW4qIHJlc3VsdCA9IGxsLT5uZXh0OwogICAgIENhcnZlKHJlc3VsdCwg biwgcmVsZWFzZWQpOwotI2lmIFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMKICAgICBp ZiAocmVzdWx0LT5kZWNvbW1pdHRlZCkgewogICAgICAgICBUQ01hbGxvY19TeXN0ZW1Db21taXQo cmVpbnRlcnByZXRfY2FzdDx2b2lkKj4ocmVzdWx0LT5zdGFydCA8PCBrUGFnZVNoaWZ0KSwgc3Rh dGljX2Nhc3Q8c2l6ZV90PihuIDw8IGtQYWdlU2hpZnQpKTsKICAgICAgICAgcmVzdWx0LT5kZWNv bW1pdHRlZCA9IGZhbHNlOwogICAgIH0KLSNlbmRpZgogICAgIEFTU0VSVChDaGVjaygpKTsKICAg ICBmcmVlX3BhZ2VzXyAtPSBuOwogICAgIHJldHVybiByZXN1bHQ7CkBAIC0xNDMxLDEyICsxNDIz LDEwIEBAIFNwYW4qIFRDTWFsbG9jX1BhZ2VIZWFwOjpBbGxvY0xhcmdlKExlbmcKIAogICBpZiAo YmVzdCAhPSBOVUxMKSB7CiAgICAgQ2FydmUoYmVzdCwgbiwgZnJvbV9yZWxlYXNlZCk7Ci0jaWYg VENNQUxMT0NfVFJBQ0tfREVDT01NSVRFRF9TUEFOUwogICAgIGlmIChiZXN0LT5kZWNvbW1pdHRl ZCkgewogICAgICAgICBUQ01hbGxvY19TeXN0ZW1Db21taXQocmVpbnRlcnByZXRfY2FzdDx2b2lk Kj4oYmVzdC0+c3RhcnQgPDwga1BhZ2VTaGlmdCksIHN0YXRpY19jYXN0PHNpemVfdD4obiA8PCBr UGFnZVNoaWZ0KSk7CiAgICAgICAgIGJlc3QtPmRlY29tbWl0dGVkID0gZmFsc2U7CiAgICAgfQot I2VuZGlmCiAgICAgQVNTRVJUKENoZWNrKCkpOwogICAgIGZyZWVfcGFnZXNfIC09IG47CiAgICAg cmV0dXJuIGJlc3Q7CkBAIC0xNDYxLDE0ICsxNDUxLDEwIEBAIFNwYW4qIFRDTWFsbG9jX1BhZ2VI ZWFwOjpTcGxpdChTcGFuKiBzcGEKICAgcmV0dXJuIGxlZnRvdmVyOwogfQogCi0jaWYgIVRDTUFM TE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMKLXN0YXRpYyBBTFdBWVNfSU5MSU5FIHZvaWQgcHJv cGFnYXRlRGVjb21taXR0ZWRTdGF0ZShTcGFuKiwgU3BhbiopIHsgfQotI2Vsc2UKIHN0YXRpYyBB TFdBWVNfSU5MSU5FIHZvaWQgcHJvcGFnYXRlRGVjb21taXR0ZWRTdGF0ZShTcGFuKiBkZXN0aW5h dGlvbiwgU3Bhbiogc291cmNlKQogewogICAgIGRlc3RpbmF0aW9uLT5kZWNvbW1pdHRlZCA9IHNv dXJjZS0+ZGVjb21taXR0ZWQ7CiB9Ci0jZW5kaWYKIAogaW5saW5lIHZvaWQgVENNYWxsb2NfUGFn ZUhlYXA6OkNhcnZlKFNwYW4qIHNwYW4sIExlbmd0aCBuLCBib29sIHJlbGVhc2VkKSB7CiAgIEFT U0VSVChuID4gMCk7CkBAIC0xNDk1LDkgKzE0ODEsNiBAQCBpbmxpbmUgdm9pZCBUQ01hbGxvY19Q YWdlSGVhcDo6Q2FydmUoU3BhCiAgIH0KIH0KIAotI2lmICFUQ01BTExPQ19UUkFDS19ERUNPTU1J VEVEX1NQQU5TCi1zdGF0aWMgQUxXQVlTX0lOTElORSB2b2lkIG1lcmdlRGVjb21taXR0ZWRTdGF0 ZXMoU3BhbiosIFNwYW4qKSB7IH0KLSNlbHNlCiBzdGF0aWMgQUxXQVlTX0lOTElORSB2b2lkIG1l cmdlRGVjb21taXR0ZWRTdGF0ZXMoU3BhbiogZGVzdGluYXRpb24sIFNwYW4qIG90aGVyKQogewog ICAgIGlmIChkZXN0aW5hdGlvbi0+ZGVjb21taXR0ZWQgJiYgIW90aGVyLT5kZWNvbW1pdHRlZCkg ewpAQCAtMTUwOSw3ICsxNDkyLDYgQEAgc3RhdGljIEFMV0FZU19JTkxJTkUgdm9pZCBtZXJnZURl Y29tbWl0dAogICAgICAgICBkZXN0aW5hdGlvbi0+ZGVjb21taXR0ZWQgPSB0cnVlOwogICAgIH0K IH0KLSNlbmRpZgogCiBpbmxpbmUgdm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6RGVsZXRlKFNwYW4q IHNwYW4pIHsKICAgQVNTRVJUKENoZWNrKCkpOwpAQCAtMTU1NiwxNSArMTUzOCwxMiBAQCBpbmxp bmUgdm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6RGVsZXRlKFNwCiAKICAgRXZlbnQoc3BhbiwgJ0Qn LCBzcGFuLT5sZW5ndGgpOwogICBzcGFuLT5mcmVlID0gMTsKLSNpZiBUQ01BTExPQ19UUkFDS19E RUNPTU1JVEVEX1NQQU5TCiAgIGlmIChzcGFuLT5kZWNvbW1pdHRlZCkgewogICAgIGlmIChzcGFu LT5sZW5ndGggPCBrTWF4UGFnZXMpCiAgICAgICBETExfUHJlcGVuZCgmZnJlZV9bc3Bhbi0+bGVu Z3RoXS5yZXR1cm5lZCwgc3Bhbik7CiAgICAgZWxzZQogICAgICAgRExMX1ByZXBlbmQoJmxhcmdl Xy5yZXR1cm5lZCwgc3Bhbik7Ci0gIH0gZWxzZQotI2VuZGlmCi0gIHsKKyAgfSBlbHNlIHsKICAg ICBpZiAoc3Bhbi0+bGVuZ3RoIDwga01heFBhZ2VzKQogICAgICAgRExMX1ByZXBlbmQoJmZyZWVf W3NwYW4tPmxlbmd0aF0ubm9ybWFsLCBzcGFuKTsKICAgICBlbHNlCkBAIC0xNTk2LDkgKzE1NzUs NyBAQCB2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjpJbmNyZW1lbnRhbFNjYXZlCiAgICAgICBETExf UmVtb3ZlKHMpOwogICAgICAgVENNYWxsb2NfU3lzdGVtUmVsZWFzZShyZWludGVycHJldF9jYXN0 PHZvaWQqPihzLT5zdGFydCA8PCBrUGFnZVNoaWZ0KSwKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgc3RhdGljX2Nhc3Q8c2l6ZV90PihzLT5sZW5ndGggPDwga1BhZ2VTaGlmdCkpOwotI2lm IFRDTUFMTE9DX1RSQUNLX0RFQ09NTUlURURfU1BBTlMKICAgICAgIHMtPmRlY29tbWl0dGVkID0g dHJ1ZTsKLSNlbmRpZgogICAgICAgRExMX1ByZXBlbmQoJnNsaXN0LT5yZXR1cm5lZCwgcyk7CiAK ICAgICAgIHNjYXZlbmdlX2NvdW50ZXJfID0gc3RkOjptYXg8c2l6ZV90Pig2NFVMLCBzdGQ6Om1p bjxzaXplX3Q+KGtEZWZhdWx0UmVsZWFzZURlbGF5LCBrRGVmYXVsdFJlbGVhc2VEZWxheSAtIChm cmVlX3BhZ2VzXyAvIGtEZWZhdWx0UmVsZWFzZURlbGF5KSkpOwo= 33581 2009-07-27 16:56:47 -0700 2009-07-28 15:06:22 -0700 Revised patch to use a background thread to release memory back to the system. 20090727-memoryscavenge.patch.txt text/plain 15819 adachan SW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9GYXN0TWFsbG9jLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBK YXZhU2NyaXB0Q29yZS93dGYvRmFzdE1hbGxvYy5jcHAJKHJldmlzaW9uIDQ2Mzg3KQorKysgSmF2 YVNjcmlwdENvcmUvd3RmL0Zhc3RNYWxsb2MuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC05NSw2ICs5 NSwxMCBAQAogI2RlZmluZSBGT1JDRV9TWVNURU1fTUFMTE9DIDEKICNlbmRpZgogCisKKy8vIFVz ZSBhIGJhY2tncm91bmQgdGhyZWFkIHRvIHBlcmlvZGljYWxseSBzY2F2ZW5nZSBtZW1vcnkgdG8g cmVsZWFzZSBiYWNrIHRvIHRoZSBzeXN0ZW0KKyNkZWZpbmUgVVNFX0JBQ0tHUk9VTkRfVEhSRUFE X1RPX1NDQVZFTkdFX01FTU9SWSAxCisKICNpZm5kZWYgTkRFQlVHCiBuYW1lc3BhY2UgV1RGIHsK IApAQCAtMTE4Nyw2ICsxMTkxLDMyIEBAIHRlbXBsYXRlIDw+IGNsYXNzIE1hcFNlbGVjdG9yPDMy PiB7CiAvLyBjb250aWd1b3VzIHJ1bnMgb2YgcGFnZXMgKGNhbGxlZCBhICJzcGFuIikuCiAvLyAt LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCiAKKyNpZiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0Vf TUVNT1JZCisvLyBUaGUgY2VudHJhbCBwYWdlIGhlYXAgY29sbGVjdHMgc3BhbnMgb2YgbWVtb3J5 IHRoYXQgaGF2ZSBiZWVuIGRlbGV0ZWQgYnV0IGFyZSBzdGlsbCBjb21taXR0ZWQgdW50aWwgdGhl eSBhcmUgcmVsZWFzZWQKKy8vIGJhY2sgdG8gdGhlIHN5c3RlbS4gIFdlIHVzZSBhIGJhY2tncm91 bmQgdGhyZWFkIHRvIHBlcmlvZGljYWxseSBzY2FuIHRoZSBsaXN0IG9mIGZyZWUgc3BhbnMgYW5k IHJlbGVhc2Ugc29tZSBiYWNrIHRvIHRoZQorLy8gc3lzdGVtLiAgRXZlcnkgNSBzZWNvbmRzLCB0 aGUgYmFja2dyb3VuZCB0aHJlYWQgd2FrZXMgdXAgYW5kIGRvZXMgdGhlIGZvbGxvd2luZzoKKy8v IC0gQ2hlY2sgaWYgd2UgbmVlZGVkIHRvIGNvbW1pdCBtZW1vcnkgaW4gdGhlIGxhc3QgNSBzZWNv bmRzLiAgSWYgc28sIHNraXAgdGhpcyBzY2F2ZW5nZSBiZWNhdXNlIGl0J3MgYSBzaWduIHRoYXQg d2UgYXJlIHNob3J0CisvLyBvZiBmcmVlIGNvbW1pdHRlZCBwYWdlcyBhbmQgc28gd2Ugc2hvdWxk IG5vdCByZWxlYXNlIHRoZW0gYmFjayB0byB0aGUgc3lzdGVtIHlldC4KKy8vIC0gT3RoZXJ3aXNl LCBnbyB0aHJvdWdoIHRoZSBsaXN0IG9mIGZyZWUgc3BhbnMgKGZyb20gbGFyZ2VzdCB0byBzbWFs bGVzdCkgYW5kIHJlbGVhc2UgdXAgdG8gYSBmcmFjdGlvbiBvZiB0aGUgZnJlZSBjb21taXR0ZWQg cGFnZXMKKy8vIGJhY2sgdG8gdGhlIHN5c3RlbS4KKy8vIC0gSWYgdGhlIG51bWJlciBvZiBmcmVl IGNvbW1pdHRlZCBwYWdlcyByZWFjaGVzIGtNaW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudCwg d2UgY2FuIHN0b3AgdGhlIHNjYXZlbmdpbmcgYW5kIGJsb2NrIHRoZQorLy8gc2NhdmVuZ2luZyB0 aHJlYWQgdW50aWwgdGhlIG51bWJlciBvZiBmcmVlIGNvbW1pdHRlZCBwYWdlcyBnb2VzIGFib3Zl IGtNaW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudC4KKworLy8gQmFja2dyb3VuZCB0aHJlYWQg d2FrZXMgdXAgZXZlcnkgNSBzZWNvbmRzIHRvIHNjYXZlbmdlIGFzIGxvbmcgYXMgdGhlcmUgaXMg bWVtb3J5IGF2YWlsYWJsZSB0byByZXR1cm4gdG8gdGhlIHN5c3RlbS4KK3N0YXRpYyBjb25zdCBp bnQga1NjYXZlbmdlVGltZXJEZWxheUluU2Vjb25kcyA9IDU7CisKKy8vIE51bWJlciBvZiBmcmVl IGNvbW1pdHRlZCBwYWdlcyB0aGF0IHdlIHdhbnQgdG8ga2VlcCBhcm91bmQuCitzdGF0aWMgY29u c3Qgc2l6ZV90IGtNaW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudCA9IDUxMjsKKworLy8gRHVy aW5nIGEgc2NhdmVuZ2UsIHdlJ2xsIHJlbGVhc2UgdXAgdG8gYSBmcmFjdGlvbiBvZiB0aGUgZnJl ZSBjb21taXR0ZWQgcGFnZXMuCisjaWYgUExBVEZPUk0oV0lOKQorLy8gV2UgYXJlIHNsaWdodGx5 IGxlc3MgYWdncmVzc2l2ZSBpbiByZWxlYXNpbmcgbWVtb3J5IG9uIFdpbmRvd3MgZHVlIHRvIHBl cmZvcm1hbmNlIHJlYXNvbnMuCitzdGF0aWMgY29uc3QgaW50IGtNYXhTY2F2ZW5nZUFtb3VudEZh Y3RvciA9IDM7CisjZWxzZQorc3RhdGljIGNvbnN0IGludCBrTWF4U2NhdmVuZ2VBbW91bnRGYWN0 b3IgPSAyOworI2VuZGlmCisjZW5kaWYKKwogY2xhc3MgVENNYWxsb2NfUGFnZUhlYXAgewogIHB1 YmxpYzoKICAgdm9pZCBpbml0KCk7CkBAIC0xMjg2LDYgKzEzMTYsMTQgQEAgY2xhc3MgVENNYWxs b2NfUGFnZUhlYXAgewogICAvLyBCeXRlcyBhbGxvY2F0ZWQgZnJvbSBzeXN0ZW0KICAgdWludDY0 X3Qgc3lzdGVtX2J5dGVzXzsKIAorI2lmIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5H RV9NRU1PUlkKKyAgLy8gTnVtYmVyIG9mIHBhZ2VzIGtlcHQgaW4gZnJlZSBsaXN0cyB0aGF0IGFy ZSBzdGlsbCBjb21taXR0ZWQuCisgIExlbmd0aCBmcmVlX2NvbW1pdHRlZF9wYWdlc187CisKKyAg Ly8gTnVtYmVyIG9mIHBhZ2VzIHRoYXQgd2UgY29tbWl0dGVkIGluIHRoZSBsYXN0IHNjYXZlbmdl IHdhaXQgaW50ZXJ2YWwuCisgIExlbmd0aCBwYWdlc19jb21taXR0ZWRfc2luY2VfbGFzdF9zY2F2 ZW5nZV87CisjZW5kaWYKKwogICBib29sIEdyb3dIZWFwKExlbmd0aCBuKTsKIAogICAvLyBSRVFV SVJFUyAgIHNwYW4tPmxlbmd0aCA+PSBuCkBAIC0xMzA4LDkgKzEzNDYsMTEgQEAgY2xhc3MgVENN YWxsb2NfUGFnZUhlYXAgewogICAvLyBzcGFuIG9mIGV4YWN0bHkgdGhlIHNwZWNpZmllZCBsZW5n dGguICBFbHNlLCByZXR1cm5zIE5VTEwuCiAgIFNwYW4qIEFsbG9jTGFyZ2UoTGVuZ3RoIG4pOwog CisjaWYgIVVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKICAgLy8gSW5j cmVtZW50YWxseSByZWxlYXNlIHNvbWUgbWVtb3J5IHRvIHRoZSBzeXN0ZW0uCiAgIC8vIEluY3Jl bWVudGFsU2NhdmVuZ2UobikgaXMgY2FsbGVkIHdoZW5ldmVyIG4gcGFnZXMgYXJlIGZyZWVkLgog ICB2b2lkIEluY3JlbWVudGFsU2NhdmVuZ2UoTGVuZ3RoIG4pOworI2VuZGlmCiAKICAgLy8gTnVt YmVyIG9mIHBhZ2VzIHRvIGRlYWxsb2NhdGUgYmVmb3JlIGRvaW5nIG1vcmUgc2NhdmVuZ2luZwog ICBpbnQ2NF90IHNjYXZlbmdlX2NvdW50ZXJfOwpAQCAtMTMyMSw2ICsxMzYxLDI0IEBAIGNsYXNz IFRDTWFsbG9jX1BhZ2VIZWFwIHsKICNpZiBkZWZpbmVkKFdURl9DSEFOR0VTKSAmJiBQTEFURk9S TShEQVJXSU4pCiAgIGZyaWVuZCBjbGFzcyBGYXN0TWFsbG9jWm9uZTsKICNlbmRpZgorCisjaWYg VVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorICBzdGF0aWMgTk9fUkVU VVJOIHZvaWQqIHJ1blNjYXZlbmdlclRocmVhZCh2b2lkKik7CisKKyAgTk9fUkVUVVJOIHZvaWQg c2NhdmVuZ2VyVGhyZWFkKCk7CisKKyAgdm9pZCBzY2F2ZW5nZSgpOworCisgIGlubGluZSBib29s IHNob3VsZENvbnRpbnVlU2NhdmVuZ2luZygpIGNvbnN0OworCisgIHB0aHJlYWRfbXV0ZXhfdCBt X3NjYXZlbmdlTXV0ZXg7CisKKyAgcHRocmVhZF9jb25kX3QgbV9zY2F2ZW5nZUNvbmRpdGlvbjsK KworICAvLyBLZWVwcyB0cmFjayBvZiB3aGV0aGVyIHRoZSBiYWNrZ3JvdW5kIHRocmVhZCBpcyBh Y3RpdmVseSBzY2F2ZW5naW5nIG1lbW9yeSBldmVyeSBrU2NhdmVuZ2VUaW1lckRlbGF5SW5TZWNv bmRzLCBvcgorICAvLyBpdCdzIGJsb2NrZWQgd2FpdGluZyBmb3IgbW9yZSBwYWdlcyB0byBiZSBk ZWxldGVkLgorICBib29sIG1fc2NhdmVuZ2VUaHJlYWRBY3RpdmU7CisjZW5kaWYgIC8vIFVTRV9C QUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKIH07CiAKIHZvaWQgVENNYWxsb2Nf UGFnZUhlYXA6OmluaXQoKQpAQCAtMTMyOSw2ICsxMzg3LDEyIEBAIHZvaWQgVENNYWxsb2NfUGFn ZUhlYXA6OmluaXQoKQogICBwYWdlbWFwX2NhY2hlXyA9IFBhZ2VNYXBDYWNoZSgwKTsKICAgZnJl ZV9wYWdlc18gPSAwOwogICBzeXN0ZW1fYnl0ZXNfID0gMDsKKworI2lmIFVTRV9CQUNLR1JPVU5E X1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKKyAgZnJlZV9jb21taXR0ZWRfcGFnZXNfID0gMDsK KyAgcGFnZXNfY29tbWl0dGVkX3NpbmNlX2xhc3Rfc2NhdmVuZ2VfID0gMDsKKyNlbmRpZiAgLy8g VVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorCiAgIHNjYXZlbmdlX2Nv dW50ZXJfID0gMDsKICAgLy8gU3RhcnQgc2NhdmVuZ2luZyBhdCBrTWF4UGFnZXMgbGlzdAogICBz Y2F2ZW5nZV9pbmRleF8gPSBrTWF4UGFnZXMtMTsKQEAgLTEzMzksOCArMTQwMyw2MyBAQCB2b2lk IFRDTWFsbG9jX1BhZ2VIZWFwOjppbml0KCkKICAgICBETExfSW5pdCgmZnJlZV9baV0ubm9ybWFs KTsKICAgICBETExfSW5pdCgmZnJlZV9baV0ucmV0dXJuZWQpOwogICB9CisKKyNpZiBVU0VfQkFD S0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgIHB0aHJlYWRfbXV0ZXhfaW5pdCgm bV9zY2F2ZW5nZU11dGV4LCAwKTsKKyAgcHRocmVhZF9jb25kX2luaXQoJm1fc2NhdmVuZ2VDb25k aXRpb24sIDApOworICBtX3NjYXZlbmdlVGhyZWFkQWN0aXZlID0gdHJ1ZTsKKyAgcHRocmVhZF90 IHRocmVhZDsKKyAgcHRocmVhZF9jcmVhdGUoJnRocmVhZCwgMCwgcnVuU2NhdmVuZ2VyVGhyZWFk LCB0aGlzKTsKKyNlbmRpZiAgLy8gVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01F TU9SWQorfQorCisjaWYgVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQor dm9pZCogVENNYWxsb2NfUGFnZUhlYXA6OnJ1blNjYXZlbmdlclRocmVhZCh2b2lkKiBjb250ZXh0 KQoreworICByZWludGVycHJldF9jYXN0PFRDTWFsbG9jX1BhZ2VIZWFwKj4oY29udGV4dCktPnNj YXZlbmdlclRocmVhZCgpOworfQorCit2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjpzY2F2ZW5nZSgp IAoreworICAgIC8vIElmIHdlIGhhdmUgdG8gY29tbWl0IG1lbW9yeSBpbiB0aGUgbGFzdCA1IHNl Y29uZHMsIGl0IG1lYW5zIHdlIGRvbid0IGhhdmUgZW5vdWdoIGZyZWUgY29tbWl0dGVkIHBhZ2Vz CisgICAgLy8gZm9yIHRoZSBhbW91bnQgb2YgYWxsb2NhdGlvbnMgdGhhdCB3ZSBkby4gIFNvIGhv bGQgb2ZmIG9uIHJlbGVhc2luZyBtZW1vcnkgYmFjayB0byB0aGUgc3lzdGVtLgorICAgIGlmIChw YWdlc19jb21taXR0ZWRfc2luY2VfbGFzdF9zY2F2ZW5nZV8gPiAwKSB7CisgICAgICAgIHBhZ2Vz X2NvbW1pdHRlZF9zaW5jZV9sYXN0X3NjYXZlbmdlXyA9IDA7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisgICAgTGVuZ3RoIHBhZ2VzRGVjb21taXR0ZWQgPSAwOworICAgIGZvciAoaW50IGkgPSBr TWF4UGFnZXM7IGkgPj0gMDsgaS0tKSB7CisgICAgICAgIFNwYW5MaXN0KiBzbGlzdCA9IChzdGF0 aWNfY2FzdDxzaXplX3Q+KGkpID09IGtNYXhQYWdlcykgPyAmbGFyZ2VfIDogJmZyZWVfW2ldOwor ICAgICAgICBpZiAoIURMTF9Jc0VtcHR5KCZzbGlzdC0+bm9ybWFsKSkgeworICAgICAgICAgICAg Ly8gUmVsZWFzZSB0aGUgbGFzdCBzcGFuIG9uIHRoZSBub3JtYWwgcG9ydGlvbiBvZiB0aGlzIGxp c3QKKyAgICAgICAgICAgIFNwYW4qIHMgPSBzbGlzdC0+bm9ybWFsLnByZXY7IAorICAgICAgICAg ICAgLy8gT25seSBkZWNvbW1pdCB1cCB0byBhIGZyYWN0aW9uIG9mIHRoZSBmcmVlIGNvbW1pdHRl ZCBwYWdlcyBpZiBwYWdlc19hbGxvY2F0ZWRfc2luY2VfbGFzdF9zY2F2ZW5nZV8gPiAwLgorICAg ICAgICAgICAgaWYgKChwYWdlc0RlY29tbWl0dGVkICsgcy0+bGVuZ3RoKSAqIGtNYXhTY2F2ZW5n ZUFtb3VudEZhY3RvciA+IGZyZWVfY29tbWl0dGVkX3BhZ2VzXykKKyAgICAgICAgICAgICAgICBj b250aW51ZTsKKyAgICAgICAgICAgIERMTF9SZW1vdmUocyk7CisgICAgICAgICAgICBUQ01hbGxv Y19TeXN0ZW1SZWxlYXNlKHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KHMtPnN0YXJ0IDw8IGtQYWdl U2hpZnQpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGF0aWNfY2FzdDxz aXplX3Q+KHMtPmxlbmd0aCA8PCBrUGFnZVNoaWZ0KSk7CisgICAgICAgICAgICBpZiAoIXMtPmRl Y29tbWl0dGVkKQorICAgICAgICAgICAgICAgIHBhZ2VzRGVjb21taXR0ZWQgKz0gcy0+bGVuZ3Ro OworICAgICAgICAgICAgcy0+ZGVjb21taXR0ZWQgPSB0cnVlOworICAgICAgICAgICAgRExMX1By ZXBlbmQoJnNsaXN0LT5yZXR1cm5lZCwgcyk7CisgICAgICAgICAgICAvLyBXZSBjYW4gc3RvcCBz Y2F2ZW5naW5nIGlmIHRoZSBudW1iZXIgb2YgZnJlZSBjb21taXR0ZWQgcGFnZXMgbGVmdCBpcyBs ZXNzIHRoYW4gb3IgZXF1YWwgdG8gdGhlIG1pbmltdW0gbnVtYmVyIHdlIHdhbnQgdG8ga2VlcCBh cm91bmQuCisgICAgICAgICAgICBpZiAoZnJlZV9jb21taXR0ZWRfcGFnZXNfIDw9IGtNaW5pbXVt RnJlZUNvbW1pdHRlZFBhZ2VDb3VudCArIHBhZ2VzRGVjb21taXR0ZWQpCisgICAgICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisgICAgcGFnZXNfY29tbWl0dGVkX3NpbmNlX2xh c3Rfc2NhdmVuZ2VfID0gMDsKKyAgICBBU1NFUlQoZnJlZV9jb21taXR0ZWRfcGFnZXNfID49IHBh Z2VzRGVjb21taXR0ZWQpOworICAgIGZyZWVfY29tbWl0dGVkX3BhZ2VzXyAtPSBwYWdlc0RlY29t bWl0dGVkOworfQorCitpbmxpbmUgYm9vbCBUQ01hbGxvY19QYWdlSGVhcDo6c2hvdWxkQ29udGlu dWVTY2F2ZW5naW5nKCkgY29uc3QgCit7CisgICAgcmV0dXJuIGZyZWVfY29tbWl0dGVkX3BhZ2Vz XyA+IGtNaW5pbXVtRnJlZUNvbW1pdHRlZFBhZ2VDb3VudDsgCiB9CiAKKyNlbmRpZiAgLy8gVVNF X0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorCiBpbmxpbmUgU3BhbiogVENN YWxsb2NfUGFnZUhlYXA6Ok5ldyhMZW5ndGggbikgewogICBBU1NFUlQoQ2hlY2soKSk7CiAgIEFT U0VSVChuID4gMCk7CkBAIC0xMzY2LDcgKzE0ODUsMTggQEAgaW5saW5lIFNwYW4qIFRDTWFsbG9j X1BhZ2VIZWFwOjpOZXcoTGVuZwogICAgIGlmIChyZXN1bHQtPmRlY29tbWl0dGVkKSB7CiAgICAg ICAgIFRDTWFsbG9jX1N5c3RlbUNvbW1pdChyZWludGVycHJldF9jYXN0PHZvaWQqPihyZXN1bHQt PnN0YXJ0IDw8IGtQYWdlU2hpZnQpLCBzdGF0aWNfY2FzdDxzaXplX3Q+KG4gPDwga1BhZ2VTaGlm dCkpOwogICAgICAgICByZXN1bHQtPmRlY29tbWl0dGVkID0gZmFsc2U7CisjaWYgVVNFX0JBQ0tH Uk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorICAgICAgICBwYWdlc19jb21taXR0ZWRf c2luY2VfbGFzdF9zY2F2ZW5nZV8gKz0gbjsKKyNlbmRpZgogICAgIH0KKyNpZiBVU0VfQkFDS0dS T1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgZWxzZSB7CisgICAgICAgIC8vIFRo ZSBuZXdseSBhbGxvY2F0ZWQgbWVtb3J5IGlzIGZyb20gYSBzcGFuIHRoYXQncyBpbiB0aGUgbm9y bWFsIHNwYW4gbGlzdCAoYWxyZWFkeSBjb21taXR0ZWQpLiAgVXBkYXRlIHRoZQorICAgICAgICAv LyBmcmVlIGNvbW1pdHRlZCBwYWdlcyBjb3VudC4KKyAgICAgICAgQVNTRVJUKGZyZWVfY29tbWl0 dGVkX3BhZ2VzXyA+PSBuKTsKKyAgICAgICAgZnJlZV9jb21taXR0ZWRfcGFnZXNfIC09IG47Cisg ICAgfQorI2VuZGlmICAvLyBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZ CiAgICAgQVNTRVJUKENoZWNrKCkpOwogICAgIGZyZWVfcGFnZXNfIC09IG47CiAgICAgcmV0dXJu IHJlc3VsdDsKQEAgLTE0MjYsNyArMTU1NiwxOCBAQCBTcGFuKiBUQ01hbGxvY19QYWdlSGVhcDo6 QWxsb2NMYXJnZShMZW5nCiAgICAgaWYgKGJlc3QtPmRlY29tbWl0dGVkKSB7CiAgICAgICAgIFRD TWFsbG9jX1N5c3RlbUNvbW1pdChyZWludGVycHJldF9jYXN0PHZvaWQqPihiZXN0LT5zdGFydCA8 PCBrUGFnZVNoaWZ0KSwgc3RhdGljX2Nhc3Q8c2l6ZV90PihuIDw8IGtQYWdlU2hpZnQpKTsKICAg ICAgICAgYmVzdC0+ZGVjb21taXR0ZWQgPSBmYWxzZTsKKyNpZiBVU0VfQkFDS0dST1VORF9USFJF QURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgICAgIHBhZ2VzX2NvbW1pdHRlZF9zaW5jZV9sYXN0 X3NjYXZlbmdlXyArPSBuOworI2VuZGlmCiAgICAgfQorI2lmIFVTRV9CQUNLR1JPVU5EX1RIUkVB RF9UT19TQ0FWRU5HRV9NRU1PUlkKKyAgICBlbHNlIHsKKyAgICAgICAgLy8gVGhlIG5ld2x5IGFs bG9jYXRlZCBtZW1vcnkgaXMgZnJvbSBhIHNwYW4gdGhhdCdzIGluIHRoZSBub3JtYWwgc3BhbiBs aXN0IChhbHJlYWR5IGNvbW1pdHRlZCkuICBVcGRhdGUgdGhlCisgICAgICAgIC8vIGZyZWUgY29t bWl0dGVkIHBhZ2VzIGNvdW50LgorICAgICAgICBBU1NFUlQoZnJlZV9jb21taXR0ZWRfcGFnZXNf ID49IG4pOworICAgICAgICBmcmVlX2NvbW1pdHRlZF9wYWdlc18gLT0gbjsKKyAgICB9CisjZW5k aWYgIC8vIFVTRV9CQUNLR1JPVU5EX1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKICAgICBBU1NF UlQoQ2hlY2soKSk7CiAgICAgZnJlZV9wYWdlc18gLT0gbjsKICAgICByZXR1cm4gYmVzdDsKQEAg LTE1MDgsNiArMTY0OSwxMCBAQCBpbmxpbmUgdm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6RGVsZXRl KFNwCiAgIC8vIG5lY2Vzc2FyeS4gIFdlIGRvIG5vdCBib3RoZXIgcmVzZXR0aW5nIHRoZSBzdGFs ZSBwYWdlbWFwCiAgIC8vIGVudHJpZXMgZm9yIHRoZSBwaWVjZXMgd2UgYXJlIG1lcmdpbmcgdG9n ZXRoZXIgYmVjYXVzZSB3ZSBvbmx5CiAgIC8vIGNhcmUgYWJvdXQgdGhlIHBhZ2VtYXAgZW50cmll cyBmb3IgdGhlIGJvdW5kYXJpZXMuCisjaWYgVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZF TkdFX01FTU9SWQorICAvLyBUcmFjayB0aGUgdG90YWwgc2l6ZSBvZiB0aGUgbmVpZ2hib3Jpbmcg ZnJlZSBzcGFucyB0aGF0IGFyZSBjb21taXR0ZWQuCisgIExlbmd0aCBuZWlnaGJvcmluZ0NvbW1p dHRlZFNwYW5zTGVuZ3RoID0gMDsKKyNlbmRpZgogICBjb25zdCBQYWdlSUQgcCA9IHNwYW4tPnN0 YXJ0OwogICBjb25zdCBMZW5ndGggbiA9IHNwYW4tPmxlbmd0aDsKICAgU3BhbiogcHJldiA9IEdl dERlc2NyaXB0b3IocC0xKTsKQEAgLTE1MTUsNiArMTY2MCwxMCBAQCBpbmxpbmUgdm9pZCBUQ01h bGxvY19QYWdlSGVhcDo6RGVsZXRlKFNwCiAgICAgLy8gTWVyZ2UgcHJlY2VkaW5nIHNwYW4gaW50 byB0aGlzIHNwYW4KICAgICBBU1NFUlQocHJldi0+c3RhcnQgKyBwcmV2LT5sZW5ndGggPT0gcCk7 CiAgICAgY29uc3QgTGVuZ3RoIGxlbiA9IHByZXYtPmxlbmd0aDsKKyNpZiBVU0VfQkFDS0dST1VO RF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgaWYgKCFwcmV2LT5kZWNvbW1pdHRlZCkK KyAgICAgICAgbmVpZ2hib3JpbmdDb21taXR0ZWRTcGFuc0xlbmd0aCArPSBsZW47CisjZW5kaWYK ICAgICBtZXJnZURlY29tbWl0dGVkU3RhdGVzKHNwYW4sIHByZXYpOwogICAgIERMTF9SZW1vdmUo cHJldik7CiAgICAgRGVsZXRlU3BhbihwcmV2KTsKQEAgLTE1MjgsNiArMTY3NywxMCBAQCBpbmxp bmUgdm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6RGVsZXRlKFNwCiAgICAgLy8gTWVyZ2UgbmV4dCBz cGFuIGludG8gdGhpcyBzcGFuCiAgICAgQVNTRVJUKG5leHQtPnN0YXJ0ID09IHArbik7CiAgICAg Y29uc3QgTGVuZ3RoIGxlbiA9IG5leHQtPmxlbmd0aDsKKyNpZiBVU0VfQkFDS0dST1VORF9USFJF QURfVE9fU0NBVkVOR0VfTUVNT1JZCisgICAgaWYgKCFuZXh0LT5kZWNvbW1pdHRlZCkKKyAgICAg ICAgbmVpZ2hib3JpbmdDb21taXR0ZWRTcGFuc0xlbmd0aCArPSBsZW47CisjZW5kaWYKICAgICBt ZXJnZURlY29tbWl0dGVkU3RhdGVzKHNwYW4sIG5leHQpOwogICAgIERMTF9SZW1vdmUobmV4dCk7 CiAgICAgRGVsZXRlU3BhbihuZXh0KTsKQEAgLTE1NTEsMTAgKzE3MDQsMjcgQEAgaW5saW5lIHZv aWQgVENNYWxsb2NfUGFnZUhlYXA6OkRlbGV0ZShTcAogICB9CiAgIGZyZWVfcGFnZXNfICs9IG47 CiAKKyNpZiBVU0VfQkFDS0dST1VORF9USFJFQURfVE9fU0NBVkVOR0VfTUVNT1JZCisgIGlmIChz cGFuLT5kZWNvbW1pdHRlZCkgeworICAgICAgLy8gSWYgdGhlIG1lcmdlZCBzcGFuIGlzIGRlY29t bWl0dGVkLCB0aGF0IG1lYW5zIHdlIGRlY29tbWl0dGVkIGFueSBuZWlnaGJvcmluZyBzcGFucyB0 aGF0IHdlcmUKKyAgICAgIC8vIGNvbW1pdHRlZC4gIFVwZGF0ZSB0aGUgZnJlZSBjb21taXR0ZWQg cGFnZXMgY291bnQuCisgICAgICBmcmVlX2NvbW1pdHRlZF9wYWdlc18gLT0gbmVpZ2hib3JpbmdD b21taXR0ZWRTcGFuc0xlbmd0aDsKKyAgfSBlbHNlIHsKKyAgICAgIC8vIElmIHRoZSBtZXJnZWQg c3BhbiByZW1haW5zIGNvbW1pdHRlZCwgYWRkIHRoZSBkZWxldGVkIHNwYW4ncyBzaXplIHRvIHRo ZSBmcmVlIGNvbW1pdHRlZCBwYWdlcyBjb3VudC4KKyAgICAgIGZyZWVfY29tbWl0dGVkX3BhZ2Vz XyArPSBuOworICB9CisKKyAgLy8gTWFrZSBzdXJlIHRoZSBzY2F2ZW5nZSB0aHJlYWQgYmVjb21l cyBhY3RpdmUgaWYgd2UgaGF2ZSBlbm91Z2ggZnJlZWQgcGFnZXMgdG8gcmVsZWFzZSBzb21lIGJh Y2sgdG8gdGhlIHN5c3RlbS4KKyAgaWYgKCFtX3NjYXZlbmdlVGhyZWFkQWN0aXZlICYmIHNob3Vs ZENvbnRpbnVlU2NhdmVuZ2luZygpKQorICAgICAgcHRocmVhZF9jb25kX3NpZ25hbCgmbV9zY2F2 ZW5nZUNvbmRpdGlvbik7CisjZWxzZQogICBJbmNyZW1lbnRhbFNjYXZlbmdlKG4pOworI2VuZGlm CisKICAgQVNTRVJUKENoZWNrKCkpOwogfQogCisjaWYgIVVTRV9CQUNLR1JPVU5EX1RIUkVBRF9U T19TQ0FWRU5HRV9NRU1PUlkKIHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OkluY3JlbWVudGFsU2Nh dmVuZ2UoTGVuZ3RoIG4pIHsKICAgLy8gRmFzdCBwYXRoOyBub3QgeWV0IHRpbWUgdG8gcmVsZWFz ZSBtZW1vcnkKICAgc2NhdmVuZ2VfY291bnRlcl8gLT0gbjsKQEAgLTE1OTIsNiArMTc2Miw3IEBA IHZvaWQgVENNYWxsb2NfUGFnZUhlYXA6OkluY3JlbWVudGFsU2NhdmUKICAgLy8gTm90aGluZyB0 byBzY2F2ZW5nZSwgZGVsYXkgZm9yIGEgd2hpbGUKICAgc2NhdmVuZ2VfY291bnRlcl8gPSBrRGVm YXVsdFJlbGVhc2VEZWxheTsKIH0KKyNlbmRpZgogCiB2b2lkIFRDTWFsbG9jX1BhZ2VIZWFwOjpS ZWdpc3RlclNpemVDbGFzcyhTcGFuKiBzcGFuLCBzaXplX3Qgc2MpIHsKICAgLy8gQXNzb2NpYXRl IHNwYW4gb2JqZWN0IHdpdGggYWxsIGludGVyaW9yIHBhZ2VzIGFzIHdlbGwKQEAgLTE3MDMsNiAr MTg3NCwxMCBAQCBib29sIFRDTWFsbG9jX1BhZ2VIZWFwOjpHcm93SGVhcChMZW5ndGggCiAgIH0K ICAgYXNrID0gYWN0dWFsX3NpemUgPj4ga1BhZ2VTaGlmdDsKIAorI2lmIFVTRV9CQUNLR1JPVU5E X1RIUkVBRF9UT19TQ0FWRU5HRV9NRU1PUlkKKyAgcGFnZXNfY29tbWl0dGVkX3NpbmNlX2xhc3Rf c2NhdmVuZ2VfICs9IGFzazsKKyNlbmRpZgorCiAgIHVpbnQ2NF90IG9sZF9zeXN0ZW1fYnl0ZXMg PSBzeXN0ZW1fYnl0ZXNfOwogICBzeXN0ZW1fYnl0ZXNfICs9IChhc2sgPDwga1BhZ2VTaGlmdCk7 CiAgIGNvbnN0IFBhZ2VJRCBwID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KHB0cikgPj4g a1BhZ2VTaGlmdDsKQEAgLTIwODMsNiArMjI1OCwzNCBAQCBzdGF0aWMgaW5saW5lIFRDTWFsbG9j X1BhZ2VIZWFwKiBnZXRQYWdlCiAKICNkZWZpbmUgcGFnZWhlYXAgZ2V0UGFnZUhlYXAoKQogCisj aWYgVVNFX0JBQ0tHUk9VTkRfVEhSRUFEX1RPX1NDQVZFTkdFX01FTU9SWQorI2lmIFBMQVRGT1JN KFdJTikKK3N0YXRpYyB2b2lkIHNsZWVwKHVuc2lnbmVkIHNlY29uZHMpCit7CisgICAgOjpTbGVl cChzZWNvbmRzICogMTAwMCk7Cit9CisjZW5kaWYKKwordm9pZCBUQ01hbGxvY19QYWdlSGVhcDo6 c2NhdmVuZ2VyVGhyZWFkKCkKK3sKKyAgd2hpbGUgKDEpIHsKKyAgICAgIGlmICghc2hvdWxkQ29u dGludWVTY2F2ZW5naW5nKCkpIHsKKyAgICAgICAgICBwdGhyZWFkX211dGV4X2xvY2soJm1fc2Nh dmVuZ2VNdXRleCk7CisgICAgICAgICAgbV9zY2F2ZW5nZVRocmVhZEFjdGl2ZSA9IGZhbHNlOwor ICAgICAgICAgIC8vIEJsb2NrIHVudGlsIHRoZXJlIGFyZSBlbm91Z2ggZnJlZWQgcGFnZXMgdG8g cmVsZWFzZSBiYWNrIHRvIHRoZSBzeXN0ZW0uCisgICAgICAgICAgcHRocmVhZF9jb25kX3dhaXQo Jm1fc2NhdmVuZ2VDb25kaXRpb24sICZtX3NjYXZlbmdlTXV0ZXgpOworICAgICAgICAgIG1fc2Nh dmVuZ2VUaHJlYWRBY3RpdmUgPSB0cnVlOworICAgICAgICAgIHB0aHJlYWRfbXV0ZXhfdW5sb2Nr KCZtX3NjYXZlbmdlTXV0ZXgpOworICAgICAgfQorICAgICAgc2xlZXAoa1NjYXZlbmdlVGltZXJE ZWxheUluU2Vjb25kcyk7CisgICAgICB7CisgICAgICAgICAgU3BpbkxvY2tIb2xkZXIgaCgmcGFn ZWhlYXBfbG9jayk7CisgICAgICAgICAgcGFnZWhlYXAtPnNjYXZlbmdlKCk7CisgICAgICB9Cisg IH0KK30KKyNlbmRpZgorCiAvLyBJZiBUTFMgaXMgYXZhaWxhYmxlLCB3ZSBhbHNvIHN0b3JlIGEg Y29weQogLy8gb2YgdGhlIHBlci10aHJlYWQgb2JqZWN0IGluIGEgX190aHJlYWQgdmFyaWFibGUK IC8vIHNpbmNlIF9fdGhyZWFkIHZhcmlhYmxlcyBhcmUgZmFzdGVyIHRvIHJlYWQKSW5kZXg6IEph dmFTY3JpcHRDb3JlL3d0Zi9UQ1N5c3RlbUFsbG9jLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2Ny aXB0Q29yZS93dGYvVENTeXN0ZW1BbGxvYy5jcHAJKHJldmlzaW9uIDQ2Mzg1KQorKysgSmF2YVNj cmlwdENvcmUvd3RmL1RDU3lzdGVtQWxsb2MuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00NDEsNiAr NDQxLDMzIEBAIHZvaWQgVENNYWxsb2NfU3lzdGVtUmVsZWFzZSh2b2lkKiBzdGFydCwKICAgQVNT RVJUX1VOVVNFRChuZXdBZGRyZXNzLCBuZXdBZGRyZXNzID09IHN0YXJ0IHx8IG5ld0FkZHJlc3Mg PT0gcmVpbnRlcnByZXRfY2FzdDx2b2lkKj4oTUFQX0ZBSUxFRCkpOwogfQogCisjZWxpZiBIQVZF KFZJUlRVQUxBTExPQykKKwordm9pZCBUQ01hbGxvY19TeXN0ZW1SZWxlYXNlKHZvaWQqIHN0YXJ0 LCBzaXplX3QgbGVuZ3RoKQoreworICAgIGlmIChWaXJ0dWFsRnJlZShzdGFydCwgbGVuZ3RoLCBN RU1fREVDT01NSVQpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBUaGUgZGVjb21taXQgbWF5 IGZhaWwgaWYgdGhlIG1lbW9yeSByZWdpb24gY29uc2lzdHMgb2YgYWxsb2NhdGlvbnMKKyAgICAv LyBmcm9tIG1vcmUgdGhhbiBvbmUgY2FsbCB0byBWaXJ0dWFsQWxsb2MuICBJbiB0aGlzIGNhc2Us IGZhbGwgYmFjayB0bworICAgIC8vIHVzaW5nIFZpcnR1YWxRdWVyeSB0byByZXRyaWV2ZSB0aGUg YWxsb2NhdGlvbiBib3VuZGFyaWVzIGFuZCBkZWNvbW1pdAorICAgIC8vIHRoZW0gZWFjaCBpbmRp dmlkdWFsbHkuCisKKyAgICB2b2lkKiBwdHIgPSBzdGFydDsKKyAgICB2b2lkKiBlbmQgPSBzdGF0 aWNfY2FzdDxjaGFyKj4oc3RhcnQpICsgbGVuZ3RoOworICAgIE1FTU9SWV9CQVNJQ19JTkZPUk1B VElPTiBpbmZvOworICAgIHdoaWxlIChwdHIgPCBlbmQpIHsKKyAgICAgICAgc2l6ZV90IHJlc3Vs dFNpemUgPSBWaXJ0dWFsUXVlcnkocHRyLCAmaW5mbywgc2l6ZW9mKGluZm8pKTsKKyAgICAgICAg QVNTRVJUX1VOVVNFRChyZXN1bHRTaXplLCByZXN1bHRTaXplID09IHNpemVvZihpbmZvKSk7CisK KyAgICAgICAgQk9PTCBzdWNjZXNzID0gVmlydHVhbEZyZWUocHRyLCBsZW5ndGggPCBpbmZvLlJl Z2lvblNpemUgPyBsZW5ndGggOiBpbmZvLlJlZ2lvblNpemUsIE1FTV9ERUNPTU1JVCk7CisgICAg ICAgIEFTU0VSVF9VTlVTRUQoc3VjY2Vzcywgc3VjY2Vzcyk7CisgICAgICAgIGxlbmd0aCAtPSBp bmZvLlJlZ2lvblNpemU7CisgICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PGNoYXIqPihwdHIpICsg aW5mby5SZWdpb25TaXplOworICAgIH0KKyAgICByZXR1cm47Cit9CisKICNlbHNlCiAKIC8vIFBs YXRmb3JtcyB0aGF0IGRvbid0IHN1cHBvcnQgcmV0dXJuaW5nIG1lbW9yeSB1c2UgYW4gZW1wdHkg aW5saW5lIHZlcnNpb24gb2YgVENNYWxsb2NfU3lzdGVtUmVsZWFzZQpAQCAtNDU3LDggKzQ4NCwy OSBAQCB2b2lkIFRDTWFsbG9jX1N5c3RlbUNvbW1pdCh2b2lkKiBzdGFydCwgCiAKICNlbGlmIEhB VkUoVklSVFVBTEFMTE9DKQogCi12b2lkIFRDTWFsbG9jX1N5c3RlbUNvbW1pdCh2b2lkKiwgc2l6 ZV90KQordm9pZCBUQ01hbGxvY19TeXN0ZW1Db21taXQodm9pZCogc3RhcnQsIHNpemVfdCBsZW5n dGgpCiB7CisgICAgaWYgKFZpcnR1YWxBbGxvYyhzdGFydCwgbGVuZ3RoLCBNRU1fQ09NTUlULCBQ QUdFX1JFQURXUklURSkgPT0gc3RhcnQpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIFRoZSBj b21taXQgbWF5IGZhaWwgaWYgdGhlIG1lbW9yeSByZWdpb24gY29uc2lzdHMgb2YgYWxsb2NhdGlv bnMKKyAgICAvLyBmcm9tIG1vcmUgdGhhbiBvbmUgY2FsbCB0byBWaXJ0dWFsQWxsb2MuICBJbiB0 aGlzIGNhc2UsIGZhbGwgYmFjayB0bworICAgIC8vIHVzaW5nIFZpcnR1YWxRdWVyeSB0byByZXRy aWV2ZSB0aGUgYWxsb2NhdGlvbiBib3VuZGFyaWVzIGFuZCBjb21taXQgdGhlbQorICAgIC8vIGVh Y2ggaW5kaXZpZHVhbGx5LgorCisgICAgdm9pZCogcHRyID0gc3RhcnQ7CisgICAgdm9pZCogZW5k ID0gc3RhdGljX2Nhc3Q8Y2hhcio+KHN0YXJ0KSArIGxlbmd0aDsKKyAgICBNRU1PUllfQkFTSUNf SU5GT1JNQVRJT04gaW5mbzsKKyAgICB3aGlsZSAocHRyIDwgZW5kKSB7CisgICAgICAgIHNpemVf dCByZXN1bHRTaXplID0gVmlydHVhbFF1ZXJ5KHB0ciwgJmluZm8sIHNpemVvZihpbmZvKSk7Cisg ICAgICAgIEFTU0VSVF9VTlVTRUQocmVzdWx0U2l6ZSwgcmVzdWx0U2l6ZSA9PSBzaXplb2YoaW5m bykpOworCisgICAgICAgIHZvaWQgKm5ld0FkZHJlc3MgPSBWaXJ0dWFsQWxsb2MocHRyLCBsZW5n dGggPCBpbmZvLlJlZ2lvblNpemUgPyBsZW5ndGggOiBpbmZvLlJlZ2lvblNpemUsIE1FTV9DT01N SVQsIFBBR0VfUkVBRFdSSVRFKTsKKyAgICAgICAgQVNTRVJUX1VOVVNFRChuZXdBZGRyZXNzLCBu ZXdBZGRyZXNzID09IHB0cik7CisgICAgICAgIGxlbmd0aCAtPSBpbmZvLlJlZ2lvblNpemU7Cisg ICAgICAgIHB0ciA9IHN0YXRpY19jYXN0PGNoYXIqPihwdHIpICsgaW5mby5SZWdpb25TaXplOwor ICAgIH0KKyAgICByZXR1cm47CiB9CiAKICNlbHNlCkluZGV4OiBKYXZhU2NyaXB0Q29yZS93dGYv VENTeXN0ZW1BbGxvYy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL3d0Zi9UQ1N5c3Rl bUFsbG9jLmgJKHJldmlzaW9uIDQ2Mzg1KQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1RDU3lzdGVt QWxsb2MuaAkod29ya2luZyBjb3B5KQpAQCAtNjQsNyArNjQsNyBAQCBleHRlcm4gdm9pZCBUQ01h bGxvY19TeXN0ZW1SZWxlYXNlKHZvaWQqCiAKIGV4dGVybiB2b2lkIFRDTWFsbG9jX1N5c3RlbUNv bW1pdCh2b2lkKiBzdGFydCwgc2l6ZV90IGxlbmd0aCk7CiAKLSNpZiAhSEFWRShNQURWX0ZSRUVf UkVVU0UpICYmICFIQVZFKE1BRFZfRE9OVE5FRUQpICYmICFIQVZFKE1NQVApCisjaWYgIUhBVkUo TUFEVl9GUkVFX1JFVVNFKSAmJiAhSEFWRShNQURWX0RPTlRORUVEKSAmJiAhSEFWRShNTUFQKSAm JiAhSEFWRShWSVJUVUFMQUxMT0MpCiBpbmxpbmUgdm9pZCBUQ01hbGxvY19TeXN0ZW1SZWxlYXNl KHZvaWQqLCBzaXplX3QpIHsgfQogI2VuZGlmCiAK