1 /* Unit test for _dl_addr_inside_object.
2 Copyright (C) 2016-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <link.h>
22 #include <elf.h>
23 #include <libc-symbols.h>
24
25 extern int _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr);
26
27 static int
28 do_test (void)
29 {
30 int ret, err = 0;
31 ElfW(Addr) addr;
32 struct link_map map;
33 ElfW(Phdr) header;
34 map.l_phdr = &header;
35 map.l_phnum = 1;
36 map.l_addr = 0x0;
37 /* Segment spans 0x2000 -> 0x4000. */
38 header.p_vaddr = 0x2000;
39 header.p_memsz = 0x2000;
40 header.p_type = PT_LOAD;
41 /* Address is above the segment e.g. > 0x4000. */
42 addr = 0x5000;
43 ret = _dl_addr_inside_object (&map, addr);
44 switch (ret)
45 {
46 case 0:
47 printf ("PASS: Above: Address is detected as outside the segment.\n");
48 break;
49 case 1:
50 printf ("FAIL: Above: Address is detected as inside the segment.\n");
51 err++;
52 break;
53 default:
54 printf ("FAIL: Above: Invalid return value.\n");
55 exit (1);
56 }
57 /* Address is inside the segment e.g. 0x2000 < addr < 0x4000. */
58 addr = 0x3000;
59 ret = _dl_addr_inside_object (&map, addr);
60 switch (ret)
61 {
62 case 0:
63 printf ("FAIL: Inside: Address is detected as outside the segment.\n");
64 err++;
65 break;
66 case 1:
67 printf ("PASS: Inside: Address is detected as inside the segment.\n");
68 break;
69 default:
70 printf ("FAIL: Inside: Invalid return value.\n");
71 exit (1);
72 }
73 /* Address is below the segment e.g. < 0x2000. */
74 addr = 0x1000;
75 ret = _dl_addr_inside_object (&map, addr);
76 switch (ret)
77 {
78 case 0:
79 printf ("PASS: Below: Address is detected as outside the segment.\n");
80 break;
81 case 1:
82 printf ("FAIL: Below: Address is detected as inside the segment.\n");
83 err++;
84 break;
85 default:
86 printf ("FAIL: Below: Invalid return value.\n");
87 exit (1);
88 }
89 /* Address is in the segment and addr == p_vaddr. */
90 addr = 0x2000;
91 ret = _dl_addr_inside_object (&map, addr);
92 switch (ret)
93 {
94 case 0:
95 printf ("FAIL: At p_vaddr: Address is detected as outside the segment.\n");
96 err++;
97 break;
98 case 1:
99 printf ("PASS: At p_vaddr: Address is detected as inside the segment.\n");
100 break;
101 default:
102 printf ("FAIL: At p_vaddr: Invalid return value.\n");
103 exit (1);
104 }
105 /* Address is in the segment and addr == p_vaddr + p_memsz - 1. */
106 addr = 0x2000 + 0x2000 - 0x1;
107 ret = _dl_addr_inside_object (&map, addr);
108 switch (ret)
109 {
110 case 0:
111 printf ("FAIL: At p_memsz-1: Address is detected as outside the segment.\n");
112 err++;
113 break;
114 case 1:
115 printf ("PASS: At p_memsz-1: Address is detected as inside the segment.\n");
116 break;
117 default:
118 printf ("FAIL: At p_memsz-1: Invalid return value.\n");
119 exit (1);
120 }
121 /* Address is outside the segment and addr == p_vaddr + p_memsz. */
122 addr = 0x2000 + 0x2000;
123 ret = _dl_addr_inside_object (&map, addr);
124 switch (ret)
125 {
126 case 0:
127 printf ("PASS: At p_memsz: Address is detected as outside the segment.\n");
128 break;
129 case 1:
130 printf ("FAIL: At p_memsz: Address is detected as inside the segment.\n");
131 err++;
132 break;
133 default:
134 printf ("FAIL: At p_memsz: Invalid return value.\n");
135 exit (1);
136 }
137 /* Address is outside the segment and p_vaddr at maximum address. */
138 addr = 0x0 - 0x2;
139 header.p_vaddr = 0x0 - 0x1;
140 header.p_memsz = 0x1;
141 ret = _dl_addr_inside_object (&map, addr);
142 switch (ret)
143 {
144 case 0:
145 printf ("PASS: At max: Address is detected as outside the segment.\n");
146 break;
147 case 1:
148 printf ("FAIL: At max: Address is detected as inside the segment.\n");
149 err++;
150 break;
151 default:
152 printf ("FAIL: At max: Invalid return value.\n");
153 exit (1);
154 }
155 /* Address is outside the segment and p_vaddr at minimum address. */
156 addr = 0x1;
157 header.p_vaddr = 0x0;
158 header.p_memsz = 0x1;
159 ret = _dl_addr_inside_object (&map, addr);
160 switch (ret)
161 {
162 case 0:
163 printf ("PASS: At min: Address is detected as outside the segment.\n");
164 break;
165 case 1:
166 printf ("FAIL: At min: Address is detected as inside the segment.\n");
167 err++;
168 break;
169 default:
170 printf ("FAIL: At min: Invalid return value.\n");
171 exit (1);
172 }
173 /* Address is always inside the segment with p_memsz at max. */
174 addr = 0x0;
175 header.p_vaddr = 0x0;
176 header.p_memsz = 0x0 - 0x1;
177 ret = _dl_addr_inside_object (&map, addr);
178 switch (ret)
179 {
180 case 0:
181 printf ("FAIL: At maxmem: Address is detected as outside the segment.\n");
182 err++;
183 break;
184 case 1:
185 printf ("PASS: At maxmem: Address is detected as inside the segment.\n");
186 break;
187 default:
188 printf ("FAIL: At maxmem: Invalid return value.\n");
189 exit (1);
190 }
191 /* Attempt to wrap addr into the segment.
192 Pick a load address in the middle of the address space.
193 Place the test address at 0x0 so it wraps to the middle again. */
194 map.l_addr = 0x0 - 0x1;
195 map.l_addr = map.l_addr / 2;
196 addr = 0;
197 /* Setup a segment covering 1/2 the address space. */
198 header.p_vaddr = 0x0;
199 header.p_memsz = 0x0 - 0x1 - map.l_addr;
200 /* No matter where you place addr everything is shifted modulo l_addr
201 and even with this underflow you're always 1 byte away from being
202 in the range. */
203 ret = _dl_addr_inside_object (&map, addr);
204 switch (ret)
205 {
206 case 0:
207 printf ("PASS: Underflow: Address is detected as outside the segment.\n");
208 break;
209 case 1:
210 printf ("FAIL: Underflow: Address is detected as inside the segment.\n");
211 err++;
212 break;
213 default:
214 printf ("FAIL: Underflow: Invalid return value.\n");
215 exit (1);
216 }
217
218 return err;
219 }
220
221 #include <support/test-driver.c>