1 files changed, 165 insertions, 85 deletions

diff --git a/linden/indra/newview/llwindebug.cpp b/linden/indra/newview/llwindebug.cpp
index 7d44fcd..b595073 100644
--- a/linden/indra/newview/llwindebug.cpp
+++ b/linden/indra/newview/llwindebug.cpp
@@ -122,7 +122,9 @@ MODULE32_NEST	Module32Next_;
 #define NL                              L"\r\n" //new line
 
 BOOL WINAPI Get_Module_By_Ret_Addr(PBYTE Ret_Addr, LPWSTR Module_Name, PBYTE & Module_Addr);
-
+void WINAPI Get_Call_Stack(const EXCEPTION_RECORD* exception_record, 
+                                                   const CONTEXT* context_record, 
+                                                   LLSD& info);
 
 void printError( CHAR* msg )
 {
@@ -185,69 +187,6 @@ BOOL GetProcessThreadIDs(DWORD process_id, std::vector<DWORD>& thread_ids)
   return( TRUE );
 }
 
-void WINAPI GetCallStackData(const CONTEXT* context_struct, LLSD& info)
-{       
-    // Fill Str with call stack info.
-    // pException can be either GetExceptionInformation() or NULL.
-    // If pException = NULL - get current call stack.
-
-    LPWSTR      Module_Name = new WCHAR[MAX_PATH];
-        PBYTE   Module_Addr = 0;
-        
-        typedef struct STACK
-        {
-                STACK * Ebp;
-                PBYTE   Ret_Addr;
-                DWORD   Param[0];
-        } STACK, * PSTACK;
-
-        PSTACK  Ebp;
-
-    if(context_struct)
-    {
-        Ebp = (PSTACK)context_struct->Ebp;
-    }
-    else
-    {
-        // The context struct is NULL, 
-        // so we will use the current stack.
-        Ebp = (PSTACK)&context_struct - 1;
-
-        // Skip frame of GetCallStackData().
-                if (!IsBadReadPtr(Ebp, sizeof(PSTACK)))
-                        Ebp = Ebp->Ebp;         //caller ebp
-    }
-
-        // Trace CALL_TRACE_MAX calls maximum - not to exceed DUMP_SIZE_MAX.
-        // Break trace on wrong stack frame.
-        for (int Ret_Addr_I = 0, i = 0;
-                (Ret_Addr_I < CALL_TRACE_MAX) && !IsBadReadPtr(Ebp, sizeof(PSTACK)) && !IsBadCodePtr(FARPROC(Ebp->Ret_Addr));
-                Ret_Addr_I++, Ebp = Ebp->Ebp, ++i)
-        {
-                // If module with Ebp->Ret_Addr found.
-
-                if (Get_Module_By_Ret_Addr(Ebp->Ret_Addr, Module_Name, Module_Addr))
-                {
-                        // Save module's address and full path.
-                        info["CallStack"][i]["ModuleName"] = ll_convert_wide_to_string(Module_Name);
-                        info["CallStack"][i]["ModuleAddress"] = (int)Module_Addr;
-                        info["CallStack"][i]["CallOffset"] = (int)(Ebp->Ret_Addr - Module_Addr);
-
-                        LLSD params;
-                        // Save 5 params of the call. We don't know the real number of params.
-                        if (!IsBadReadPtr(Ebp, sizeof(PSTACK) + 5 * sizeof(DWORD)))
-                        {
-                                for(int j = 0; j < 5; ++j)
-                                {
-                                        params[j] = (int)Ebp->Param[j];
-                                }
-                        }
-                        info["CallStack"][i]["Parameters"] = params;
-                }
-                info["CallStack"][i]["ReturnAddress"] = (int)Ebp->Ret_Addr;                     
-        }
-}
-
 BOOL GetThreadCallStack(DWORD thread_id, LLSD& info)
 {
     if(GetCurrentThreadId() == thread_id)
@@ -272,7 +211,7 @@ BOOL GetThreadCallStack(DWORD thread_id, LLSD& info)
         context_struct.ContextFlags = CONTEXT_FULL;
         if(GetThreadContext(thread_handle, &context_struct))
         {
-            GetCallStackData(&context_struct, info);
+            Get_Call_Stack(NULL, &context_struct, info);
             result = true;
         }
         ResumeThread(thread_handle);
@@ -327,16 +266,98 @@ BOOL WINAPI Get_Module_By_Ret_Addr(PBYTE Ret_Addr, LPWSTR Module_Name, PBYTE & M
         return found;
 } //Get_Module_By_Ret_Addr
 
+bool has_valid_call_before(PDWORD cur_stack_loc)
+{
+        PBYTE p_first_byte = (PBYTE)(*cur_stack_loc - 1);
+        PBYTE p_second_byte = (PBYTE)(*cur_stack_loc -2);
+        PBYTE p_fifth_byte = (PBYTE)(*cur_stack_loc - 5);
+        PBYTE p_sixth_byte = (PBYTE)(*cur_stack_loc - 6);
+
+        // make sure we can read it
+        if(IsBadReadPtr(p_sixth_byte, 6 * sizeof(BYTE)))
+        {
+                return false;
+        }
+
+        // check for 9a + 4 bytes
+        if(*p_fifth_byte == 0x9A)
+        {
+                return true;
+        }
+
+        // Check for E8 + 4 bytes and last byte is 00 or FF
+        if(*p_fifth_byte == 0xE8 && (*p_first_byte == 0x00 || *p_first_byte == 0xFF))
+        {
+                return true;
+        }
+        
+        // the other is six bytes
+        if(*p_sixth_byte == 0xFF || *p_second_byte == 0xFF)
+        {
+                return true;
+        }
+
+        return false;
+}
+
+PBYTE get_valid_frame(PBYTE esp)
+{
+        PDWORD cur_stack_loc = NULL;
+        const int max_search = 400;
+        WCHAR   module_name[MAX_PATH];
+        PBYTE   module_addr = 0;
+
+        // round to highest multiple of four
+        esp = (esp + (4 - ((int)esp % 4)) % 4);
+
+        // scroll through stack a few hundred places.
+        for (cur_stack_loc = (PDWORD) esp; cur_stack_loc < (PDWORD)esp + max_search; cur_stack_loc += 1)
+        {
+                // if you can read the pointer,
+                if (IsBadReadPtr(cur_stack_loc, sizeof(PDWORD)))
+                {
+                        continue;
+                }
+
+                //  check if it's in a module
+                if (!Get_Module_By_Ret_Addr((PBYTE)*cur_stack_loc, module_name, module_addr))
+                {
+                        continue;
+                }
+
+                // check if the code before the instruction ptr is a call 
+                if(!has_valid_call_before(cur_stack_loc))
+                {
+                        continue;
+                }
+                
+                // if these all pass, return that ebp, otherwise continue till we're dead
+                return (PBYTE)(cur_stack_loc - 1);
+        }
+
+        return NULL;
+}
 //******************************************************************
-void WINAPI Get_Call_Stack(PEXCEPTION_POINTERS pException, LLSD& info)
+void WINAPI Get_Call_Stack(const EXCEPTION_RECORD* exception_record, 
+                                                   const CONTEXT* context_record, 
+                                                   LLSD& info)
 //******************************************************************
 // Fill Str with call stack info.
 // pException can be either GetExceptionInformation() or NULL.
 // If pException = NULL - get current call stack.
-{       
+{
         LPWSTR  Module_Name = new WCHAR[MAX_PATH];
         PBYTE   Module_Addr = 0;
-        
+        LLSD params;
+        PBYTE   Esp = NULL;
+        LLSD tmp_info;
+
+        bool fake_frame = false;
+        bool ebp_used = false;
+        const int HEURISTIC_MAX_WALK = 10;
+        int heuristic_walk_i = 0;
+        int Ret_Addr_I = 0;
+
         typedef struct STACK
         {
                 STACK * Ebp;
@@ -347,15 +368,23 @@ void WINAPI Get_Call_Stack(PEXCEPTION_POINTERS pException, LLSD& info)
         STACK   Stack = {0, 0};
         PSTACK  Ebp;
 
-        if (pException)         //fake frame for exception address
+        if (exception_record && context_record)         //fake frame for exception address
         {
-                Stack.Ebp = (PSTACK)pException->ContextRecord->Ebp;
-                Stack.Ret_Addr = (PBYTE)pException->ExceptionRecord->ExceptionAddress;
+                Stack.Ebp = (PSTACK)(context_record->Ebp);
+                Stack.Ret_Addr = (PBYTE)exception_record->ExceptionAddress;
                 Ebp = &Stack;
+                Esp = (PBYTE) context_record->Esp;
+                fake_frame = true;
+        }
+        else if(context_record)
+        {
+        Ebp = (PSTACK)(context_record->Ebp);
+                Esp = (PBYTE)(context_record->Esp);
         }
         else
         {
-                Ebp = (PSTACK)&pException - 1;  //frame addr of Get_Call_Stack()
+                Ebp = (PSTACK)&exception_record - 1;    //frame addr of Get_Call_Stack()
+                Esp = (PBYTE)&exception_record;
 
                 // Skip frame of Get_Call_Stack().
                 if (!IsBadReadPtr(Ebp, sizeof(PSTACK)))
@@ -364,22 +393,21 @@ void WINAPI Get_Call_Stack(PEXCEPTION_POINTERS pException, LLSD& info)
 
         // Trace CALL_TRACE_MAX calls maximum - not to exceed DUMP_SIZE_MAX.
         // Break trace on wrong stack frame.
-        for (int Ret_Addr_I = 0, i = 0;
-                (Ret_Addr_I < CALL_TRACE_MAX) && !IsBadReadPtr(Ebp, sizeof(PSTACK)) && !IsBadCodePtr(FARPROC(Ebp->Ret_Addr));
-                Ret_Addr_I++, Ebp = Ebp->Ebp, ++i)
+        for (Ret_Addr_I = 0;
+                heuristic_walk_i < HEURISTIC_MAX_WALK && 
+                Ret_Addr_I < CALL_TRACE_MAX && !IsBadReadPtr(Ebp, sizeof(PSTACK)) && !IsBadCodePtr(FARPROC(Ebp->Ret_Addr));
+                Ret_Addr_I++)
         {
                 // If module with Ebp->Ret_Addr found.
-
                 if (Get_Module_By_Ret_Addr(Ebp->Ret_Addr, Module_Name, Module_Addr))
                 {
                         // Save module's address and full path.
-                        info["CallStack"][i]["ModuleName"] = ll_convert_wide_to_string(Module_Name);
-                        info["CallStack"][i]["ModuleAddress"] = (int)Module_Addr;
-                        info["CallStack"][i]["CallOffset"] = (int)(Ebp->Ret_Addr - Module_Addr);
+                        tmp_info["CallStack"][Ret_Addr_I]["ModuleName"] = ll_convert_wide_to_string(Module_Name);
+                        tmp_info["CallStack"][Ret_Addr_I]["ModuleAddress"] = (int)Module_Addr;
+                        tmp_info["CallStack"][Ret_Addr_I]["CallOffset"] = (int)(Ebp->Ret_Addr - Module_Addr);
 
-                        LLSD params;
                         // Save 5 params of the call. We don't know the real number of params.
-                        if (pException && !Ret_Addr_I)  //fake frame for exception address
+                        if (fake_frame && !Ret_Addr_I)  //fake frame for exception address
                                 params[0] = "Exception Offset";
                         else if (!IsBadReadPtr(Ebp, sizeof(PSTACK) + 5 * sizeof(DWORD)))
                         {
@@ -388,10 +416,62 @@ void WINAPI Get_Call_Stack(PEXCEPTION_POINTERS pException, LLSD& info)
                                         params[j] = (int)Ebp->Param[j];
                                 }
                         }
-                        info["CallStack"][i]["Parameters"] = params;
+                        tmp_info["CallStack"][Ret_Addr_I]["Parameters"] = params;
+                }
+
+                tmp_info["CallStack"][Ret_Addr_I]["ReturnAddress"] = (int)Ebp->Ret_Addr;
+
+                // get ready for next frame
+                // Set ESP to just after return address.  Not the real esp, but just enough after the return address
+                if(!fake_frame) {
+                        Esp = (PBYTE)Ebp + 8;
+                } 
+                else
+                {
+                        fake_frame = false;
+                }
+
+                // is next ebp valid?
+                // only run if we've never found a good ebp
+                if(     !ebp_used && 
+                        (IsBadReadPtr(Ebp->Ebp, sizeof(PSTACK)) || 
+                        IsBadCodePtr(FARPROC(Ebp->Ebp->Ret_Addr)) ||
+                        !Get_Module_By_Ret_Addr(Ebp->Ebp->Ret_Addr, Module_Name, Module_Addr)))
+                {
+                        heuristic_walk_i++;
+                        PBYTE new_ebp = get_valid_frame(Esp);
+                        if (new_ebp != NULL)
+                        {
+                                Ebp = (PSTACK)new_ebp;
+                        }
+                }
+                else
+                {
+                        ebp_used = true;
+                        Ebp = Ebp->Ebp;
                 }
-                info["CallStack"][i]["ReturnAddress"] = (int)Ebp->Ret_Addr;                     
         }
+
+        // Now go back through and edit out heuristic stacks that could very well be bogus.
+        // Leave the top and the last stack chosen by the heuristic, however.
+        if(heuristic_walk_i > 2)
+        {
+                info["CallStack"][0] = tmp_info["CallStack"][0];
+                std::string ttest = info["CallStack"][0]["ModuleName"];
+                for(int cur_frame = 1; 
+                        (cur_frame + heuristic_walk_i - 2 < Ret_Addr_I); 
+                        ++cur_frame)
+                {
+                        // edit out the middle heuristic found frames
+                        info["CallStack"][cur_frame] = tmp_info["CallStack"][cur_frame + heuristic_walk_i - 2];
+                }
+        }
+        else
+        {
+                info = tmp_info;
+        }
+
+
 } //Get_Call_Stack
 
 //***********************************
@@ -508,7 +588,7 @@ LLSD WINAPI Get_Exception_Info(PEXCEPTION_POINTERS pException)
         } //if (pException)
         
         // Save call stack info.
-        Get_Call_Stack(pException, info);
+        Get_Call_Stack(pException->ExceptionRecord, pException->ContextRecord, info);
 
         return info;
 } //Get_Exception_Info
@@ -565,7 +645,7 @@ LPTOP_LEVEL_EXCEPTION_FILTER WINAPI MyDummySetUnhandledExceptionFilter(
 
         llinfos << "Someone tried to set the exception filter. Listing call stack modules" << llendl;
         LLSD cs_info;
-        GetCallStackData(NULL, cs_info);
+        Get_Call_Stack(NULL, NULL, cs_info);
         
         if(cs_info.has("CallStack") && cs_info["CallStack"].isArray())
         {