| /* |
| * Check decoding of set_thread_area and get_thread_area syscalls on x86 |
| * architecture. |
| * |
| * Copyright (c) 2018 The strace developers. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "tests.h" |
| |
| #include <asm/unistd.h> |
| |
| #if defined __NR_get_thread_area && defined __NR_set_thread_area \ |
| && defined HAVE_STRUCT_USER_DESC |
| |
| # include <assert.h> |
| # include <errno.h> |
| # include <stdbool.h> |
| # include <stdio.h> |
| # include <stdint.h> |
| # include <string.h> |
| # include <unistd.h> |
| |
| # include "print_user_desc.c" |
| |
| long errnum; |
| |
| static void |
| printptr(kernel_ulong_t ptr, const char *ptr_str) |
| { |
| if (ptr_str) |
| printf("%s", ptr_str); |
| else |
| printf("%#llx", zero_extend_signed_to_ull(ptr)); |
| } |
| |
| /** |
| * Perform set_thread_area call along with printing the expected output. |
| * |
| * @param ptr_val Pointer to thread area argument. |
| * @param ptr_str Explicit string representation of the argument. |
| * @param valid Whether argument points to the valid memory and its contents |
| * should be decoded. |
| * @param entry_number_str explicit decoding of the entry_number field. |
| */ |
| static long |
| set_thread_area(kernel_ulong_t ptr_val, const char *ptr_str, bool valid, |
| const char *entry_number_str) |
| { |
| struct user_desc *ptr = (struct user_desc *) (uintptr_t) ptr_val; |
| long rc = -1; |
| int saved_errno; |
| |
| rc = syscall(__NR_set_thread_area, ptr_val); |
| saved_errno = errno; |
| printf("set_thread_area("); |
| |
| if (valid) |
| print_user_desc(ptr, entry_number_str); |
| else |
| printptr(ptr_val, ptr_str); |
| |
| errno = saved_errno; |
| printf(") = %s", sprintrc(rc)); |
| if (!rc) |
| printf(" (entry_number=%u)", ptr->entry_number); |
| |
| puts(""); |
| |
| return rc; |
| } |
| |
| /** |
| * Perform get_thread_are call along with printing the expected output and |
| * checking the result against the argument of the previous set_thread_area |
| * call, if it had place. |
| * |
| * @param ptr_val Pointer to thread area argument. |
| * @param ptr_str Explicit string representation of the argument. |
| * @param valid Whether argument points to the valid memory and its contents |
| * should be decoded. |
| * @param set_rc Return code of the previous set_thread_area call. |
| * @param expected The value of the argument passed to the previous |
| * set_thread_area call. |
| */ |
| static void |
| get_thread_area(kernel_ulong_t ptr_val, const char *ptr_str, bool valid, |
| long set_rc, kernel_ulong_t expected) |
| { |
| struct user_desc *ptr = (struct user_desc *) (uintptr_t) ptr_val; |
| struct user_desc *expected_ptr = |
| (struct user_desc *) (uintptr_t) expected; |
| int saved_errno; |
| long rc; |
| |
| rc = syscall(__NR_get_thread_area, ptr_val); |
| saved_errno = errno; |
| |
| printf("get_thread_area("); |
| |
| if (valid && !rc) { |
| if (!set_rc) { |
| assert(ptr->entry_number == expected_ptr->entry_number); |
| assert(ptr->base_addr == expected_ptr->base_addr); |
| assert(ptr->limit == expected_ptr->limit); |
| assert(ptr->seg_32bit == expected_ptr->seg_32bit); |
| assert(ptr->contents == expected_ptr->contents); |
| assert(ptr->read_exec_only == |
| expected_ptr->read_exec_only); |
| assert(ptr->limit_in_pages == |
| expected_ptr->limit_in_pages); |
| assert(ptr->seg_not_present == |
| expected_ptr->seg_not_present); |
| assert(ptr->useable == expected_ptr->useable); |
| /* |
| * We do not check lm as 32-bit processes ignore it, and |
| * only 32-bit processes can successfully execute |
| * get_thread_area. |
| */ |
| } |
| |
| print_user_desc(ptr, |
| (int) ptr->entry_number == -1 ? "-1" : NULL); |
| } else { |
| printptr(ptr_val, ptr_str); |
| } |
| |
| errno = saved_errno; |
| printf(") = %s\n", sprintrc(rc)); |
| } |
| |
| int main(void) |
| { |
| struct user_desc *ta1 = tail_alloc(sizeof(*ta1)); |
| struct user_desc *ta2 = tail_alloc(sizeof(*ta2)); |
| unsigned *bogus_entry_number = tail_alloc(sizeof(*bogus_entry_number)); |
| |
| long set_rc = -1; |
| |
| /* |
| * Let's do some weird syscall, it will mark the beginning of our |
| * expected output. |
| */ |
| syscall(__NR_reboot, 0, 0, 0, 0); |
| |
| set_rc = set_thread_area((uintptr_t) ARG_STR(NULL), false, NULL); |
| get_thread_area((uintptr_t) ARG_STR(NULL), false, set_rc, |
| (uintptr_t) NULL); |
| |
| set_rc = set_thread_area(-1, NULL, false, NULL); |
| get_thread_area(-1, NULL, false, set_rc, -1); |
| |
| fill_memory(ta1, sizeof(*ta1)); |
| fill_memory_ex(ta2, sizeof(*ta2), 0xA5, 0x5A); |
| |
| set_thread_area((uintptr_t) (ta1 + 1), NULL, false, NULL); |
| |
| set_thread_area((uintptr_t) bogus_entry_number, NULL, false, NULL); |
| |
| set_thread_area((uintptr_t) ta1, NULL, true, NULL); |
| |
| ta1->entry_number = -1; |
| ta1->base_addr = 0; |
| ta1->limit = 0; |
| ta1->contents = 1; |
| ta1->seg_32bit = 1; |
| ta1->seg_not_present = 0; |
| |
| set_rc = set_thread_area((uintptr_t) ta1, NULL, true, "-1"); |
| |
| *bogus_entry_number = 2718281828U; |
| get_thread_area((uintptr_t) bogus_entry_number, |
| "{entry_number=2718281828, ...}", |
| false, set_rc, (uintptr_t) ta1); |
| |
| /* That one should return -EFAULT on i386 */ |
| *bogus_entry_number = 12; |
| get_thread_area((uintptr_t) bogus_entry_number, |
| "{entry_number=12, ...}", |
| false, set_rc, (uintptr_t) ta1); |
| |
| ta2->entry_number = 3141592653U; |
| get_thread_area((uintptr_t) ta2, "{entry_number=3141592653, ...}", |
| false, set_rc, (uintptr_t) ta1); |
| |
| ta2->entry_number = -1; |
| get_thread_area((uintptr_t) ta2, "{entry_number=-1, ...}", |
| false, set_rc, (uintptr_t) ta1); |
| |
| ta2->entry_number = ta1->entry_number; |
| assert(set_rc == 0 || (int) ta2->entry_number == -1); |
| get_thread_area((uintptr_t) ta2, "{entry_number=-1, ...}", |
| true, set_rc, (uintptr_t) ta1); |
| |
| puts("+++ exited with 0 +++"); |
| |
| return 0; |
| } |
| |
| #else |
| |
| SKIP_MAIN_UNDEFINED("__NR_get_thread_area && __NR_set_thread_area" |
| " && HAVE_STRUCT_USER_DESC"); |
| |
| #endif |