diff options
Diffstat (limited to 'libbacktrace/backtrace_test.c')
| -rw-r--r-- | libbacktrace/backtrace_test.c | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/libbacktrace/backtrace_test.c b/libbacktrace/backtrace_test.c new file mode 100644 index 0000000..6155c9b --- /dev/null +++ b/libbacktrace/backtrace_test.c @@ -0,0 +1,239 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <sys/types.h> +#include <signal.h> +#include <sys/ptrace.h> +#include <sys/wait.h> +#include <errno.h> +#include <unistd.h> +#include <inttypes.h> + +#include <backtrace/backtrace.h> + +#define FINISH(pid) dump_frames(&backtrace); if (pid < 0) exit(1); else return false; + +#define WAIT_INTERVAL_USECS 1000 + +// Prototypes for functions in the test library. +int test_level_one(int, int, int, int, bool (*)(pid_t)); + +int test_recursive_call(int, bool (*)(pid_t)); + +void dump_frames(const backtrace_t* backtrace) { + for (size_t i = 0; i < backtrace->num_frames; i++) { + printf("%zu ", i); + if (backtrace->frames[i].map_name) { + printf("%s", backtrace->frames[i].map_name); + } else { + printf("<unknown>"); + } + if (backtrace->frames[i].proc_name) { + printf(" %s", backtrace->frames[i].proc_name); + if (backtrace->frames[i].proc_offset) { + printf("+%" PRIuPTR, backtrace->frames[i].proc_offset); + } + } + printf("\n"); + } +} + +void wait_for_stop(pid_t pid, size_t max_usecs_to_wait) { + siginfo_t si; + size_t usecs_waited = 0; + + while (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) < 0 && (errno == EINTR || errno == ESRCH)) { + if (usecs_waited >= max_usecs_to_wait) { + printf("The process did not get to a stopping point in %zu usecs.\n", + usecs_waited); + break; + } + usleep(WAIT_INTERVAL_USECS); + usecs_waited += WAIT_INTERVAL_USECS; + } +} + +bool check_frame(const backtrace_t* backtrace, size_t frame_num, + const char* expected_name) { + if (backtrace->frames[frame_num].proc_name == NULL) { + printf(" Frame %zu function name expected %s, real value is NULL.\n", + frame_num, expected_name); + return false; + } + if (strcmp(backtrace->frames[frame_num].proc_name, expected_name) != 0) { + printf(" Frame %zu function name expected %s, real value is %s.\n", + frame_num, expected_name, backtrace->frames[frame_num].proc_name); + return false; + } + return true; +} + +bool verify_level_backtrace(pid_t pid) { + const char* test_type; + if (pid < 0) { + test_type = "current"; + } else { + test_type = "running"; + } + + backtrace_t backtrace; + if (!backtrace_get_data(&backtrace, pid)) { + printf(" backtrace_get_data failed on %s process.\n", test_type); + FINISH(pid); + } + + if (backtrace.num_frames == 0) { + printf(" backtrace_get_data returned no frames for %s process.\n", + test_type); + FINISH(pid); + } + + // Look through the frames starting at the highest to find the + // frame we want. + size_t frame_num = 0; + for (size_t i = backtrace.num_frames-1; i > 2; i--) { + if (backtrace.frames[i].proc_name != NULL && + strcmp(backtrace.frames[i].proc_name, "test_level_one") == 0) { + frame_num = i; + break; + } + } + if (!frame_num) { + printf(" backtrace_get_data did not include the test_level_one frame.\n"); + FINISH(pid); + } + + if (!check_frame(&backtrace, frame_num, "test_level_one")) { + FINISH(pid); + } + if (!check_frame(&backtrace, frame_num-1, "test_level_two")) { + FINISH(pid); + } + if (!check_frame(&backtrace, frame_num-2, "test_level_three")) { + FINISH(pid); + } + if (!check_frame(&backtrace, frame_num-3, "test_level_four")) { + FINISH(pid); + } + backtrace_free_data(&backtrace); + + return true; +} + +bool verify_max_backtrace(pid_t pid) { + const char* test_type; + if (pid < 0) { + test_type = "current"; + } else { + test_type = "running"; + } + + backtrace_t backtrace; + if (!backtrace_get_data(&backtrace, pid)) { + printf(" backtrace_get_data failed on %s process.\n", test_type); + FINISH(pid); + } + + if (backtrace.num_frames != MAX_BACKTRACE_FRAMES) { + printf(" backtrace_get_data %s process max frame check failed:\n", + test_type); + printf(" Expected num frames to be %zu, found %zu\n", + MAX_BACKTRACE_FRAMES, backtrace.num_frames); + FINISH(pid); + } + backtrace_free_data(&backtrace); + + return true; +} + +void verify_proc_test(pid_t pid, bool (*verify_func)(pid_t)) { + printf(" Waiting 5 seconds for process to get to infinite loop.\n"); + sleep(5); + if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) { + printf("Failed to attach to pid %d\n", pid); + kill(pid, SIGKILL); + exit(1); + } + + // Wait up to 1 second for the process to get to a point that we can trace it. + wait_for_stop(pid, 1000000); + + bool pass = verify_func(pid); + if (ptrace(PTRACE_DETACH, pid, 0, 0) != 0) { + printf("Failed to detach from pid %d\n", pid); + kill(pid, SIGKILL); + exit(1); + } + + kill(pid, SIGKILL); + int status; + if (waitpid(pid, &status, 0) != pid) { + printf("Forked process did not terminate properly.\n"); + exit(1); + } + + if (!pass) { + exit(1); + } +} + +int main() { + printf("Running level test on current process...\n"); + int value = test_level_one(1, 2, 3, 4, verify_level_backtrace); + if (value == 0) { + printf("This should never happen.\n"); + exit(1); + } + printf(" Passed.\n"); + + printf("Running max level test on current process...\n"); + value = test_recursive_call(MAX_BACKTRACE_FRAMES+10, verify_max_backtrace); + if (value == 0) { + printf("This should never happen.\n"); + exit(1); + } + printf(" Passed.\n"); + + printf("Running level test on process...\n"); + pid_t pid; + if ((pid = fork()) == 0) { + value = test_level_one(1, 2, 3, 4, NULL); + if (value == 0) { + printf("This should never happen.\n"); + } + exit(1); + } + verify_proc_test(pid, verify_level_backtrace); + printf(" Passed.\n"); + + printf("Running max frame test on process...\n"); + if ((pid = fork()) == 0) { + value = test_recursive_call(MAX_BACKTRACE_FRAMES+10, NULL); + if (value == 0) { + printf("This should never happen.\n"); + } + exit(1); + } + verify_proc_test(pid, verify_max_backtrace); + printf(" Passed.\n"); + + printf("All tests passed.\n"); + return 0; +} |