1
2 /*--------------------------------------------------------------------*/
3 /*--- Startup: create initial process image on Linux ---*/
4 /*--- initimg-linux.c ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2000-2010 Julian Seward
12 jseward@acm.org
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 02111-1307, USA.
28
29 The GNU General Public License is contained in the file COPYING.
30 */
31
32 #if defined(VGO_linux)
33
34 #include "pub_core_basics.h"
35 #include "pub_core_vki.h"
36 #include "pub_core_debuglog.h"
37 #include "pub_core_libcbase.h"
38 #include "pub_core_libcassert.h"
39 #include "pub_core_libcfile.h"
40 #include "pub_core_libcproc.h"
41 #include "pub_core_libcprint.h"
42 #include "pub_core_xarray.h"
43 #include "pub_core_clientstate.h"
44 #include "pub_core_aspacemgr.h"
45 #include "pub_core_mallocfree.h"
46 #include "pub_core_machine.h"
47 #include "pub_core_ume.h"
48 #include "pub_core_options.h"
49 #include "pub_core_syscall.h"
50 #include "pub_core_tooliface.h" /* VG_TRACK */
51 #include "pub_core_threadstate.h" /* ThreadArchState */
52 #include "priv_initimg_pathscan.h"
53 #include "pub_core_initimg.h" /* self */
54
55 /* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
56 #define _GNU_SOURCE
57 #define _FILE_OFFSET_BITS 64
58 /* This is for ELF types etc, and also the AT_ constants. */
59 #ifdef ANDROID
60 #include <linux/elf.h>
61 #define AT_FPUCW 18
62 #else
63 #include <elf.h>
64 #endif
65 /* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
66
67
68 /*====================================================================*/
69 /*=== Loading the client ===*/
70 /*====================================================================*/
71
72 /* Load the client whose name is VG_(argv_the_exename). */
73
load_client(ExeInfo * info,Addr * client_ip,Addr * client_toc)74 static void load_client ( /*OUT*/ExeInfo* info,
75 /*OUT*/Addr* client_ip,
76 /*OUT*/Addr* client_toc)
77 {
78 HChar* exe_name;
79 Int ret;
80 SysRes res;
81
82 vg_assert( VG_(args_the_exename) != NULL);
83 exe_name = ML_(find_executable)( VG_(args_the_exename) );
84
85 if (!exe_name) {
86 VG_(printf)("valgrind: %s: command not found\n", VG_(args_the_exename));
87 VG_(exit)(127); // 127 is Posix NOTFOUND
88 }
89
90 VG_(memset)(info, 0, sizeof(*info));
91 ret = VG_(do_exec)(exe_name, info);
92 if (ret < 0) {
93 VG_(printf)("valgrind: could not execute '%s'\n", exe_name);
94 VG_(exit)(1);
95 }
96
97 // The client was successfully loaded! Continue.
98
99 /* Get hold of a file descriptor which refers to the client
100 executable. This is needed for attaching to GDB. */
101 res = VG_(open)(exe_name, VKI_O_RDONLY, VKI_S_IRUSR);
102 if (!sr_isError(res))
103 VG_(cl_exec_fd) = sr_Res(res);
104
105 /* Copy necessary bits of 'info' that were filled in */
106 *client_ip = info->init_ip;
107 *client_toc = info->init_toc;
108 VG_(brk_base) = VG_(brk_limit) = VG_PGROUNDUP(info->brkbase);
109 }
110
111
112 /*====================================================================*/
113 /*=== Setting up the client's environment ===*/
114 /*====================================================================*/
115
116 /* Prepare the client's environment. This is basically a copy of our
117 environment, except:
118
119 LD_PRELOAD=$VALGRIND_LIB/vgpreload_core-PLATFORM.so:
120 ($VALGRIND_LIB/vgpreload_TOOL-PLATFORM.so:)?
121 $LD_PRELOAD
122
123 If this is missing, then it is added.
124
125 Also, remove any binding for VALGRIND_LAUNCHER=. The client should
126 not be able to see this.
127
128 If this needs to handle any more variables it should be hacked
129 into something table driven. The copy is VG_(malloc)'d space.
130 */
setup_client_env(HChar ** origenv,const HChar * toolname)131 static HChar** setup_client_env ( HChar** origenv, const HChar* toolname)
132 {
133 HChar* preload_core = "vgpreload_core";
134 HChar* ld_preload = "LD_PRELOAD=";
135 HChar* v_launcher = VALGRIND_LAUNCHER "=";
136 Int ld_preload_len = VG_(strlen)( ld_preload );
137 Int v_launcher_len = VG_(strlen)( v_launcher );
138 Bool ld_preload_done = False;
139 Int vglib_len = VG_(strlen)(VG_(libdir));
140 Bool debug = False;
141
142 HChar** cpp;
143 HChar** ret;
144 HChar* preload_tool_path;
145 Int envc, i;
146
147 /* Alloc space for the vgpreload_core.so path and vgpreload_<tool>.so
148 paths. We might not need the space for vgpreload_<tool>.so, but it
149 doesn't hurt to over-allocate briefly. The 16s are just cautious
150 slop. */
151 Int preload_core_path_len = vglib_len + sizeof(preload_core)
152 + sizeof(VG_PLATFORM) + 16;
153 Int preload_tool_path_len = vglib_len + VG_(strlen)(toolname)
154 + sizeof(VG_PLATFORM) + 16;
155 Int preload_string_len = preload_core_path_len + preload_tool_path_len;
156 HChar* preload_string = VG_(malloc)("initimg-linux.sce.1",
157 preload_string_len);
158 vg_assert(origenv);
159 vg_assert(toolname);
160 vg_assert(preload_string);
161
162 /* Determine if there's a vgpreload_<tool>_<platform>.so file, and setup
163 preload_string. */
164 preload_tool_path = VG_(malloc)("initimg-linux.sce.2", preload_tool_path_len);
165 vg_assert(preload_tool_path);
166 VG_(snprintf)(preload_tool_path, preload_tool_path_len,
167 "%s/vgpreload_%s-%s.so", VG_(libdir), toolname, VG_PLATFORM);
168 if (VG_(access)(preload_tool_path, True/*r*/, False/*w*/, False/*x*/) == 0) {
169 VG_(snprintf)(preload_string, preload_string_len, "%s/%s-%s.so:%s",
170 VG_(libdir), preload_core, VG_PLATFORM, preload_tool_path);
171 } else {
172 VG_(snprintf)(preload_string, preload_string_len, "%s/%s-%s.so",
173 VG_(libdir), preload_core, VG_PLATFORM);
174 }
175 VG_(free)(preload_tool_path);
176
177 VG_(debugLog)(2, "initimg", "preload_string:\n");
178 VG_(debugLog)(2, "initimg", " \"%s\"\n", preload_string);
179
180 /* Count the original size of the env */
181 if (debug) VG_(printf)("\n\n");
182 envc = 0;
183 for (cpp = origenv; cpp && *cpp; cpp++) {
184 envc++;
185 if (debug) VG_(printf)("XXXXXXXXX: BEFORE %s\n", *cpp);
186 }
187
188 /* Allocate a new space */
189 ret = VG_(malloc) ("initimg-linux.sce.3",
190 sizeof(HChar *) * (envc+1+1)); /* 1 new entry + NULL */
191 vg_assert(ret);
192
193 /* copy it over */
194 for (cpp = ret; *origenv; ) {
195 if (debug) VG_(printf)("XXXXXXXXX: COPY %s\n", *origenv);
196 *cpp++ = *origenv++;
197 }
198 *cpp = NULL;
199
200 vg_assert(envc == (cpp - ret));
201
202 /* Walk over the new environment, mashing as we go */
203 for (cpp = ret; cpp && *cpp; cpp++) {
204 if (VG_(memcmp)(*cpp, ld_preload, ld_preload_len) == 0) {
205 Int len = VG_(strlen)(*cpp) + preload_string_len;
206 HChar *cp = VG_(malloc)("initimg-linux.sce.4", len);
207 vg_assert(cp);
208
209 VG_(snprintf)(cp, len, "%s%s:%s",
210 ld_preload, preload_string, (*cpp)+ld_preload_len);
211
212 *cpp = cp;
213
214 ld_preload_done = True;
215 }
216 if (debug) VG_(printf)("XXXXXXXXX: MASH %s\n", *cpp);
217 }
218
219 /* Add the missing bits */
220 if (!ld_preload_done) {
221 Int len = ld_preload_len + preload_string_len;
222 HChar *cp = VG_(malloc) ("initimg-linux.sce.5", len);
223 vg_assert(cp);
224
225 VG_(snprintf)(cp, len, "%s%s", ld_preload, preload_string);
226
227 ret[envc++] = cp;
228 if (debug) VG_(printf)("XXXXXXXXX: ADD %s\n", cp);
229 }
230
231 /* ret[0 .. envc-1] is live now. */
232 /* Find and remove a binding for VALGRIND_LAUNCHER. */
233 for (i = 0; i < envc; i++)
234 if (0 == VG_(memcmp(ret[i], v_launcher, v_launcher_len)))
235 break;
236
237 if (i < envc) {
238 for (; i < envc-1; i++)
239 ret[i] = ret[i+1];
240 envc--;
241 }
242
243 VG_(free)(preload_string);
244 ret[envc] = NULL;
245
246 for (i = 0; i < envc; i++) {
247 if (debug) VG_(printf)("XXXXXXXXX: FINAL %s\n", ret[i]);
248 }
249
250 return ret;
251 }
252
253
254 /*====================================================================*/
255 /*=== Setting up the client's stack ===*/
256 /*====================================================================*/
257
258 #ifndef AT_DCACHEBSIZE
259 #define AT_DCACHEBSIZE 19
260 #endif /* AT_DCACHEBSIZE */
261
262 #ifndef AT_ICACHEBSIZE
263 #define AT_ICACHEBSIZE 20
264 #endif /* AT_ICACHEBSIZE */
265
266 #ifndef AT_UCACHEBSIZE
267 #define AT_UCACHEBSIZE 21
268 #endif /* AT_UCACHEBSIZE */
269
270 #ifndef AT_BASE_PLATFORM
271 #define AT_BASE_PLATFORM 24
272 #endif /* AT_BASE_PLATFORM */
273
274 #ifndef AT_RANDOM
275 #define AT_RANDOM 25
276 #endif /* AT_RANDOM */
277
278 #ifndef AT_EXECFN
279 #define AT_EXECFN 31
280 #endif /* AT_EXECFN */
281
282 #ifndef AT_SYSINFO
283 #define AT_SYSINFO 32
284 #endif /* AT_SYSINFO */
285
286 #ifndef AT_SYSINFO_EHDR
287 #define AT_SYSINFO_EHDR 33
288 #endif /* AT_SYSINFO_EHDR */
289
290 #ifndef AT_SECURE
291 #define AT_SECURE 23 /* secure mode boolean */
292 #endif /* AT_SECURE */
293
294 /* Add a string onto the string table, and return its address */
copy_str(char ** tab,const char * str)295 static char *copy_str(char **tab, const char *str)
296 {
297 char *cp = *tab;
298 char *orig = cp;
299
300 while(*str)
301 *cp++ = *str++;
302 *cp++ = '\0';
303
304 if (0)
305 VG_(printf)("copied %p \"%s\" len %lld\n", orig, orig, (Long)(cp-orig));
306
307 *tab = cp;
308
309 return orig;
310 }
311
312
313 /* ----------------------------------------------------------------
314
315 This sets up the client's initial stack, containing the args,
316 environment and aux vector.
317
318 The format of the stack is:
319
320 higher address +-----------------+ <- clstack_end
321 | |
322 : string table :
323 | |
324 +-----------------+
325 | AT_NULL |
326 - -
327 | auxv |
328 +-----------------+
329 | NULL |
330 - -
331 | envp |
332 +-----------------+
333 | NULL |
334 - -
335 | argv |
336 +-----------------+
337 | argc |
338 lower address +-----------------+ <- sp
339 | undefined |
340 : :
341
342 Allocate and create the initial client stack. It is allocated down
343 from clstack_end, which was previously determined by the address
344 space manager. The returned value is the SP value for the client.
345
346 The client's auxv is created by copying and modifying our own one.
347 As a side effect of scanning our own auxv, some important bits of
348 info are collected:
349
350 VG_(cache_line_size_ppc32) // ppc32 only -- cache line size
351 VG_(have_altivec_ppc32) // ppc32 only -- is Altivec supported?
352
353 ---------------------------------------------------------------- */
354
355 struct auxv
356 {
357 Word a_type;
358 union {
359 void *a_ptr;
360 Word a_val;
361 } u;
362 };
363
364 static
find_auxv(UWord * sp)365 struct auxv *find_auxv(UWord* sp)
366 {
367 sp++; // skip argc (Nb: is word-sized, not int-sized!)
368
369 while (*sp != 0) // skip argv
370 sp++;
371 sp++;
372
373 while (*sp != 0) // skip env
374 sp++;
375 sp++;
376
377 #if defined(VGA_ppc32) || defined(VGA_ppc64)
378 # if defined AT_IGNOREPPC
379 while (*sp == AT_IGNOREPPC) // skip AT_IGNOREPPC entries
380 sp += 2;
381 # endif
382 #endif
383
384 return (struct auxv *)sp;
385 }
386
387 static
setup_client_stack(void * init_sp,char ** orig_envp,const ExeInfo * info,UInt ** client_auxv,Addr clstack_end,SizeT clstack_max_size)388 Addr setup_client_stack( void* init_sp,
389 char** orig_envp,
390 const ExeInfo* info,
391 UInt** client_auxv,
392 Addr clstack_end,
393 SizeT clstack_max_size )
394 {
395 SysRes res;
396 char **cpp;
397 char *strtab; /* string table */
398 char *stringbase;
399 Addr *ptr;
400 struct auxv *auxv;
401 const struct auxv *orig_auxv;
402 const struct auxv *cauxv;
403 unsigned stringsize; /* total size of strings in bytes */
404 unsigned auxsize; /* total size of auxv in bytes */
405 Int argc; /* total argc */
406 Int envc; /* total number of env vars */
407 unsigned stacksize; /* total client stack size */
408 Addr client_SP; /* client stack base (initial SP) */
409 Addr clstack_start;
410 Int i;
411 Bool have_exename;
412
413 vg_assert(VG_IS_PAGE_ALIGNED(clstack_end+1));
414 vg_assert( VG_(args_for_client) );
415
416 /* use our own auxv as a prototype */
417 orig_auxv = find_auxv(init_sp);
418
419 /* ==================== compute sizes ==================== */
420
421 /* first of all, work out how big the client stack will be */
422 stringsize = 0;
423 have_exename = VG_(args_the_exename) != NULL;
424
425 /* paste on the extra args if the loader needs them (ie, the #!
426 interpreter and its argument) */
427 argc = 0;
428 if (info->interp_name != NULL) {
429 argc++;
430 stringsize += VG_(strlen)(info->interp_name) + 1;
431 }
432 if (info->interp_args != NULL) {
433 argc++;
434 stringsize += VG_(strlen)(info->interp_args) + 1;
435 }
436
437 /* now scan the args we're given... */
438 if (have_exename)
439 stringsize += VG_(strlen)( VG_(args_the_exename) ) + 1;
440
441 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
442 argc++;
443 stringsize += VG_(strlen)( * (HChar**)
444 VG_(indexXA)( VG_(args_for_client), i ))
445 + 1;
446 }
447
448 /* ...and the environment */
449 envc = 0;
450 for (cpp = orig_envp; cpp && *cpp; cpp++) {
451 envc++;
452 stringsize += VG_(strlen)(*cpp) + 1;
453 }
454
455 /* now, how big is the auxv? */
456 auxsize = sizeof(*auxv); /* there's always at least one entry: AT_NULL */
457 for (cauxv = orig_auxv; cauxv->a_type != AT_NULL; cauxv++) {
458 if (cauxv->a_type == AT_PLATFORM ||
459 cauxv->a_type == AT_BASE_PLATFORM)
460 stringsize += VG_(strlen)(cauxv->u.a_ptr) + 1;
461 else if (cauxv->a_type == AT_RANDOM)
462 stringsize += 16;
463 else if (cauxv->a_type == AT_EXECFN)
464 stringsize += VG_(strlen)(VG_(args_the_exename)) + 1;
465 auxsize += sizeof(*cauxv);
466 }
467
468 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
469 auxsize += 2 * sizeof(*cauxv);
470 # endif
471
472 /* OK, now we know how big the client stack is */
473 stacksize =
474 sizeof(Word) + /* argc */
475 (have_exename ? sizeof(char **) : 0) + /* argc[0] == exename */
476 sizeof(char **)*argc + /* argv */
477 sizeof(char **) + /* terminal NULL */
478 sizeof(char **)*envc + /* envp */
479 sizeof(char **) + /* terminal NULL */
480 auxsize + /* auxv */
481 VG_ROUNDUP(stringsize, sizeof(Word)); /* strings (aligned) */
482
483 if (0) VG_(printf)("stacksize = %d\n", stacksize);
484
485 /* client_SP is the client's stack pointer */
486 client_SP = clstack_end - stacksize;
487 client_SP = VG_ROUNDDN(client_SP, 16); /* make stack 16 byte aligned */
488
489 /* base of the string table (aligned) */
490 stringbase = strtab = (char *)clstack_end
491 - VG_ROUNDUP(stringsize, sizeof(int));
492
493 clstack_start = VG_PGROUNDDN(client_SP);
494
495 /* The max stack size */
496 clstack_max_size = VG_PGROUNDUP(clstack_max_size);
497
498 /* Record stack extent -- needed for stack-change code. */
499 VG_(clstk_base) = clstack_start;
500 VG_(clstk_end) = clstack_end;
501
502 if (0)
503 VG_(printf)("stringsize=%d auxsize=%d stacksize=%d maxsize=0x%x\n"
504 "clstack_start %p\n"
505 "clstack_end %p\n",
506 stringsize, auxsize, stacksize, (Int)clstack_max_size,
507 (void*)clstack_start, (void*)clstack_end);
508
509 /* ==================== allocate space ==================== */
510
511 { SizeT anon_size = clstack_end - clstack_start + 1;
512 SizeT resvn_size = clstack_max_size - anon_size;
513 Addr anon_start = clstack_start;
514 Addr resvn_start = anon_start - resvn_size;
515 SizeT inner_HACK = 0;
516 Bool ok;
517
518 /* So far we've only accounted for space requirements down to the
519 stack pointer. If this target's ABI requires a redzone below
520 the stack pointer, we need to allocate an extra page, to
521 handle the worst case in which the stack pointer is almost at
522 the bottom of a page, and so there is insufficient room left
523 over to put the redzone in. In this case the simple thing to
524 do is allocate an extra page, by shrinking the reservation by
525 one page and growing the anonymous area by a corresponding
526 page. */
527 vg_assert(VG_STACK_REDZONE_SZB >= 0);
528 vg_assert(VG_STACK_REDZONE_SZB < VKI_PAGE_SIZE);
529 if (VG_STACK_REDZONE_SZB > 0) {
530 vg_assert(resvn_size > VKI_PAGE_SIZE);
531 resvn_size -= VKI_PAGE_SIZE;
532 anon_start -= VKI_PAGE_SIZE;
533 anon_size += VKI_PAGE_SIZE;
534 }
535
536 vg_assert(VG_IS_PAGE_ALIGNED(anon_size));
537 vg_assert(VG_IS_PAGE_ALIGNED(resvn_size));
538 vg_assert(VG_IS_PAGE_ALIGNED(anon_start));
539 vg_assert(VG_IS_PAGE_ALIGNED(resvn_start));
540 vg_assert(resvn_start == clstack_end + 1 - clstack_max_size);
541
542 # ifdef ENABLE_INNER
543 inner_HACK = 1024*1024; // create 1M non-fault-extending stack
544 # endif
545
546 if (0)
547 VG_(printf)("%#lx 0x%lx %#lx 0x%lx\n",
548 resvn_start, resvn_size, anon_start, anon_size);
549
550 /* Create a shrinkable reservation followed by an anonymous
551 segment. Together these constitute a growdown stack. */
552 res = VG_(mk_SysRes_Error)(0);
553 ok = VG_(am_create_reservation)(
554 resvn_start,
555 resvn_size -inner_HACK,
556 SmUpper,
557 anon_size +inner_HACK
558 );
559 if (ok) {
560 /* allocate a stack - mmap enough space for the stack */
561 res = VG_(am_mmap_anon_fixed_client)(
562 anon_start -inner_HACK,
563 anon_size +inner_HACK,
564 VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC
565 );
566 }
567 if ((!ok) || sr_isError(res)) {
568 /* Allocation of the stack failed. We have to stop. */
569 VG_(printf)("valgrind: "
570 "I failed to allocate space for the application's stack.\n");
571 VG_(printf)("valgrind: "
572 "This may be the result of a very large --main-stacksize=\n");
573 VG_(printf)("valgrind: setting. Cannot continue. Sorry.\n\n");
574 VG_(exit)(0);
575 }
576
577 vg_assert(ok);
578 vg_assert(!sr_isError(res));
579 }
580
581 /* ==================== create client stack ==================== */
582
583 ptr = (Addr*)client_SP;
584
585 /* --- client argc --- */
586 *ptr++ = argc + (have_exename ? 1 : 0);
587
588 /* --- client argv --- */
589 if (info->interp_name) {
590 *ptr++ = (Addr)copy_str(&strtab, info->interp_name);
591 VG_(free)(info->interp_name);
592 }
593 if (info->interp_args) {
594 *ptr++ = (Addr)copy_str(&strtab, info->interp_args);
595 VG_(free)(info->interp_args);
596 }
597
598 if (have_exename)
599 *ptr++ = (Addr)copy_str(&strtab, VG_(args_the_exename));
600
601 for (i = 0; i < VG_(sizeXA)( VG_(args_for_client) ); i++) {
602 *ptr++ = (Addr)copy_str(
603 &strtab,
604 * (HChar**) VG_(indexXA)( VG_(args_for_client), i )
605 );
606 }
607 *ptr++ = 0;
608
609 /* --- envp --- */
610 VG_(client_envp) = (Char **)ptr;
611 for (cpp = orig_envp; cpp && *cpp; ptr++, cpp++)
612 *ptr = (Addr)copy_str(&strtab, *cpp);
613 *ptr++ = 0;
614
615 /* --- auxv --- */
616 auxv = (struct auxv *)ptr;
617 *client_auxv = (UInt *)auxv;
618
619 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
620 auxv[0].a_type = AT_IGNOREPPC;
621 auxv[0].u.a_val = AT_IGNOREPPC;
622 auxv[1].a_type = AT_IGNOREPPC;
623 auxv[1].u.a_val = AT_IGNOREPPC;
624 auxv += 2;
625 # endif
626
627 for (; orig_auxv->a_type != AT_NULL; auxv++, orig_auxv++) {
628 const NSegment *ehdrseg;
629
630 /* copy the entry... */
631 *auxv = *orig_auxv;
632
633 /* ...and fix up / examine the copy */
634 switch(auxv->a_type) {
635
636 case AT_IGNORE:
637 case AT_PHENT:
638 case AT_PAGESZ:
639 case AT_FLAGS:
640 case AT_NOTELF:
641 case AT_UID:
642 case AT_EUID:
643 case AT_GID:
644 case AT_EGID:
645 case AT_CLKTCK:
646 case AT_FPUCW:
647 /* All these are pointerless, so we don't need to do
648 anything about them. */
649 break;
650
651 case AT_PHDR:
652 if (info->phdr == 0)
653 auxv->a_type = AT_IGNORE;
654 else
655 auxv->u.a_val = info->phdr;
656 break;
657
658 case AT_PHNUM:
659 if (info->phdr == 0)
660 auxv->a_type = AT_IGNORE;
661 else
662 auxv->u.a_val = info->phnum;
663 break;
664
665 case AT_BASE:
666 auxv->u.a_val = info->interp_base;
667 break;
668
669 case AT_PLATFORM:
670 case AT_BASE_PLATFORM:
671 /* points to a platform description string */
672 auxv->u.a_ptr = copy_str(&strtab, orig_auxv->u.a_ptr);
673 break;
674
675 case AT_ENTRY:
676 auxv->u.a_val = info->entry;
677 break;
678
679 case AT_HWCAP:
680 # if defined(VGP_arm_linux)
681 { Bool has_neon = (auxv->u.a_val & VKI_HWCAP_NEON) > 0;
682 VG_(debugLog)(2, "initimg",
683 "ARM has-neon from-auxv: %s\n",
684 has_neon ? "YES" : "NO");
685 VG_(machine_arm_set_has_NEON)( has_neon );
686 }
687 # endif
688 break;
689
690 case AT_DCACHEBSIZE:
691 case AT_ICACHEBSIZE:
692 case AT_UCACHEBSIZE:
693 # if defined(VGP_ppc32_linux)
694 /* acquire cache info */
695 if (auxv->u.a_val > 0) {
696 VG_(machine_ppc32_set_clszB)( auxv->u.a_val );
697 VG_(debugLog)(2, "initimg",
698 "PPC32 cache line size %u (type %u)\n",
699 (UInt)auxv->u.a_val, (UInt)auxv->a_type );
700 }
701 # elif defined(VGP_ppc64_linux)
702 /* acquire cache info */
703 if (auxv->u.a_val > 0) {
704 VG_(machine_ppc64_set_clszB)( auxv->u.a_val );
705 VG_(debugLog)(2, "initimg",
706 "PPC64 cache line size %u (type %u)\n",
707 (UInt)auxv->u.a_val, (UInt)auxv->a_type );
708 }
709 # endif
710 break;
711
712 # if defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
713 case AT_IGNOREPPC:
714 break;
715 # endif
716
717 case AT_SECURE:
718 /* If this is 1, then it means that this program is
719 running suid, and therefore the dynamic linker should
720 be careful about LD_PRELOAD, etc. However, since
721 stage1 (the thing the kernel actually execve's) should
722 never be SUID, and we need LD_PRELOAD to work for the
723 client, we set AT_SECURE to 0. */
724 auxv->u.a_val = 0;
725 break;
726
727 case AT_SYSINFO:
728 /* Trash this, because we don't reproduce it */
729 auxv->a_type = AT_IGNORE;
730 break;
731
732 # if !defined(VGP_ppc32_linux) && !defined(VGP_ppc64_linux)
733 case AT_SYSINFO_EHDR:
734 /* Trash this, because we don't reproduce it */
735 ehdrseg = VG_(am_find_nsegment)((Addr)auxv->u.a_ptr);
736 vg_assert(ehdrseg);
737 VG_(am_munmap_valgrind)(ehdrseg->start, ehdrseg->end - ehdrseg->start);
738 auxv->a_type = AT_IGNORE;
739 break;
740 # endif
741
742 case AT_RANDOM:
743 /* points to 16 random bytes - we need to ensure this is
744 propagated to the client as glibc will assume it is
745 present if it is built for kernel 2.6.29 or later */
746 auxv->u.a_ptr = strtab;
747 VG_(memcpy)(strtab, orig_auxv->u.a_ptr, 16);
748 strtab += 16;
749 break;
750
751 case AT_EXECFN:
752 /* points to the executable filename */
753 auxv->u.a_ptr = copy_str(&strtab, VG_(args_the_exename));
754 break;
755
756 default:
757 /* stomp out anything we don't know about */
758 VG_(debugLog)(2, "initimg",
759 "stomping auxv entry %lld\n",
760 (ULong)auxv->a_type);
761 auxv->a_type = AT_IGNORE;
762 break;
763 }
764 }
765 *auxv = *orig_auxv;
766 vg_assert(auxv->a_type == AT_NULL);
767
768 vg_assert((strtab-stringbase) == stringsize);
769
770 /* client_SP is pointing at client's argc/argv */
771
772 if (0) VG_(printf)("startup SP = %#lx\n", client_SP);
773 return client_SP;
774 }
775
776
777 /* Allocate the client data segment. It is an expandable anonymous
778 mapping abutting a shrinkable reservation of size max_dseg_size.
779 The data segment starts at VG_(brk_base), which is page-aligned,
780 and runs up to VG_(brk_limit), which isn't. */
781
setup_client_dataseg(SizeT max_size)782 static void setup_client_dataseg ( SizeT max_size )
783 {
784 Bool ok;
785 SysRes sres;
786 Addr anon_start = VG_(brk_base);
787 SizeT anon_size = VKI_PAGE_SIZE;
788 Addr resvn_start = anon_start + anon_size;
789 SizeT resvn_size = max_size - anon_size;
790
791 vg_assert(VG_IS_PAGE_ALIGNED(anon_size));
792 vg_assert(VG_IS_PAGE_ALIGNED(resvn_size));
793 vg_assert(VG_IS_PAGE_ALIGNED(anon_start));
794 vg_assert(VG_IS_PAGE_ALIGNED(resvn_start));
795
796 /* Because there's been no brk activity yet: */
797 vg_assert(VG_(brk_base) == VG_(brk_limit));
798
799 /* Try to create the data seg and associated reservation where
800 VG_(brk_base) says. */
801 ok = VG_(am_create_reservation)(
802 resvn_start,
803 resvn_size,
804 SmLower,
805 anon_size
806 );
807
808 if (!ok) {
809 /* Hmm, that didn't work. Well, let aspacem suggest an address
810 it likes better, and try again with that. */
811 anon_start = VG_(am_get_advisory_client_simple)
812 ( 0/*floating*/, anon_size+resvn_size, &ok );
813 if (ok) {
814 resvn_start = anon_start + anon_size;
815 ok = VG_(am_create_reservation)(
816 resvn_start,
817 resvn_size,
818 SmLower,
819 anon_size
820 );
821 if (ok)
822 VG_(brk_base) = VG_(brk_limit) = anon_start;
823 }
824 /* that too might have failed, but if it has, we're hosed: there
825 is no Plan C. */
826 }
827 vg_assert(ok);
828
829 /* We make the data segment (heap) executable because LinuxThreads on
830 ppc32 creates trampolines in this area. Also, on x86/Linux the data
831 segment is RWX natively, at least according to /proc/self/maps.
832 Also, having a non-executable data seg would kill any program which
833 tried to create code in the data seg and then run it. */
834 sres = VG_(am_mmap_anon_fixed_client)(
835 anon_start,
836 anon_size,
837 VKI_PROT_READ|VKI_PROT_WRITE|VKI_PROT_EXEC
838 );
839 vg_assert(!sr_isError(sres));
840 vg_assert(sr_Res(sres) == anon_start);
841 }
842
843
844 /*====================================================================*/
845 /*=== TOP-LEVEL: VG_(setup_client_initial_image) ===*/
846 /*====================================================================*/
847
848 /* Create the client's initial memory image. */
VG_(ii_create_image)849 IIFinaliseImageInfo VG_(ii_create_image)( IICreateImageInfo iicii )
850 {
851 ExeInfo info;
852 HChar** env = NULL;
853
854 IIFinaliseImageInfo iifii;
855 VG_(memset)( &iifii, 0, sizeof(iifii) );
856
857 //--------------------------------------------------------------
858 // Load client executable, finding in $PATH if necessary
859 // p: get_helprequest_and_toolname() [for 'exec', 'need_help']
860 // p: layout_remaining_space [so there's space]
861 //--------------------------------------------------------------
862 VG_(debugLog)(1, "initimg", "Loading client\n");
863
864 if (VG_(args_the_exename) == NULL)
865 VG_(err_missing_prog)();
866
867 load_client(&info, &iifii.initial_client_IP, &iifii.initial_client_TOC);
868
869 //--------------------------------------------------------------
870 // Set up client's environment
871 // p: set-libdir [for VG_(libdir)]
872 // p: get_helprequest_and_toolname [for toolname]
873 //--------------------------------------------------------------
874 VG_(debugLog)(1, "initimg", "Setup client env\n");
875 env = setup_client_env(iicii.envp, iicii.toolname);
876
877 //--------------------------------------------------------------
878 // Setup client stack, eip, and VG_(client_arg[cv])
879 // p: load_client() [for 'info']
880 // p: fix_environment() [for 'env']
881 //--------------------------------------------------------------
882 {
883 /* When allocating space for the client stack on Linux, take
884 notice of the --main-stacksize value. This makes it possible
885 to run programs with very large (primary) stack requirements
886 simply by specifying --main-stacksize. */
887 /* Logic is as follows:
888 - by default, use the client's current stack rlimit
889 - if that exceeds 16M, clamp to 16M
890 - if a larger --main-stacksize value is specified, use that instead
891 - in all situations, the minimum allowed stack size is 1M
892 */
893 void* init_sp = iicii.argv - 1;
894 SizeT m1 = 1024 * 1024;
895 SizeT m16 = 16 * m1;
896 SizeT szB = (SizeT)VG_(client_rlimit_stack).rlim_cur;
897 if (szB < m1) szB = m1;
898 if (szB > m16) szB = m16;
899 if (VG_(clo_main_stacksize) > 0) szB = VG_(clo_main_stacksize);
900 if (szB < m1) szB = m1;
901 szB = VG_PGROUNDUP(szB);
902 VG_(debugLog)(1, "initimg",
903 "Setup client stack: size will be %ld\n", szB);
904
905 iifii.clstack_max_size = szB;
906
907 iifii.initial_client_SP
908 = setup_client_stack( init_sp, env,
909 &info, &iifii.client_auxv,
910 iicii.clstack_top, iifii.clstack_max_size );
911
912 VG_(free)(env);
913
914 VG_(debugLog)(2, "initimg",
915 "Client info: "
916 "initial_IP=%p initial_TOC=%p brk_base=%p\n",
917 (void*)(iifii.initial_client_IP),
918 (void*)(iifii.initial_client_TOC),
919 (void*)VG_(brk_base) );
920 VG_(debugLog)(2, "initimg",
921 "Client info: "
922 "initial_SP=%p max_stack_size=%ld\n",
923 (void*)(iifii.initial_client_SP),
924 (SizeT)iifii.clstack_max_size );
925 }
926
927 //--------------------------------------------------------------
928 // Setup client data (brk) segment. Initially a 1-page segment
929 // which abuts a shrinkable reservation.
930 // p: load_client() [for 'info' and hence VG_(brk_base)]
931 //--------------------------------------------------------------
932 {
933 SizeT m1 = 1024 * 1024;
934 SizeT m8 = 8 * m1;
935 SizeT dseg_max_size = (SizeT)VG_(client_rlimit_data).rlim_cur;
936 VG_(debugLog)(1, "initimg", "Setup client data (brk) segment\n");
937 if (dseg_max_size < m1) dseg_max_size = m1;
938 if (dseg_max_size > m8) dseg_max_size = m8;
939 dseg_max_size = VG_PGROUNDUP(dseg_max_size);
940
941 setup_client_dataseg( dseg_max_size );
942 }
943
944 return iifii;
945 }
946
947
948 /*====================================================================*/
949 /*=== TOP-LEVEL: VG_(finalise_thread1state) ===*/
950 /*====================================================================*/
951
952 /* Just before starting the client, we may need to make final
953 adjustments to its initial image. Also we need to set up the VEX
954 guest state for thread 1 (the root thread) and copy in essential
955 starting values. This is handed the IIFinaliseImageInfo created by
956 VG_(ii_create_image).
957 */
VG_(ii_finalise_image)958 void VG_(ii_finalise_image)( IIFinaliseImageInfo iifii )
959 {
960 ThreadArchState* arch = &VG_(threads)[1].arch;
961
962 /* On Linux we get client_{ip/sp/toc}, and start the client with
963 all other registers zeroed. */
964
965 # if defined(VGP_x86_linux)
966 vg_assert(0 == sizeof(VexGuestX86State) % 16);
967
968 /* Zero out the initial state, and set up the simulated FPU in a
969 sane way. */
970 LibVEX_GuestX86_initialise(&arch->vex);
971
972 /* Zero out the shadow areas. */
973 VG_(memset)(&arch->vex_shadow1, 0, sizeof(VexGuestX86State));
974 VG_(memset)(&arch->vex_shadow2, 0, sizeof(VexGuestX86State));
975
976 /* Put essential stuff into the new state. */
977 arch->vex.guest_ESP = iifii.initial_client_SP;
978 arch->vex.guest_EIP = iifii.initial_client_IP;
979
980 /* initialise %cs, %ds and %ss to point at the operating systems
981 default code, data and stack segments */
982 asm volatile("movw %%cs, %0" : : "m" (arch->vex.guest_CS));
983 asm volatile("movw %%ds, %0" : : "m" (arch->vex.guest_DS));
984 asm volatile("movw %%ss, %0" : : "m" (arch->vex.guest_SS));
985
986 # elif defined(VGP_amd64_linux)
987 vg_assert(0 == sizeof(VexGuestAMD64State) % 16);
988
989 /* Zero out the initial state, and set up the simulated FPU in a
990 sane way. */
991 LibVEX_GuestAMD64_initialise(&arch->vex);
992
993 /* Zero out the shadow areas. */
994 VG_(memset)(&arch->vex_shadow1, 0, sizeof(VexGuestAMD64State));
995 VG_(memset)(&arch->vex_shadow2, 0, sizeof(VexGuestAMD64State));
996
997 /* Put essential stuff into the new state. */
998 arch->vex.guest_RSP = iifii.initial_client_SP;
999 arch->vex.guest_RIP = iifii.initial_client_IP;
1000
1001 # elif defined(VGP_ppc32_linux)
1002 vg_assert(0 == sizeof(VexGuestPPC32State) % 16);
1003
1004 /* Zero out the initial state, and set up the simulated FPU in a
1005 sane way. */
1006 LibVEX_GuestPPC32_initialise(&arch->vex);
1007
1008 /* Zero out the shadow areas. */
1009 VG_(memset)(&arch->vex_shadow1, 0, sizeof(VexGuestPPC32State));
1010 VG_(memset)(&arch->vex_shadow2, 0, sizeof(VexGuestPPC32State));
1011
1012 /* Put essential stuff into the new state. */
1013 arch->vex.guest_GPR1 = iifii.initial_client_SP;
1014 arch->vex.guest_CIA = iifii.initial_client_IP;
1015
1016 # elif defined(VGP_ppc64_linux)
1017 vg_assert(0 == sizeof(VexGuestPPC64State) % 16);
1018
1019 /* Zero out the initial state, and set up the simulated FPU in a
1020 sane way. */
1021 LibVEX_GuestPPC64_initialise(&arch->vex);
1022
1023 /* Zero out the shadow areas. */
1024 VG_(memset)(&arch->vex_shadow1, 0, sizeof(VexGuestPPC64State));
1025 VG_(memset)(&arch->vex_shadow2, 0, sizeof(VexGuestPPC64State));
1026
1027 /* Put essential stuff into the new state. */
1028 arch->vex.guest_GPR1 = iifii.initial_client_SP;
1029 arch->vex.guest_GPR2 = iifii.initial_client_TOC;
1030 arch->vex.guest_CIA = iifii.initial_client_IP;
1031
1032 # elif defined(VGP_arm_linux)
1033 /* Zero out the initial state, and set up the simulated FPU in a
1034 sane way. */
1035 LibVEX_GuestARM_initialise(&arch->vex);
1036
1037 /* Zero out the shadow areas. */
1038 VG_(memset)(&arch->vex_shadow1, 0, sizeof(VexGuestARMState));
1039 VG_(memset)(&arch->vex_shadow2, 0, sizeof(VexGuestARMState));
1040
1041 arch->vex.guest_R13 = iifii.initial_client_SP;
1042 arch->vex.guest_R15T = iifii.initial_client_IP;
1043
1044 /* This is just EABI stuff. */
1045 // FIXME jrs: what's this for?
1046 arch->vex.guest_R1 = iifii.initial_client_SP;
1047
1048 # else
1049 # error Unknown platform
1050 # endif
1051
1052 /* Tell the tool that we just wrote to the registers. */
1053 VG_TRACK( post_reg_write, Vg_CoreStartup, /*tid*/1, /*offset*/0,
1054 sizeof(VexGuestArchState));
1055 }
1056
1057 #endif // defined(VGO_linux)
1058
1059 /*--------------------------------------------------------------------*/
1060 /*--- ---*/
1061 /*--------------------------------------------------------------------*/
1062