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