1 /* pseudo-reloc.c
2
3 Contributed by Egor Duda <deo@logos-m.ru>
4 Modified by addition of runtime_pseudo_reloc version 2
5 by Kai Tietz <kai.tietz@onevision.com>
6
7 THIS SOFTWARE IS NOT COPYRIGHTED
8
9 This source code is offered for use in the public domain. You may
10 use, modify or distribute it freely.
11
12 This code is distributed in the hope that it will be useful but
13 WITHOUT ANY WARRANTY. ALL WARRENTIES, EXPRESS OR IMPLIED ARE HEREBY
14 DISCLAMED. This includes but is not limited to warrenties of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 */
17
18 //#include <windows.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <stdarg.h>
22 #include <memory.h>
23 #include <internal.h>
24
25 #if defined(__CYGWIN__)
26 #include <wchar.h>
27 #include <ntdef.h>
28 #include <sys/cygwin.h>
29 /* copied from winsup.h */
30 # define NO_COPY __attribute__((nocommon)) __attribute__((section(".data_cygwin_nocopy")))
31 /* custom status code: */
32 #define STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION ((NTSTATUS) 0xe0000269)
33 #define SHORT_MSG_BUF_SZ 128
34 #else
35 # define NO_COPY
36 #endif
37
38 #ifdef __GNUC__
39 #define ATTRIBUTE_NORETURN __attribute__ ((noreturn))
40 #else
41 #define ATTRIBUTE_NORETURN
42 #endif
43
44 #ifndef __MINGW_LSYMBOL
45 #define __MINGW_LSYMBOL(sym) sym
46 #endif
47
48 extern char __RUNTIME_PSEUDO_RELOC_LIST__;
49 extern char __RUNTIME_PSEUDO_RELOC_LIST_END__;
50 extern char __MINGW_LSYMBOL(_image_base__);
51
52 void _pei386_runtime_relocator (void);
53
54 /* v1 relocation is basically:
55 * *(base + .target) += .addend
56 * where (base + .target) is always assumed to point
57 * to a DWORD (4 bytes).
58 */
59 typedef struct {
60 DWORD addend;
61 DWORD target;
62 } runtime_pseudo_reloc_item_v1;
63
64 /* v2 relocation is more complex. In effect, it is
65 * *(base + .target) += *(base + .sym) - (base + .sym)
66 * with care taken in both reading, sign extension, and writing
67 * because .flags may indicate that (base + .target) may point
68 * to a BYTE, WORD, DWORD, or QWORD (w64).
69 */
70 typedef struct {
71 DWORD sym;
72 DWORD target;
73 DWORD flags;
74 } runtime_pseudo_reloc_item_v2;
75
76 typedef struct {
77 DWORD magic1;
78 DWORD magic2;
79 DWORD version;
80 } runtime_pseudo_reloc_v2;
81
82 static void ATTRIBUTE_NORETURN
__report_error(const char * msg,...)83 __report_error (const char *msg, ...)
84 {
85 #ifdef __CYGWIN__
86 /* This function is used to print short error messages
87 * to stderr, which may occur during DLL initialization
88 * while fixing up 'pseudo' relocations. This early, we
89 * may not be able to use cygwin stdio functions, so we
90 * use the win32 WriteFile api. This should work with both
91 * normal win32 console IO handles, redirected ones, and
92 * cygwin ptys.
93 */
94 char buf[SHORT_MSG_BUF_SZ];
95 wchar_t module[MAX_PATH];
96 char * posix_module = NULL;
97 static const char UNKNOWN_MODULE[] = "<unknown module>: ";
98 static const size_t UNKNOWN_MODULE_LEN = sizeof (UNKNOWN_MODULE) - 1;
99 static const char CYGWIN_FAILURE_MSG[] = "Cygwin runtime failure: ";
100 static const size_t CYGWIN_FAILURE_MSG_LEN = sizeof (CYGWIN_FAILURE_MSG) - 1;
101 DWORD len;
102 DWORD done;
103 va_list args;
104 HANDLE errh = GetStdHandle (STD_ERROR_HANDLE);
105 ssize_t modulelen = GetModuleFileNameW (NULL, module, sizeof (module));
106
107 if (errh == INVALID_HANDLE_VALUE)
108 cygwin_internal (CW_EXIT_PROCESS,
109 STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
110 1);
111
112 if (modulelen > 0)
113 posix_module = cygwin_create_path (CCP_WIN_W_TO_POSIX, module);
114
115 va_start (args, msg);
116 len = (DWORD) vsnprintf (buf, SHORT_MSG_BUF_SZ, msg, args);
117 va_end (args);
118 buf[SHORT_MSG_BUF_SZ-1] = '\0'; /* paranoia */
119
120 if (posix_module)
121 {
122 WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
123 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
124 WriteFile (errh, (PCVOID)posix_module,
125 strlen(posix_module), &done, NULL);
126 WriteFile (errh, (PCVOID)": ", 2, &done, NULL);
127 WriteFile (errh, (PCVOID)buf, len, &done, NULL);
128 free (posix_module);
129 }
130 else
131 {
132 WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
133 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
134 WriteFile (errh, (PCVOID)UNKNOWN_MODULE,
135 UNKNOWN_MODULE_LEN, &done, NULL);
136 WriteFile (errh, (PCVOID)buf, len, &done, NULL);
137 }
138 WriteFile (errh, (PCVOID)"\n", 1, &done, NULL);
139
140 cygwin_internal (CW_EXIT_PROCESS,
141 STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
142 1);
143 /* not reached, but silences noreturn warning */
144 abort ();
145 #else
146 va_list argp;
147 va_start (argp, msg);
148 # ifdef __MINGW64_VERSION_MAJOR
149 __mingw_fprintf (stderr, "Mingw-w64 runtime failure:\n");
150 __mingw_vfprintf (stderr, msg, argp);
151 # else
152 fprintf (stderr, "Mingw runtime failure:\n");
153 vfprintf (stderr, msg, argp);
154 #endif
155 va_end (argp);
156 abort ();
157 #endif
158 }
159
160 /* For mingw-w64 we have additional helpers to get image information
161 on runtime. This allows us to cache for pseudo-relocation pass
162 the temporary access of code/read-only sections.
163 This step speeds up pseudo-relocation pass. */
164 #ifdef __MINGW64_VERSION_MAJOR
165 extern int __mingw_GetSectionCount (void);
166 extern PIMAGE_SECTION_HEADER __mingw_GetSectionForAddress (LPVOID p);
167 extern PBYTE _GetPEImageBase (void);
168
169 typedef struct sSecInfo {
170 /* Keeps altered section flags, or zero if nothing was changed. */
171 DWORD old_protect;
172 PBYTE sec_start;
173 PIMAGE_SECTION_HEADER hash;
174 } sSecInfo;
175
176 static sSecInfo *the_secs = NULL;
177 static int maxSections = 0;
178
179 static void
mark_section_writable(LPVOID addr)180 mark_section_writable (LPVOID addr)
181 {
182 MEMORY_BASIC_INFORMATION b;
183 PIMAGE_SECTION_HEADER h;
184 int i;
185
186 for (i = 0; i < maxSections; i++)
187 {
188 if (the_secs[i].sec_start <= ((LPBYTE) addr)
189 && ((LPBYTE) addr) < (the_secs[i].sec_start + the_secs[i].hash->Misc.VirtualSize))
190 return;
191 }
192 h = __mingw_GetSectionForAddress (addr);
193 if (!h)
194 {
195 __report_error ("Address %p has no image-section", addr);
196 return;
197 }
198 the_secs[i].hash = h;
199 the_secs[i].old_protect = 0;
200 the_secs[i].sec_start = _GetPEImageBase () + h->VirtualAddress;
201
202 if (!VirtualQuery (the_secs[i].sec_start, &b, sizeof(b)))
203 {
204 __report_error (" VirtualQuery failed for %d bytes at address %p",
205 (int) h->Misc.VirtualSize, the_secs[i].sec_start);
206 return;
207 }
208
209 if (b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE)
210 {
211 if (!VirtualProtect (b.BaseAddress, b.RegionSize,
212 PAGE_EXECUTE_READWRITE,
213 &the_secs[i].old_protect))
214 __report_error (" VirtualProtect failed with code 0x%x",
215 (int) GetLastError ());
216 }
217 ++maxSections;
218 return;
219 }
220
221 static void
restore_modified_sections(void)222 restore_modified_sections (void)
223 {
224 int i;
225 MEMORY_BASIC_INFORMATION b;
226 DWORD oldprot;
227
228 for (i = 0; i < maxSections; i++)
229 {
230 if (the_secs[i].old_protect == 0)
231 continue;
232 if (!VirtualQuery (the_secs[i].sec_start, &b, sizeof(b)))
233 {
234 __report_error (" VirtualQuery failed for %d bytes at address %p",
235 (int) the_secs[i].hash->Misc.VirtualSize,
236 the_secs[i].sec_start);
237 return;
238 }
239 VirtualProtect (b.BaseAddress, b.RegionSize, the_secs[i].old_protect,
240 &oldprot);
241 }
242 }
243
244 #endif /* __MINGW64_VERSION_MAJOR */
245
246 /* This function temporarily marks the page containing addr
247 * writable, before copying len bytes from *src to *addr, and
248 * then restores the original protection settings to the page.
249 *
250 * Using this function eliminates the requirement with older
251 * pseudo-reloc implementations, that sections containing
252 * pseudo-relocs (such as .text and .rdata) be permanently
253 * marked writable. This older behavior sabotaged any memory
254 * savings achieved by shared libraries on win32 -- and was
255 * slower, too. However, on cygwin as of binutils 2.20 the
256 * .text section is still marked writable, and the .rdata section
257 * is folded into the (writable) .data when --enable-auto-import.
258 */
259 static void
__write_memory(void * addr,const void * src,size_t len)260 __write_memory (void *addr, const void *src, size_t len)
261 {
262 MEMORY_BASIC_INFORMATION b;
263 DWORD oldprot;
264 int call_unprotect = 0;
265
266 if (!len)
267 return;
268
269 #ifdef __MINGW64_VERSION_MAJOR
270 mark_section_writable ((LPVOID) addr);
271 #endif
272
273 if (!VirtualQuery (addr, &b, sizeof(b)))
274 {
275 __report_error (" VirtualQuery failed for %d bytes at address %p",
276 (int) sizeof(b), addr);
277 }
278
279 /* Temporarily allow write access to read-only protected memory. */
280 if (b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE)
281 {
282 call_unprotect = 1;
283 VirtualProtect (b.BaseAddress, b.RegionSize, PAGE_EXECUTE_READWRITE,
284 &oldprot);
285 }
286
287 /* write the data. */
288 memcpy (addr, src, len);
289 /* Restore original protection. */
290 if (call_unprotect && b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE)
291 VirtualProtect (b.BaseAddress, b.RegionSize, oldprot, &oldprot);
292 }
293
294 #define RP_VERSION_V1 0
295 #define RP_VERSION_V2 1
296
297 static void
do_pseudo_reloc(void * start,void * end,void * base)298 do_pseudo_reloc (void * start, void * end, void * base)
299 {
300 ptrdiff_t addr_imp, reldata;
301 ptrdiff_t reloc_target = (ptrdiff_t) ((char *)end - (char*)start);
302 runtime_pseudo_reloc_v2 *v2_hdr = (runtime_pseudo_reloc_v2 *) start;
303 runtime_pseudo_reloc_item_v2 *r;
304
305 /* A valid relocation list will contain at least one entry, and
306 * one v1 data structure (the smallest one) requires two DWORDs.
307 * So, if the relocation list is smaller than 8 bytes, bail.
308 */
309 if (reloc_target < 8)
310 return;
311
312 /* Check if this is the old pseudo relocation version. */
313 /* There are two kinds of v1 relocation lists:
314 * 1) With a (v2-style) version header. In this case, the
315 * first entry in the list is a 3-DWORD structure, with
316 * value:
317 * { 0, 0, RP_VERSION_V1 }
318 * In this case, we skip to the next entry in the list,
319 * knowing that all elements after the head item can
320 * be cast to runtime_pseudo_reloc_item_v1.
321 * 2) Without a (v2-style) version header. In this case, the
322 * first element in the list IS an actual v1 relocation
323 * record, which is two DWORDs. Because there will never
324 * be a case where a v1 relocation record has both
325 * addend == 0 and target == 0, this case will not be
326 * confused with the prior one.
327 * All current binutils, when generating a v1 relocation list,
328 * use the second (e.g. original) form -- that is, without the
329 * v2-style version header.
330 */
331 if (reloc_target >= 12
332 && v2_hdr->magic1 == 0 && v2_hdr->magic2 == 0
333 && v2_hdr->version == RP_VERSION_V1)
334 {
335 /* We have a list header item indicating that the rest
336 * of the list contains v1 entries. Move the pointer to
337 * the first true v1 relocation record. By definition,
338 * that v1 element will not have both addend == 0 and
339 * target == 0 (and thus, when interpreted as a
340 * runtime_pseudo_reloc_v2, it will not have both
341 * magic1 == 0 and magic2 == 0).
342 */
343 v2_hdr++;
344 }
345
346 if (v2_hdr->magic1 != 0 || v2_hdr->magic2 != 0)
347 {
348 /*************************
349 * Handle v1 relocations *
350 *************************/
351 runtime_pseudo_reloc_item_v1 * o;
352 for (o = (runtime_pseudo_reloc_item_v1 *) v2_hdr;
353 o < (runtime_pseudo_reloc_item_v1 *)end;
354 o++)
355 {
356 DWORD newval;
357 reloc_target = (ptrdiff_t) base + o->target;
358 newval = (*((DWORD*) reloc_target)) + o->addend;
359 __write_memory ((void *) reloc_target, &newval, sizeof(DWORD));
360 }
361 return;
362 }
363
364 /* If we got this far, then we have relocations of version 2 or newer */
365
366 /* Check if this is a known version. */
367 if (v2_hdr->version != RP_VERSION_V2)
368 {
369 __report_error (" Unknown pseudo relocation protocol version %d.\n",
370 (int) v2_hdr->version);
371 return;
372 }
373
374 /*************************
375 * Handle v2 relocations *
376 *************************/
377
378 /* Walk over header. */
379 r = (runtime_pseudo_reloc_item_v2 *) &v2_hdr[1];
380
381 for (; r < (runtime_pseudo_reloc_item_v2 *) end; r++)
382 {
383 /* location where new address will be written */
384 reloc_target = (ptrdiff_t) base + r->target;
385
386 /* get sym pointer. It points either to the iat entry
387 * of the referenced element, or to the stub function.
388 */
389 addr_imp = (ptrdiff_t) base + r->sym;
390 addr_imp = *((ptrdiff_t *) addr_imp);
391
392 /* read existing relocation value from image, casting to the
393 * bitsize indicated by the 8 LSBs of flags. If the value is
394 * negative, manually sign-extend to ptrdiff_t width. Raise an
395 * error if the bitsize indicated by the 8 LSBs of flags is not
396 * supported.
397 */
398 switch ((r->flags & 0xff))
399 {
400 case 8:
401 reldata = (ptrdiff_t) (*((unsigned char *)reloc_target));
402 if ((reldata & 0x80) != 0)
403 reldata |= ~((ptrdiff_t) 0xff);
404 break;
405 case 16:
406 reldata = (ptrdiff_t) (*((unsigned short *)reloc_target));
407 if ((reldata & 0x8000) != 0)
408 reldata |= ~((ptrdiff_t) 0xffff);
409 break;
410 case 32:
411 reldata = (ptrdiff_t) (*((unsigned int *)reloc_target));
412 #ifdef _WIN64
413 if ((reldata & 0x80000000) != 0)
414 reldata |= ~((ptrdiff_t) 0xffffffff);
415 #endif
416 break;
417 #ifdef _WIN64
418 case 64:
419 reldata = (ptrdiff_t) (*((unsigned long long *)reloc_target));
420 break;
421 #endif
422 default:
423 reldata=0;
424 __report_error (" Unknown pseudo relocation bit size %d.\n",
425 (int) (r->flags & 0xff));
426 break;
427 }
428
429 /* Adjust the relocation value */
430 reldata -= ((ptrdiff_t) base + r->sym);
431 reldata += addr_imp;
432
433 /* Write the new relocation value back to *reloc_target */
434 switch ((r->flags & 0xff))
435 {
436 case 8:
437 __write_memory ((void *) reloc_target, &reldata, 1);
438 break;
439 case 16:
440 __write_memory ((void *) reloc_target, &reldata, 2);
441 break;
442 case 32:
443 __write_memory ((void *) reloc_target, &reldata, 4);
444 break;
445 #ifdef _WIN64
446 case 64:
447 __write_memory ((void *) reloc_target, &reldata, 8);
448 break;
449 #endif
450 }
451 }
452 }
453
454 void
_pei386_runtime_relocator(void)455 _pei386_runtime_relocator (void)
456 {
457 static NO_COPY int was_init = 0;
458 #ifdef __MINGW64_VERSION_MAJOR
459 int mSecs;
460 #endif /* __MINGW64_VERSION_MAJOR */
461
462 if (was_init)
463 return;
464 ++was_init;
465 #ifdef __MINGW64_VERSION_MAJOR
466 mSecs = __mingw_GetSectionCount ();
467 the_secs = (sSecInfo *) _alloca (sizeof (sSecInfo) * (size_t) mSecs);
468 maxSections = 0;
469 #endif /* __MINGW64_VERSION_MAJOR */
470
471 do_pseudo_reloc (&__RUNTIME_PSEUDO_RELOC_LIST__,
472 &__RUNTIME_PSEUDO_RELOC_LIST_END__,
473 #ifdef __GNUC__
474 &__MINGW_LSYMBOL(_image_base__)
475 #else
476 &__ImageBase
477 #endif
478 );
479 #ifdef __MINGW64_VERSION_MAJOR
480 restore_modified_sections ();
481 #endif /* __MINGW64_VERSION_MAJOR */
482 }
483