22614 2008-12-02 17:52:40 -0800 Need to add Win32 implementation of ThreadSpecific. 2017-05-03 11:04:35 -0700 1 1 1 Unclassified WebKit JavaScriptCore 528+ (Nightly build) PC Windows XP RESOLVED FIXED P2 Normal --- 1 jianli webkit-unassigned ap bfulgham fpizlo jianli mark.lam pvollan thakis oldest_to_newest 101133 0 jianli 2008-12-02 17:52:40 -0800 Need to add Win32 implementation of ThreadSpecific. 101134 1 25697 jianli 2008-12-02 17:54:55 -0800 Created attachment 25697 Proposed Patch 101160 2 25697 ap 2008-12-03 00:24:33 -0800 Comment on attachment 25697 Proposed Patch > -#if USE(PTHREADS) || PLATFORM(WIN) > +#if USE(PTHREADS) || PLATFORM(WIN) || PLATFORM(WIN_OS) No need to keep PLATFORM(WIN), because it can only be set if PLATFORM(WIN_OS) is set. > +#if USE(PTHREADS) || PLATFORM(WIN) > pthread_key_t m_key; Similarly, I think this test should be just USE(PTHREADS). > +template<typename T> > +inline void ThreadSpecific<T>::destroy(void* ptr) What calls destroy() when a thread exits? Per <http://msdn.microsoft.com/en-us/library/ms686801(VS.85).aspx>, data kept in per-thread storage must be destroyed manually in a DLL_THREAD_DETACH callback. r-, because I think that per-thread data leaks. 101285 3 25731 jianli 2008-12-03 18:20:24 -0800 Created attachment 25731 Proposed Patch 101286 4 jianli 2008-12-03 18:26:17 -0800 (In reply to comment #2) > (From update of attachment 25697 [review]) > > -#if USE(PTHREADS) || PLATFORM(WIN) > > +#if USE(PTHREADS) || PLATFORM(WIN) || PLATFORM(WIN_OS) > > No need to keep PLATFORM(WIN), because it can only be set if PLATFORM(WIN_OS) > is set. Removed. > > > +#if USE(PTHREADS) || PLATFORM(WIN) > > pthread_key_t m_key; > > Similarly, I think this test should be just USE(PTHREADS). Removed. > > > +template<typename T> > > +inline void ThreadSpecific<T>::destroy(void* ptr) > > What calls destroy() when a thread exits? Per > <http://msdn.microsoft.com/en-us/library/ms686801(VS.85).aspx>, data kept in > per-thread storage must be destroyed manually in a DLL_THREAD_DETACH callback. > > r-, because I think that per-thread data leaks. Though MSDN says that it is expected to call TlsFree in a DLL_THREAD_DETACH callback, it is not absolutely required. We can still call TlsFree in other place. > 101300 5 25731 ap 2008-12-03 23:16:11 -0800 Comment on attachment 25731 Proposed Patch Sorry, I pasted a wrong MSDN link, it was supposed to be <http://msdn.microsoft.com/en-us/library/ms686997(VS.85).aspx>. MSDN suggests calling TlsFree from DLL_PROCESS_DETACH, and it is indeed OK to call it manually, or even not to call it at all - but I'm not talking about leaking TLS keys. The problem is about leaking TLS data of each thread. In pthread implementation of this class, destroy() is called automatically for each ThreadSpecific object on thread exit, because the callback is registered by pthread_key_create() - but nothing calls destroy() in this patch. 102831 6 26105 jianli 2008-12-17 16:20:42 -0800 Created attachment 26105 Proposed Patch 102832 7 jianli 2008-12-17 16:22:18 -0800 Thanks for pointing this out. I've fixed this problem. Please review my change again. Sorry for taking so long to reply since I am just back from a trip. (In reply to comment #5) > (From update of attachment 25731 [review]) > Sorry, I pasted a wrong MSDN link, it was supposed to be > <http://msdn.microsoft.com/en-us/library/ms686997(VS.85).aspx>. > > MSDN suggests calling TlsFree from DLL_PROCESS_DETACH, and it is indeed OK to > call it manually, or even not to call it at all - but I'm not talking about > leaking TLS keys. The problem is about leaking TLS data of each thread. In > pthread implementation of this class, destroy() is called automatically for > each ThreadSpecific object on thread exit, because the callback is registered > by pthread_key_create() - but nothing calls destroy() in this patch. > 103327 8 26105 ap 2008-12-23 14:53:08 -0800 Comment on attachment 26105 Proposed Patch Are you suggesting the code for use on all Win32 ports, or only on those that don't use pthreads already? I can't tell for sure from the patch - I may be mistaken, but it seems that ifdefs are still confused a little. > + * JavaScriptCore.xcodeproj/project.pbxproj: All code in ThreadSpecific.cpp is Windows-only, so it should be called ThreadSpecificWin.cpp, and it shouldn't be in this Mac-specific project file. > + * Copyright (C) 2008 Apple Inc. All rights reserved. I don't see any Apple code in this file, so you needn't assign copyright to Apple. > + > +#include "ThreadSpecific.h" All cpp files must include config.h first. > +#if PLATFORM(WIN_OS) In ThreadSpecificWin.cpp, there will be no need for the ifdef. > +void ThreadSpecificThreadExit() { The brace should go on next line. > + ThreadSpecific<int>::ThreadExit(); I think that ThreadExit() function needn't be in the class - having to pass a dummy template parameter is ugly. I think you could make a separate class with the same layout, and static_cast to it - this will make the assumption of same layout explicit. > +#if PLATFORM(WIN_OS) > +// ThreadSpecificThreadExit should be called each time when a thread is detached. > +extern void ThreadSpecificThreadExit(); > +#endif Will calling this function be a JavaScriptCore API requirement? Then it should be in API/JSBase.h, and named differently, but that sounds like a particularly unfortunate requirement to impose on clients. Many libraries have initialization calls, but few need explicit shutdown, especially on each thread. I don't see a good solution, maybe we should discuss this on the mailing list. > + m_key = TlsAlloc(); > + if (m_key == TLS_OUT_OF_INDEXES) > + CRASH(); > + > + int slot = InterlockedIncrement(&g_tls_key_count) - 1; It seems that TLS is almost re-implemented here, in addition to using the platform-provided solution. I hope that there is a simpler solution. The main issue here is that this basically changes JavaScriptCore API in an objectionable way - I don't have a proposal, but this definitely needs to be resolved. Sorry for not reviewing this earlier, I overlooked the patch when it was added. 103328 9 ap 2008-12-23 15:00:25 -0800 (In reply to comment #8) > The main issue here is that this basically changes JavaScriptCore API in an > objectionable way - I don't have a proposal, but this definitely needs to be > resolved. Oh, in fact, nothing in JavaScriptCore uses ThreadSpecific, so I do have a proposal. I think that threads created with WTF::createThread() should just clean up when exiting - as it is done in Win32+pthreads case in wtfThreadEntryPoint (ThreadingWin.cpp). 103840 10 jianli 2008-12-30 15:56:31 -0800 I've fixed most of things you pointed out. There are a couple more things I need to get further feedback from you. 1) You asked me to remove "copyright to apple". What should I put there? Do I just need to remove the copyright line and keep other comments intact? 2) As to calling ThreadSpecificThreadExit, I do not think making the cleanup call from WTF thread is enough. This approach does not take care of the TLS cleanup in the main thread and other threads not created by WTF::createThread. I did not have a good solution here either. Which mailing list should I send to for further discussion if needed? I could only think of the following possible ways: a) If we could make TLS allocations be self manageable, we do not need to deal with this issue. That is, the caller is responsible to free the TLS allocation when it is not longer needed. b) Call ThreadSpecificThreadExit in each DllMain() when reason parameter is DLL_THREAD_DETACH or DLL_PROCESS_DETACH. c) If TLS data is only used in exe, not dll, we can use the hack as described in this article at http://www.codeproject.com/threads/tls.asp. (In reply to comment #9) > (In reply to comment #8) > > The main issue here is that this basically changes JavaScriptCore API in an > > objectionable way - I don't have a proposal, but this definitely needs to be > > resolved. > > Oh, in fact, nothing in JavaScriptCore uses ThreadSpecific, so I do have a > proposal. I think that threads created with WTF::createThread() should just > clean up when exiting - as it is done in Win32+pthreads case in > wtfThreadEntryPoint (ThreadingWin.cpp). > 103873 11 ap 2008-12-30 23:47:33 -0800 > 1) You asked me to remove "copyright to apple". What should I put there? My understanding is that you work for Google - so, it's actually a question for your manager. Normally, it's either a company or an individual that makes the contribution. > 2) As to calling ThreadSpecificThreadExit, I do not think making the cleanup > call from WTF thread is enough. This approach does not take care of the TLS > cleanup in the main thread and other threads not created by WTF::createThread. We don't care about cleanup on the main thread, similarly to how we intentionally avoid cleaning up most static objects for better performance. Also, ThreadSpecific objects are only used in WebCore, not JavaScriptCore, and all WebCore threads are created with WTF::createThread(). > I did not have a good solution here either. Which mailing list should I send to > for further discussion if needed? There's always webkit-dev@lists.webkit.org :) 104524 12 26450 jianli 2009-01-05 20:45:11 -0800 Created attachment 26450 Proposed Patch 104526 13 jianli 2009-01-05 20:47:05 -0800 I fixed all the issues. Please review again. Thanks a lot. (In reply to comment #11) > > 1) You asked me to remove "copyright to apple". What should I put there? > > My understanding is that you work for Google - so, it's actually a question for > your manager. Normally, it's either a company or an individual that makes the > contribution. > > > 2) As to calling ThreadSpecificThreadExit, I do not think making the cleanup > > call from WTF thread is enough. This approach does not take care of the TLS > > cleanup in the main thread and other threads not created by WTF::createThread. > > We don't care about cleanup on the main thread, similarly to how we > intentionally avoid cleaning up most static objects for better performance. > Also, ThreadSpecific objects are only used in WebCore, not JavaScriptCore, and > all WebCore threads are created with WTF::createThread(). > > > I did not have a good solution here either. Which mailing list should I send to > > for further discussion if needed? > > There's always webkit-dev@lists.webkit.org :) > 104552 14 26450 ap 2009-01-06 02:29:31 -0800 Comment on attachment 26450 Proposed Patch > -#if USE(PTHREADS) || PLATFORM(WIN) > +#if USE(PTHREADS) > // Windows currently doesn't use pthreads for basic threading, but implementing destructor functions is easier > // with pthreads, so we use it here. This comment is no longer true after your change, you should just remove it. > +// ThreadSpecificThreadExit should be called each time when a thread is detached. This comment needs to be more specific. What about adding "This is done automatically for threads created with WTF::createThread."? > + // Note: any layout change to this struct should also be applied to the duplicated class in ThreadSpecificWin.cpp. Please don't call it a class, as it's a struct. And I don't think that having a copy is unavoidable - can we find a way to re-use a single definition? > + friend void ThreadSpecificThreadExit(); Why is this function a friend of the class? > +// The maximum number of TLS keys that can be created. For now, this is fixed. > +const int kMaxTlsKeySize = 256; Is there a plan to make it not fixed? Please extend the comment to mention why this is desired, or remove the "for now" part, and explain why this is OK. > +template<typename T> > +inline ThreadSpecific<T>::ThreadSpecific() : m_key(0) The initializer should go on a separate line: inline ThreadSpecific<T>::ThreadSpecific() : m_key(0) > + m_key = TlsAlloc(); > + if (m_key == TLS_OUT_OF_INDEXES) > + CRASH(); > + > + int slot = InterlockedIncrement(&g_tls_key_count) - 1; > + if (slot >= kMaxTlsKeySize) > + CRASH(); > + g_tls_keys[slot] = m_key; You are still re-implementing TLS, but also using the OS-provided functions. With an array of your own, I don't think that you need TlsXXX functions at all, as it only creates possibilities for the two lists to go out of sync. You can just use an index into g_tls_keys as a key. > + // 2) Does not reclaim the key saved in g_tls_keys since we assume the normal usage is always creating ThreadSpecific. I don't understand this comment. > +#include "config.h" > +#include "ThreadSpecific.h" > +#include <wtf/Noncopyable.h> There should be an empty line after config.h. > +#if !USE(PTHREADS) No need to conditionalize the whole file - platforms that don't need it can just omit it from the build. You can add an #error to make this clearer: #if !USE(PTHREADS) #error This file should not be compiled by ports that use Windows native ThreadSpecific implementation #endif > +namespace { > +template<typename T> struct Data : Noncopyable { > + T* value; > + WTF::ThreadSpecific<T>* owner; > +}; > +} Is there really a need to duplicate the structure? Why? > +void ThreadSpecificThreadExit() > +{ > + for (long i = 0; i < g_tls_key_count; i++) { > + Data<int>* data = static_cast<Data<int>*>(TlsGetValue(g_tls_keys[i])); > + if (data) { > + TlsSetValue(data->owner->m_key, 0); > + delete data->value; > + delete data; > + } > + } > +} This needs to employ the same idiom that pthreads version now does - the value pointer should only be reset after the destructor is called, not before. There is a significant semantic discrepancy between this cleanup function and what pthreads does. From pthread_key_create manpage: An optional destructor function may be associated with each key value. At thread exit, if a key value has a non-NULL destructor pointer, and the thread has a non-NULL value associated with the key, the function pointed to is called with the current associated value as its sole argument. The order of destructor calls is unspecified if more than one destructor exists for a thread when it exits. If, after all the destructors have been called for all non-NULL values with associated destructors, there are still some non-NULL values with associated destructors, then the process is repeated. If, after at least [PTHREAD_DESTRUCTOR_ITERATIONS] iterations of destructor calls for outstanding non-NULL values, there are still some non-NULL values with associated destructors, the implementation stops calling destructors. Your implementation doesn't perform the second part (repetition). I don't think we rely on it anywhere in WebKit now, but this difference should be at least documented in blazing detail, and at best eliminated. This is getting closer to landable shape, but still needs improvement, r- for now. 104667 15 ap 2009-01-06 16:21:43 -0800 (In reply to comment #14) > You are still re-implementing TLS, but also using the OS-provided functions. > With an array of your own, I don't think that you need TlsXXX functions at all, Please ignore this comment, it's nonsense. 104680 16 26483 jianli 2009-01-06 18:39:09 -0800 Created attachment 26483 Proposed Patch 104681 17 26484 jianli 2009-01-06 19:02:50 -0800 Created attachment 26484 Proposed Patch 104682 18 jianli 2009-01-06 19:07:13 -0800 I've fixed all issues. Please take a look at my latest patch 26484 and ignore the 5th patch. Please also see some comments embedded below. Thanks. (In reply to comment #14) > (From update of attachment 26450 [review]) > > -#if USE(PTHREADS) || PLATFORM(WIN) > > +#if USE(PTHREADS) > > // Windows currently doesn't use pthreads for basic threading, but implementing destructor functions is easier > > // with pthreads, so we use it here. > > This comment is no longer true after your change, you should just remove it. > > > +// ThreadSpecificThreadExit should be called each time when a thread is detached. > > This comment needs to be more specific. What about adding "This is done > automatically for threads created with WTF::createThread."? > > > + // Note: any layout change to this struct should also be applied to the duplicated class in ThreadSpecificWin.cpp. > > Please don't call it a class, as it's a struct. And I don't think that having a > copy is unavoidable - can we find a way to re-use a single definition? > > > + friend void ThreadSpecificThreadExit(); > > Why is this function a friend of the class? Removed. > > > +// The maximum number of TLS keys that can be created. For now, this is fixed. > > +const int kMaxTlsKeySize = 256; > > Is there a plan to make it not fixed? Please extend the comment to mention why > this is desired, or remove the "for now" part, and explain why this is OK. > > > +template<typename T> > > +inline ThreadSpecific<T>::ThreadSpecific() : m_key(0) > > The initializer should go on a separate line: > > inline ThreadSpecific<T>::ThreadSpecific() > : m_key(0) > > > + m_key = TlsAlloc(); > > + if (m_key == TLS_OUT_OF_INDEXES) > > + CRASH(); > > + > > + int slot = InterlockedIncrement(&g_tls_key_count) - 1; > > + if (slot >= kMaxTlsKeySize) > > + CRASH(); > > + g_tls_keys[slot] = m_key; > > You are still re-implementing TLS, but also using the OS-provided functions. > With an array of your own, I don't think that you need TlsXXX functions at all, > as it only creates possibilities for the two lists to go out of sync. > > You can just use an index into g_tls_keys as a key. > > > + // 2) Does not reclaim the key saved in g_tls_keys since we assume the normal usage is always creating ThreadSpecific. > > I don't understand this comment. I removed the comment here. Please see my comment above for more details. > > > +#include "config.h" > > +#include "ThreadSpecific.h" > > +#include <wtf/Noncopyable.h> > > There should be an empty line after config.h. > > > +#if !USE(PTHREADS) > > No need to conditionalize the whole file - platforms that don't need it can > just omit it from the build. You can add an #error to make this clearer: > > #if !USE(PTHREADS) > #error This file should not be compiled by ports that use Windows native > ThreadSpecific implementation > #endif > > > +namespace { > > +template<typename T> struct Data : Noncopyable { > > + T* value; > > + WTF::ThreadSpecific<T>* owner; > > +}; > > +} > > Is there really a need to duplicate the structure? Why? Changed declaration of Data from private to public in order to remove the duplicate definition. > > > +void ThreadSpecificThreadExit() > > +{ > > + for (long i = 0; i < g_tls_key_count; i++) { > > + Data<int>* data = static_cast<Data<int>*>(TlsGetValue(g_tls_keys[i])); > > + if (data) { > > + TlsSetValue(data->owner->m_key, 0); > > + delete data->value; > > + delete data; > > + } > > + } > > +} > > This needs to employ the same idiom that pthreads version now does - the value > pointer should only be reset after the destructor is called, not before. > > There is a significant semantic discrepancy between this cleanup function and > what pthreads does. From pthread_key_create manpage: > > An optional destructor function may be associated with each key value. At > thread exit, if a key value > has a non-NULL destructor pointer, and the thread has a non-NULL value > associated with the key, the > function pointed to is called with the current associated value as its > sole argument. The order of > destructor calls is unspecified if more than one destructor exists for a > thread when it exits. > > If, after all the destructors have been called for all non-NULL values > with associated destructors, > there are still some non-NULL values with associated destructors, then the > process is repeated. If, > after at least [PTHREAD_DESTRUCTOR_ITERATIONS] iterations of destructor > calls for outstanding non-NULL > values, there are still some non-NULL values with associated destructors, > the implementation stops > calling destructors. > > Your implementation doesn't perform the second part (repetition). I don't think > we rely on it anywhere in WebKit now, but this difference should be at least > documented in blazing detail, and at best eliminated. I think we do not need to add this comment because pthread_setspecific is called in destroy() destructor to set the TLS value to NULL and thus repeated call of destructor is not likely. > > > This is getting closer to landable shape, but still needs improvement, r- for > now. > 104696 19 26484 ap 2009-01-07 00:11:39 -0800 Comment on attachment 26484 Proposed Patch > -#if USE(PTHREADS) || PLATFORM(WIN) > -// Windows currently doesn't use pthreads for basic threading, but implementing destructor functions is easier > -// with pthreads, so we use it here. > -#include <pthread.h> > +#if !USE(PTHREADS) && PLATFORM(WIN_OS) > +#include <windows.h> > #endif Why did you remove the include of pthread.h? I only requested removing the comment (Windows no longer uses pthreads for ThreadSpecific, so explaining why we do that makes no sense), not the whole section. > +extern void ThreadSpecificThreadExit(); There is no need for "extern" here - function declarations are always extern. + ThreadSpecific<int>::Data* data = static_cast<ThreadSpecific<int>::Data*>(TlsGetValue(g_tls_keys[i])); As mentioned earlier, this needs a comment explaining why it is OK to always use ThreadSpecific<int>. + if (data) { + data->destructor(data); + } Please omit braces around this single-line statement. > I think we do not need to add this comment because pthread_setspecific is > called in destroy() destructor to set the TLS value to NULL and thus repeated > call of destructor is not likely. Actually, this is not sufficient, because a different thread specific value can become non-NULL: we only reset the one being destroyed at the moment. +#if !USE(PTHREADS) + void (*destructor)(void*); +#endif Oh, that's a great fix, I missed this problem in my review! >> > + friend void ThreadSpecificThreadExit(); >> >> Why is this function a friend of the class? > > Removed. <...> > Changed declaration of Data from private to public in order to remove the > duplicate definition. Perhaps I do not understand what problem you are solving here, but why not keep Data private, while keeping the friend declaration? Would the duplicate you remove be needed in that case? This is getting close, but I think it could use one more round of review - at least because of the removed pthread.h include, which would break the build on some platforms! 104755 20 26502 jianli 2009-01-07 12:55:40 -0800 Created attachment 26502 Proposed Patch 104756 21 jianli 2009-01-07 13:00:04 -0800 All fixed. Thanks. (In reply to comment #19) > (From update of attachment 26484 [review]) > > -#if USE(PTHREADS) || PLATFORM(WIN) > > -// Windows currently doesn't use pthreads for basic threading, but implementing destructor functions is easier > > -// with pthreads, so we use it here. > > -#include <pthread.h> > > +#if !USE(PTHREADS) && PLATFORM(WIN_OS) > > +#include <windows.h> > > #endif > > Why did you remove the include of pthread.h? I only requested removing the > comment (Windows no longer uses pthreads for ThreadSpecific, so explaining why > we do that makes no sense), not the whole section. > Sorry, I accidentally removed this. I put it back. > > +extern void ThreadSpecificThreadExit(); > > There is no need for "extern" here - function declarations are always extern. > Removed. > + ThreadSpecific<int>::Data* data = > static_cast<ThreadSpecific<int>::Data*>(TlsGetValue(g_tls_keys[i])); > > As mentioned earlier, this needs a comment explaining why it is OK to always > use ThreadSpecific<int>. > Added comment. > + if (data) { > + data->destructor(data); > + } > > Please omit braces around this single-line statement. > Removed. > > I think we do not need to add this comment because pthread_setspecific is > > called in destroy() destructor to set the TLS value to NULL and thus repeated > > call of destructor is not likely. > > Actually, this is not sufficient, because a different thread specific value can > become non-NULL: we only reset the one being destroyed at the moment. > Added the comment at the beginning of the file. > +#if !USE(PTHREADS) > + void (*destructor)(void*); > +#endif > > Oh, that's a great fix, I missed this problem in my review! > > >> > + friend void ThreadSpecificThreadExit(); > >> > >> Why is this function a friend of the class? > > > > Removed. > <...> > > Changed declaration of Data from private to public in order to remove the > > duplicate definition. > > Perhaps I do not understand what problem you are solving here, but why not keep > Data private, while keeping the friend declaration? Would the duplicate you > remove be needed in that case? > Originally I added friend declaration in order to let ThreadSpecificThreadExit to access some private data member in ThreadSpecific<>. It is not needed now. However, just as you suggested, this friend declaration can be used to keep Data private. So I put it back. > This is getting close, but I think it could use one more round of review - at > least because of the removed pthread.h include, which would break the build on > some platforms! > 104866 22 26502 ap 2009-01-08 05:44:21 -0800 Comment on attachment 26502 Proposed Patch > + * WebKit the repeated call bahavior is utilized. Typo: "bahavior". > +#include "config.h" > + > +#include "ThreadSpecific.h" The coding style asks for an empty line after ThreadSpecific.h, not after config.h. > + // The layout of ThreadSpecific<T>::Data does not depend on T. So we are safe to do the static cast to ThreadSpecific<int> in order to access its data member. Please use spaces for indenting, not tabs. r=me, I'm going to fix these minor details before landing. 104875 23 ap 2009-01-08 08:49:40 -0800 Committed r39708. While waiting for build, I forgot to fix the nitpicks other than the tabs, butt hey are really minor. 1304123 24 26502 thakis 2017-05-03 11:02:01 -0700 Comment on attachment 26502 Proposed Patch View in context: https://bugs.webkit.org/attachment.cgi?id=26502&action=review > JavaScriptCore/wtf/ThreadSpecific.h:152 > + // Does not invoke destructor functions. They will be called from ThreadSpecificThreadExit when the thread is detached. You probably don't care since it's now 9 years after you wrote this code, but this dtor is never called. ThreadSpecificThreadExit calls the destructor function, but that's set to &ThreadSpecific<T>::destroy, and that only calls data->value->~T(), not data->owner->~ThreadSpecific(). From what I can tell, this is still the case in webkit trunk today. 25697 2008-12-02 17:54:55 -0800 2008-12-03 00:24:33 -0800 Proposed Patch ThreadSpecificWin32.txt text/plain 2357 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM4OTI3KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDgtMTItMDIgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWMuaDoKKyAgICAgICAgKFdURjo6OjpUaHJl YWRTcGVjaWZpYyk6CisgICAgICAgIChXVEY6Ojo6flRocmVhZFNwZWNpZmljKToKKyAgICAgICAg KFdURjo6OjpnZXQpOgorICAgICAgICAoV1RGOjo6OnNldCk6CisgICAgICAgIChXVEY6Ojo6ZGVz dHJveSk6CisKIDIwMDgtMTItMDIgIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVuQGFwcGxlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDogSmF2YVNjcmlwdENvcmUv d3RmL1RocmVhZFNwZWNpZmljLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1Ro cmVhZFNwZWNpZmljLmgJKHJldmlzaW9uIDM4NzYxKQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1Ro cmVhZFNwZWNpZmljLmgJKHdvcmtpbmcgY29weSkKQEAgLTUyLDE1ICs1MiwxOSBAQCBwcml2YXRl OgogICAgIHZvaWQgc2V0KFQqKTsKICAgICB2b2lkIHN0YXRpYyBkZXN0cm95KHZvaWQqIHB0cik7 CiAKLSNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMp IHx8IFBMQVRGT1JNKFdJTikgfHwgUExBVEZPUk0oV0lOX09TKQogICAgIHN0cnVjdCBEYXRhIDog Tm9uY29weWFibGUgewogICAgICAgICBEYXRhKFQqIHZhbHVlLCBUaHJlYWRTcGVjaWZpYzxUPiog b3duZXIpIDogdmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30KIAogICAgICAgICBUKiB2YWx1 ZTsKICAgICAgICAgVGhyZWFkU3BlY2lmaWM8VD4qIG93bmVyOwogICAgIH07CisjZW5kaWYgICAg CiAKKyNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKICAgICBwdGhyZWFkX2tleV90 IG1fa2V5OworI2Vsc2UKKyAgICBEV09SRCBtX2tleTsKICNlbmRpZgogfTsKIApAQCAtMTAyLDYg KzEwNiw0NSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2CiAgICAg ZGVsZXRlIGRhdGE7CiB9CiAKKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKwordGVtcGxhdGU8dHlw ZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVjaWZpYzxUPjo6VGhyZWFkU3BlY2lmaWMoKSA6IG1f a2V5KDApCit7CisgICAgbV9rZXkgPSBUbHNBbGxvYygpOworICAgIGlmIChtX2tleSA9PSBUTFNf T1VUX09GX0lOREVYRVMpCisgICAgICAgIENSQVNIKCk7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1l IFQ+CitpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VD46On5UaHJlYWRTcGVjaWZpYygpCit7CisgICAg VGxzRnJlZShtX2tleSk7IC8vIERvZXMgbm90IGludm9rZSBkZXN0cnVjdG9yIGZ1bmN0aW9ucy4K K30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSBUKiBUaHJlYWRTcGVjaWZpYzxUPjo6 Z2V0KCkKK3sKKyAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KFRsc0dldFZhbHVl KG1fa2V5KSk7CisgICAgcmV0dXJuIGRhdGEgPyBkYXRhLT52YWx1ZSA6IDA7Cit9CisKK3RlbXBs YXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6c2V0KFQqIHB0 cikKK3sKKyAgICBBU1NFUlQoIWdldCgpKTsKKyAgICBUbHNTZXRWYWx1ZShtX2tleSwgbmV3IERh dGEocHRyLCB0aGlzKSk7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9pZCBU aHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2b2lkKiBwdHIpCit7CisgICAgRGF0YSogZGF0YSA9 IHN0YXRpY19jYXN0PERhdGEqPihwdHIpOworICAgIFRsc1NldFZhbHVlKGRhdGEtPm93bmVyLT5t X2tleSwgMCk7CisgICAgZGVsZXRlIGRhdGEtPnZhbHVlOworICAgIGRlbGV0ZSBkYXRhOworfQor CiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhp cyBwbGF0Zm9ybS4KICNlbmRpZgo= 25731 2008-12-03 18:20:24 -0800 2008-12-03 23:16:11 -0800 Proposed Patch ThreadSpecificWin32-2.txt text/plain 2726 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM4OTI3KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDgtMTItMDIgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWMuaDoKKyAgICAgICAgKFdURjo6OjpUaHJl YWRTcGVjaWZpYyk6CisgICAgICAgIChXVEY6Ojo6flRocmVhZFNwZWNpZmljKToKKyAgICAgICAg KFdURjo6OjpnZXQpOgorICAgICAgICAoV1RGOjo6OnNldCk6CisgICAgICAgIChXVEY6Ojo6ZGVz dHJveSk6CisKIDIwMDgtMTItMDIgIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVuQGFwcGxlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDogSmF2YVNjcmlwdENvcmUv d3RmL1RocmVhZFNwZWNpZmljLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1Ro cmVhZFNwZWNpZmljLmgJKHJldmlzaW9uIDM4NzYxKQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1Ro cmVhZFNwZWNpZmljLmgJKHdvcmtpbmcgY29weSkKQEAgLTMxLDcgKzMxLDcgQEAKIAogI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogCi0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShX SU4pCisjaWYgVVNFKFBUSFJFQURTKQogLy8gV2luZG93cyBjdXJyZW50bHkgZG9lc24ndCB1c2Ug cHRocmVhZHMgZm9yIGJhc2ljIHRocmVhZGluZywgYnV0IGltcGxlbWVudGluZyBkZXN0cnVjdG9y IGZ1bmN0aW9ucyBpcyBlYXNpZXIKIC8vIHdpdGggcHRocmVhZHMsIHNvIHdlIHVzZSBpdCBoZXJl LgogI2luY2x1ZGUgPHB0aHJlYWQuaD4KQEAgLTUyLDE5ICs1MiwyMyBAQCBwcml2YXRlOgogICAg IHZvaWQgc2V0KFQqKTsKICAgICB2b2lkIHN0YXRpYyBkZXN0cm95KHZvaWQqIHB0cik7CiAKLSNp ZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMpIHx8IFBM QVRGT1JNKFdJTl9PUykKICAgICBzdHJ1Y3QgRGF0YSA6IE5vbmNvcHlhYmxlIHsKICAgICAgICAg RGF0YShUKiB2YWx1ZSwgVGhyZWFkU3BlY2lmaWM8VD4qIG93bmVyKSA6IHZhbHVlKHZhbHVlKSwg b3duZXIob3duZXIpIHt9CiAKICAgICAgICAgVCogdmFsdWU7CiAgICAgICAgIFRocmVhZFNwZWNp ZmljPFQ+KiBvd25lcjsKICAgICB9OworI2VuZGlmICAgIAogCisjaWYgVVNFKFBUSFJFQURTKQog ICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CisjZWxzZQorICAgIERXT1JEIG1fa2V5OwogI2VuZGlm CiB9OwogCi0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4pCisjaWYgVVNFKFBUSFJF QURTKQogdGVtcGxhdGU8dHlwZW5hbWUgVD4KIGlubGluZSBUaHJlYWRTcGVjaWZpYzxUPjo6VGhy ZWFkU3BlY2lmaWMoKQogewpAQCAtMTAyLDYgKzEwNiw0NSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRT cGVjaWZpYzxUPjo6ZGVzdHJveSh2CiAgICAgZGVsZXRlIGRhdGE7CiB9CiAKKyNlbGlmIFBMQVRG T1JNKFdJTl9PUykKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVjaWZp YzxUPjo6VGhyZWFkU3BlY2lmaWMoKSA6IG1fa2V5KDApCit7CisgICAgbV9rZXkgPSBUbHNBbGxv YygpOworICAgIGlmIChtX2tleSA9PSBUTFNfT1VUX09GX0lOREVYRVMpCisgICAgICAgIENSQVNI KCk7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VD46 On5UaHJlYWRTcGVjaWZpYygpCit7CisgICAgVGxzRnJlZShtX2tleSk7IC8vIERvZXMgbm90IGlu dm9rZSBkZXN0cnVjdG9yIGZ1bmN0aW9ucy4KK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lu bGluZSBUKiBUaHJlYWRTcGVjaWZpYzxUPjo6Z2V0KCkKK3sKKyAgICBEYXRhKiBkYXRhID0gc3Rh dGljX2Nhc3Q8RGF0YSo+KFRsc0dldFZhbHVlKG1fa2V5KSk7CisgICAgcmV0dXJuIGRhdGEgPyBk YXRhLT52YWx1ZSA6IDA7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9pZCBU aHJlYWRTcGVjaWZpYzxUPjo6c2V0KFQqIHB0cikKK3sKKyAgICBBU1NFUlQoIWdldCgpKTsKKyAg ICBUbHNTZXRWYWx1ZShtX2tleSwgbmV3IERhdGEocHRyLCB0aGlzKSk7Cit9CisKK3RlbXBsYXRl PHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2b2lk KiBwdHIpCit7CisgICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihwdHIpOworICAg IFRsc1NldFZhbHVlKGRhdGEtPm93bmVyLT5tX2tleSwgMCk7CisgICAgZGVsZXRlIGRhdGEtPnZh bHVlOworICAgIGRlbGV0ZSBkYXRhOworfQorCiAjZWxzZQogI2Vycm9yIFRocmVhZFNwZWNpZmlj IGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRpZgo= 26105 2008-12-17 16:20:42 -0800 2008-12-23 14:53:08 -0800 Proposed Patch ThreadSpecificWin32_3.txt text/plain 8736 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5MzY4KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMDgtMTItMTcgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2o6CisgICAg ICAgICogSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAg KiB3dGYvVGhyZWFkU3BlY2lmaWMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdURjo6VGhyZWFkU3Bl Y2lmaWNUaHJlYWRFeGl0KToKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWMuaDoKKyAgICAg ICAgKFdURjo6OjpUaHJlYWRTcGVjaWZpYyk6CisgICAgICAgIChXVEY6Ojo6flRocmVhZFNwZWNp ZmljKToKKyAgICAgICAgKFdURjo6OjpnZXQpOgorICAgICAgICAoV1RGOjo6OnNldCk6CisgICAg ICAgIChXVEY6Ojo6VGhyZWFkRXhpdCk6CisKIDIwMDgtMTItMTcgIFNhbSBXZWluaWcgIDxzYW1A d2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBHYXZpbiBCYXJyYWNsb3VnaC4KSW5k ZXg6IEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJvai9XVEYvV1RGLnZjcHJvago9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dU Ri52Y3Byb2oJKHJldmlzaW9uIDM5MzY3KQorKysgSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENv cmUudmNwcm9qL1dURi9XVEYudmNwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC00MjcsNiArNDI3LDEw IEBACiAJCQk+DQogCQk8L0ZpbGU+DQogCQk8RmlsZQ0KKwkJCVJlbGF0aXZlUGF0aD0iLi5cLi5c d3RmXFRocmVhZFNwZWNpZmljLmNwcCINCisJCQk+DQorCQk8L0ZpbGU+DQorCQk8RmlsZQ0KIAkJ CVJlbGF0aXZlUGF0aD0iLi5cLi5cd3RmXFRocmVhZFNwZWNpZmljLmgiDQogCQkJPg0KIAkJPC9G aWxlPg0KSW5kZXg6IEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24gMzkzNjcpCisrKyBKYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNv cHkpCkBAIC00OTgsNiArNDk4LDcgQEAKIAkJMUM5MDUxNDUwQkE5RThBNzAwODFFOUQwIC8qIEJh c2UueGNjb25maWcgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnhjY29uZmlnOyBwYXRoID0gQmFzZS54Y2NvbmZp Zzsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJMUNBQThCNEEwRDMyQzM5QTAwNDFCQ0ZG IC8qIEphdmFTY3JpcHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSmF2YVNj cmlwdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQkxQ0FBOEI0QjBEMzJDMzlBMDA0 MUJDRkYgLyogSmF2YVNjcmlwdENvcmUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gSmF2YVNjcmlwdENvcmUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJMkU0Njk4 NzkwRUY5QzdGOTAwQTk1ODIyIC8qIFRocmVhZFNwZWNpZmljLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFRocmVhZFNwZWNpZmljLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJNDVFMTJEODgwNkE0OUIwRjAwRTlERjg0IC8qIGpzYy5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGluZGVudFdpZHRoID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBqc2MuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB0YWJXaWR0aCA9IDQ7IH07CiAJCTUxODYxMTFEMEND ODI0ODMwMDgxNDEyQiAvKiBEZXF1ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBEZXF1ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MUYwRUI2MTA1Qzg2QzZC MDBFNkRGMUIgLyogRm91bmRhdGlvbi5mcmFtZXdvcmsgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSB3cmFwcGVyLmZyYW1ld29yazsgbmFtZSA9IEZvdW5k YXRpb24uZnJhbWV3b3JrOyBwYXRoID0gL1N5c3RlbS9MaWJyYXJ5L0ZyYW1ld29ya3MvRm91bmRh dGlvbi5mcmFtZXdvcms7IHNvdXJjZVRyZWUgPSAiPGFic29sdXRlPiI7IH07CkBAIC0xMTExLDYg KzExMTIsNyBAQAogCQkJCTY1NDFCRDZGMDhFODBBMTcwMDJDQkVFNyAvKiBUQ1NwaW5Mb2NrLmgg Ki8sCiAJCQkJNjU0MUJENzAwOEU4MEExNzAwMkNCRUU3IC8qIFRDU3lzdGVtQWxsb2MuY3BwICov LAogCQkJCTY1NDFCRDcxMDhFODBBMTcwMDJDQkVFNyAvKiBUQ1N5c3RlbUFsbG9jLmggKi8sCisJ CQkJMkU0Njk4NzkwRUY5QzdGOTAwQTk1ODIyIC8qIFRocmVhZFNwZWNpZmljLmNwcCAqLywKIAkJ CQlFMUI3QzhCRDBEQTNBMzM2MDA3NEIwREMgLyogVGhyZWFkU3BlY2lmaWMuaCAqLywKIAkJCQlF MUVFNzkyMjBENkM5NUNEMDBGRUEzQkEgLyogVGhyZWFkaW5nLmggKi8sCiAJCQkJRTFFRTc5M0Mw RDZDOUI5MjAwRkVBM0JBIC8qIFRocmVhZGluZ1B0aHJlYWRzLmNwcCAqLywKSW5kZXg6IEphdmFT Y3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlw dENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmNwcAkocmV2aXNpb24gMCkKKysrIEphdmFTY3JpcHRD b3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDQgQEAK Ky8qDQorICogQ29weXJpZ2h0IChDKSAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucw0KKyAqIGFyZSBtZXQ6DQorICoN CisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQNCisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLiANCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiAgICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZQ0KKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLiANCisgKiAzLiAgTmVpdGhlciB0aGUgbmFt ZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZg0KKyAq ICAgICBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkDQorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNp ZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4gDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQ0K KyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQNCisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFDQorICogRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWQ0KKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTDQorICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOw0KKyAq IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORA0KKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUDQorICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFIE9GDQorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisjaW5jbHVkZSAiVGhyZWFkU3BlY2lmaWMu aCINCisNCituYW1lc3BhY2UgV1RGIHsNCisNCisjaWYgUExBVEZPUk0oV0lOX09TKQ0KKw0KK2xv bmcgZ190bHNfa2V5X2NvdW50ID0gMDsNCitEV09SRCBnX3Rsc19rZXlzW2tNYXhUbHNLZXlTaXpl XTsNCisNCit2b2lkIFRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCgpIHsKKyAgICBUaHJlYWRTcGVj aWZpYzxpbnQ+OjpUaHJlYWRFeGl0KCk7Cit9DQorDQorI2VuZGlmDQorDQorfSAvLyBuYW1lc3Bh Y2UgV1RGDQpJbmRleDogSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgJKHJldmlzaW9uIDM5 MzY3KQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgJKHdvcmtpbmcgY29w eSkKQEAgLTMxLDE0ICszMSwyMSBAQAogCiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAK LSNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMpCiAv LyBXaW5kb3dzIGN1cnJlbnRseSBkb2Vzbid0IHVzZSBwdGhyZWFkcyBmb3IgYmFzaWMgdGhyZWFk aW5nLCBidXQgaW1wbGVtZW50aW5nIGRlc3RydWN0b3IgZnVuY3Rpb25zIGlzIGVhc2llcgogLy8g d2l0aCBwdGhyZWFkcywgc28gd2UgdXNlIGl0IGhlcmUuCiAjaW5jbHVkZSA8cHRocmVhZC5oPgor I2VsaWYgUExBVEZPUk0oV0lOX09TKQorI2luY2x1ZGUgPHdpbmRvd3MuaD4KICNlbmRpZgogCiBu YW1lc3BhY2UgV1RGIHsKIAorI2lmIFBMQVRGT1JNKFdJTl9PUykKKy8vIFRocmVhZFNwZWNpZmlj VGhyZWFkRXhpdCBzaG91bGQgYmUgY2FsbGVkIGVhY2ggdGltZSB3aGVuIGEgdGhyZWFkIGlzIGRl dGFjaGVkLgorZXh0ZXJuIHZvaWQgVGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0KCk7CisjZW5kaWYK KwogdGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgVGhyZWFkU3BlY2lmaWMgOiBOb25jb3B5YWJs ZSB7CiBwdWJsaWM6CiAgICAgVGhyZWFkU3BlY2lmaWMoKTsKQEAgLTQ3LDI0ICs1NCwzNSBAQCBw dWJsaWM6CiAgICAgVCYgb3BlcmF0b3IqKCk7CiAgICAgflRocmVhZFNwZWNpZmljKCk7CiAKKyNp ZiBQTEFURk9STShXSU5fT1MpCisgICAgc3RhdGljIHZvaWQgVGhyZWFkRXhpdCgpOworI2VuZGlm CisKIHByaXZhdGU6CiAgICAgVCogZ2V0KCk7CiAgICAgdm9pZCBzZXQoVCopOworCisjaWYgVVNF KFBUSFJFQURTKQogICAgIHZvaWQgc3RhdGljIGRlc3Ryb3kodm9pZCogcHRyKTsKKyNlbmRpZgog Ci0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4pCisjaWYgVVNFKFBUSFJFQURTKSB8 fCBQTEFURk9STShXSU5fT1MpCiAgICAgc3RydWN0IERhdGEgOiBOb25jb3B5YWJsZSB7CiAgICAg ICAgIERhdGEoVCogdmFsdWUsIFRocmVhZFNwZWNpZmljPFQ+KiBvd25lcikgOiB2YWx1ZSh2YWx1 ZSksIG93bmVyKG93bmVyKSB7fQogCiAgICAgICAgIFQqIHZhbHVlOwogICAgICAgICBUaHJlYWRT cGVjaWZpYzxUPiogb3duZXI7CiAgICAgfTsKKyNlbmRpZgogCisjaWYgVVNFKFBUSFJFQURTKQog ICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CisjZWxpZiBQTEFURk9STShXSU5fT1MpCisgICAgRFdP UkQgbV9rZXk7CiAjZW5kaWYKIH07CiAKLSNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJ TikKKyNpZiBVU0UoUFRIUkVBRFMpCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogaW5saW5lIFRocmVh ZFNwZWNpZmljPFQ+OjpUaHJlYWRTcGVjaWZpYygpCiB7CkBAIC0xMDIsNiArMTIwLDYzIEBAIGlu bGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpkZXN0cm95KHYKICAgICBkZWxldGUgZGF0YTsK IH0KIAorI2VsaWYgUExBVEZPUk0oV0lOX09TKQorCisvLyBUaGUgbWF4aW11bSBudW1iZXIgb2Yg VExTIGtleXMgdGhhdCBjYW4gYmUgY3JlYXRlZC4gRm9yIG5vdywgdGhpcyBpcyBmaXhlZC4KK2Nv bnN0IGludCBrTWF4VGxzS2V5U2l6ZSA9IDI1NjsKKworZXh0ZXJuIGxvbmcgZ190bHNfa2V5X2Nv dW50OworZXh0ZXJuIERXT1JEIGdfdGxzX2tleXNba01heFRsc0tleVNpemVdOworCit0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgoraW5saW5lIFRocmVhZFNwZWNpZmljPFQ+OjpUaHJlYWRTcGVjaWZpYygp IDogbV9rZXkoMCkKK3sKKyAgICBtX2tleSA9IFRsc0FsbG9jKCk7CisgICAgaWYgKG1fa2V5ID09 IFRMU19PVVRfT0ZfSU5ERVhFUykKKyAgICAgICAgQ1JBU0goKTsKKworICAgIGludCBzbG90ID0g SW50ZXJsb2NrZWRJbmNyZW1lbnQoJmdfdGxzX2tleV9jb3VudCkgLSAxOworICAgIGlmIChzbG90 ID49IGtNYXhUbHNLZXlTaXplKQorICAgICAgICBDUkFTSCgpOworICAgIGdfdGxzX2tleXNbc2xv dF0gPSBtX2tleTsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVj aWZpYzxUPjo6flRocmVhZFNwZWNpZmljKCkKK3sKKyAgICAvLyBOb3RlOgorICAgIC8vIDEpIERv ZXMgbm90IGludm9rZSBkZXN0cnVjdG9yIGZ1bmN0aW9ucy4gVGhleSB3aWxsIGJlIGNhbGxlZCBm cm9tIFRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCB3aGVuIHRoZSB0aHJlYWQgaXMgZGV0YWNoZWQu CisgICAgLy8gMikgRG9lcyBub3QgcmVjbGFpbSB0aGUga2V5IHNhdmVkIGluIGdfdGxzX2tleXMg c2luY2Ugd2UgYXNzdW1lIHRoZSBub3JtYWwgdXNhZ2UgaXMgYWx3YXlzIGNyZWF0aW5nIFRocmVh ZFNwZWNpZmljLgorICAgIFRsc0ZyZWUobV9rZXkpOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBU PgoraW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQ+OjpnZXQoKQoreworICAgIERhdGEqIGRhdGEg PSBzdGF0aWNfY2FzdDxEYXRhKj4oVGxzR2V0VmFsdWUobV9rZXkpKTsKKyAgICByZXR1cm4gZGF0 YSA/IGRhdGEtPnZhbHVlIDogMDsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSB2 b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpzZXQoVCogcHRyKQoreworICAgIEFTU0VSVCghZ2V0KCkp OworICAgIFRsc1NldFZhbHVlKG1fa2V5LCBuZXcgRGF0YShwdHIsIHRoaXMpKTsKK30KKwordGVt cGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpUaHJlYWRF eGl0KCkKK3sKKyAgICBmb3IgKGxvbmcgaSA9IDA7IGkgPCBnX3Rsc19rZXlfY291bnQ7IGkrKykg eworICAgICAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KFRsc0dldFZhbHVlKGdf dGxzX2tleXNbaV0pKTsKKyAgICAgICAgaWYgKGRhdGEpIHsKKyAgICAgICAgICAgIFRsc1NldFZh bHVlKGRhdGEtPm93bmVyLT5tX2tleSwgMCk7CisgICAgICAgICAgICBkZWxldGUgZGF0YS0+dmFs dWU7CisgICAgICAgICAgICBkZWxldGUgZGF0YTsKKyAgICAgICAgfQorICAgIH0KK30KKwogI2Vs c2UKICNlcnJvciBUaHJlYWRTcGVjaWZpYyBpcyBub3QgaW1wbGVtZW50ZWQgZm9yIHRoaXMgcGxh dGZvcm0uCiAjZW5kaWYK 26450 2009-01-05 20:45:11 -0800 2009-01-06 02:29:31 -0800 Proposed Patch ThreadSpecificWin32_4.txt text/plain 7066 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5NjM3KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjAgQEAKKzIwMDktMDEtMDUgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorICAgICAgICBBZGQgV2luMzIgaW1wbGVtZW50YXRpb24gb2YgVGhyZWFkU3BlY2lmaWMu CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYxNAor CisgICAgICAgICogSmF2YVNjcmlwdENvcmUudmNwcm9qL1dURi9XVEYudmNwcm9qOgorICAgICAg ICAqIHd0Zi9UaHJlYWRTcGVjaWZpYy5oOgorICAgICAgICAoV1RGOjo6OlRocmVhZFNwZWNpZmlj KToKKyAgICAgICAgKFdURjo6Ojp+VGhyZWFkU3BlY2lmaWMpOgorICAgICAgICAoV1RGOjo6Omdl dCk6CisgICAgICAgIChXVEY6Ojo6c2V0KToKKyAgICAgICAgKiB3dGYvVGhyZWFkU3BlY2lmaWNX aW4uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdURjo6VGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0KToK KyAgICAgICAgKiB3dGYvVGhyZWFkaW5nV2luLmNwcDoKKyAgICAgICAgKFdURjo6d3RmVGhyZWFk RW50cnlQb2ludCk6CisKIDIwMDktMDEtMDUgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKEJ1aWxkIGZpeCkuCkluZGV4OiBKYXZh U2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2oKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL1dURi9XVEYudmNwcm9q CShyZXZpc2lvbiAzOTYzMikKKysrIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJv ai9XVEYvV1RGLnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAtNDMxLDYgKzQzMSwxMCBAQAogCQkJ Pg0KIAkJPC9GaWxlPg0KIAkJPEZpbGUNCisJCQlSZWxhdGl2ZVBhdGg9Ii4uXC4uXHd0ZlxUaHJl YWRTcGVjaWZpY1dpbi5jcHAiDQorCQkJPg0KKwkJPC9GaWxlPg0KKwkJPEZpbGUNCiAJCQlSZWxh dGl2ZVBhdGg9Ii4uXC4uXHd0ZlxUaHJlYWRTcGVjaWZpYy5oIg0KIAkJCT4NCiAJCTwvRmlsZT4N CkluZGV4OiBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMuaAkocmV2aXNpb24gMzk2MzIpCisr KyBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMuaAkod29ya2luZyBjb3B5KQpAQCAt MSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA5IEppYW4gTGkgPGppYW5saUBjaHJv bWl1bS5vcmc+CiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMxLDE0ICszMiwy MSBAQAogCiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKLSNpZiBVU0UoUFRIUkVBRFMp IHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMpCiAvLyBXaW5kb3dzIGN1cnJlbnRs eSBkb2Vzbid0IHVzZSBwdGhyZWFkcyBmb3IgYmFzaWMgdGhyZWFkaW5nLCBidXQgaW1wbGVtZW50 aW5nIGRlc3RydWN0b3IgZnVuY3Rpb25zIGlzIGVhc2llcgogLy8gd2l0aCBwdGhyZWFkcywgc28g d2UgdXNlIGl0IGhlcmUuCiAjaW5jbHVkZSA8cHRocmVhZC5oPgorI2VsaWYgUExBVEZPUk0oV0lO X09TKQorI2luY2x1ZGUgPHdpbmRvd3MuaD4KICNlbmRpZgogCiBuYW1lc3BhY2UgV1RGIHsKIAor I2lmICFVU0UoUFRIUkVBRFMpICYmIFBMQVRGT1JNKFdJTl9PUykKKy8vIFRocmVhZFNwZWNpZmlj VGhyZWFkRXhpdCBzaG91bGQgYmUgY2FsbGVkIGVhY2ggdGltZSB3aGVuIGEgdGhyZWFkIGlzIGRl dGFjaGVkLgorZXh0ZXJuIHZvaWQgVGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0KCk7CisjZW5kaWYK KwogdGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgVGhyZWFkU3BlY2lmaWMgOiBOb25jb3B5YWJs ZSB7CiBwdWJsaWM6CiAgICAgVGhyZWFkU3BlY2lmaWMoKTsKQEAgLTUwLDIxICs1OCwzMCBAQCBw dWJsaWM6CiBwcml2YXRlOgogICAgIFQqIGdldCgpOwogICAgIHZvaWQgc2V0KFQqKTsKKworI2lm IFVTRShQVEhSRUFEUykKICAgICB2b2lkIHN0YXRpYyBkZXN0cm95KHZvaWQqIHB0cik7CisjZW5k aWYKIAotI2lmIFVTRShQVEhSRUFEUykgfHwgUExBVEZPUk0oV0lOKQorI2lmIFVTRShQVEhSRUFE UykgfHwgUExBVEZPUk0oV0lOX09TKQorICAgIC8vIE5vdGU6IGFueSBsYXlvdXQgY2hhbmdlIHRv IHRoaXMgc3RydWN0IHNob3VsZCBhbHNvIGJlIGFwcGxpZWQgdG8gdGhlIGR1cGxpY2F0ZWQgY2xh c3MgaW4gVGhyZWFkU3BlY2lmaWNXaW4uY3BwLgogICAgIHN0cnVjdCBEYXRhIDogTm9uY29weWFi bGUgewogICAgICAgICBEYXRhKFQqIHZhbHVlLCBUaHJlYWRTcGVjaWZpYzxUPiogb3duZXIpIDog dmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30KIAogICAgICAgICBUKiB2YWx1ZTsKICAgICAg ICAgVGhyZWFkU3BlY2lmaWM8VD4qIG93bmVyOwogICAgIH07CisjZW5kaWYKIAorI2lmIFVTRShQ VEhSRUFEUykKICAgICBwdGhyZWFkX2tleV90IG1fa2V5OworI2VsaWYgUExBVEZPUk0oV0lOX09T KQorICAgIGZyaWVuZCB2b2lkIFRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCgpOworICAgIERXT1JE IG1fa2V5OwogI2VuZGlmCiB9OwogCi0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4p CisjaWYgVVNFKFBUSFJFQURTKQogdGVtcGxhdGU8dHlwZW5hbWUgVD4KIGlubGluZSBUaHJlYWRT cGVjaWZpYzxUPjo6VGhyZWFkU3BlY2lmaWMoKQogewpAQCAtMTA1LDYgKzEyMiw1MCBAQCBpbmxp bmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2CiAgICAgZGVsZXRlIGRhdGE7CiB9 CiAKKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKworLy8gVGhlIG1heGltdW0gbnVtYmVyIG9mIFRM UyBrZXlzIHRoYXQgY2FuIGJlIGNyZWF0ZWQuIEZvciBub3csIHRoaXMgaXMgZml4ZWQuCitjb25z dCBpbnQga01heFRsc0tleVNpemUgPSAyNTY7CisKK2V4dGVybiBsb25nIGdfdGxzX2tleV9jb3Vu dDsKK2V4dGVybiBEV09SRCBnX3Rsc19rZXlzW2tNYXhUbHNLZXlTaXplXTsKKwordGVtcGxhdGU8 dHlwZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVjaWZpYzxUPjo6VGhyZWFkU3BlY2lmaWMoKSA6 IG1fa2V5KDApCit7CisgICAgbV9rZXkgPSBUbHNBbGxvYygpOworICAgIGlmIChtX2tleSA9PSBU TFNfT1VUX09GX0lOREVYRVMpCisgICAgICAgIENSQVNIKCk7CisKKyAgICBpbnQgc2xvdCA9IElu dGVybG9ja2VkSW5jcmVtZW50KCZnX3Rsc19rZXlfY291bnQpIC0gMTsKKyAgICBpZiAoc2xvdCA+ PSBrTWF4VGxzS2V5U2l6ZSkKKyAgICAgICAgQ1JBU0goKTsKKyAgICBnX3Rsc19rZXlzW3Nsb3Rd ID0gbV9rZXk7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgVGhyZWFkU3BlY2lm aWM8VD46On5UaHJlYWRTcGVjaWZpYygpCit7CisgICAgLy8gTm90ZToKKyAgICAvLyAxKSBEb2Vz IG5vdCBpbnZva2UgZGVzdHJ1Y3RvciBmdW5jdGlvbnMuIFRoZXkgd2lsbCBiZSBjYWxsZWQgZnJv bSBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQgd2hlbiB0aGUgdGhyZWFkIGlzIGRldGFjaGVkLgor ICAgIC8vIDIpIERvZXMgbm90IHJlY2xhaW0gdGhlIGtleSBzYXZlZCBpbiBnX3Rsc19rZXlzIHNp bmNlIHdlIGFzc3VtZSB0aGUgbm9ybWFsIHVzYWdlIGlzIGFsd2F5cyBjcmVhdGluZyBUaHJlYWRT cGVjaWZpYy4KKyAgICBUbHNGcmVlKG1fa2V5KTsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4K K2lubGluZSBUKiBUaHJlYWRTcGVjaWZpYzxUPjo6Z2V0KCkKK3sKKyAgICBEYXRhKiBkYXRhID0g c3RhdGljX2Nhc3Q8RGF0YSo+KFRsc0dldFZhbHVlKG1fa2V5KSk7CisgICAgcmV0dXJuIGRhdGEg PyBkYXRhLT52YWx1ZSA6IDA7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9p ZCBUaHJlYWRTcGVjaWZpYzxUPjo6c2V0KFQqIHB0cikKK3sKKyAgICBBU1NFUlQoIWdldCgpKTsK KyAgICBUbHNTZXRWYWx1ZShtX2tleSwgbmV3IERhdGEocHRyLCB0aGlzKSk7Cit9CisKICNlbHNl CiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVudGVkIGZvciB0aGlzIHBsYXRm b3JtLgogI2VuZGlmCkluZGV4OiBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWNXaW4u Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpY1dpbi5j cHAJKHJldmlzaW9uIDApCisrKyBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWNXaW4u Y3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDUzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDA5IEppYW4gTGkgPGppYW5saUBjaHJvbWl1bS5vcmc+CisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAq IExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVp dGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFu eSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0 aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisg KiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisg KiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBm aWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJv c3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiVGhyZWFkU3BlY2lmaWMuaCIKKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUu aD4KKworI2lmICFVU0UoUFRIUkVBRFMpCisKK25hbWVzcGFjZSB7Cit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPiBzdHJ1Y3QgRGF0YSA6IE5vbmNvcHlhYmxlIHsKKyAgICBUKiB2YWx1ZTsKKyAgICBXVEY6 OlRocmVhZFNwZWNpZmljPFQ+KiBvd25lcjsKK307Cit9CisKK25hbWVzcGFjZSBXVEYgeworCits b25nIGdfdGxzX2tleV9jb3VudCA9IDA7CitEV09SRCBnX3Rsc19rZXlzW2tNYXhUbHNLZXlTaXpl XTsKKwordm9pZCBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQoKQoreworICAgIGZvciAobG9uZyBp ID0gMDsgaSA8IGdfdGxzX2tleV9jb3VudDsgaSsrKSB7CisgICAgICAgIERhdGE8aW50PiogZGF0 YSA9IHN0YXRpY19jYXN0PERhdGE8aW50Pio+KFRsc0dldFZhbHVlKGdfdGxzX2tleXNbaV0pKTsK KyAgICAgICAgaWYgKGRhdGEpIHsKKyAgICAgICAgICAgIFRsc1NldFZhbHVlKGRhdGEtPm93bmVy LT5tX2tleSwgMCk7CisgICAgICAgICAgICBkZWxldGUgZGF0YS0+dmFsdWU7CisgICAgICAgICAg ICBkZWxldGUgZGF0YTsKKyAgICAgICAgfQorICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV1RG CisKKyNlbmRpZgpJbmRleDogSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAJKHJldmlzaW9u IDM5NjMyKQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTY0LDYgKzY0LDkgQEAKICNpbmNsdWRlICJUaHJlYWRpbmcuaCIKIAogI2luY2x1 ZGUgIk1haW5UaHJlYWQuaCIKKyNpZiAhVVNFKFBUSFJFQURTKSAmJiBQTEFURk9STShXSU5fT1Mp CisjaW5jbHVkZSAiVGhyZWFkU3BlY2lmaWMuaCIKKyNlbmRpZgogI2luY2x1ZGUgPHByb2Nlc3Mu aD4KICNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KQEAgLTE3 NSw2ICsxNzgsMTEgQEAgc3RhdGljIHVuc2lnbmVkIF9fc3RkY2FsbCB3dGZUaHJlYWRFbnRyeQog CiAgICAgdm9pZCogcmVzdWx0ID0gaW52b2NhdGlvbi5mdW5jdGlvbihpbnZvY2F0aW9uLmRhdGEp OwogCisjaWYgIVVTRShQVEhSRUFEUykgJiYgUExBVEZPUk0oV0lOX09TKQorICAgIC8vIERvIHRo ZSBUTFMgY2xlYW51cC4KKyAgICBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQoKTsKKyNlbmRpZgkK KwogICAgIHJldHVybiByZWludGVycHJldF9jYXN0PHVuc2lnbmVkPihyZXN1bHQpOwogfQogCg== 26483 2009-01-06 18:39:09 -0800 2009-01-06 23:42:32 -0800 Proposed Patch ThreadSpecificWin32_5.txt text/plain 8796 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5NjY5KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDEtMDYgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2o6CisgICAg ICAgICogd3RmL1RocmVhZFNwZWNpZmljLmg6CisgICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmlj RGF0YTo6VGhyZWFkU3BlY2lmaWNEYXRhKToKKyAgICAgICAgKFdURjo6OjpnZXQpOgorICAgICAg ICAoV1RGOjo6OnNldCk6CisgICAgICAgIChXVEY6Ojo6VGhyZWFkU3BlY2lmaWMpOgorICAgICAg ICAoV1RGOjo6On5UaHJlYWRTcGVjaWZpYyk6CisgICAgICAgIChXVEY6Ojo6ZGVzdHJveSk6Cisg ICAgICAgICogd3RmL1RocmVhZFNwZWNpZmljV2luLmNwcDogQWRkZWQuCisgICAgICAgIChXVEY6 OlRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCk6CisgICAgICAgICogd3RmL1RocmVhZGluZ1dpbi5j cHA6CisgICAgICAgIChXVEY6Ond0ZlRocmVhZEVudHJ5UG9pbnQpOgorCiAyMDA5LTAxLTA2ICBP bGl2ZXIgSHVudCAgPG9saXZlckBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQ2Ft ZXJvbiBad2FyaWNoLgpJbmRleDogSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9q L1dURi9XVEYudmNwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLnZjcHJvai9XVEYvV1RGLnZjcHJvagkocmV2aXNpb24gMzk2MzIpCisrKyBKYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2oJKHdvcmtpbmcgY29weSkK QEAgLTQzMSw2ICs0MzEsMTAgQEAKIAkJCT4NCiAJCTwvRmlsZT4NCiAJCTxGaWxlDQorCQkJUmVs YXRpdmVQYXRoPSIuLlwuLlx3dGZcVGhyZWFkU3BlY2lmaWNXaW4uY3BwIg0KKwkJCT4NCisJCTwv RmlsZT4NCisJCTxGaWxlDQogCQkJUmVsYXRpdmVQYXRoPSIuLlwuLlx3dGZcVGhyZWFkU3BlY2lm aWMuaCINCiAJCQk+DQogCQk8L0ZpbGU+DQpJbmRleDogSmF2YVNjcmlwdENvcmUvd3RmL1RocmVh ZFNwZWNpZmljLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNp ZmljLmgJKHJldmlzaW9uIDM5NjMyKQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNp ZmljLmgJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChD KSAyMDA4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykg MjAwOSBKaWFuIExpIDxqaWFubGlAY2hyb21pdW0ub3JnPgogICoKICAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCkBAIC0zMSwxNCArMzIsMTggQEAKIAogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJs ZS5oPgogCi0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4pCi0vLyBXaW5kb3dzIGN1 cnJlbnRseSBkb2Vzbid0IHVzZSBwdGhyZWFkcyBmb3IgYmFzaWMgdGhyZWFkaW5nLCBidXQgaW1w bGVtZW50aW5nIGRlc3RydWN0b3IgZnVuY3Rpb25zIGlzIGVhc2llcgotLy8gd2l0aCBwdGhyZWFk cywgc28gd2UgdXNlIGl0IGhlcmUuCi0jaW5jbHVkZSA8cHRocmVhZC5oPgorI2lmICFVU0UoUFRI UkVBRFMpICYmIFBMQVRGT1JNKFdJTl9PUykKKyNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjZW5kaWYK IAogbmFtZXNwYWNlIFdURiB7CiAKKyNpZiAhVVNFKFBUSFJFQURTKSAmJiBQTEFURk9STShXSU5f T1MpCisvLyBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQgc2hvdWxkIGJlIGNhbGxlZCBlYWNoIHRp bWUgd2hlbiBhIHRocmVhZCBpcyBkZXRhY2hlZC4KKy8vIFRoaXMgaXMgZG9uZSBhdXRvbWF0aWNh bGx5IGZvciB0aHJlYWRzIGNyZWF0ZWQgd2l0aCBXVEY6OmNyZWF0ZVRocmVhZC4KK2V4dGVybiB2 b2lkIFRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCgpOworI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVu YW1lIFQ+IGNsYXNzIFRocmVhZFNwZWNpZmljIDogTm9uY29weWFibGUgewogcHVibGljOgogICAg IFRocmVhZFNwZWNpZmljKCk7CkBAIC01MCwyMSArNTUsMjkgQEAgcHVibGljOgogcHJpdmF0ZToK ICAgICBUKiBnZXQoKTsKICAgICB2b2lkIHNldChUKik7Ci0gICAgdm9pZCBzdGF0aWMgZGVzdHJv eSh2b2lkKiBwdHIpOwogCi0jaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4pCi0gICAg c3RydWN0IERhdGEgOiBOb25jb3B5YWJsZSB7Ci0gICAgICAgIERhdGEoVCogdmFsdWUsIFRocmVh ZFNwZWNpZmljPFQ+KiBvd25lcikgOiB2YWx1ZSh2YWx1ZSksIG93bmVyKG93bmVyKSB7fQotCi0g ICAgICAgIFQqIHZhbHVlOwotICAgICAgICBUaHJlYWRTcGVjaWZpYzxUPiogb3duZXI7Ci0gICAg fTsKKyAgICB2b2lkIHN0YXRpYyBkZXN0cm95KHZvaWQqIHB0cik7CiAKKyNpZiBVU0UoUFRIUkVB RFMpCiAgICAgcHRocmVhZF9rZXlfdCBtX2tleTsKKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKyAg ICBpbnQgbV9pbmRleDsKKyNlbmRpZgorfTsKKyAgICAKKyNpZiBVU0UoUFRIUkVBRFMpIHx8IFBM QVRGT1JNKFdJTl9PUykKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+IHN0cnVjdCBUaHJlYWRTcGVjaWZp Y0RhdGEgOiBOb25jb3B5YWJsZSB7CisgICAgVGhyZWFkU3BlY2lmaWNEYXRhKFQqIHZhbHVlLCBU aHJlYWRTcGVjaWZpYzxUPiogb3duZXIpIDogdmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30K KyAgICAKKyAgICBUKiB2YWx1ZTsKKyAgICBUaHJlYWRTcGVjaWZpYzxUPiogb3duZXI7CisjaWYg IVVTRShQVEhSRUFEUykKKyAgICB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCopOwogI2VuZGlmCiB9 OworI2VuZGlmCiAKLSNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0Uo UFRIUkVBRFMpCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQ+ OjpUaHJlYWRTcGVjaWZpYygpCiB7CkBAIC04Miw3ICs5NSw1MiBAQCBpbmxpbmUgVGhyZWFkU3Bl Y2lmaWM8VD46On5UaHJlYWRTcGVjaWZpCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogaW5saW5lIFQq IFRocmVhZFNwZWNpZmljPFQ+OjpnZXQoKQogewotICAgIERhdGEqIGRhdGEgPSBzdGF0aWNfY2Fz dDxEYXRhKj4ocHRocmVhZF9nZXRzcGVjaWZpYyhtX2tleSkpOworICAgIFRocmVhZFNwZWNpZmlj RGF0YTxUPiogZGF0YSA9IHN0YXRpY19jYXN0PFRocmVhZFNwZWNpZmljRGF0YTxUPio+KHB0aHJl YWRfZ2V0c3BlY2lmaWMobV9rZXkpKTsKKyAgICByZXR1cm4gZGF0YSA/IGRhdGEtPnZhbHVlIDog MDsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSB2b2lkIFRocmVhZFNwZWNpZmlj PFQ+OjpzZXQoVCogcHRyKQoreworICAgIEFTU0VSVCghZ2V0KCkpOworICAgIHB0aHJlYWRfc2V0 c3BlY2lmaWMobV9rZXksIG5ldyBUaHJlYWRTcGVjaWZpY0RhdGE8VD4ocHRyLCB0aGlzKSk7Cit9 CisKKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKworLy8gVGhlIG1heGltdW0gbnVtYmVyIG9mIFRM UyBrZXlzIHRoYXQgY2FuIGJlIGNyZWF0ZWQuIEZvciBzaW1wbGlmaWNhdGlvbiwgd2UgYXNzdW1l IHRoYXQ6CisvLyAxKSBPbmNlIHRoZSBpbnN0YW5jZSBvZiBUaHJlYWRTcGVjaWZpYzw+IGlzIGNy ZWF0ZWQsIGl0IHdpbGwgbm90IGJlIGRlc3RydWN0ZWQgdW50aWwgdGhlIHByb2dyYW0gZGllcy4K Ky8vIDIpIFdlIGRvIG5vdCBuZWVkIHRvIGhvbGQgbWFueSBpbnN0YW5jZXMgb2YgVGhyZWFkU3Bl Y2lmaWM8PiBkYXRhLiBUaGlzIGZpeGVkIG51bWJlciBzaG91bGQgYmUgZmFyIGVub3VnaC4KK2Nv bnN0IGludCBrTWF4VGxzS2V5U2l6ZSA9IDI1NjsKKworZXh0ZXJuIGxvbmcgZ190bHNfa2V5X2Nv dW50OworZXh0ZXJuIERXT1JEIGdfdGxzX2tleXNba01heFRsc0tleVNpemVdOworCit0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgoraW5saW5lIFRocmVhZFNwZWNpZmljPFQ+OjpUaHJlYWRTcGVjaWZpYygp CisgICAgOiBtX2luZGV4KC0xKQoreworICAgIERXT1JEIHRsc19rZXkgPSBUbHNBbGxvYygpOwor ICAgIGlmICh0bHNfa2V5ID09IFRMU19PVVRfT0ZfSU5ERVhFUykKKyAgICAgICAgQ1JBU0goKTsK KworICAgIG1faW5kZXggPSBJbnRlcmxvY2tlZEluY3JlbWVudCgmZ190bHNfa2V5X2NvdW50KSAt IDE7CisgICAgaWYgKG1faW5kZXggPj0ga01heFRsc0tleVNpemUpCisgICAgICAgIENSQVNIKCk7 CisgICAgZ190bHNfa2V5c1ttX2luZGV4XSA9IHRsc19rZXk7Cit9CisKK3RlbXBsYXRlPHR5cGVu YW1lIFQ+CitpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VD46On5UaHJlYWRTcGVjaWZpYygpCit7Cisg ICAgLy8gRG9lcyBub3QgaW52b2tlIGRlc3RydWN0b3IgZnVuY3Rpb25zLiBUaGV5IHdpbGwgYmUg Y2FsbGVkIGZyb20gVGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0IHdoZW4gdGhlIHRocmVhZCBpcyBk ZXRhY2hlZC4KKyAgICBUbHNGcmVlKGdfdGxzX2tleXNbbV9pbmRleF0pOworfQorCit0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgoraW5saW5lIFQqIFRocmVhZFNwZWNpZmljPFQ+OjpnZXQoKQoreworICAg IFRocmVhZFNwZWNpZmljRGF0YTxUPiogZGF0YSA9IHN0YXRpY19jYXN0PFRocmVhZFNwZWNpZmlj RGF0YTxUPio+KFRsc0dldFZhbHVlKGdfdGxzX2tleXNbbV9pbmRleF0pKTsKICAgICByZXR1cm4g ZGF0YSA/IGRhdGEtPnZhbHVlIDogMDsKIH0KIApAQCAtOTAsMjQgKzE0OCwzMiBAQCB0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgogaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8VD46OnNldChUKiBwdHIp CiB7CiAgICAgQVNTRVJUKCFnZXQoKSk7Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhtX2tleSwg bmV3IERhdGEocHRyLCB0aGlzKSk7CisgICAgVGhyZWFkU3BlY2lmaWNEYXRhPFQ+KiBkYXRhID0g bmV3IFRocmVhZFNwZWNpZmljRGF0YTxUPihwdHIsIHRoaXMpOworICAgIGRhdGEtPmRlc3RydWN0 b3IgPSAmVGhyZWFkU3BlY2lmaWM8VD46OmRlc3Ryb3k7CisgICAgVGxzU2V0VmFsdWUoZ190bHNf a2V5c1ttX2luZGV4XSwgZGF0YSk7CiB9CiAKKyNlbHNlCisjZXJyb3IgVGhyZWFkU3BlY2lmaWMg aXMgbm90IGltcGxlbWVudGVkIGZvciB0aGlzIHBsYXRmb3JtLgorI2VuZGlmCisKIHRlbXBsYXRl PHR5cGVuYW1lIFQ+CiBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2b2lk KiBwdHIpCiB7Ci0gICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihwdHIpOworICAg IFRocmVhZFNwZWNpZmljRGF0YTxUPiogZGF0YSA9IHN0YXRpY19jYXN0PFRocmVhZFNwZWNpZmlj RGF0YTxUPio+KHB0cik7CiAgICAgZGF0YS0+dmFsdWUtPn5UKCk7CiAgICAgZmFzdEZyZWUoZGF0 YS0+dmFsdWUpOwogICAgIC8vIE9ubHkgcmVzZXQgdGhlIHBvaW50ZXIgYWZ0ZXIgdmFsdWUgZGVz dHJ1Y3RvciBmaW5pc2hlcyAtIG90aGVyd2lzZSwgY29kZSBpbiBkZXN0cnVjdG9yIGNvdWxkIHRy aWdnZXIKICAgICAvLyByZS1jcmVhdGlvbiBvZiB0aGUgb2JqZWN0LgorI2lmIFVTRShQVEhSRUFE UykKICAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEtPm93bmVyLT5tX2tleSwgMCk7Ci0gICAg ZGVsZXRlIGRhdGE7Ci19Ci0KKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKyAgICBUbHNTZXRWYWx1 ZShnX3Rsc19rZXlzW2RhdGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CiAjZWxzZQogI2Vycm9yIFRo cmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4KICNlbmRp ZgorICAgIGRlbGV0ZSBkYXRhOworfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogaW5saW5lIFRo cmVhZFNwZWNpZmljPFQ+OjpvcGVyYXRvciBUKigpCkluZGV4OiBKYXZhU2NyaXB0Q29yZS93dGYv VGhyZWFkU3BlY2lmaWNXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL3d0Zi9U aHJlYWRTcGVjaWZpY1dpbi5jcHAJKHJldmlzaW9uIDApCisrKyBKYXZhU2NyaXB0Q29yZS93dGYv VGhyZWFkU3BlY2lmaWNXaW4uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQ1IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDA5IEppYW4gTGkgPGppYW5saUBjaHJvbWl1bS5vcmc+CisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICog dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICoKKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJUaHJlYWRTcGVjaWZpYy5oIgorI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorCisjaWYgVVNFKFBUSFJFQURTKQorI2Vycm9yIFRoaXMg ZmlsZSBzaG91bGQgbm90IGJlIGNvbXBpbGVkIGJ5IHBvcnRzIHRoYXQgZG8gbm90IHVzZSBXaW5k b3dzIG5hdGl2ZSBUaHJlYWRTcGVjaWZpYyBpbXBsZW1lbnRhdGlvbi4KKyNlbmRpZgorCituYW1l c3BhY2UgV1RGIHsKKworbG9uZyBnX3Rsc19rZXlfY291bnQgPSAwOworRFdPUkQgZ190bHNfa2V5 c1trTWF4VGxzS2V5U2l6ZV07CisKK3ZvaWQgVGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0KCkKK3sK KyAgICBmb3IgKGxvbmcgaSA9IDA7IGkgPCBnX3Rsc19rZXlfY291bnQ7IGkrKykgeworICAgICAg ICBUaHJlYWRTcGVjaWZpY0RhdGE8aW50PiogZGF0YSA9IHN0YXRpY19jYXN0PFRocmVhZFNwZWNp ZmljRGF0YTxpbnQ+Kj4oVGxzR2V0VmFsdWUoZ190bHNfa2V5c1tpXSkpOworICAgICAgICBpZiAo ZGF0YSkgeworICAgICAgICAgICAgZGF0YS0+ZGVzdHJ1Y3RvcihkYXRhKTsKKyAgICAgICAgfQor ICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2UgV1RGCkluZGV4OiBKYXZhU2NyaXB0Q29yZS93dGYv VGhyZWFkaW5nV2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFk aW5nV2luLmNwcAkocmV2aXNpb24gMzk2MzIpCisrKyBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFk aW5nV2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjQsNiArNjQsOSBAQAogI2luY2x1ZGUgIlRo cmVhZGluZy5oIgogCiAjaW5jbHVkZSAiTWFpblRocmVhZC5oIgorI2lmICFVU0UoUFRIUkVBRFMp ICYmIFBMQVRGT1JNKFdJTl9PUykKKyNpbmNsdWRlICJUaHJlYWRTcGVjaWZpYy5oIgorI2VuZGlm CiAjaW5jbHVkZSA8cHJvY2Vzcy5oPgogI2luY2x1ZGUgPHdpbmRvd3MuaD4KICNpbmNsdWRlIDx3 dGYvSGFzaE1hcC5oPgpAQCAtMTc1LDYgKzE3OCwxMSBAQCBzdGF0aWMgdW5zaWduZWQgX19zdGRj YWxsIHd0ZlRocmVhZEVudHJ5CiAKICAgICB2b2lkKiByZXN1bHQgPSBpbnZvY2F0aW9uLmZ1bmN0 aW9uKGludm9jYXRpb24uZGF0YSk7CiAKKyNpZiAhVVNFKFBUSFJFQURTKSAmJiBQTEFURk9STShX SU5fT1MpCisgICAgLy8gRG8gdGhlIFRMUyBjbGVhbnVwLgorICAgIFRocmVhZFNwZWNpZmljVGhy ZWFkRXhpdCgpOworI2VuZGlmCQorCiAgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8dW5zaWdu ZWQ+KHJlc3VsdCk7CiB9CiAK 26484 2009-01-06 19:02:50 -0800 2009-01-07 00:11:39 -0800 Proposed Patch ThreadSpecificWin32_6.txt text/plain 8185 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5NjY5KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjMgQEAKKzIwMDktMDEtMDYgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2o6CisgICAg ICAgICogd3RmL1RocmVhZFNwZWNpZmljLmg6CisgICAgICAgIChXVEY6OlRocmVhZFNwZWNpZmlj OjpEYXRhOjpEYXRhKToKKyAgICAgICAgKFdURjo6OjpUaHJlYWRTcGVjaWZpYyk6CisgICAgICAg IChXVEY6Ojo6flRocmVhZFNwZWNpZmljKToKKyAgICAgICAgKFdURjo6OjpnZXQpOgorICAgICAg ICAoV1RGOjo6OnNldCk6CisgICAgICAgIChXVEY6Ojo6ZGVzdHJveSk6CisgICAgICAgICogd3Rm L1RocmVhZFNwZWNpZmljV2luLmNwcDogQWRkZWQuCisgICAgICAgIChXVEY6OlRocmVhZFNwZWNp ZmljVGhyZWFkRXhpdCk6CisgICAgICAgICogd3RmL1RocmVhZGluZ1dpbi5jcHA6CisgICAgICAg IChXVEY6Ond0ZlRocmVhZEVudHJ5UG9pbnQpOgorCiAyMDA5LTAxLTA2ICBPbGl2ZXIgSHVudCAg PG9saXZlckBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQ2FtZXJvbiBad2FyaWNo LgpJbmRleDogSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL1dURi9XVEYudmNw cm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnZjcHJvai9X VEYvV1RGLnZjcHJvagkocmV2aXNpb24gMzk2MzIpCisrKyBKYXZhU2NyaXB0Q29yZS9KYXZhU2Ny aXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2oJKHdvcmtpbmcgY29weSkKQEAgLTQzMSw2ICs0 MzEsMTAgQEAKIAkJCT4NCiAJCTwvRmlsZT4NCiAJCTxGaWxlDQorCQkJUmVsYXRpdmVQYXRoPSIu LlwuLlx3dGZcVGhyZWFkU3BlY2lmaWNXaW4uY3BwIg0KKwkJCT4NCisJCTwvRmlsZT4NCisJCTxG aWxlDQogCQkJUmVsYXRpdmVQYXRoPSIuLlwuLlx3dGZcVGhyZWFkU3BlY2lmaWMuaCINCiAJCQk+ DQogCQk8L0ZpbGU+DQpJbmRleDogSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgJKHJldmlz aW9uIDM5NjMyKQorKysgSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgJKHdvcmtp bmcgY29weSkKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBKaWFuIExp IDxqaWFubGlAY2hyb21pdW0ub3JnPgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBA IC0zMSwxNCArMzIsMTggQEAKIAogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogCi0jaWYg VVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShXSU4pCi0vLyBXaW5kb3dzIGN1cnJlbnRseSBkb2Vz bid0IHVzZSBwdGhyZWFkcyBmb3IgYmFzaWMgdGhyZWFkaW5nLCBidXQgaW1wbGVtZW50aW5nIGRl c3RydWN0b3IgZnVuY3Rpb25zIGlzIGVhc2llcgotLy8gd2l0aCBwdGhyZWFkcywgc28gd2UgdXNl IGl0IGhlcmUuCi0jaW5jbHVkZSA8cHRocmVhZC5oPgorI2lmICFVU0UoUFRIUkVBRFMpICYmIFBM QVRGT1JNKFdJTl9PUykKKyNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjZW5kaWYKIAogbmFtZXNwYWNl IFdURiB7CiAKKyNpZiAhVVNFKFBUSFJFQURTKSAmJiBQTEFURk9STShXSU5fT1MpCisvLyBUaHJl YWRTcGVjaWZpY1RocmVhZEV4aXQgc2hvdWxkIGJlIGNhbGxlZCBlYWNoIHRpbWUgd2hlbiBhIHRo cmVhZCBpcyBkZXRhY2hlZC4KKy8vIFRoaXMgaXMgZG9uZSBhdXRvbWF0aWNhbGx5IGZvciB0aHJl YWRzIGNyZWF0ZWQgd2l0aCBXVEY6OmNyZWF0ZVRocmVhZC4KK2V4dGVybiB2b2lkIFRocmVhZFNw ZWNpZmljVGhyZWFkRXhpdCgpOworI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNz IFRocmVhZFNwZWNpZmljIDogTm9uY29weWFibGUgewogcHVibGljOgogICAgIFRocmVhZFNwZWNp ZmljKCk7CkBAIC00NywyNCArNTIsMzIgQEAgcHVibGljOgogICAgIFQmIG9wZXJhdG9yKigpOwog ICAgIH5UaHJlYWRTcGVjaWZpYygpOwogCisjaWYgVVNFKFBUSFJFQURTKSB8fCBQTEFURk9STShX SU5fT1MpCitzdHJ1Y3QgRGF0YSA6IE5vbmNvcHlhYmxlIHsKKyAgICBEYXRhKFQqIHZhbHVlLCBU aHJlYWRTcGVjaWZpYzxUPiogb3duZXIpIDogdmFsdWUodmFsdWUpLCBvd25lcihvd25lcikge30K KyAgICAKKyAgICBUKiB2YWx1ZTsKKyAgICBUaHJlYWRTcGVjaWZpYzxUPiogb3duZXI7CisjaWYg IVVTRShQVEhSRUFEUykKKyAgICB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCopOworI2VuZGlmCit9 OworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgVCogZ2V0KCk7CiAgICAgdm9pZCBzZXQoVCopOwot ICAgIHZvaWQgc3RhdGljIGRlc3Ryb3kodm9pZCogcHRyKTsKIAotI2lmIFVTRShQVEhSRUFEUykg fHwgUExBVEZPUk0oV0lOKQotICAgIHN0cnVjdCBEYXRhIDogTm9uY29weWFibGUgewotICAgICAg ICBEYXRhKFQqIHZhbHVlLCBUaHJlYWRTcGVjaWZpYzxUPiogb3duZXIpIDogdmFsdWUodmFsdWUp LCBvd25lcihvd25lcikge30KLQotICAgICAgICBUKiB2YWx1ZTsKLSAgICAgICAgVGhyZWFkU3Bl Y2lmaWM8VD4qIG93bmVyOwotICAgIH07CisgICAgdm9pZCBzdGF0aWMgZGVzdHJveSh2b2lkKiBw dHIpOwogCisjaWYgVVNFKFBUSFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CisjZWxp ZiBQTEFURk9STShXSU5fT1MpCisgICAgaW50IG1faW5kZXg7CiAjZW5kaWYKIH07CiAKLSNpZiBV U0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMpCiB0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQ+OjpUaHJlYWRTcGVjaWZpYygp CiB7CkBAIC05Myw2ICsxMDYsNTcgQEAgaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8VD46OnNl dChUKiBwdAogICAgIHB0aHJlYWRfc2V0c3BlY2lmaWMobV9rZXksIG5ldyBEYXRhKHB0ciwgdGhp cykpOwogfQogCisjZWxpZiBQTEFURk9STShXSU5fT1MpCisKKy8vIFRoZSBtYXhpbXVtIG51bWJl ciBvZiBUTFMga2V5cyB0aGF0IGNhbiBiZSBjcmVhdGVkLiBGb3Igc2ltcGxpZmljYXRpb24sIHdl IGFzc3VtZSB0aGF0OgorLy8gMSkgT25jZSB0aGUgaW5zdGFuY2Ugb2YgVGhyZWFkU3BlY2lmaWM8 PiBpcyBjcmVhdGVkLCBpdCB3aWxsIG5vdCBiZSBkZXN0cnVjdGVkIHVudGlsIHRoZSBwcm9ncmFt IGRpZXMuCisvLyAyKSBXZSBkbyBub3QgbmVlZCB0byBob2xkIG1hbnkgaW5zdGFuY2VzIG9mIFRo cmVhZFNwZWNpZmljPD4gZGF0YS4gVGhpcyBmaXhlZCBudW1iZXIgc2hvdWxkIGJlIGZhciBlbm91 Z2guCitjb25zdCBpbnQga01heFRsc0tleVNpemUgPSAyNTY7CisKK2V4dGVybiBsb25nIGdfdGxz X2tleV9jb3VudDsKK2V4dGVybiBEV09SRCBnX3Rsc19rZXlzW2tNYXhUbHNLZXlTaXplXTsKKwor dGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVjaWZpYzxUPjo6VGhyZWFkU3Bl Y2lmaWMoKQorICAgIDogbV9pbmRleCgtMSkKK3sKKyAgICBEV09SRCB0bHNfa2V5ID0gVGxzQWxs b2MoKTsKKyAgICBpZiAodGxzX2tleSA9PSBUTFNfT1VUX09GX0lOREVYRVMpCisgICAgICAgIENS QVNIKCk7CisKKyAgICBtX2luZGV4ID0gSW50ZXJsb2NrZWRJbmNyZW1lbnQoJmdfdGxzX2tleV9j b3VudCkgLSAxOworICAgIGlmIChtX2luZGV4ID49IGtNYXhUbHNLZXlTaXplKQorICAgICAgICBD UkFTSCgpOworICAgIGdfdGxzX2tleXNbbV9pbmRleF0gPSB0bHNfa2V5OworfQorCit0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgoraW5saW5lIFRocmVhZFNwZWNpZmljPFQ+Ojp+VGhyZWFkU3BlY2lmaWMo KQoreworICAgIC8vIERvZXMgbm90IGludm9rZSBkZXN0cnVjdG9yIGZ1bmN0aW9ucy4gVGhleSB3 aWxsIGJlIGNhbGxlZCBmcm9tIFRocmVhZFNwZWNpZmljVGhyZWFkRXhpdCB3aGVuIHRoZSB0aHJl YWQgaXMgZGV0YWNoZWQuCisgICAgVGxzRnJlZShnX3Rsc19rZXlzW21faW5kZXhdKTsKK30KKwor dGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSBUKiBUaHJlYWRTcGVjaWZpYzxUPjo6Z2V0KCkK K3sKKyAgICBEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8RGF0YSo+KFRsc0dldFZhbHVlKGdfdGxz X2tleXNbbV9pbmRleF0pKTsKKyAgICByZXR1cm4gZGF0YSA/IGRhdGEtPnZhbHVlIDogMDsKK30K KwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK2lubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+Ojpz ZXQoVCogcHRyKQoreworICAgIEFTU0VSVCghZ2V0KCkpOworICAgIERhdGEqIGRhdGEgPSBuZXcg RGF0YShwdHIsIHRoaXMpOworICAgIGRhdGEtPmRlc3RydWN0b3IgPSAmVGhyZWFkU3BlY2lmaWM8 VD46OmRlc3Ryb3k7CisgICAgVGxzU2V0VmFsdWUoZ190bHNfa2V5c1ttX2luZGV4XSwgZGF0YSk7 Cit9CisKKyNlbHNlCisjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVudGVkIGZv ciB0aGlzIHBsYXRmb3JtLgorI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiBpbmxpbmUg dm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2b2lkKiBwdHIpCiB7CkBAIC0xMDEsMTMg KzE2NSwxNSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2CiAgICAg ZmFzdEZyZWUoZGF0YS0+dmFsdWUpOwogICAgIC8vIE9ubHkgcmVzZXQgdGhlIHBvaW50ZXIgYWZ0 ZXIgdmFsdWUgZGVzdHJ1Y3RvciBmaW5pc2hlcyAtIG90aGVyd2lzZSwgY29kZSBpbiBkZXN0cnVj dG9yIGNvdWxkIHRyaWdnZXIKICAgICAvLyByZS1jcmVhdGlvbiBvZiB0aGUgb2JqZWN0LgorI2lm IFVTRShQVEhSRUFEUykKICAgICBwdGhyZWFkX3NldHNwZWNpZmljKGRhdGEtPm93bmVyLT5tX2tl eSwgMCk7Ci0gICAgZGVsZXRlIGRhdGE7Ci19Ci0KKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKyAg ICBUbHNTZXRWYWx1ZShnX3Rsc19rZXlzW2RhdGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CiAjZWxz ZQogI2Vycm9yIFRocmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0 Zm9ybS4KICNlbmRpZgorICAgIGRlbGV0ZSBkYXRhOworfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBU PgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQ+OjpvcGVyYXRvciBUKigpCkluZGV4OiBKYXZhU2Ny aXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWNXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3Jp cHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpY1dpbi5jcHAJKHJldmlzaW9uIDApCisrKyBKYXZhU2Ny aXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWNXaW4uY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDQ1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEppYW4gTGkgPGppYW5saUBjaHJvbWl1 bS5vcmc+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgor ICoKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJUaHJlYWRTcGVjaWZp Yy5oIgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorCisjaWYgVVNFKFBUSFJFQURTKQor I2Vycm9yIFRoaXMgZmlsZSBzaG91bGQgbm90IGJlIGNvbXBpbGVkIGJ5IHBvcnRzIHRoYXQgZG8g bm90IHVzZSBXaW5kb3dzIG5hdGl2ZSBUaHJlYWRTcGVjaWZpYyBpbXBsZW1lbnRhdGlvbi4KKyNl bmRpZgorCituYW1lc3BhY2UgV1RGIHsKKworbG9uZyBnX3Rsc19rZXlfY291bnQgPSAwOworRFdP UkQgZ190bHNfa2V5c1trTWF4VGxzS2V5U2l6ZV07CisKK3ZvaWQgVGhyZWFkU3BlY2lmaWNUaHJl YWRFeGl0KCkKK3sKKyAgICBmb3IgKGxvbmcgaSA9IDA7IGkgPCBnX3Rsc19rZXlfY291bnQ7IGkr KykgeworICAgICAgICBUaHJlYWRTcGVjaWZpYzxpbnQ+OjpEYXRhKiBkYXRhID0gc3RhdGljX2Nh c3Q8VGhyZWFkU3BlY2lmaWM8aW50Pjo6RGF0YSo+KFRsc0dldFZhbHVlKGdfdGxzX2tleXNbaV0p KTsKKyAgICAgICAgaWYgKGRhdGEpIHsKKyAgICAgICAgICAgIGRhdGEtPmRlc3RydWN0b3IoZGF0 YSk7CisgICAgICAgIH0KKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdURgpJbmRleDogSmF2 YVNjcmlwdENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlw dENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAJKHJldmlzaW9uIDM5NjMyKQorKysgSmF2YVNjcmlw dENvcmUvd3RmL1RocmVhZGluZ1dpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY0LDYgKzY0LDkg QEAKICNpbmNsdWRlICJUaHJlYWRpbmcuaCIKIAogI2luY2x1ZGUgIk1haW5UaHJlYWQuaCIKKyNp ZiAhVVNFKFBUSFJFQURTKSAmJiBQTEFURk9STShXSU5fT1MpCisjaW5jbHVkZSAiVGhyZWFkU3Bl Y2lmaWMuaCIKKyNlbmRpZgogI2luY2x1ZGUgPHByb2Nlc3MuaD4KICNpbmNsdWRlIDx3aW5kb3dz Lmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KQEAgLTE3NSw2ICsxNzgsMTEgQEAgc3RhdGlj IHVuc2lnbmVkIF9fc3RkY2FsbCB3dGZUaHJlYWRFbnRyeQogCiAgICAgdm9pZCogcmVzdWx0ID0g aW52b2NhdGlvbi5mdW5jdGlvbihpbnZvY2F0aW9uLmRhdGEpOwogCisjaWYgIVVTRShQVEhSRUFE UykgJiYgUExBVEZPUk0oV0lOX09TKQorICAgIC8vIERvIHRoZSBUTFMgY2xlYW51cC4KKyAgICBU aHJlYWRTcGVjaWZpY1RocmVhZEV4aXQoKTsKKyNlbmRpZgkKKwogICAgIHJldHVybiByZWludGVy cHJldF9jYXN0PHVuc2lnbmVkPihyZXN1bHQpOwogfQogCg== 26502 2009-01-07 12:55:40 -0800 2009-01-08 05:44:21 -0800 Proposed Patch ThreadSpecificWin32_7.txt text/plain 9134 jianli SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5NjgzKQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjIgQEAKKzIwMDktMDEtMDcgIEppYW4gTGkg IDxqaWFubGlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXaW4zMiBpbXBsZW1lbnRhdGlvbiBvZiBUaHJlYWRTcGVjaWZp Yy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjE0 CisKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2o6CisgICAg ICAgICogd3RmL1RocmVhZFNwZWNpZmljLmg6CisgICAgICAgIChXVEY6Ojo6VGhyZWFkU3BlY2lm aWMpOgorICAgICAgICAoV1RGOjo6On5UaHJlYWRTcGVjaWZpYyk6CisgICAgICAgIChXVEY6Ojo6 Z2V0KToKKyAgICAgICAgKFdURjo6OjpzZXQpOgorICAgICAgICAoV1RGOjo6OmRlc3Ryb3kpOgor ICAgICAgICAqIHd0Zi9UaHJlYWRTcGVjaWZpY1dpbi5jcHA6IEFkZGVkLgorICAgICAgICAoV1RG OjpUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQpOgorICAgICAgICAqIHd0Zi9UaHJlYWRpbmdXaW4u Y3BwOgorICAgICAgICAoV1RGOjp3dGZUaHJlYWRFbnRyeVBvaW50KToKKwogMjAwOS0wMS0wNiAg R2F2aW4gQmFycmFjbG91Z2ggIDxiYXJhY2xvdWdoQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBNYWNpZWogU3RhY2hvd2lhay4KSW5kZXg6IEphdmFTY3JpcHRDb3JlL0phdmFTY3Jp cHRDb3JlLnZjcHJvai9XVEYvV1RGLnZjcHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS52Y3Byb2ovV1RGL1dURi52Y3Byb2oJKHJldmlzaW9uIDM5NjgyKQor KysgSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUudmNwcm9qL1dURi9XVEYudmNwcm9qCSh3 b3JraW5nIGNvcHkpCkBAIC00MzEsNiArNDMxLDEwIEBACiAJCQk+DQogCQk8L0ZpbGU+DQogCQk8 RmlsZQ0KKwkJCVJlbGF0aXZlUGF0aD0iLi5cLi5cd3RmXFRocmVhZFNwZWNpZmljV2luLmNwcCIN CisJCQk+DQorCQk8L0ZpbGU+DQorCQk8RmlsZQ0KIAkJCVJlbGF0aXZlUGF0aD0iLi5cLi5cd3Rm XFRocmVhZFNwZWNpZmljLmgiDQogCQkJPg0KIAkJPC9GaWxlPg0KSW5kZXg6IEphdmFTY3JpcHRD b3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL3d0 Zi9UaHJlYWRTcGVjaWZpYy5oCShyZXZpc2lvbiAzOTY4MikKKysrIEphdmFTY3JpcHRDb3JlL3d0 Zi9UaHJlYWRTcGVjaWZpYy5oCSh3b3JraW5nIGNvcHkpCkBAIC0xLDUgKzEsNiBAQAogLyoKICAq IENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBD b3B5cmlnaHQgKEMpIDIwMDkgSmlhbiBMaSA8amlhbmxpQGNocm9taXVtLm9yZz4KICAqCiAgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjYsMTkgKzI3LDM2IEBACiAgKiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgog ICovCiAKKy8qIFRocmVhZCBsb2NhbCBzdG9yYWdlIGlzIGltcGxlbWVudGVkIGJ5IHVzaW5nIGVp dGhlciBwdGhyZWFkIEFQSSBvciBXaW5kb3dzCisgKiBuYXRpdmUgQVBJLiBUaGVyZSBpcyBzdWJ0 bGUgc2VtYW50aWMgZGlzY3JlcGFuY3kgZm9yIHRoZSBjbGVhbnVwIGZ1bmN0aW9uCisgKiBpbXBs ZW1lbnRhdGlvbiBhcyBub3RlZCBiZWxvdzoKKyAqICAgQCBJbiBwdGhyZWFkIGltcGxlbWVudGF0 aW9uLCB0aGUgZGVzdHJ1Y3RvciBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZAorICogICAgIHJlcGVh dGVkbHkgaWYgdGhlcmUgaXMgc3RpbGwgbm9uLU5VTEwgdmFsdWUgYXNzb2NpYXRlZCB3aXRoIHRo ZSBmdW5jdGlvbi4KKyAqICAgQCBJbiBXaW5kb3dzIG5hdGl2ZSBpbXBsZW1lbnRhdGlvbiwgdGhl IGRlc3RydWN0b3IgZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQKKyAqICAgICBvbmx5IG9uY2UuCisg KiBUaGlzIHNlbWFudGljIGRpc2NyZXBhbmN5IGRvZXMgbm90IGltcG9zZSBhbnkgcHJvYmxlbSBi ZWNhdXNlIG5vd2hlcmUgaW4KKyAqIFdlYktpdCB0aGUgcmVwZWF0ZWQgY2FsbCBiYWhhdmlvciBp cyB1dGlsaXplZC4KKyAqLworCiAjaWZuZGVmIFdURl9UaHJlYWRTcGVjaWZpY19oCiAjZGVmaW5l IFdURl9UaHJlYWRTcGVjaWZpY19oCiAKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KIAot I2lmIFVTRShQVEhSRUFEUykgfHwgUExBVEZPUk0oV0lOKQotLy8gV2luZG93cyBjdXJyZW50bHkg ZG9lc24ndCB1c2UgcHRocmVhZHMgZm9yIGJhc2ljIHRocmVhZGluZywgYnV0IGltcGxlbWVudGlu ZyBkZXN0cnVjdG9yIGZ1bmN0aW9ucyBpcyBlYXNpZXIKLS8vIHdpdGggcHRocmVhZHMsIHNvIHdl IHVzZSBpdCBoZXJlLgorI2lmIFVTRShQVEhSRUFEUykKICNpbmNsdWRlIDxwdGhyZWFkLmg+Cisj ZWxpZiBQTEFURk9STShXSU5fT1MpCisjaW5jbHVkZSA8d2luZG93cy5oPgogI2VuZGlmCiAKIG5h bWVzcGFjZSBXVEYgewogCisjaWYgIVVTRShQVEhSRUFEUykgJiYgUExBVEZPUk0oV0lOX09TKQor Ly8gVGhyZWFkU3BlY2lmaWNUaHJlYWRFeGl0IHNob3VsZCBiZSBjYWxsZWQgZWFjaCB0aW1lIHdo ZW4gYSB0aHJlYWQgaXMgZGV0YWNoZWQuCisvLyBUaGlzIGlzIGRvbmUgYXV0b21hdGljYWxseSBm b3IgdGhyZWFkcyBjcmVhdGVkIHdpdGggV1RGOjpjcmVhdGVUaHJlYWQuCit2b2lkIFRocmVhZFNw ZWNpZmljVGhyZWFkRXhpdCgpOworI2VuZGlmCisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNz IFRocmVhZFNwZWNpZmljIDogTm9uY29weWFibGUgewogcHVibGljOgogICAgIFRocmVhZFNwZWNp ZmljKCk7CkBAIC00OCwyMyArNjYsMzQgQEAgcHVibGljOgogICAgIH5UaHJlYWRTcGVjaWZpYygp OwogCiBwcml2YXRlOgorI2lmICFVU0UoUFRIUkVBRFMpICYmIFBMQVRGT1JNKFdJTl9PUykKKyAg ICBmcmllbmQgdm9pZCBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQoKTsKKyNlbmRpZgorICAgIAog ICAgIFQqIGdldCgpOwogICAgIHZvaWQgc2V0KFQqKTsKICAgICB2b2lkIHN0YXRpYyBkZXN0cm95 KHZvaWQqIHB0cik7CiAKLSNpZiBVU0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBV U0UoUFRIUkVBRFMpIHx8IFBMQVRGT1JNKFdJTl9PUykKICAgICBzdHJ1Y3QgRGF0YSA6IE5vbmNv cHlhYmxlIHsKICAgICAgICAgRGF0YShUKiB2YWx1ZSwgVGhyZWFkU3BlY2lmaWM8VD4qIG93bmVy KSA6IHZhbHVlKHZhbHVlKSwgb3duZXIob3duZXIpIHt9CiAKICAgICAgICAgVCogdmFsdWU7CiAg ICAgICAgIFRocmVhZFNwZWNpZmljPFQ+KiBvd25lcjsKKyNpZiAhVVNFKFBUSFJFQURTKQorICAg ICAgICB2b2lkICgqZGVzdHJ1Y3Rvcikodm9pZCopOworI2VuZGlmCiAgICAgfTsKKyNlbmRpZgog CisjaWYgVVNFKFBUSFJFQURTKQogICAgIHB0aHJlYWRfa2V5X3QgbV9rZXk7CisjZWxpZiBQTEFU Rk9STShXSU5fT1MpCisgICAgaW50IG1faW5kZXg7CiAjZW5kaWYKIH07CiAKLSNpZiBVU0UoUFRI UkVBRFMpIHx8IFBMQVRGT1JNKFdJTikKKyNpZiBVU0UoUFRIUkVBRFMpCiB0ZW1wbGF0ZTx0eXBl bmFtZSBUPgogaW5saW5lIFRocmVhZFNwZWNpZmljPFQ+OjpUaHJlYWRTcGVjaWZpYygpCiB7CkBA IC05MywyNCArMTIyLDgyIEBAIGlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpzZXQoVCog cHQKICAgICBwdGhyZWFkX3NldHNwZWNpZmljKG1fa2V5LCBuZXcgRGF0YShwdHIsIHRoaXMpKTsK IH0KIAorI2VsaWYgUExBVEZPUk0oV0lOX09TKQorCisvLyBUaGUgbWF4aW11bSBudW1iZXIgb2Yg VExTIGtleXMgdGhhdCBjYW4gYmUgY3JlYXRlZC4gRm9yIHNpbXBsaWZpY2F0aW9uLCB3ZSBhc3N1 bWUgdGhhdDoKKy8vIDEpIE9uY2UgdGhlIGluc3RhbmNlIG9mIFRocmVhZFNwZWNpZmljPD4gaXMg Y3JlYXRlZCwgaXQgd2lsbCBub3QgYmUgZGVzdHJ1Y3RlZCB1bnRpbCB0aGUgcHJvZ3JhbSBkaWVz LgorLy8gMikgV2UgZG8gbm90IG5lZWQgdG8gaG9sZCBtYW55IGluc3RhbmNlcyBvZiBUaHJlYWRT cGVjaWZpYzw+IGRhdGEuIFRoaXMgZml4ZWQgbnVtYmVyIHNob3VsZCBiZSBmYXIgZW5vdWdoLgor Y29uc3QgaW50IGtNYXhUbHNLZXlTaXplID0gMjU2OworCitleHRlcm4gbG9uZyBnX3Rsc19rZXlf Y291bnQ7CitleHRlcm4gRFdPUkQgZ190bHNfa2V5c1trTWF4VGxzS2V5U2l6ZV07CisKK3RlbXBs YXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VD46OlRocmVhZFNwZWNpZmlj KCkKKyAgICA6IG1faW5kZXgoLTEpCit7CisgICAgRFdPUkQgdGxzX2tleSA9IFRsc0FsbG9jKCk7 CisgICAgaWYgKHRsc19rZXkgPT0gVExTX09VVF9PRl9JTkRFWEVTKQorICAgICAgICBDUkFTSCgp OworCisgICAgbV9pbmRleCA9IEludGVybG9ja2VkSW5jcmVtZW50KCZnX3Rsc19rZXlfY291bnQp IC0gMTsKKyAgICBpZiAobV9pbmRleCA+PSBrTWF4VGxzS2V5U2l6ZSkKKyAgICAgICAgQ1JBU0go KTsKKyAgICBnX3Rsc19rZXlzW21faW5kZXhdID0gdGxzX2tleTsKK30KKwordGVtcGxhdGU8dHlw ZW5hbWUgVD4KK2lubGluZSBUaHJlYWRTcGVjaWZpYzxUPjo6flRocmVhZFNwZWNpZmljKCkKK3sK KyAgICAvLyBEb2VzIG5vdCBpbnZva2UgZGVzdHJ1Y3RvciBmdW5jdGlvbnMuIFRoZXkgd2lsbCBi ZSBjYWxsZWQgZnJvbSBUaHJlYWRTcGVjaWZpY1RocmVhZEV4aXQgd2hlbiB0aGUgdGhyZWFkIGlz IGRldGFjaGVkLgorICAgIFRsc0ZyZWUoZ190bHNfa2V5c1ttX2luZGV4XSk7Cit9CisKK3RlbXBs YXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgVCogVGhyZWFkU3BlY2lmaWM8VD46OmdldCgpCit7Cisg ICAgRGF0YSogZGF0YSA9IHN0YXRpY19jYXN0PERhdGEqPihUbHNHZXRWYWx1ZShnX3Rsc19rZXlz W21faW5kZXhdKSk7CisgICAgcmV0dXJuIGRhdGEgPyBkYXRhLT52YWx1ZSA6IDA7Cit9CisKK3Rl bXBsYXRlPHR5cGVuYW1lIFQ+CitpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6c2V0KFQq IHB0cikKK3sKKyAgICBBU1NFUlQoIWdldCgpKTsKKyAgICBEYXRhKiBkYXRhID0gbmV3IERhdGEo cHRyLCB0aGlzKTsKKyAgICBkYXRhLT5kZXN0cnVjdG9yID0gJlRocmVhZFNwZWNpZmljPFQ+Ojpk ZXN0cm95OworICAgIFRsc1NldFZhbHVlKGdfdGxzX2tleXNbbV9pbmRleF0sIGRhdGEpOworfQor CisjZWxzZQorI2Vycm9yIFRocmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhp cyBwbGF0Zm9ybS4KKyNlbmRpZgorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogaW5saW5lIHZvaWQg VGhyZWFkU3BlY2lmaWM8VD46OmRlc3Ryb3kodm9pZCogcHRyKQogewogICAgIERhdGEqIGRhdGEg PSBzdGF0aWNfY2FzdDxEYXRhKj4ocHRyKTsKIAorI2lmIFVTRShQVEhSRUFEUykKICAgICAvLyBX ZSB3YW50IGdldCgpIHRvIGtlZXAgd29ya2luZyB3aGlsZSBkYXRhIGRlc3RydWN0b3Igd29ya3Ms IGJlY2F1c2UgaXQgY2FuIGJlIGNhbGxlZCBpbmRpcmVjdGx5IGJ5IHRoZSBkZXN0cnVjdG9yLgog ICAgIC8vIFNvbWUgcHRocmVhZHMgaW1wbGVtZW50YXRpb25zIHplcm8gb3V0IHRoZSBwb2ludGVy IGJlZm9yZSBjYWxsaW5nIGRlc3Ryb3koKSwgc28gd2UgdGVtcG9yYXJpbHkgcmVzZXQgaXQuCiAg ICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9rZXksIHB0cik7CisjZW5kaWYK KyAgICAKICAgICBkYXRhLT52YWx1ZS0+flQoKTsKICAgICBmYXN0RnJlZShkYXRhLT52YWx1ZSk7 Ci0gICAgcHRocmVhZF9zZXRzcGVjaWZpYyhkYXRhLT5vd25lci0+bV9rZXksIDApOwotICAgIGRl bGV0ZSBkYXRhOwotfQogCisjaWYgVVNFKFBUSFJFQURTKQorICAgIHB0aHJlYWRfc2V0c3BlY2lm aWMoZGF0YS0+b3duZXItPm1fa2V5LCAwKTsKKyNlbGlmIFBMQVRGT1JNKFdJTl9PUykKKyAgICBU bHNTZXRWYWx1ZShnX3Rsc19rZXlzW2RhdGEtPm93bmVyLT5tX2luZGV4XSwgMCk7CiAjZWxzZQog I2Vycm9yIFRocmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9y bS4KICNlbmRpZgogCisgICAgZGVsZXRlIGRhdGE7Cit9CisKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+ CiBpbmxpbmUgVGhyZWFkU3BlY2lmaWM8VD46Om9wZXJhdG9yIFQqKCkKIHsKSW5kZXg6IEphdmFT Y3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpY1dpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNj cmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljV2luLmNwcAkocmV2aXNpb24gMCkKKysrIEphdmFT Y3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpY1dpbi5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgSmlhbiBMaSA8amlhbmxpQGNocm9t aXVtLm9yZz4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFu a2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0Eu CisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlRocmVhZFNwZWNp ZmljLmgiCisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisKKyNpZiBVU0UoUFRIUkVBRFMp CisjZXJyb3IgVGhpcyBmaWxlIHNob3VsZCBub3QgYmUgY29tcGlsZWQgYnkgcG9ydHMgdGhhdCBk byBub3QgdXNlIFdpbmRvd3MgbmF0aXZlIFRocmVhZFNwZWNpZmljIGltcGxlbWVudGF0aW9uLgor I2VuZGlmCisKK25hbWVzcGFjZSBXVEYgeworCitsb25nIGdfdGxzX2tleV9jb3VudCA9IDA7CitE V09SRCBnX3Rsc19rZXlzW2tNYXhUbHNLZXlTaXplXTsKKwordm9pZCBUaHJlYWRTcGVjaWZpY1Ro cmVhZEV4aXQoKQoreworICAgIGZvciAobG9uZyBpID0gMDsgaSA8IGdfdGxzX2tleV9jb3VudDsg aSsrKSB7CisJCS8vIFRoZSBsYXlvdXQgb2YgVGhyZWFkU3BlY2lmaWM8VD46OkRhdGEgZG9lcyBu b3QgZGVwZW5kIG9uIFQuIFNvIHdlIGFyZSBzYWZlIHRvIGRvIHRoZSBzdGF0aWMgY2FzdCB0byBU aHJlYWRTcGVjaWZpYzxpbnQ+IGluIG9yZGVyIHRvIGFjY2VzcyBpdHMgZGF0YSBtZW1iZXIuCisg ICAgICAgIFRocmVhZFNwZWNpZmljPGludD46OkRhdGEqIGRhdGEgPSBzdGF0aWNfY2FzdDxUaHJl YWRTcGVjaWZpYzxpbnQ+OjpEYXRhKj4oVGxzR2V0VmFsdWUoZ190bHNfa2V5c1tpXSkpOworICAg ICAgICBpZiAoZGF0YSkKKyAgICAgICAgICAgIGRhdGEtPmRlc3RydWN0b3IoZGF0YSk7CisgICAg fQorfQorCit9IC8vIG5hbWVzcGFjZSBXVEYKSW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9UaHJl YWRpbmdXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIEphdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRpbmdX aW4uY3BwCShyZXZpc2lvbiAzOTY4MikKKysrIEphdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRpbmdX aW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02NCw2ICs2NCw5IEBACiAjaW5jbHVkZSAiVGhyZWFk aW5nLmgiCiAKICNpbmNsdWRlICJNYWluVGhyZWFkLmgiCisjaWYgIVVTRShQVEhSRUFEUykgJiYg UExBVEZPUk0oV0lOX09TKQorI2luY2x1ZGUgIlRocmVhZFNwZWNpZmljLmgiCisjZW5kaWYKICNp bmNsdWRlIDxwcm9jZXNzLmg+CiAjaW5jbHVkZSA8d2luZG93cy5oPgogI2luY2x1ZGUgPHd0Zi9I YXNoTWFwLmg+CkBAIC0xNzUsNiArMTc4LDExIEBAIHN0YXRpYyB1bnNpZ25lZCBfX3N0ZGNhbGwg d3RmVGhyZWFkRW50cnkKIAogICAgIHZvaWQqIHJlc3VsdCA9IGludm9jYXRpb24uZnVuY3Rpb24o aW52b2NhdGlvbi5kYXRhKTsKIAorI2lmICFVU0UoUFRIUkVBRFMpICYmIFBMQVRGT1JNKFdJTl9P UykKKyAgICAvLyBEbyB0aGUgVExTIGNsZWFudXAuCisgICAgVGhyZWFkU3BlY2lmaWNUaHJlYWRF eGl0KCk7CisjZW5kaWYJCisKICAgICByZXR1cm4gcmVpbnRlcnByZXRfY2FzdDx1bnNpZ25lZD4o cmVzdWx0KTsKIH0KIAo=