| /* Unit test for _dl_addr_inside_object. |
| Copyright (C) 2016-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <link.h> |
| #include <elf.h> |
| #include <libc-symbols.h> |
| |
| extern int _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr); |
| |
| static int |
| do_test (void) |
| { |
| int ret, err = 0; |
| ElfW(Addr) addr; |
| struct link_map map; |
| ElfW(Phdr) header; |
| map.l_phdr = &header; |
| map.l_phnum = 1; |
| map.l_addr = 0x0; |
| /* Segment spans 0x2000 -> 0x4000. */ |
| header.p_vaddr = 0x2000; |
| header.p_memsz = 0x2000; |
| header.p_type = PT_LOAD; |
| /* Address is above the segment e.g. > 0x4000. */ |
| addr = 0x5000; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: Above: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: Above: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: Above: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is inside the segment e.g. 0x2000 < addr < 0x4000. */ |
| addr = 0x3000; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("FAIL: Inside: Address is detected as outside the segment.\n"); |
| err++; |
| break; |
| case 1: |
| printf ("PASS: Inside: Address is detected as inside the segment.\n"); |
| break; |
| default: |
| printf ("FAIL: Inside: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is below the segment e.g. < 0x2000. */ |
| addr = 0x1000; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: Below: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: Below: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: Below: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is in the segment and addr == p_vaddr. */ |
| addr = 0x2000; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("FAIL: At p_vaddr: Address is detected as outside the segment.\n"); |
| err++; |
| break; |
| case 1: |
| printf ("PASS: At p_vaddr: Address is detected as inside the segment.\n"); |
| break; |
| default: |
| printf ("FAIL: At p_vaddr: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is in the segment and addr == p_vaddr + p_memsz - 1. */ |
| addr = 0x2000 + 0x2000 - 0x1; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("FAIL: At p_memsz-1: Address is detected as outside the segment.\n"); |
| err++; |
| break; |
| case 1: |
| printf ("PASS: At p_memsz-1: Address is detected as inside the segment.\n"); |
| break; |
| default: |
| printf ("FAIL: At p_memsz-1: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is outside the segment and addr == p_vaddr + p_memsz. */ |
| addr = 0x2000 + 0x2000; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: At p_memsz: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: At p_memsz: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: At p_memsz: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is outside the segment and p_vaddr at maximum address. */ |
| addr = 0x0 - 0x2; |
| header.p_vaddr = 0x0 - 0x1; |
| header.p_memsz = 0x1; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: At max: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: At max: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: At max: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is outside the segment and p_vaddr at minimum address. */ |
| addr = 0x1; |
| header.p_vaddr = 0x0; |
| header.p_memsz = 0x1; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: At min: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: At min: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: At min: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Address is always inside the segment with p_memsz at max. */ |
| addr = 0x0; |
| header.p_vaddr = 0x0; |
| header.p_memsz = 0x0 - 0x1; |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("FAIL: At maxmem: Address is detected as outside the segment.\n"); |
| err++; |
| break; |
| case 1: |
| printf ("PASS: At maxmem: Address is detected as inside the segment.\n"); |
| break; |
| default: |
| printf ("FAIL: At maxmem: Invalid return value.\n"); |
| exit (1); |
| } |
| /* Attempt to wrap addr into the segment. |
| Pick a load address in the middle of the address space. |
| Place the test address at 0x0 so it wraps to the middle again. */ |
| map.l_addr = 0x0 - 0x1; |
| map.l_addr = map.l_addr / 2; |
| addr = 0; |
| /* Setup a segment covering 1/2 the address space. */ |
| header.p_vaddr = 0x0; |
| header.p_memsz = 0x0 - 0x1 - map.l_addr; |
| /* No matter where you place addr everything is shifted modulo l_addr |
| and even with this underflow you're always 1 byte away from being |
| in the range. */ |
| ret = _dl_addr_inside_object (&map, addr); |
| switch (ret) |
| { |
| case 0: |
| printf ("PASS: Underflow: Address is detected as outside the segment.\n"); |
| break; |
| case 1: |
| printf ("FAIL: Underflow: Address is detected as inside the segment.\n"); |
| err++; |
| break; |
| default: |
| printf ("FAIL: Underflow: Invalid return value.\n"); |
| exit (1); |
| } |
| |
| return err; |
| } |
| |
| #include <support/test-driver.c> |