Example #1
0
 def process_launch_o(self, localPath):
     # process launch command output redirect always goes to host the process is running on
     if lldb.remote_platform:
         # process launch -o requires a path that is valid on the target
         self.assertIsNotNone(lldb.remote_platform.GetWorkingDirectory())
         remote_path = lldbutil.append_to_process_working_directory("lldb-stdout-redirect.txt")
         self.runCmd('process launch -o {remote}'.format(remote=remote_path))
         # copy remote_path to local host
         self.runCmd('platform get-file {remote} "{local}"'.format(
             remote=remote_path, local=self.golden_filename))
     else:
         self.runCmd('process launch -o "{local}"'.format(local=self.golden_filename))
Example #2
0
    def launch_new_process_and_redirect_stdout(self):
        """Exercise SBTaget.Launch() API with redirected stdout."""
        exe = os.path.join(os.getcwd(), "a.out")

        # Create a target by the debugger.
        target = self.dbg.CreateTarget(exe)
        self.assertTrue(target, VALID_TARGET)

        # Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done.
        # We should still see the entire stdout redirected once the process is finished.
        line = line_number('main.c', '// a(3) -> c(3)')
        breakpoint = target.BreakpointCreateByLocation('main.c', line)

        # Now launch the process, do not stop at entry point, and redirect stdout to "stdout.txt" file.
        # The inferior should run to completion after "process.Continue()" call.
        local_path = "stdout.txt"
        if lldb.remote_platform:
            stdout_path = lldbutil.append_to_process_working_directory(
                "lldb-stdout-redirect.txt")
        else:
            stdout_path = local_path
        error = lldb.SBError()
        process = target.Launch(self.dbg.GetListener(), None, None, None,
                                stdout_path, None, None, 0, False, error)
        process.Continue()
        #self.runCmd("process status")
        if lldb.remote_platform:
            # copy output file to host
            lldb.remote_platform.Get(lldb.SBFileSpec(stdout_path),
                                     lldb.SBFileSpec(local_path))

        # The 'stdout.txt' file should now exist.
        self.assertTrue(
            os.path.isfile("stdout.txt"),
            "'stdout.txt' exists due to redirected stdout via SBTarget.Launch() API."
        )

        # Read the output file produced by running the program.
        with open('stdout.txt', 'r') as f:
            output = f.read()

        # Let's delete the 'stdout.txt' file as a cleanup step.
        try:
            os.remove("stdout.txt")
            pass
        except OSError:
            pass

        self.expect(output, exe=False, substrs=["a(1)", "b(2)", "a(3)"])
Example #3
0
 def process_launch_o(self, localPath):
     # process launch command output redirect always goes to host the process is running on
     if lldb.remote_platform:
         # process launch -o requires a path that is valid on the target
         self.assertIsNotNone(lldb.remote_platform.GetWorkingDirectory())
         remote_path = lldbutil.append_to_process_working_directory(
             "lldb-stdout-redirect.txt")
         self.runCmd(
             'process launch -o {remote}'.format(remote=remote_path))
         # copy remote_path to local host
         self.runCmd('platform get-file {remote} "{local}"'.format(
             remote=remote_path, local=self.golden_filename))
     else:
         self.runCmd('process launch -o "{local}"'.format(
             local=self.golden_filename))
Example #4
0
    def launch_new_process_and_redirect_stdout(self):
        """Exercise SBTaget.Launch() API with redirected stdout."""
        exe = os.path.join(os.getcwd(), "a.out")

        # Create a target by the debugger.
        target = self.dbg.CreateTarget(exe)
        self.assertTrue(target, VALID_TARGET)

        # Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done.
        # We should still see the entire stdout redirected once the process is finished.
        line = line_number('main.c', '// a(3) -> c(3)')
        breakpoint = target.BreakpointCreateByLocation('main.c', line)

        # Now launch the process, do not stop at entry point, and redirect stdout to "stdout.txt" file.
        # The inferior should run to completion after "process.Continue()" call.
        local_path = "stdout.txt";
        if lldb.remote_platform:
            stdout_path = lldbutil.append_to_process_working_directory("lldb-stdout-redirect.txt")
        else:
            stdout_path = local_path
        error = lldb.SBError()
        process = target.Launch (self.dbg.GetListener(), None, None, None, stdout_path, None, None, 0, False, error)
        process.Continue()
        #self.runCmd("process status")
        if lldb.remote_platform:
            # copy output file to host
            lldb.remote_platform.Get(lldb.SBFileSpec(stdout_path), lldb.SBFileSpec(local_path))

        # The 'stdout.txt' file should now exist.
        self.assertTrue(os.path.isfile("stdout.txt"),
                        "'stdout.txt' exists due to redirected stdout via SBTarget.Launch() API.")

        # Read the output file produced by running the program.
        with open('stdout.txt', 'r') as f:
            output = f.read()

        # Let's delete the 'stdout.txt' file as a cleanup step.
        try:
            os.remove("stdout.txt")
            pass
        except OSError:
            pass

        self.expect(output, exe=False,
            substrs = ["a(1)", "b(2)", "a(3)"])
    def setpgid(self):
        exe = os.path.join(os.getcwd(), 'a.out')

        # Use a file as a synchronization point between test and inferior.
        pid_file_path = lldbutil.append_to_process_working_directory(
                "pid_file_%d" % (int(time.time())))
        self.addTearDownHook(lambda: self.run_platform_command("rm %s" % (pid_file_path)))

        popen = self.spawnSubprocess(exe, [pid_file_path])
        self.addTearDownHook(self.cleanupSubprocesses)

        max_attempts = 5
        for i in range(max_attempts):
            err, retcode, msg = self.run_platform_command("ls %s" % pid_file_path)
            if err.Success() and retcode == 0:
                break
            else:
                print msg
            if i < max_attempts:
                # Exponential backoff!
                time.sleep(pow(2, i) * 0.25)
        else:
            self.fail("Child PID file %s not found even after %d attempts." % (pid_file_path, max_attempts))

        err, retcode, pid = self.run_platform_command("cat %s" % (pid_file_path))

        self.assertTrue(err.Success() and retcode == 0,
                "Failed to read file %s: %s, retcode: %d" % (pid_file_path, err.GetCString(), retcode))

        # make sure we cleanup the forked child also
        def cleanupChild():
            if lldb.remote_platform:
                lldb.remote_platform.Kill(int(pid))
            else:
                if os.path.exists("/proc/" + pid):
                    os.kill(int(pid), signal.SIGKILL)
        self.addTearDownHook(cleanupChild)

        # Create a target by the debugger.
        target = self.dbg.CreateTarget(exe)
        self.assertTrue(target, VALID_TARGET)

        listener = lldb.SBListener("my.attach.listener")
        error = lldb.SBError()
        process = target.AttachToProcessWithID(listener, int(pid), error)
        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

        # set a breakpoint just before the setpgid() call
        lldbutil.run_break_set_by_file_and_line(self, 'main.c', self.line, num_expected_locations=-1)

        thread = process.GetSelectedThread()

        # release the child from its loop
        self.expect("expr release_child_flag = 1", substrs = ["= 1"])
        process.Continue()

        # make sure the child's process group id is different from its pid
        self.expect("print (int)getpgid(0)", substrs = [pid], matching=False)

        # step over the setpgid() call
        thread.StepOver()
        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)

        # verify that the process group has been set correctly
        # this also checks that we are still in full control of the child
        self.expect("print (pid_t)getpgid(0)", substrs = [pid])

        # run to completion
        process.Continue()
        self.assertEqual(process.GetState(), lldb.eStateExited)
    def setpgid(self):
        exe = os.path.join(os.getcwd(), 'a.out')

        # Use a file as a synchronization point between test and inferior.
        pid_file_path = lldbutil.append_to_process_working_directory(
            "pid_file_%d" % (int(time.time())))
        self.addTearDownHook(
            lambda: self.run_platform_command("rm %s" % (pid_file_path)))

        popen = self.spawnSubprocess(exe, [pid_file_path])
        self.addTearDownHook(self.cleanupSubprocesses)

        max_attempts = 5
        for i in range(max_attempts):
            err, retcode, msg = self.run_platform_command("ls %s" %
                                                          pid_file_path)
            if err.Success() and retcode == 0:
                break
            else:
                print msg
            if i < max_attempts:
                # Exponential backoff!
                time.sleep(pow(2, i) * 0.25)
        else:
            self.fail("Child PID file %s not found even after %d attempts." %
                      (pid_file_path, max_attempts))

        err, retcode, pid = self.run_platform_command("cat %s" %
                                                      (pid_file_path))

        self.assertTrue(
            err.Success() and retcode == 0,
            "Failed to read file %s: %s, retcode: %d" %
            (pid_file_path, err.GetCString(), retcode))

        # make sure we cleanup the forked child also
        def cleanupChild():
            if lldb.remote_platform:
                lldb.remote_platform.Kill(int(pid))
            else:
                if os.path.exists("/proc/" + pid):
                    os.kill(int(pid), signal.SIGKILL)

        self.addTearDownHook(cleanupChild)

        # Create a target by the debugger.
        target = self.dbg.CreateTarget(exe)
        self.assertTrue(target, VALID_TARGET)

        listener = lldb.SBListener("my.attach.listener")
        error = lldb.SBError()
        process = target.AttachToProcessWithID(listener, int(pid), error)
        self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

        # set a breakpoint just before the setpgid() call
        lldbutil.run_break_set_by_file_and_line(self,
                                                'main.c',
                                                self.line,
                                                num_expected_locations=-1)

        thread = process.GetSelectedThread()
        # this gives a chance for the thread to exit the sleep syscall and sidesteps
        # <https://llvm.org/bugs/show_bug.cgi?id=23659> on linux
        thread.StepInstruction(False)

        # release the child from its loop
        self.expect("expr release_child_flag = 1", substrs=["= 1"])
        process.Continue()

        # make sure the child's process group id is different from its pid
        self.expect("print (int)getpgid(0)", substrs=[pid], matching=False)

        # step over the setpgid() call
        thread.StepOver()
        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)

        # verify that the process group has been set correctly
        # this also checks that we are still in full control of the child
        self.expect("print (pid_t)getpgid(0)", substrs=[pid])

        # run to completion
        process.Continue()
        self.assertEqual(process.GetState(), lldb.eStateExited)