• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Test program for unwinding of frames.
2    Copyright (C) 2013, 2014, 2016 Red Hat, Inc.
3    This file is part of elfutils.
4 
5    This file is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 3 of the License, or
8    (at your option) any later version.
9 
10    elfutils is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14 
15    You should have received a copy of the GNU General Public License
16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17 
18 #include <config.h>
19 #include <assert.h>
20 #include <inttypes.h>
21 #include <stdio.h>
22 #include <stdio_ext.h>
23 #include <locale.h>
24 #include <dirent.h>
25 #include <stdlib.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #include <dwarf.h>
29 #ifdef __linux__
30 #include <sys/resource.h>
31 #include <sys/ptrace.h>
32 #include <signal.h>
33 #include <sys/types.h>
34 #include <sys/wait.h>
35 #include <sys/user.h>
36 #include <fcntl.h>
37 #include <string.h>
38 #include <argp.h>
39 #include ELFUTILS_HEADER(dwfl)
40 #endif
41 #include "system.h"
42 
43 #ifndef __linux__
44 
45 int
main(int argc,char ** argv)46 main (int argc __attribute__ ((unused)), char **argv)
47 {
48   fprintf (stderr, "%s: Unwinding not supported for this architecture\n",
49 	   argv[0]);
50   return 77;
51 }
52 
53 #else /* __linux__ */
54 
55 static int
dump_modules(Dwfl_Module * mod,void ** userdata,const char * name,Dwarf_Addr start,void * arg)56 dump_modules (Dwfl_Module *mod, void **userdata __attribute__ ((unused)),
57 	      const char *name, Dwarf_Addr start,
58 	      void *arg __attribute__ ((unused)))
59 {
60   Dwarf_Addr end;
61   dwfl_module_info (mod, NULL, NULL, &end, NULL, NULL, NULL, NULL);
62   printf ("%#" PRIx64 "\t%#" PRIx64 "\t%s\n", (uint64_t) start, (uint64_t) end,
63 	  name);
64   return DWARF_CB_OK;
65 }
66 
67 static bool use_raise_jmp_patching;
68 static pid_t check_tid;
69 
70 static void
callback_verify(pid_t tid,unsigned frameno,Dwarf_Addr pc,const char * symname,Dwfl * dwfl)71 callback_verify (pid_t tid, unsigned frameno, Dwarf_Addr pc,
72 		 const char *symname, Dwfl *dwfl)
73 {
74   static bool seen_main = false;
75   if (symname && *symname == '.')
76     symname++;
77   if (symname && strcmp (symname, "main") == 0)
78     seen_main = true;
79   if (pc == 0)
80     {
81       assert (seen_main);
82       return;
83     }
84   if (check_tid == 0)
85     check_tid = tid;
86   if (tid != check_tid)
87     {
88       // For the main thread we are only interested if we can unwind till
89       // we see the "main" symbol.
90       return;
91     }
92   Dwfl_Module *mod;
93   /* See case 4. Special case to help out simple frame pointer unwinders. */
94   static bool duplicate_sigusr2 = false;
95   if (duplicate_sigusr2)
96     frameno--;
97   static bool reduce_frameno = false;
98   if (reduce_frameno)
99     frameno--;
100   if (! use_raise_jmp_patching && frameno >= 2)
101     frameno += 2;
102   const char *symname2 = NULL;
103   switch (frameno)
104   {
105     case 0:
106       if (! reduce_frameno && symname
107 	       && (strcmp (symname, "__kernel_vsyscall") == 0
108 		   || strcmp (symname, "__libc_do_syscall") == 0))
109 	reduce_frameno = true;
110       else
111 	assert (symname && strcmp (symname, "raise") == 0);
112       break;
113     case 1:
114       assert (symname != NULL && strcmp (symname, "sigusr2") == 0);
115       break;
116     case 2: // x86_64 only
117       /* __restore_rt - glibc maybe does not have to have this symbol.  */
118       break;
119     case 3: // use_raise_jmp_patching
120       if (use_raise_jmp_patching)
121 	{
122 	  /* Verify we trapped on the very first instruction of jmp.  */
123 	  assert (symname != NULL && strcmp (symname, "jmp") == 0);
124 	  mod = dwfl_addrmodule (dwfl, pc - 1);
125 	  if (mod)
126 	    symname2 = dwfl_module_addrname (mod, pc - 1);
127 	  assert (symname2 == NULL || strcmp (symname2, "jmp") != 0);
128 	  break;
129 	}
130       FALLTHROUGH;
131     case 4:
132       /* Some simple frame unwinders get this wrong and think sigusr2
133 	 is calling itself again. Allow it and just pretend there is
134 	 an extra sigusr2 frame. */
135       if (symname != NULL && strcmp (symname, "sigusr2") == 0)
136 	{
137 	  duplicate_sigusr2 = true;
138 	  break;
139 	}
140       assert (symname != NULL && strcmp (symname, "stdarg") == 0);
141       break;
142     case 5:
143       /* Verify we trapped on the very last instruction of child.  */
144       assert (symname != NULL && strcmp (symname, "backtracegen") == 0);
145       mod = dwfl_addrmodule (dwfl, pc);
146       if (mod)
147 	symname2 = dwfl_module_addrname (mod, pc);
148 
149       // Note that the following assert might in theory even fail on x86_64,
150       // there is no guarantee that the compiler doesn't reorder the
151       // instructions or even inserts some padding instructions at the end
152       // (which apparently happens on ppc64).
153       if (use_raise_jmp_patching)
154         assert (symname2 == NULL || strcmp (symname2, "backtracegen") != 0);
155       break;
156   }
157 }
158 
159 static int
frame_callback(Dwfl_Frame * state,void * frame_arg)160 frame_callback (Dwfl_Frame *state, void *frame_arg)
161 {
162   int *framenop = frame_arg;
163   Dwarf_Addr pc;
164   bool isactivation;
165 
166   if (*framenop > 16)
167     {
168       error (0, 0, "Too many frames: %d\n", *framenop);
169       return DWARF_CB_ABORT;
170     }
171 
172   if (! dwfl_frame_pc (state, &pc, &isactivation))
173     {
174       error (0, 0, "%s", dwfl_errmsg (-1));
175       return DWARF_CB_ABORT;
176     }
177   Dwarf_Addr pc_adjusted = pc - (isactivation ? 0 : 1);
178 
179   /* Get PC->SYMNAME.  */
180   Dwfl_Thread *thread = dwfl_frame_thread (state);
181   Dwfl *dwfl = dwfl_thread_dwfl (thread);
182   Dwfl_Module *mod = dwfl_addrmodule (dwfl, pc_adjusted);
183   const char *symname = NULL;
184   if (mod)
185     symname = dwfl_module_addrname (mod, pc_adjusted);
186 
187   printf ("#%2d %#" PRIx64 "%4s\t%s\n", *framenop, (uint64_t) pc,
188 	  ! isactivation ? "- 1" : "", symname);
189   pid_t tid = dwfl_thread_tid (thread);
190   callback_verify (tid, *framenop, pc, symname, dwfl);
191   (*framenop)++;
192 
193   return DWARF_CB_OK;
194 }
195 
196 static int
thread_callback(Dwfl_Thread * thread,void * thread_arg)197 thread_callback (Dwfl_Thread *thread, void *thread_arg __attribute__((unused)))
198 {
199   printf ("TID %ld:\n", (long) dwfl_thread_tid (thread));
200   int frameno = 0;
201   switch (dwfl_thread_getframes (thread, frame_callback, &frameno))
202     {
203     case 0:
204       break;
205     case DWARF_CB_ABORT:
206       return DWARF_CB_ABORT;
207     case -1:
208       error (0, 0, "dwfl_thread_getframes: %s", dwfl_errmsg (-1));
209       /* All platforms do not have yet proper unwind termination.  */
210       break;
211     default:
212       abort ();
213     }
214   return DWARF_CB_OK;
215 }
216 
217 static void
dump(Dwfl * dwfl)218 dump (Dwfl *dwfl)
219 {
220   ptrdiff_t ptrdiff = dwfl_getmodules (dwfl, dump_modules, NULL, 0);
221   assert (ptrdiff == 0);
222   bool err = false;
223   switch (dwfl_getthreads (dwfl, thread_callback, NULL))
224     {
225     case 0:
226       break;
227     case DWARF_CB_ABORT:
228       err = true;
229       break;
230     case -1:
231       error (0, 0, "dwfl_getthreads: %s", dwfl_errmsg (-1));
232       err = true;
233       break;
234     default:
235       abort ();
236     }
237   callback_verify (0, 0, 0, NULL, dwfl);
238   if (err)
239     exit (EXIT_FAILURE);
240 }
241 
242 struct see_exec_module
243 {
244   Dwfl_Module *mod;
245   char selfpath[PATH_MAX + 1];
246 };
247 
248 static int
see_exec_module(Dwfl_Module * mod,void ** userdata,const char * name,Dwarf_Addr start,void * arg)249 see_exec_module (Dwfl_Module *mod, void **userdata __attribute__ ((unused)),
250 		 const char *name __attribute__ ((unused)),
251 		 Dwarf_Addr start __attribute__ ((unused)), void *arg)
252 {
253   struct see_exec_module *data = arg;
254   if (strcmp (name, data->selfpath) != 0)
255     return DWARF_CB_OK;
256   assert (data->mod == NULL);
257   data->mod = mod;
258   return DWARF_CB_ABORT;
259 }
260 
261 /* We used to do this on x86_64 only (see backtrace-child why we now don't):
262      PC will get changed to function 'jmp' by backtrace.c function
263      prepare_thread.  Then SIGUSR2 will be signalled to backtrace-child
264      which will invoke function sigusr2.
265      This is all done so that signal interrupts execution of the very first
266      instruction of a function.  Properly handled unwind should not slip into
267      the previous unrelated function.  */
268 
269 #ifdef __x86_64__
270 /* #define RAISE_JMP_PATCHING 1 */
271 #endif
272 
273 static void
prepare_thread(pid_t pid2,void (* jmp)(void))274 prepare_thread (pid_t pid2 __attribute__ ((unused)),
275 		void (*jmp) (void) __attribute__ ((unused)))
276 {
277 #ifndef RAISE_JMP_PATCHING
278   abort ();
279 #else /* RAISE_JMP_PATCHING */
280   long l;
281   struct user_regs_struct user_regs;
282   errno = 0;
283   l = ptrace (PTRACE_GETREGS, pid2, 0, (intptr_t) &user_regs);
284   assert (l == 0);
285   user_regs.rip = (intptr_t) jmp;
286   l = ptrace (PTRACE_SETREGS, pid2, 0, (intptr_t) &user_regs);
287   assert (l == 0);
288   l = ptrace (PTRACE_CONT, pid2, NULL, (void *) (intptr_t) SIGUSR2);
289   int status;
290   pid_t got = waitpid (pid2, &status, __WALL);
291   assert (got == pid2);
292   assert (WIFSTOPPED (status));
293   assert (WSTOPSIG (status) == SIGUSR1);
294 #endif /* RAISE_JMP_PATCHING */
295 }
296 
297 #include <asm/unistd.h>
298 #include <unistd.h>
299 
300 static void
report_pid(Dwfl * dwfl,pid_t pid)301 report_pid (Dwfl *dwfl, pid_t pid)
302 {
303   int result = dwfl_linux_proc_report (dwfl, pid);
304   if (result < 0)
305     error (2, 0, "dwfl_linux_proc_report: %s", dwfl_errmsg (-1));
306   else if (result > 0)
307     error (2, result, "dwfl_linux_proc_report");
308 
309   if (dwfl_report_end (dwfl, NULL, NULL) != 0)
310     error (2, 0, "dwfl_report_end: %s", dwfl_errmsg (-1));
311 
312   result = dwfl_linux_proc_attach (dwfl, pid, true);
313   if (result < 0)
314     error (2, 0, "dwfl_linux_proc_attach: %s", dwfl_errmsg (-1));
315   else if (result > 0)
316     error (2, result, "dwfl_linux_proc_attach");
317 }
318 
319 static Dwfl *
pid_to_dwfl(pid_t pid)320 pid_to_dwfl (pid_t pid)
321 {
322   static char *debuginfo_path;
323   static const Dwfl_Callbacks proc_callbacks =
324     {
325       .find_debuginfo = dwfl_standard_find_debuginfo,
326       .debuginfo_path = &debuginfo_path,
327 
328       .find_elf = dwfl_linux_proc_find_elf,
329     };
330   Dwfl *dwfl = dwfl_begin (&proc_callbacks);
331   if (dwfl == NULL)
332     error (2, 0, "dwfl_begin: %s", dwfl_errmsg (-1));
333   report_pid (dwfl, pid);
334   return dwfl;
335 }
336 
337 static void
exec_dump(const char * exec)338 exec_dump (const char *exec)
339 {
340   pid_t pid = fork ();
341   switch (pid)
342   {
343     case -1:
344       abort ();
345     case 0:
346       execl (exec, exec, "--ptraceme", NULL);
347       abort ();
348     default:
349       break;
350   }
351 
352   /* Catch the main thread.  Catch it first otherwise the /proc evaluation of
353      PID may have caught still ourselves before executing execl above.  */
354   errno = 0;
355   int status;
356   pid_t got = waitpid (pid, &status, 0);
357   assert (got == pid);
358   assert (WIFSTOPPED (status));
359   // Main thread will signal SIGUSR2.  Other thread will signal SIGUSR1.
360   assert (WSTOPSIG (status) == SIGUSR2);
361 
362   /* Catch the spawned thread.  Do not use __WCLONE as we could get racy
363      __WCLONE, probably despite pthread_create already had to be called the new
364      task is not yet alive enough for waitpid.  */
365   pid_t pid2 = waitpid (-1, &status, __WALL);
366   assert (pid2 > 0);
367   assert (pid2 != pid);
368   assert (WIFSTOPPED (status));
369   // Main thread will signal SIGUSR2.  Other thread will signal SIGUSR1.
370   assert (WSTOPSIG (status) == SIGUSR1);
371 
372   Dwfl *dwfl = pid_to_dwfl (pid);
373   char *selfpathname;
374   int i = asprintf (&selfpathname, "/proc/%ld/exe", (long) pid);
375   assert (i > 0);
376   struct see_exec_module data;
377   ssize_t ssize = readlink (selfpathname, data.selfpath,
378 			    sizeof (data.selfpath));
379   free (selfpathname);
380   assert (ssize > 0 && ssize < (ssize_t) sizeof (data.selfpath));
381   data.selfpath[ssize] = '\0';
382   data.mod = NULL;
383   dwfl_getmodules (dwfl, see_exec_module, &data, 0);
384   assert (data.mod != NULL);
385   GElf_Addr loadbase;
386   Elf *elf = dwfl_module_getelf (data.mod, &loadbase);
387   GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
388   assert (ehdr != NULL);
389   /* It is false also on x86_64 with i386 inferior.  */
390 #ifndef RAISE_JMP_PATCHING
391   use_raise_jmp_patching = false;
392 #else /* RAISE_JMP_PATCHING_ */
393   use_raise_jmp_patching = ehdr->e_machine == EM_X86_64;
394 #endif /* __x86_64__ */
395   void (*jmp) (void) = 0;
396   if (use_raise_jmp_patching)
397     {
398       // Find inferior symbol named "jmp".
399       int nsym = dwfl_module_getsymtab (data.mod);
400       int symi;
401       for (symi = 1; symi < nsym; ++symi)
402 	{
403 	  GElf_Sym symbol;
404 	  const char *symbol_name = dwfl_module_getsym (data.mod, symi, &symbol, NULL);
405 	  if (symbol_name == NULL)
406 	    continue;
407 	  switch (GELF_ST_TYPE (symbol.st_info))
408 	    {
409 	    case STT_SECTION:
410 	    case STT_FILE:
411 	    case STT_TLS:
412 	      continue;
413 	    default:
414 	      if (strcmp (symbol_name, "jmp") != 0)
415 		continue;
416 	      break;
417 	    }
418 	  /* LOADBASE is already applied here.  */
419 	  jmp = (void (*) (void)) (uintptr_t) symbol.st_value;
420 	  break;
421 	}
422       assert (symi < nsym);
423       prepare_thread (pid2, jmp);
424     }
425   dwfl_end (dwfl);
426   check_tid = pid2;
427   dwfl = pid_to_dwfl (pid);
428   dump (dwfl);
429   dwfl_end (dwfl);
430 }
431 
432 #define OPT_BACKTRACE_EXEC 0x100
433 
434 static const struct argp_option options[] =
435   {
436     { "backtrace-exec", OPT_BACKTRACE_EXEC, "EXEC", 0, N_("Run executable"), 0 },
437     { NULL, 0, NULL, 0, NULL, 0 }
438   };
439 
440 
441 static error_t
parse_opt(int key,char * arg,struct argp_state * state)442 parse_opt (int key, char *arg, struct argp_state *state)
443 {
444   switch (key)
445     {
446     case ARGP_KEY_INIT:
447       state->child_inputs[0] = state->input;
448       break;
449 
450     case OPT_BACKTRACE_EXEC:
451       exec_dump (arg);
452       exit (0);
453 
454     default:
455       return ARGP_ERR_UNKNOWN;
456     }
457   return 0;
458 }
459 
460 int
main(int argc,char ** argv)461 main (int argc __attribute__ ((unused)), char **argv)
462 {
463   /* We use no threads here which can interfere with handling a stream.  */
464   __fsetlocking (stdin, FSETLOCKING_BYCALLER);
465   __fsetlocking (stdout, FSETLOCKING_BYCALLER);
466   __fsetlocking (stderr, FSETLOCKING_BYCALLER);
467 
468   /* Set locale.  */
469   (void) setlocale (LC_ALL, "");
470 
471   elf_version (EV_CURRENT);
472 
473   Dwfl *dwfl = NULL;
474   const struct argp_child argp_children[] =
475     {
476       { .argp = dwfl_standard_argp () },
477       { .argp = NULL }
478     };
479   const struct argp argp =
480     {
481       options, parse_opt, NULL, NULL, argp_children, NULL, NULL
482     };
483   (void) argp_parse (&argp, argc, argv, 0, NULL, &dwfl);
484   assert (dwfl != NULL);
485   /* We want to make sure the dwfl was properly attached.  */
486   if (dwfl_pid (dwfl) < 0)
487     error (2, 0, "dwfl_pid: %s", dwfl_errmsg (-1));
488   dump (dwfl);
489   dwfl_end (dwfl);
490   return 0;
491 }
492 
493 #endif /* ! __linux__ */
494 
495