1 /* libunwind - a platform-independent unwind library 2 Copyright (C) 2002 Hewlett-Packard Co 3 Copyright (C) 2007 David Mosberger-Tang 4 Contributed by David Mosberger-Tang <dmosberger (at) gmail.com> 5 6 This file is part of libunwind. 7 8 Permission is hereby granted, free of charge, to any person obtaining 9 a copy of this software and associated documentation files (the 10 "Software"), to deal in the Software without restriction, including 11 without limitation the rights to use, copy, modify, merge, publish, 12 distribute, sublicense, and/or sell copies of the Software, and to 13 permit persons to whom the Software is furnished to do so, subject to 14 the following conditions: 15 16 The above copyright notice and this permission notice shall be 17 included in all copies or substantial portions of the Software. 18 19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 22 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 23 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 24 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 25 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 26 27 #ifdef HAVE_CONFIG_H 28 #include <config.h> 29 #endif 30 31 #include <stdlib.h> 32 #include <string.h> 33 34 #include "unwind_i.h" 35 36 #ifdef UNW_REMOTE_ONLY 37 38 /* unw_local_addr_space is a NULL pointer in this case. */ 39 PROTECTED unw_addr_space_t unw_local_addr_space; 40 41 #else /* !UNW_REMOTE_ONLY */ 42 43 static struct unw_addr_space local_addr_space; 44 45 PROTECTED unw_addr_space_t unw_local_addr_space = &local_addr_space; 46 47 # ifdef UNW_LOCAL_ONLY 48 49 HIDDEN void * 50 tdep_uc_addr (ucontext_t *uc, int reg) 51 { 52 return x86_r_uc_addr (uc, reg); 53 } 54 55 # endif /* UNW_LOCAL_ONLY */ 56 57 HIDDEN unw_dyn_info_list_t _U_dyn_info_list; 58 59 /* XXX fix me: there is currently no way to locate the dyn-info list 60 by a remote unwinder. On ia64, this is done via a special 61 unwind-table entry. Perhaps something similar can be done with 62 DWARF2 unwind info. */ 63 64 static void 65 put_unwind_info (unw_addr_space_t as, unw_proc_info_t *proc_info, void *arg) 66 { 67 /* it's a no-op */ 68 } 69 70 static int 71 get_dyn_info_list_addr (unw_addr_space_t as, unw_word_t *dyn_info_list_addr, 72 void *arg) 73 { 74 *dyn_info_list_addr = (unw_word_t) &_U_dyn_info_list; 75 return 0; 76 } 77 78 /* ANDROID support update. */ 79 #ifndef PAGE_SIZE 80 #define PAGE_SIZE 4096 81 #endif 82 /* End of ANDROID update. */ 83 84 #define PAGE_START(a) ((a) & ~(PAGE_SIZE-1)) 85 86 /* Cache of already validated addresses */ 87 #define NLGA 4 88 static unw_word_t last_good_addr[NLGA]; 89 static int lga_victim; 90 91 static int 92 validate_mem (unw_word_t addr) 93 { 94 int i, victim; 95 #ifdef HAVE_MINCORE 96 unsigned char mvec[2]; /* Unaligned access may cross page boundary */ 97 #endif 98 size_t len; 99 100 if (PAGE_START(addr + sizeof (unw_word_t) - 1) == PAGE_START(addr)) 101 len = PAGE_SIZE; 102 else 103 len = PAGE_SIZE * 2; 104 105 addr = PAGE_START(addr); 106 107 if (addr == 0) 108 return -1; 109 110 for (i = 0; i < NLGA; i++) 111 { 112 if (last_good_addr[i] && (addr == last_good_addr[i])) 113 return 0; 114 } 115 116 #ifdef HAVE_MINCORE 117 if (mincore ((void *) addr, len, mvec) == -1) 118 #else 119 if (msync ((void *) addr, len, MS_ASYNC) == -1) 120 #endif 121 return -1; 122 123 victim = lga_victim; 124 for (i = 0; i < NLGA; i++) { 125 if (!last_good_addr[victim]) { 126 last_good_addr[victim++] = addr; 127 return 0; 128 } 129 victim = (victim + 1) % NLGA; 130 } 131 132 /* All slots full. Evict the victim. */ 133 last_good_addr[victim] = addr; 134 victim = (victim + 1) % NLGA; 135 lga_victim = victim; 136 137 return 0; 138 } 139 140 static int 141 access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val, int write, 142 void *arg) 143 { 144 if (write) 145 { 146 /* ANDROID support update. */ 147 #ifdef UNW_LOCAL_ONLY 148 if (map_local_is_writable (addr, sizeof(unw_word_t))) 149 { 150 #endif 151 Debug (16, "mem[%x] <- %x\n", addr, *val); 152 *(unw_word_t *) addr = *val; 153 #ifdef UNW_LOCAL_ONLY 154 } 155 else 156 { 157 Debug (16, "Unwritable memory mem[%x] <- %x\n", addr, *val); 158 return -1; 159 } 160 #endif 161 /* End of ANDROID update. */ 162 } 163 else 164 { 165 /* validate address */ 166 const struct cursor *c = (const struct cursor *)arg; 167 if (c && c->validate && validate_mem(addr)) 168 return -1; 169 /* ANDROID support update. */ 170 #ifdef UNW_LOCAL_ONLY 171 if (map_local_is_readable (addr, sizeof(unw_word_t))) 172 { 173 #endif 174 *val = *(unw_word_t *) addr; 175 Debug (16, "mem[%x] -> %x\n", addr, *val); 176 #ifdef UNW_LOCAL_ONLY 177 } 178 else 179 { 180 Debug (16, "Unreadable memory mem[%x] -> XXX\n", addr); 181 return -1; 182 } 183 #endif 184 /* End of ANDROID update. */ 185 } 186 return 0; 187 } 188 189 static int 190 access_reg (unw_addr_space_t as, unw_regnum_t reg, unw_word_t *val, int write, 191 void *arg) 192 { 193 unw_word_t *addr; 194 ucontext_t *uc = ((struct cursor *)arg)->uc; 195 196 if (unw_is_fpreg (reg)) 197 goto badreg; 198 199 if (!(addr = x86_r_uc_addr (uc, reg))) 200 goto badreg; 201 202 if (write) 203 { 204 *(unw_word_t *) addr = *val; 205 Debug (12, "%s <- %x\n", unw_regname (reg), *val); 206 } 207 else 208 { 209 *val = *(unw_word_t *) addr; 210 Debug (12, "%s -> %x\n", unw_regname (reg), *val); 211 } 212 return 0; 213 214 badreg: 215 Debug (1, "bad register number %u\n", reg); 216 return -UNW_EBADREG; 217 } 218 219 static int 220 access_fpreg (unw_addr_space_t as, unw_regnum_t reg, unw_fpreg_t *val, 221 int write, void *arg) 222 { 223 ucontext_t *uc = ((struct cursor *)arg)->uc; 224 unw_fpreg_t *addr; 225 226 if (!unw_is_fpreg (reg)) 227 goto badreg; 228 229 if (!(addr = x86_r_uc_addr (uc, reg))) 230 goto badreg; 231 232 if (write) 233 { 234 Debug (12, "%s <- %08lx.%08lx.%08lx\n", unw_regname (reg), 235 ((long *)val)[0], ((long *)val)[1], ((long *)val)[2]); 236 *(unw_fpreg_t *) addr = *val; 237 } 238 else 239 { 240 *val = *(unw_fpreg_t *) addr; 241 Debug (12, "%s -> %08lx.%08lx.%08lx\n", unw_regname (reg), 242 ((long *)val)[0], ((long *)val)[1], ((long *)val)[2]); 243 } 244 return 0; 245 246 badreg: 247 Debug (1, "bad register number %u\n", reg); 248 /* attempt to access a non-preserved register */ 249 return -UNW_EBADREG; 250 } 251 252 static int 253 get_static_proc_name (unw_addr_space_t as, unw_word_t ip, 254 char *buf, size_t buf_len, unw_word_t *offp, 255 void *arg) 256 { 257 return _Uelf32_get_proc_name (as, getpid (), ip, buf, buf_len, offp, arg); 258 } 259 260 static int 261 access_mem_unrestricted (unw_addr_space_t as, unw_word_t addr, unw_word_t *val, 262 int write, void *arg) 263 { 264 if (write) 265 return -1; 266 267 *val = *(unw_word_t *) addr; 268 Debug (16, "mem[%x] -> %x\n", addr, *val); 269 return 0; 270 } 271 272 // This initializes just enough of the address space to call the 273 // access memory function. 274 PROTECTED void 275 unw_local_access_addr_space_init (unw_addr_space_t as) 276 { 277 memset (as, 0, sizeof (*as)); 278 as->acc.access_mem = access_mem_unrestricted; 279 } 280 281 HIDDEN void 282 x86_local_addr_space_init (void) 283 { 284 memset (&local_addr_space, 0, sizeof (local_addr_space)); 285 local_addr_space.caching_policy = UNW_CACHE_GLOBAL; 286 local_addr_space.acc.find_proc_info = dwarf_find_proc_info; 287 local_addr_space.acc.put_unwind_info = put_unwind_info; 288 local_addr_space.acc.get_dyn_info_list_addr = get_dyn_info_list_addr; 289 local_addr_space.acc.access_mem = access_mem; 290 local_addr_space.acc.access_reg = access_reg; 291 local_addr_space.acc.access_fpreg = access_fpreg; 292 local_addr_space.acc.resume = x86_local_resume; 293 local_addr_space.acc.get_proc_name = get_static_proc_name; 294 unw_flush_cache (&local_addr_space, 0, 0); 295 296 map_local_init (); 297 } 298 299 #endif /* !UNW_REMOTE_ONLY */ 300
