diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/functionalities/process_group')
3 files changed, 198 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/functionalities/process_group/Makefile b/packages/Python/lldbsuite/test/functionalities/process_group/Makefile new file mode 100644 index 0000000..0d70f25 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/process_group/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../make + +C_SOURCES := main.c + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py b/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py new file mode 100644 index 0000000..25be37b --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py @@ -0,0 +1,107 @@ +"""Test that we handle inferiors which change their process group""" + +from __future__ import print_function + + + +import os +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class ChangeProcessGroupTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.c. + self.line = line_number('main.c', '// Set breakpoint here') + + @skipIfFreeBSD # Times out on FreeBSD llvm.org/pr23731 + @skipIfWindows # setpgid call does not exist on Windows + @expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16]) + def test_setpgid(self): + self.build() + 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 + value = thread.GetSelectedFrame().EvaluateExpression("release_child_flag = 1") + self.assertTrue(value.IsValid() and value.GetValueAsUnsigned(0) == 1); + process.Continue() + + # make sure the child's process group id is different from its pid + value = thread.GetSelectedFrame().EvaluateExpression("(int)getpgid(0)") + self.assertTrue(value.IsValid()) + self.assertNotEqual(value.GetValueAsUnsigned(0), int(pid)); + + # 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 + value = thread.GetSelectedFrame().EvaluateExpression("(int)getpgid(0)") + self.assertTrue(value.IsValid()) + self.assertEqual(value.GetValueAsUnsigned(0), int(pid)); + + # run to completion + process.Continue() + self.assertEqual(process.GetState(), lldb.eStateExited) + + def run_platform_command(self, cmd): + platform = self.dbg.GetSelectedPlatform() + shell_command = lldb.SBPlatformShellCommand(cmd) + err = platform.Run(shell_command) + return (err, shell_command.GetStatus(), shell_command.GetOutput()) diff --git a/packages/Python/lldbsuite/test/functionalities/process_group/main.c b/packages/Python/lldbsuite/test/functionalities/process_group/main.c new file mode 100644 index 0000000..c730c62 --- /dev/null +++ b/packages/Python/lldbsuite/test/functionalities/process_group/main.c @@ -0,0 +1,86 @@ +#include <stdio.h> +#include <unistd.h> +#include <sys/wait.h> + +#if defined(__linux__) +#include <sys/prctl.h> +#endif + +volatile int release_child_flag = 0; + +int main(int argc, char const *argv[]) +{ + pid_t child = fork(); + if (child == -1) + { + perror("fork"); + return 1; + } + + if (child > 0) + { // parent + if (argc < 2) + { + fprintf(stderr, "Need pid filename.\n"); + return 2; + } + + // Let the test suite know the child's pid. + FILE *pid_file = fopen(argv[1], "w"); + if (pid_file == NULL) + { + perror("fopen"); + return 3; + } + + fprintf(pid_file, "%d\n", child); + if (fclose(pid_file) == EOF) + { + perror("fclose"); + return 4; + } + + // And wait for the child to finish it's work. + int status = 0; + pid_t wpid = wait(&status); + if (wpid == -1) + { + perror("wait"); + return 5; + } + if (wpid != child) + { + fprintf(stderr, "wait() waited for wrong child\n"); + return 6; + } + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + { + fprintf(stderr, "child did not exit correctly\n"); + return 7; + } + } + else + { // child +#if defined(__linux__) + // Immediately enable any ptracer so that we can allow the stub attach + // operation to succeed. Some Linux kernels are locked down so that + // only an ancestor process can be a ptracer of a process. This disables that + // restriction. Without it, attach-related stub tests will fail. +#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY) + // For now we execute on best effort basis. If this fails for + // some reason, so be it. + const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0); + (void) prctl_result; +#endif +#endif + + while (! release_child_flag) // Wait for debugger to attach + sleep(1); + + printf("Child's previous process group is: %d\n", getpgid(0)); + setpgid(0, 0); // Set breakpoint here + printf("Child's process group set to: %d\n", getpgid(0)); + } + + return 0; +} |
