third party sw is good, not well tested
[dyninst.git] / common / src / linuxKludges.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  *
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  *
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  *
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  *
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  *
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #include "common/src/headers.h"
32 #include "common/src/parseauxv.h"
33 #include "common/src/linuxKludges.h"
34 #include "common/src/Types.h"
35
36 #include <elf.h>
37
38 #include <vector>
39 #include <fstream>
40 #include <sstream>
41 #include <algorithm>
42 #include <sys/types.h>
43 #include <sys/ptrace.h>
44 #include <sys/syscall.h>
45 #include <sys/uio.h>
46 #include <unistd.h>
47 #include <dirent.h>
48 #include <string.h>
49
50
51 /**** process_vm_readv / process_vm_writev
52  * Added in kernel 3.2 and some backports -- try it and check ENOSYS.
53  * The wrappers are defined in glibc 2.15, otherwise make our own.
54  */
55 #if !__GLIBC_PREREQ(2,15)
56
57 static ssize_t process_vm_readv(pid_t pid,
58     const struct iovec *local_iov, unsigned long liovcnt,
59     const struct iovec *remote_iov, unsigned long riovcnt,
60     unsigned long flags)
61 {
62 #ifdef SYS_process_vm_readv
63   return syscall(SYS_process_vm_readv,
64       pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
65 #else
66   errno = ENOSYS;
67   return -1;
68 #endif
69 }
70
71 static ssize_t process_vm_writev(pid_t pid,
72     const struct iovec *local_iov, unsigned long liovcnt,
73     const struct iovec *remote_iov, unsigned long riovcnt,
74     unsigned long flags)
75 {
76 #ifdef SYS_process_vm_writev
77   return syscall(SYS_process_vm_writev,
78       pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
79 #else
80   errno = ENOSYS;
81   return -1;
82 #endif
83 }
84
85 #endif /* !__GLIBC_PREREQ(2,15) */
86
87
88 typedef int (*intKludge)();
89
90 int P_getopt(int argc, char *argv[], const char *optstring)
91 {
92   /* On linux we prepend a + character */
93   char newopt[strlen(optstring)+5];
94   strcpy(newopt, "+");
95   strcat(newopt, optstring);
96   return getopt(argc, argv, newopt);
97 }
98
99 int P_copy(const char *from, const char *to) {
100     std::ifstream src(from, std::ios::binary);
101     std::ofstream dst(to, std::ios::binary | std::ios::trunc);
102     dst << src.rdbuf();
103     dst.close();
104     src.close();
105     return (src && dst) ? 0 : -1;
106 }
107
108
109 unsigned long long PDYN_div1000(unsigned long long in) {
110    /* Divides by 1000 without an integer division instruction or library call, both of
111     * which are slow.
112     * We do only shifts, adds, and subtracts.
113     *
114     * We divide by 1000 in this way:
115     * multiply by 1/1000, or multiply by (1/1000)*2^30 and then right-shift by 30.
116     * So what is 1/1000 * 2^30?
117     * It is 1,073,742.   (actually this is rounded)
118     * So we can multiply by 1,073,742 and then right-shift by 30 (neat, eh?)
119     *
120     * Now for multiplying by 1,073,742...
121     * 1,073,742 = (1,048,576 + 16384 + 8192 + 512 + 64 + 8 + 4 + 2)
122     * or, slightly optimized:
123     * = (1,048,576 + 16384 + 8192 + 512 + 64 + 16 - 2)
124     * for a total of 8 shifts and 6 add/subs, or 14 operations.
125     *
126     */
127
128    unsigned long long temp = in << 20; // multiply by 1,048,576
129       // beware of overflow; left shift by 20 is quite a lot.
130       // If you know that the input fits in 32 bits (4 billion) then
131       // no problem.  But if it's much bigger then start worrying...
132
133    temp += in << 14; // 16384
134    temp += in << 13; // 8192
135    temp += in << 9;  // 512
136    temp += in << 6;  // 64
137    temp += in << 4;  // 16
138    temp -= in >> 2;  // 2
139
140    return (temp >> 30); // divide by 2^30
141 }
142
143 unsigned long long PDYN_divMillion(unsigned long long in) {
144    /* Divides by 1,000,000 without an integer division instruction or library call,
145     * both of which are slow.
146     * We do only shifts, adds, and subtracts.
147     *
148     * We divide by 1,000,000 in this way:
149     * multiply by 1/1,000,000, or multiply by (1/1,000,000)*2^30 and then right-shift
150     * by 30.  So what is 1/1,000,000 * 2^30?
151     * It is 1,074.   (actually this is rounded)
152     * So we can multiply by 1,074 and then right-shift by 30 (neat, eh?)
153     *
154     * Now for multiplying by 1,074
155     * 1,074 = (1024 + 32 + 16 + 2)
156     * for a total of 4 shifts and 4 add/subs, or 8 operations.
157     *
158     * Note: compare with div1000 -- it's cheaper to divide by a million than
159     *       by a thousand (!)
160     *
161     */
162
163    unsigned long long temp = in << 10; // multiply by 1024
164       // beware of overflow...if the input arg uses more than 52 bits
165       // than start worrying about whether (in << 10) plus the smaller additions
166       // we're gonna do next will fit in 64...
167
168    temp += in << 5; // 32
169    temp += in << 4; // 16
170    temp += in << 1; // 2
171
172    return (temp >> 30); // divide by 2^30
173 }
174
175 unsigned long long PDYN_mulMillion(unsigned long long in) {
176    unsigned long long result = in;
177
178    /* multiply by 125 by multiplying by 128 and subtracting 3x */
179    result = (result << 7) - result - result - result;
180
181    /* multiply by 125 again, for a total of 15625x */
182    result = (result << 7) - result - result - result;
183
184    /* multiply by 64, for a total of 1,000,000x */
185    result <<= 6;
186
187    /* cost was: 3 shifts and 6 subtracts
188     * cost of calling mul1000(mul1000()) would be: 6 shifts and 4 subtracts
189     *
190     * Another algorithm is to multiply by 2^6 and then 5^6.
191     * The former is super-cheap (one shift); the latter is more expensive.
192     * 5^6 = 15625 = 16384 - 512 - 256 + 8 + 1
193     * so multiplying by 5^6 means 4 shift operations and 4 add/sub ops
194     * so multiplying by 1000000 means 5 shift operations and 4 add/sub ops.
195     * That may or may not be cheaper than what we're doing (3 shifts; 6 subtracts);
196     * I'm not sure.  --ari
197     */
198
199    return result;
200 }
201
202 #if defined(cap_gnu_demangler)
203 #include <cxxabi.h>
204 using namespace abi;
205 #endif
206
207 char * P_cplus_demangle( const char * symbol, bool nativeCompiler,
208                                 bool includeTypes )
209 {
210   static char* last_symbol = NULL;
211   static bool last_native = false;
212   static bool last_typed = false;
213   static char* last_demangled = NULL;
214
215   if(last_symbol && last_demangled && (nativeCompiler == last_native)
216       && (includeTypes == last_typed) && (strcmp(symbol, last_symbol) == 0))
217   {
218       return strdup(last_demangled);
219   }
220
221 #if defined(cap_gnu_demangler)
222    int status;
223    char *demangled = __cxa_demangle(symbol, NULL, NULL, &status);
224    if (status == -1) {
225       //Memory allocation failure.
226       return NULL;
227    }
228    if (status == -2) {
229       //Not a C++ name
230       return NULL;
231    }
232    assert(status == 0); //Success
233 #else
234    int opts = 0;
235    opts |= includeTypes ? DMGL_PARAMS | DMGL_ANSI : 0;
236    //   [ pgcc/CC are the "native" compilers on Linux. Go figure. ]
237    // pgCC's mangling scheme most closely resembles that of the Annotated
238    // C++ Reference Manual, only with "some exceptions" (to quote the PGI
239    // documentation). I guess we'll demangle names with "some exceptions".
240    opts |= nativeCompiler ? DMGL_ARM : 0;
241    char * demangled = cplus_demangle( const_cast< char *>(symbol), opts);
242 #endif
243
244    if( demangled == NULL ) { return NULL; }
245
246    if( ! includeTypes ) {
247         /* de-demangling never increases the length */
248         char * dedemangled = strdup( demangled );
249         assert( dedemangled != NULL );
250         dedemangle( demangled, dedemangled );
251         assert( dedemangled != NULL );
252
253         free( demangled );
254         demangled = dedemangled;
255    }
256
257    free(last_symbol);
258    free(last_demangled);
259    last_native = nativeCompiler;
260    last_typed = includeTypes;
261    last_symbol = strdup(symbol);
262    last_demangled = strdup(demangled);
263
264    return demangled;
265 } /* end P_cplus_demangle() */
266
267 bool PtraceBulkRead(Address inTraced, unsigned size, void *inSelf, int pid)
268 {
269    static bool have_process_vm_readv = true;
270
271    const unsigned char *ap = (const unsigned char*) inTraced;
272    unsigned char *dp = (unsigned char *) inSelf;
273    Address w = 0x0;               /* ptrace I/O buffer */
274    int len = sizeof(void *);
275    unsigned cnt;
276
277    if (0 == size) {
278       return true;
279    }
280
281    /* If process_vm_readv is available, we may be able to read it all in one syscall. */
282    if (have_process_vm_readv) {
283       struct iovec local_iov = { inSelf, size };
284       struct iovec remote_iov = { (void*)inTraced, size };
285       ssize_t ret = process_vm_readv(pid, &local_iov, 1, &remote_iov, 1, 0);
286       if (ret == -1) {
287          if (errno == ENOSYS) {
288             have_process_vm_readv = false;
289          } else if (errno == EFAULT) {
290             /* Could be a no-read page -- ptrace may be allowed to
291              * peek anyway, so fallthrough and let ptrace try.  */
292          } else {
293             fprintf(stderr, "[%s:%d]ERROR: process_vm_readv failed!\n", FILE__, __LINE__);
294             fprintf(stderr, "ERROR: %s\n", strerror(errno) );
295             return false;
296          }
297       } else if (ret < size) {
298          /* partial reads won't split an iovec, but we only have one... huh?! */
299          fprintf(stderr, "[%s:%d]ERROR: process_vm_readv incomplete!\n", FILE__, __LINE__);
300          fprintf(stderr, "ERROR: only %zi bytes of %u copied!\n", ret, size );
301          return false;
302       } else {
303          return true;
304       }
305    }
306
307    cnt = inTraced % len;
308    if (cnt) {
309       /* Start of request is not aligned. */
310       unsigned char *p = (unsigned char*) &w;
311
312       /* Read the segment containing the unaligned portion, and
313          copy what was requested to DP. */
314       errno = 0;
315       w = P_ptrace(PTRACE_PEEKDATA, pid, (Address) (ap-cnt), w, len);
316       if (errno) {
317           fprintf(stderr, "[%s:%d]ERROR: ptrace PEEKTEXT failed!\n",FILE__, __LINE__);
318           fprintf(stderr, "ERROR: %s\n", strerror(errno) );
319          return false;
320       }
321       for (unsigned i = 0; i < len-cnt && i < size; i++)
322          dp[i] = p[cnt+i];
323
324       if (len-cnt >= size) {
325          return true; /* done */
326       }
327
328       dp += len-cnt;
329       ap += len-cnt;
330       size -= len-cnt;
331    }
332    /* Copy aligned portion */
333    while (size >= (u_int)len) {
334       errno = 0;
335       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0, len);
336       if (errno) {
337           fprintf(stderr, "[%s:%d]ERROR: ptrace PEEKTEXT failed!\n",FILE__, __LINE__);
338           fprintf(stderr, "ERROR: %s\n", strerror(errno) );
339          return false;
340       }
341       memcpy(dp, &w, len);
342       dp += len;
343       ap += len;
344       size -= len;
345    }
346
347    if (size > 0) {
348       /* Some unaligned data remains */
349       unsigned char *p = (unsigned char *) &w;
350
351       /* Read the segment containing the unaligned portion, and
352          copy what was requested to DP. */
353       errno = 0;
354       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0, len);
355       if (errno) {
356           fprintf(stderr, "[%s:%d]ERROR: ptrace PEEKTEXT failed!\n", FILE__,__LINE__);
357           fprintf(stderr, "ERROR: %s\n", strerror(errno) );
358          return false;
359       }
360       for (unsigned i = 0; i < size; i++)
361          dp[i] = p[i];
362    }
363    return true;
364
365 }
366
367 bool PtraceBulkWrite(Dyninst::Address inTraced, unsigned nbytes,
368                      const void *inSelf, int pid)
369 {
370    static bool have_process_vm_writev = true;
371
372    unsigned char *ap = (unsigned char*) inTraced;
373    const unsigned char *dp = (const unsigned char*) inSelf;
374    Address w = 0x0;               /* ptrace I/O buffer */
375    int len = sizeof(Address); /* address alignment of ptrace I/O requests */
376    unsigned cnt;
377
378    if (0 == nbytes) {
379       return true;
380    }
381
382    /* If process_vm_writev is available, we may be able to write it all in one syscall. */
383    if (have_process_vm_writev) {
384       struct iovec local_iov = { const_cast<void*>(inSelf), nbytes };
385       struct iovec remote_iov = { (void*)inTraced, nbytes };
386       ssize_t ret = process_vm_writev(pid, &local_iov, 1, &remote_iov, 1, 0);
387       if (ret == -1) {
388          if (errno == ENOSYS) {
389             have_process_vm_writev = false;
390          } else if (errno == EFAULT) {
391             /* Could be a read-only page -- ptrace may be allowed to
392              * poke anyway, so fallthrough and let ptrace try.  */
393          } else {
394             fprintf(stderr, "[%s:%d]ERROR: process_vm_writev failed!\n", FILE__, __LINE__);
395             fprintf(stderr, "ERROR: %s\n", strerror(errno) );
396             return false;
397          }
398       } else if (ret < nbytes) {
399          /* partial writes won't split an iovec, but we only have one... huh?! */
400          fprintf(stderr, "[%s:%d]ERROR: process_vm_writev incomplete!\n", FILE__, __LINE__);
401          fprintf(stderr, "ERROR: only %zi bytes of %u copied!\n", ret, nbytes );
402          return false;
403       } else {
404          return true;
405       }
406    }
407
408    if ((cnt = ((Address)ap) % len)) {
409       /* Start of request is not aligned. */
410       unsigned char *p = (unsigned char*) &w;
411
412       /* Read the segment containing the unaligned portion, edit
413          in the data from DP, and write the segment back. */
414       errno = 0;
415       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) (ap-cnt), 0);
416
417       if (errno) {
418          return false;
419       }
420
421       for (unsigned i = 0; i < len-cnt && i < nbytes; i++)
422          p[cnt+i] = dp[i];
423
424       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) (ap-cnt), w)) {
425          return false;
426       }
427
428       if (len-cnt >= nbytes) {
429          return true; /* done */
430       }
431
432       dp += len-cnt;
433       ap += len-cnt;
434       nbytes -= len-cnt;
435    }
436
437    /* Copy aligned portion */
438    while (nbytes >= (u_int)len) {
439       assert(0 == ((Address)ap) % len);
440       memcpy(&w, dp, len);
441       int retval =  P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w);
442       if (retval < 0) {
443          return false;
444       }
445
446       // Check...
447       dp += len;
448       ap += len;
449       nbytes -= len;
450    }
451
452    if (nbytes > 0) {
453       /* Some unaligned data remains */
454       unsigned char *p = (unsigned char *) &w;
455
456       /* Read the segment containing the unaligned portion, edit
457          in the data from DP, and write it back. */
458       errno = 0;
459       w = P_ptrace(PTRACE_PEEKTEXT, pid, (Address) ap, 0);
460
461       if (errno) {
462          return false;
463       }
464
465
466       for (unsigned i = 0; i < nbytes; i++)
467          p[i] = dp[i];
468
469       if (0 > P_ptrace(PTRACE_POKETEXT, pid, (Address) ap, w)) {
470          return false;
471       }
472    }
473    return true;
474 }
475
476 // These constants are not defined in all versions of elf.h
477 #ifndef AT_BASE
478 #define AT_BASE 7
479 #endif
480 #ifndef AT_NULL
481 #define AT_NULL 0
482 #endif
483 #ifndef AT_SYSINFO
484 #define AT_SYSINFO 32
485 #endif
486 #ifndef AT_SYSINFO_EHDR
487 #define AT_SYSINFO_EHDR 33
488 #endif
489
490 static bool couldBeVsyscallPage(map_entries *entry, bool strict, Address) {
491    if (strict) {
492        if (entry->prems != PREMS_PRIVATE)
493          return false;
494       if (entry->path[0] != '\0')
495          return false;
496    }
497    if (entry->offset != 0)
498       return false;
499    if (entry->dev_major != 0 || entry->dev_minor != 0)
500       return false;
501    if (entry->inode != 0)
502       return false;
503
504    return true;
505 }
506
507 bool AuxvParser::readAuxvInfo()
508 {
509   /**
510    * The location of the vsyscall is stored in /proc/PID/auxv in Linux 2.6.
511    * auxv consists of a list of name/value pairs, ending with the AT_NULL
512    * name.  There isn't a direct way to get the vsyscall info on Linux 2.4
513    **/
514   uint32_t *buffer32 = NULL;
515   uint64_t *buffer64 = NULL;
516   unsigned pos = 0;
517   Address dso_start = 0x0, text_start = 0x0;
518
519   struct {
520     unsigned long type;
521     unsigned long value;
522   } auxv_entry;
523
524   /**
525    * Try to read from /proc/%d/auxv.  On Linux 2.4 systems auxv
526    * doesn't exist, which is okay because vsyscall isn't used.
527    * On latter 2.6 kernels the AT_SYSINFO field isn't present,
528    * so we have to resort to more "extreme" measures.
529    **/
530   buffer64 = (uint64_t *) readAuxvFromProc();
531   if (!buffer64) {
532      buffer64 = (uint64_t *) readAuxvFromStack();
533   }
534   if (!buffer64) {
535      return false;
536   }
537   buffer32 = (uint32_t *) buffer64;
538   do {
539      /**Fill in the auxv_entry structure.  We may have to do different
540       * size reads depending on the address space.  No matter which
541       * size we read, we'll fill the data in to auxv_entry, which may
542       * involve a size shift up.
543       **/
544      if (addr_size == 4) {
545         auxv_entry.type = (unsigned long) buffer32[pos];
546         pos++;
547         auxv_entry.value = (unsigned long) buffer32[pos];
548         pos++;
549      }
550      else {
551         auxv_entry.type = (unsigned long) buffer64[pos];
552         pos++;
553         auxv_entry.value = (unsigned long) buffer64[pos];
554         pos++;
555      }
556
557      switch(auxv_entry.type) {
558         case AT_SYSINFO:
559            text_start = auxv_entry.value;
560            break;
561         case AT_SYSINFO_EHDR:
562            dso_start = auxv_entry.value;
563            break;
564         case AT_PAGESZ:
565            page_size = auxv_entry.value;
566            break;
567         case AT_BASE:
568            interpreter_base = auxv_entry.value;
569            break;
570         case AT_PHDR:
571            phdr = auxv_entry.value;
572            break;
573      }
574
575   } while (auxv_entry.type != AT_NULL);
576
577
578   if (buffer64)
579      free(buffer64);
580   if (!page_size)
581      page_size = getpagesize();
582 //#if !defined(arch_x86) && !defined(arch_x86_64)
583 #if !defined(arch_x86) && !defined(arch_x86_64) && !defined(arch_aarch64)
584   //No vsyscall page needed or present
585   return true;
586 #endif
587
588   /**
589    * Even if we found dso_start in /proc/pid/auxv, the vsyscall 'page'
590    * can be larger than a single page.  Thus we look through /proc/pid/maps
591    * for known, default, or guessed start address(es).
592    **/
593   std::vector<Address> guessed_addrs;
594
595   /* The first thing to check is the auxvinfo, if we have any. */
596   if( dso_start != 0x0 )
597      guessed_addrs.push_back( dso_start );
598
599   /**
600    * We'll make several educatbed attempts at guessing an address
601    * for the vsyscall page.  After deciding on a guess, we'll try to
602    * verify that using /proc/pid/maps.
603    **/
604
605   // Guess some constants that we've seen before.
606 #if defined(arch_x86)
607   guessed_addrs.push_back(0xffffe000); //Many early 2.6 systems
608   guessed_addrs.push_back(0xffffd000); //RHEL4
609 #endif
610 #if defined(arch_x86_64)
611   guessed_addrs.push_back(0xffffffffff600000);
612 #endif
613
614   /**
615    * Look through every entry in /proc/maps, and compare it to every
616    * entry in guessed_addrs.  If a guessed_addr looks like the right
617    * thing, then we'll go ahead and call it the vsyscall page.
618    **/
619   unsigned num_maps;
620   map_entries *secondary_match = NULL;
621   map_entries *maps = getVMMaps(pid, num_maps);
622   for (unsigned i=0; i<guessed_addrs.size(); i++) {
623      Address addr = guessed_addrs[i];
624      for (unsigned j=0; j<num_maps; j++) {
625         map_entries *entry = &(maps[j]);
626         if (addr < entry->start || addr >= entry->end)
627            continue;
628
629         if (dso_start == entry->start ||
630             couldBeVsyscallPage(entry, true, page_size)) {
631            //We found a possible page using a strict check.
632            // This is really likely to be it.
633            vsyscall_base = entry->start;
634            vsyscall_end = entry->end;
635            vsyscall_text = text_start;
636            found_vsyscall = true;
637            free(maps);
638            return true;
639         }
640
641         if (couldBeVsyscallPage(entry, false, page_size)) {
642            //We found an entry that loosely looks like the
643            // vsyscall page.  Let's hang onto this and return
644            // it if we find nothing else.
645            secondary_match = entry;
646         }
647      }
648   }
649
650   /**
651    * There were no hits using our guessed_addrs scheme.  Let's
652    * try to look at every entry in the maps table (not just the
653    * guessed addresses), and see if any of those look like a vsyscall page.
654    **/
655   for (unsigned i=0; i<num_maps; i++) {
656      if (couldBeVsyscallPage(&(maps[i]), true, page_size)) {
657         vsyscall_base = maps[i].start;
658         vsyscall_end = maps[i].end;
659         vsyscall_text = text_start;
660         found_vsyscall = true;
661         free(maps);
662         return true;
663      }
664   }
665
666   /**
667    * Return any secondary possiblitiy pages we found in our earlier search.
668    **/
669   if (secondary_match) {
670      vsyscall_base = secondary_match->start;
671      vsyscall_end = secondary_match->end;
672      vsyscall_text = text_start;
673      found_vsyscall = true;
674      free(maps);
675      return true;
676   }
677
678   /**
679    * Time to give up.  Sigh.
680    **/
681   found_vsyscall = false;
682   free(maps);
683   return false;
684 }
685
686 #if 0
687 /**
688  * get_word_at is a helper function for readAuxvFromStack.  It reads
689  * a word out of the mutatee's stack via the debugger interface, and
690  * it keeps the word cached for future reads.
691  * The gwa_* global variables are basically parameters to get_word_at
692  * and should be reset before every call
693  *
694  * gwa_buffer is a cache of data we've read before.  It's backwards
695  * for convience, higher addresses are cached towards the base of gwa_buffer
696  * and lower addresses are cached at the top.  This is because we read from
697  * high addresses to low ones, but we want to start caching at the start of
698  * gwa_buffer.
699  **/
700 static unsigned long *gwa_buffer = NULL;
701 static unsigned gwa_size = 0;
702 static unsigned gwa_pos = 0;
703 static unsigned long gwa_base_addr = 0;
704
705 static unsigned long get_word_at(process *p, unsigned long addr, bool &err) {
706    bool result;
707    unsigned word_size = p->getAddressWidth();
708    unsigned long word;
709
710    /**
711     * On AMD64 controlling 32-bit mutatee words are 32 bits long.
712     * We don't want to deal with this now, so treat as a 64 bit read
713     * (from aligned_addr) and then pick the correct 32 bits to return
714     * at the end of this function.
715     **/
716    unsigned long aligned_addr = addr;
717    if (word_size == 4 && sizeof(long) == 8 && addr % 8 == 4)
718       aligned_addr -= 4;
719
720    /**
721     * Allocate gwa_buffer on first call
722     **/
723    if (gwa_buffer == NULL) {
724       gwa_buffer = (unsigned long *) malloc(gwa_size);
725    }
726
727    /**
728     * If gwa_buffer isn't big enough, grow it.
729     **/
730    if (gwa_base_addr - gwa_size >= aligned_addr) {
731       while (gwa_base_addr - gwa_size >= aligned_addr)
732          gwa_size = gwa_size * 2;
733       gwa_buffer = (unsigned long *) realloc(gwa_buffer, gwa_size);
734    }
735
736    /**
737     * Keep adding words to the cache (gwa_buffer) until we've cached
738     * the word the user is interested in.
739     **/
740    while (gwa_base_addr - (gwa_pos * sizeof(long)) >= aligned_addr) {
741       result = p->readDataSpace((void *) aligned_addr, sizeof(long), &word, false);
742       if (!result) {
743          err = true;
744          return 0x0;
745       }
746       gwa_buffer[gwa_pos] = word;
747       gwa_pos++;
748    }
749
750    /**
751     * Return the word the user wants out of the cache.  'word' is the
752     * long value we want to return.  On 64-bit mutator/32-bit mutatees
753     * we may need to return a specific 32-bits of word.
754     **/
755    word = gwa_buffer[(gwa_base_addr - aligned_addr) / sizeof(long)];
756
757    if (word_size == 4 && sizeof(long) == 8 && addr % 8 == 4) {
758       //64-bit mutator, 32 bit mutatee, looking for unaligned word
759       uint32_t *words = (uint32_t *) &word;
760       return (long) words[1];
761    }
762    else if (word_size == 4 && sizeof(long) == 8)
763    {
764       //64-bit mutator, 32 bit mutatee, looking for aligned word
765       uint32_t *words = (uint32_t *) &word;
766       return (long) words[0];
767    }
768    else
769    {
770       //mutator and mutatee are same size
771       return word;
772    }
773 }
774
775
776 /**
777  * Another helper function for readAuxvInfoFromStack.  We want to know
778  * the top byte of the stack.  Unfortunately, if we're running this it's
779  * probably because /proc/PID/ isn't reliable, so we can't use maps.
780  * Check the machine's stack pointer, page align it, and start walking
781  * back looking for an unaccessible page.
782  **/
783 static Address getStackTop(AddrSpaceReader *proc, bool &err) {
784    Address stack_pointer;
785    Address pagesize = getpagesize();
786    bool result;
787    long word;
788    err = false;
789
790
791    stack_pointer = proc->readRegContents(PTRACE_REG_SP);
792    dyn_lwp *init_lwp = proc->getInitialLwp();
793    if (!init_lwp) {
794       err = true;
795       return 0x0;
796    }
797
798    Frame frame = init_lwp->getActiveFrame();
799    stack_pointer = frame.getSP();
800    if (!stack_pointer) {
801       err = true;
802       return 0x0;
803    }
804
805    //Align sp to pagesize
806    stack_pointer = (stack_pointer & ~(pagesize - 1)) + pagesize;
807
808    //Read pages until we get to an unmapped page
809    for (;;) {
810       result = proc->readDataSpace((void *) stack_pointer, sizeof(long), &word,
811                                    false);
812       if (!result) {
813          break;
814       }
815       stack_pointer += pagesize;
816    }
817
818    //The vsyscall page sometimes hangs out above the stack.  Test if this
819    // page is it, then move back down one if it is.
820    char pagestart[4];
821    result = proc->readDataSpace((void *) (stack_pointer - pagesize), 4, pagestart,
822                                 false);
823    if (result) {
824       if (pagestart[0] == 0x7F && pagestart[1] == 'E' &&
825           pagestart[2] == 'L' &&  pagestart[3] == 'F')
826       {
827          stack_pointer -= pagesize;
828       }
829    }
830
831    return stack_pointer;
832 }
833
834 /**
835  * We can't read /proc/PID/auxv for some reason (BProc is a likely candidate).
836  * We'll instead pull this data from the mutatee's stack.  On Linux the top of
837  * the stack at process startup is arranged like the following:
838  *          -------------------------------------
839  * esp ->   |                argc               |
840  *          |               argv[0]             |
841  *          |                ...                |
842  *          |               argv[n]             |
843  *          |                                   |
844  *          |               envp[0]             |
845  *          |                ...                |
846  *          |               envp[n]             |
847  *          |                NULL               |
848  *          |                                   |
849  *          |  { auxv[0].type, auxv[0].value }  |
850  *          |                ...                |
851  *          |  { auxv[n].type, auxv[n].value }  |
852  *          |  {      NULL   ,     NULL      }  |
853  *          |                                   |
854  *          |      Some number of NULL words    |
855  *          |        Strings for argv[]         |
856  *          |        Strings for envp[]         |
857  *          |                NULL               |
858  *          -------------------------------------
859  *
860  * We want to get at the name/value pairs of auxv.  Unfortunately,
861  * if we're attaching the stack pointer has probably moved.  Instead
862  * we'll try to read the from the bottom up, which is more difficult.
863  * argv[] and envp[] are pointers to the strings at the bottom of
864  * the stack.  We'll search backwards for these pointers, then move back
865  * down until we think we have the auxv array.  Yea us.
866  **/
867 void *AuxvParser::readAuxvFromStack(process *proc) {
868    gwa_buffer = NULL;
869    gwa_size = 1024 * 1024; //One megabyte default
870    gwa_pos = 0;
871    unsigned word_size = proc->getAddressWidth();
872    bool err = false;
873
874    // Get the base address of the mutatee's stack.  For example,
875    //  on many standard linux/x86 machines this will return
876    //  0xc0000000
877    gwa_base_addr = getStackTop(proc, err);
878    if (err)
879       return NULL;
880    gwa_base_addr -= word_size;
881
882    unsigned long current = gwa_base_addr;
883    unsigned long strings_start, strings_end;
884    unsigned long l1, l2, auxv_start, word;
885    unsigned char *buffer = NULL;
886    unsigned bytes_to_read;
887
888    // Go through initial NULL word
889    while (get_word_at(proc, current, err) == 0x0) {
890       if (err) goto done_err;
891       current -= word_size;
892    }
893
894    // Go through the auxv[] and envp[] strings
895    strings_end = current;
896    while (get_word_at(proc, current, err) != 0x0) {
897       if (err) goto done_err;
898       current -= word_size;
899    }
900    strings_start = current + word_size;
901
902    //Read until we find a pair of pointers into the strings
903    // section, this should mean we're now above the auxv vector
904    // and in envp or argv
905    for (;;) {
906       l1 = get_word_at(proc, current, err);
907       if (err) goto done_err;
908       l2 = get_word_at(proc, current - word_size, err);
909       if (err) goto done_err;
910       if (l1 >= strings_start && l1 < strings_end &&
911           l2 >= strings_start && l2 < strings_end)
912          break;
913       current -= word_size;
914    }
915
916    //Read back down until we get to the end of envp[]
917    while (get_word_at(proc, current, err) != 0x0) {
918       if (err) goto done_err;
919       current += word_size;
920    }
921    //Through the NULL byte before auxv..
922    while (get_word_at(proc, current, err) == 0x0) {
923       if (err) goto done_err;
924       current += word_size;
925    }
926
927    //Success. Found the start of auxv.
928    auxv_start = current;
929
930    //Read auxv into buffer
931    bytes_to_read = strings_start - auxv_start;
932    buffer = (unsigned char *) malloc(bytes_to_read + word_size*2);
933    if (!buffer)
934       goto done_err;
935    for (unsigned pos = 0; pos < bytes_to_read; pos += word_size) {
936       word = get_word_at(proc, auxv_start + pos, err);
937       if (err) goto done_err;
938       if (word_size == 4)
939          *((uint32_t *) (buffer + pos)) = (uint32_t) word;
940       else
941          *((unsigned long *) (buffer + pos)) = word;
942    }
943
944    goto done;
945
946  done_err:
947    if (buffer)
948       free(buffer);
949    buffer = NULL;
950  done:
951    if (gwa_buffer)
952       free(gwa_buffer);
953    return (void *) buffer;
954 }
955
956 #else
957
958 void *AuxvParser::readAuxvFromStack() {
959    /**
960     * Disabled, for now.  Re-enable if /proc/pid/auxv doesn't exist.
961     **/
962    return NULL;
963 }
964
965 #endif
966
967 #define READ_BLOCK_SIZE (1024 * 5)
968 void *AuxvParser::readAuxvFromProc() {
969    char filename[64];
970    unsigned char *buffer = NULL;
971    unsigned char *temp;
972    unsigned buffer_size = READ_BLOCK_SIZE;
973    unsigned pos = 0;
974    ssize_t result = 0;
975    int fd = -1;
976
977    sprintf(filename, "/proc/%d/auxv", pid);
978    fd = open(filename, O_RDONLY, 0);
979    if (fd == -1)
980       goto done_err;
981
982    buffer = (unsigned char *) malloc(buffer_size);
983    if (!buffer) {
984       goto done_err;
985    }
986
987    for (;;) {
988       result = read(fd, buffer + pos, READ_BLOCK_SIZE);
989       if (result == -1) {
990          perror("Couldn't read auxv entry");
991          goto done_err;
992       }
993       else if (!result && !pos) {
994          //Didn't find any data to read
995          perror("Could read auxv entry");
996          goto done_err;
997       }
998       else if (result < READ_BLOCK_SIZE) {
999          //Success
1000          goto done;
1001       }
1002       else if (result == READ_BLOCK_SIZE) {
1003          //WTF... 5k wasn't enough for auxv?
1004          buffer_size *= 2;
1005          temp = (unsigned char *) realloc(buffer, buffer_size);
1006          if (!temp)
1007             goto done_err;
1008          buffer = temp;
1009          pos += READ_BLOCK_SIZE;
1010       }
1011       else {
1012          fprintf(stderr, "[%s:%u] - Unknown error reading auxv\n",
1013                  __FILE__, __LINE__);
1014          goto done_err;
1015       }
1016    }
1017
1018    done_err:
1019       if (buffer)
1020          free(buffer);
1021       buffer = NULL;
1022    done:
1023       if (fd != -1)
1024          close(fd);
1025       return buffer;
1026 }
1027
1028
1029 map_entries *getVMMaps(int pid, unsigned &maps_size) {
1030    std::ostringstream maps_filename;
1031    maps_filename << "/proc/" << pid << "/maps";
1032    std::ifstream maps_file(maps_filename.str());
1033
1034    std::vector<map_entries> maps;
1035    while (maps_file.good()) {
1036       char delim;
1037       std::string prems;
1038       map_entries map;
1039       memset(&map, 0, sizeof(map));
1040
1041       maps_file >> std::hex >> map.start >> delim >> map.end >> prems >> map.offset
1042          >> map.dev_major >> delim >> map.dev_minor >> std::dec >> map.inode;
1043
1044       for (auto i = prems.begin(); i != prems.end(); ++i)
1045          switch (*i) {
1046             case 'r':
1047                map.prems |= PREMS_READ;
1048                break;
1049             case 'w':
1050                map.prems |= PREMS_WRITE;
1051                break;
1052             case 'x':
1053                map.prems |= PREMS_EXEC;
1054                break;
1055             case 'p':
1056                map.prems |= PREMS_PRIVATE;
1057                break;
1058             case 's':
1059                map.prems |= PREMS_EXEC;
1060                break;
1061          }
1062
1063       std::string path;
1064       std::getline(maps_file, path);
1065       path.erase(0, path.find_first_not_of(" \t"));
1066       strncpy(map.path, path.c_str(), sizeof(map.path) - 1);
1067
1068       if (maps_file.good())
1069          maps.push_back(map);
1070    }
1071
1072    if (maps.empty()) {
1073       maps_size = 0;
1074       return NULL;
1075    }
1076
1077    map_entries *cmaps = (map_entries *)calloc(maps.size() + 1, sizeof(map_entries));
1078    if (cmaps != NULL) {
1079       std::copy(maps.begin(), maps.end(), cmaps);
1080       maps_size = maps.size();
1081    }
1082    return cmaps;
1083 }
1084
1085 bool findProcLWPs(pid_t pid, std::vector<pid_t> &lwps)
1086 {
1087    char name[32];
1088    struct dirent *direntry;
1089
1090    /**
1091     * Linux 2.6:
1092     **/
1093    snprintf(name, 32, "/proc/%d/task", pid);
1094    DIR *dirhandle = opendir(name);
1095    if (dirhandle)
1096    {
1097       //Only works on Linux 2.6
1098       while((direntry = readdir(dirhandle)) != NULL) {
1099          unsigned lwp_id = atoi(direntry->d_name);
1100          if (lwp_id)
1101             lwps.push_back(lwp_id);
1102       }
1103       closedir(dirhandle);
1104       return true;
1105    }
1106    /**
1107     * Linux 2.4:
1108     *
1109     * PIDs that are created by pthreads have a '.' prepending their name
1110     * in /proc.  We'll check all of those for the ones that have this lwp
1111     * as a parent pid.
1112     **/
1113    dirhandle = opendir("/proc");
1114    if (!dirhandle)
1115    {
1116       //No /proc directory.  I give up.  No threads for you.
1117       return false;
1118    }
1119    while ((direntry = readdir(dirhandle)) != NULL)
1120    {
1121       if (direntry->d_name[0] != '.') {
1122          //fprintf(stderr, "%s[%d]: Skipping entry %s\n", FILE__, __LINE__, direntry->d_name);
1123          continue;
1124       }
1125       unsigned lwp_id = atoi(direntry->d_name+1);
1126       int lwp_ppid = 0;
1127       if (!lwp_id)
1128          continue;
1129       sprintf(name, "/proc/%d/status", lwp_id);
1130       FILE *fd = P_fopen(name, "r");
1131       if (!fd) {
1132          continue;
1133      }
1134      char buffer[1024];
1135      while (fgets(buffer, 1024, fd)) {
1136          if (strncmp(buffer, "Tgid", 4) == 0) {
1137              sscanf(buffer, "%*s %d", &lwp_ppid);
1138              break;
1139          }
1140      }
1141
1142      fclose(fd);
1143
1144      if (lwp_ppid != pid) {
1145          continue;
1146      }
1147      lwps.push_back(lwp_id);
1148   }
1149   closedir(dirhandle);
1150   lwps.push_back(pid);
1151
1152   return true;
1153 }