Changes for Bug 17384

[ravitheja]

Summary

Virtual dynamic shared objects, or vdso files were
not loaded for Linux OS.In Bug 17384 the call
stack could not be unwinded from functions
residing in the vdso object.

This commit adds support for loading such files by
reading the Aux vectors since a vdso is invisibily
mapped to the inferiors address space and the
actual file is not present in the filesystem. The
presence of the vdso is detected by inspecting
the Aux vector for AT_SYSINFO_EHDR tag.

[tberghammer]

Looks good with a few minor suggestions inline

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

578–579

(nit): It isn't needed

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

91–95

I would suggest to merge these 2 with setting m_vdso_base to LLDB_INVALID_ADDRESS if we don't have a vdso

[clayborg]

I don't know anything about shared library loading on Linux.

[ovyalov]

Looks good - minor comments.

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

513

Please combine these 2 lines - FileSpec file_spec("[vdso]", false);

test/functionalities/inferior-assert/TestInferiorAssert.py

161

Could you store result of "i386" in self.getArchitecture() as temp variable outside of frames's loop?

[ravitheja]

Updates for previous comments.

[ovyalov]

Hi,

looks like TestHelloWorld and TestInferiorAssert began to fail after this change - http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake/builds/7880
Could you mark these tests as XFAILs for now?

[ravitheja]

Hi,
I actually checked these two testcases, they are passing at my end, could u send me the logs and the lldb executables , so that I can check at my end ? I think I can try to resolve it, in other case I will mark them as XFAILS.

[ovyalov]

You can get test logs from this link - https://pantheon.corp.google.com/storage/browser/lldb_test_traces/lldb-x86_64-ubuntu-14.04-cmake/?project=android-devtools-lldb-build

I suspect that there are a few problems here:

1. TestHelloWorld - there is a race within the test since inferior takes time to initialize llvm.org/pr24600
2. TestInferiorAssert - I think it's failing because of the way how GCE works with vdso

looking at: Stack traces for SBProcess: pid = 12637, state = stopped, threads = 1, executable = test_with_attach_to_process_with_id_api_dwarf
Stack trace for thread id=0x315d name=test_with_attac queue=None stop reason=signal
  frame #0: 0x000000f7788d80 None`None + -18446744069557678719



Expecting sub string: main.c:30
Not matched

FAIL

I propose to mark these tests back as XFAIL for i386 - create a new bug for GCE-related failures and mark TestHelloWorld as failing due llvm.org/pr24600 as well.

[ravitheja]

Hi,
This link for the traces needs a password, could u maybe provide me the login details or upload these somewhere else ? Also could u provide me the value of the AuxVectors during this test ?

BR,
A Ravi Theja

[ovyalov]

In D14118#277675, @ravitheja wrote:

Hi,
This link for the traces needs a password, could u maybe provide me the login details or upload these somewhere else ? Also could u provide me the value of the AuxVectors during this test ?

BR,
A Ravi Theja

Hi Ravi,

I shared logs archive with you in Google Drive - please try to download it.
Unfortunately, I don't have AUXV values for test - potentially, you can get GCE instance for yourself (https://cloud.google.com/compute/docs/linux-quickstart) and try to reproduce this problem on it.

[ravitheja]

Hello,
I tried making an instance on GCE but it asks for a credit card information which I unfortunately don’t have. Can you provide me maybe access through some other way ? btw I checked the logs u sent me and the vdso is being loaded but the unwinding till main is diferent from what I see on the Ubuntu machine I have.

BR,
A Ravi Theja

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

protected:
     lldb::addr_t m_entry_point;
 
     /// Auxiliary vector of the inferior process.
     std::unique_ptr<AuxVector> m_auxv;
 
     /// Rendezvous breakpoint.
     lldb::break_id_t m_dyld_bid;
 
+    /// Contains AT_SYSINFO_EHDR, which means a vDSO has been
+    /// mapped to the address space
+    bool m_contains_vdso;
+
+    lldb::addr_t m_vdso_base;
+
     /// Loaded module list. (link map for each module)
     std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>> m_loaded_modules;
 
     /// Enables a breakpoint on a function called by the runtime
     /// linker each time a module is loaded or unloaded.
     virtual void
     SetRendezvousBreakpoint();
 
protected:
     lldb::addr_t
     ComputeLoadOffset();
 
     /// Computes a value for m_entry_point returning the computed address on
     /// success and LLDB_INVALID_ADDRESS on failure.
     lldb::addr_t
     GetEntryPoint();
 
+    /// Evaluate if Aux vectors contain vDSO information
+    /// in case they do, read and assign the address to m_vdso_base
+    void
+    EvalVdsoStatus();
+
     /// Loads Module from inferior process.
     void
     ResolveExecutableModule(lldb::ModuleSP &module_sp);
 
 private:
     DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
 #endif // liblldb_DynamicLoaderPOSIXDYLD_h_

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

 }
 
 DynamicLoaderPOSIXDYLD::DynamicLoaderPOSIXDYLD(Process *process)
     : DynamicLoader(process),
       m_rendezvous(process),
       m_load_offset(LLDB_INVALID_ADDRESS),
       m_entry_point(LLDB_INVALID_ADDRESS),
       m_auxv(),
-      m_dyld_bid(LLDB_INVALID_BREAK_ID)
+      m_dyld_bid(LLDB_INVALID_BREAK_ID),
+      m_contains_vdso(false),
+      m_vdso_base(LLDB_INVALID_ADDRESS)
 {
 }
 
 DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD()
 {
     if (m_dyld_bid != LLDB_INVALID_BREAK_ID)
     {
         m_process->GetTarget().RemoveBreakpointByID (m_dyld_bid);
DynamicLoaderPOSIXDYLD::DidAttach()
     ModuleSP executable_sp = GetTargetExecutable ();
     ResolveExecutableModule (executable_sp);
 
     // find the main process load offset
     addr_t load_offset = ComputeLoadOffset ();
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " executable '%s', load_offset 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, executable_sp ? executable_sp->GetFileSpec().GetPath().c_str () : "<null executable>", load_offset);
 
+    EvalVdsoStatus();
+
     // if we dont have a load address we cant re-base
     bool rebase_exec = (load_offset == LLDB_INVALID_ADDRESS) ? false : true;
 
     // if we have a valid executable
     if (executable_sp.get())
     {
         lldb_private::ObjectFile * obj = executable_sp->GetObjectFile();
         if (obj)
DynamicLoaderPOSIXDYLD::DidLaunch()
 
     ModuleSP executable;
     addr_t load_offset;
 
     m_auxv.reset(new AuxVector(m_process));
 
     executable = GetTargetExecutable();
     load_offset = ComputeLoadOffset();
+    EvalVdsoStatus();
 
     if (executable.get() && load_offset != LLDB_INVALID_ADDRESS)
     {
         ModuleList module_list;
         module_list.Append(executable);
         UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
 
         if (log)
if (!m_rendezvous.Resolve())
                         __FUNCTION__);
         return;
     }
 
     // The rendezvous class doesn't enumerate the main module, so track
     // that ourselves here.
     ModuleSP executable = GetTargetExecutable();
     m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
-
+    if (m_contains_vdso)
+    {
+        FileSpec file_spec;
+        file_spec.SetFile("[vdso]", false);
+        ModuleSP module_sp = LoadModuleAtAddress(file_spec, LLDB_INVALID_ADDRESS, m_vdso_base, false);
+        if (module_sp.get())
+        {
+            module_list.Append(module_sp);
+        }
+    }
     for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
     {
         ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
         if (module_sp.get())
         {
             module_list.Append(module_sp);
         }
         else
DynamicLoaderPOSIXDYLD::ComputeLoadOffset()
 
     if (!file_entry.IsValid())
         return LLDB_INVALID_ADDRESS;
             
     m_load_offset = virt_entry - file_entry.GetFileAddress();
     return m_load_offset;
 }
 
+void
+DynamicLoaderPOSIXDYLD::EvalVdsoStatus()
+{
+    AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AT_SYSINFO_EHDR);
+
+    if (I != m_auxv->end())
+    {
+        m_contains_vdso = true;
+        m_vdso_base = I->value;
+    }
+
+    return;
+}
+
 addr_t
 DynamicLoaderPOSIXDYLD::GetEntryPoint()
 {
     if (m_entry_point != LLDB_INVALID_ADDRESS)
         return m_entry_point;
 
     if (m_auxv.get() == NULL)
         return LLDB_INVALID_ADDRESS;

test/functionalities/inferior-assert/TestInferiorAssert.py

 """Test that lldb functions correctly after the inferior has asserted."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, time
 import lldb, lldbutil, lldbplatformutil
 from lldbtest import *
 
 class AssertingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836
     def test_inferior_asserting_register(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_registers()
 
-    @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.build()
         self.inferior_asserting_disassemble()
 
     @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
-    @expectedFailurei386('llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly')
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_expr()
 
-    @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""
         self.build()
         self.inferior_asserting_step()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
def inferior_asserting_disassemble(self):
         self.check_stop_reason()
 
         process = target.GetProcess()
         self.assertTrue(process.IsValid(), "current process is valid")
 
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid(), "current thread is valid")
 
+        lastframeID = thread.GetFrameAtIndex(thread.GetNumFrames() - 1).GetFrameID()
+
         # lldb should be able to disassemble frames from the inferior after asserting.
         for frame in thread:
             self.assertTrue(frame.IsValid(), "current frame is valid")
 
             self.runCmd("frame select " + str(frame.GetFrameID()), RUN_SUCCEEDED)
 
             # Don't expect the function name to be in the disassembly as the assert
             # function might be a no-return function where the PC is past the end
             # of the function and in the next function. We also can't back the PC up
             # because we don't know how much to back it up by on targets with opcodes
             # that have differing sizes
             pc_backup_offset = 1
             if frame.GetFrameID() == 0:
                 pc_backup_offset = 0
+            if "i386" in self.getArchitecture():
+                if lastframeID == frame.GetFrameID():
+                    pc_backup_offset = 0
             self.expect("disassemble -a %s" % (frame.GetPC() - pc_backup_offset),
                     substrs = ['<+0>: '])
 
     def check_expr_in_main(self, thread):
         depth = thread.GetNumFrames()
         for i in range(depth):
             frame = thread.GetFrameAtIndex(i)
             self.assertTrue(frame.IsValid(), "current frame is valid")

test/python_api/hello_world/TestHelloWorld.py

def test_with_process_launch_api(self):
             from lldbutil import stop_reason_to_str
             self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
                       stop_reason_to_str(thread.GetStopReason()))
 
         # The breakpoint should have a hit count of 1.
         self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
 
     @add_test_categories(['pyapi'])
-    @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     @expectedFailureWindows("llvm.org/pr24600")
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         # Spawn a new process
def test_with_attach_to_process_with_id_api(self):
         # Let's check the stack traces of the attached process.
         import lldbutil
         stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
         self.expect(stacktraces, exe=False,
             substrs = ['main.c:%d' % self.line2,
                        '(int)argc=3'])
 
     @add_test_categories(['pyapi'])
-    @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     @expectedFailureWindows("llvm.org/pr24600")
     def test_with_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         # Spawn a new process