Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
6c894b6930409e0b8e5d725776b9d5b6c2dc5517
[simgrid.git] / src / mc / mc_unw.cpp
1 /* Copyright (c) 2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 /** \file
8  *  Libunwind support for mc_address_space objects.
9  */
10
11 // We need this for the register indices:
12 // #define _GNU_SOURCE
13
14 #include <string.h>
15
16 // On x86_64, libunwind unw_context_t has the same layout as ucontext_t:
17 #include <sys/ucontext.h>
18
19 #include <libunwind.h>
20
21 #include "mc_object_info.h"
22 #include "mc_process.h"
23 #include "mc_unw.h"
24
25 extern "C" {
26
27 // ***** Implementation
28
29 /** Get frame unwind information (libunwind method)
30  *
31  *  Delegates to the local/ptrace implementation.
32  */
33 static int find_proc_info(unw_addr_space_t as,
34               unw_word_t ip, unw_proc_info_t *pip,
35               int need_unwind_info, void* arg)
36 {
37   mc_unw_context_t context = (mc_unw_context_t) arg;
38   return unw_get_accessors(context->process->unw_underlying_addr_space)->find_proc_info(
39     context->process->unw_underlying_addr_space, ip, pip,
40     need_unwind_info, context->process->unw_underlying_context
41   );
42 }
43
44 /** Release frame unwind information (libunwind method)
45  *
46  *  Delegates to the local/ptrace implementation.
47  */
48 static void put_unwind_info(unw_addr_space_t as,
49               unw_proc_info_t *pip, void* arg)
50 {
51   mc_unw_context_t context = (mc_unw_context_t) arg;
52   return unw_get_accessors(context->process->unw_underlying_addr_space)->put_unwind_info(
53     context->process->unw_underlying_addr_space, pip,
54     context->process->unw_underlying_context
55   );
56 }
57
58 /** (libunwind method)
59  *
60  *  Not implemented.
61  */
62 static int get_dyn_info_list_addr(unw_addr_space_t as,
63               unw_word_t *dilap, void* arg)
64 {
65   mc_unw_context_t context = (mc_unw_context_t) arg;
66   return unw_get_accessors(context->process->unw_underlying_addr_space)->get_dyn_info_list_addr(
67     context->process->unw_underlying_addr_space,
68     dilap,
69     context->process->unw_underlying_context
70   );
71 }
72
73 /** Read from the target address space memory (libunwind method)
74  *
75  *  Delegates to the `mc_process_t`.
76  */
77 static int access_mem(unw_addr_space_t as,
78               unw_word_t addr, unw_word_t *valp,
79               int write, void* arg)
80 {
81   mc_unw_context_t context = (mc_unw_context_t) arg;
82   if (write)
83     return - UNW_EREADONLYREG;
84   MC_address_space_read(context->address_space,
85     MC_ADDRESS_SPACE_READ_FLAGS_NONE, valp, (void*) addr, sizeof(unw_word_t), MC_PROCESS_INDEX_ANY);
86   // We don't handle failure gracefully.
87   return 0;
88 }
89
90 static void* get_reg(unw_context_t* context, unw_regnum_t regnum)
91 {
92 #ifdef __x86_64
93   mcontext_t* mcontext = &context->uc_mcontext;
94   switch (regnum) {
95   case UNW_X86_64_RAX: return &mcontext->gregs[REG_RAX];
96   case UNW_X86_64_RDX: return &mcontext->gregs[REG_RDX];
97   case UNW_X86_64_RCX: return &mcontext->gregs[REG_RCX];
98   case UNW_X86_64_RBX: return &mcontext->gregs[REG_RBX];
99   case UNW_X86_64_RSI: return &mcontext->gregs[REG_RSI];
100   case UNW_X86_64_RDI: return &mcontext->gregs[REG_RDI];
101   case UNW_X86_64_RBP: return &mcontext->gregs[REG_RBP];
102   case UNW_X86_64_RSP: return &mcontext->gregs[REG_RSP];
103   case UNW_X86_64_R8:  return &mcontext->gregs[REG_R8];
104   case UNW_X86_64_R9:  return &mcontext->gregs[REG_R9];
105   case UNW_X86_64_R10: return &mcontext->gregs[REG_R10];
106   case UNW_X86_64_R11: return &mcontext->gregs[REG_R11];
107   case UNW_X86_64_R12: return &mcontext->gregs[REG_R12];
108   case UNW_X86_64_R13: return &mcontext->gregs[REG_R13];
109   case UNW_X86_64_R14: return &mcontext->gregs[REG_R14];
110   case UNW_X86_64_R15: return &mcontext->gregs[REG_R15];
111   case UNW_X86_64_RIP: return &mcontext->gregs[REG_RIP];
112   default: return NULL;
113   }
114 #else
115   return NULL;
116 #endif
117 }
118
119 /** Read a standard register (libunwind method)
120  */
121 static int access_reg(unw_addr_space_t as,
122               unw_regnum_t regnum, unw_word_t *valp,
123               int write, void* arg)
124 {
125   mc_unw_context_t as_context = (mc_unw_context_t) arg;
126   unw_context_t* context = &as_context->context;
127   if (write)
128     return -UNW_EREADONLYREG;
129   greg_t* preg = (greg_t*) get_reg(context, regnum);
130   if (!preg)
131     return -UNW_EBADREG;
132   *valp = *preg;
133   return 0;
134 }
135
136 /** Read a floating-point register (libunwind method)
137  *
138  *  FP registers are caller-saved. The values saved by functions such as
139  *  `getcontext()` is not relevant for the caller. It is not really necessary
140  *  to save and handle them.
141  */
142 static int access_fpreg(unw_addr_space_t as,
143               unw_regnum_t regnum, unw_fpreg_t *fpvalp,
144               int write, void* arg)
145 {
146   return -UNW_EBADREG;
147 }
148
149 /** Resume the execution of the context (libunwind method)
150  *
151  * We don't use this.
152  */
153 static int resume(unw_addr_space_t as,
154               unw_cursor_t *cp, void* arg)
155 {
156   return -UNW_EUNSPEC;
157 }
158
159 /** Find informations about a function (libunwind method)
160  */
161 static int get_proc_name(unw_addr_space_t as,
162               unw_word_t addr, char *bufp,
163               size_t buf_len, unw_word_t *offp,
164               void* arg)
165 {
166   mc_unw_context_t context = (mc_unw_context_t) arg;
167   dw_frame_t frame = MC_process_find_function(context->process, (void*) addr);
168   if (!frame)
169     return - UNW_ENOINFO;
170   *offp = (unw_word_t) frame->low_pc - addr;
171
172   strncpy(bufp, frame->name, buf_len);
173   if (bufp[buf_len - 1]) {
174     bufp[buf_len - 1] = 0;
175     return -UNW_ENOMEM;
176   }
177
178   return 0;
179 }
180
181 // ***** Init
182
183 unw_accessors_t mc_unw_accessors =
184   {
185     &find_proc_info,
186     &put_unwind_info,
187     &get_dyn_info_list_addr,
188     &access_mem,
189     &access_reg,
190     &access_fpreg,
191     &resume,
192     &get_proc_name
193   };
194
195 // ***** Context management
196
197 int mc_unw_init_context(
198   mc_unw_context_t context, mc_process_t process, unw_context_t* c)
199 {
200   context->address_space = process;
201   context->process = process;
202
203   // Take a copy of the context for our own purpose:
204   context->context = *c;
205 #if defined(PROCESSOR_x86_64) || defined(PROCESSOR_i686)
206   // On x86_64, ucontext_t contains a pointer to itself for FP registers.
207   // We don't really need support for FR registers as they are caller saved
208   // and probably never use those fields as libunwind-x86_64 does not read
209   // FP registers from the unw_context_t
210   // but we fix the pointer in order to avoid dangling pointers:
211   context->context.uc_mcontext.fpregs = &(context->context.__fpregs_mem);
212 #else
213   // Do we need to do any fixup like this?
214   #error Target CPU type is not handled.
215 #endif
216
217   return 0;
218 }
219
220 int mc_unw_destroy_context(mc_unw_context_t context)
221 {
222   context->address_space = NULL;
223   context->process = NULL;
224   return 0;
225 }
226
227 // ***** Cursor management
228
229 int mc_unw_init_cursor(unw_cursor_t *cursor, mc_unw_context_t context)
230 {
231   if (!context->process || !context->address_space)
232     return -UNW_EUNSPEC;
233   mc_address_space_t as = context->address_space;
234
235   mc_process_t process = dynamic_cast<mc_process_t>(as);
236   if (process && MC_process_is_self(process))
237     return unw_init_local(cursor, &context->context);
238
239   return unw_init_remote(cursor, context->process->unw_addr_space, context);
240 }
241
242 }