mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-08 14:20:07 +00:00
222 lines
6.2 KiB
C
222 lines
6.2 KiB
C
/* Unit test for _dl_addr_inside_object.
|
|
Copyright (C) 2016-2024 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
|
|
<https://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>
|