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))
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 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))
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)