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@gmail.com>
5
6This file is part of libunwind.
7
8Permission is hereby granted, free of charge, to any person obtaining
9a copy of this software and associated documentation files (the
10"Software"), to deal in the Software without restriction, including
11without limitation the rights to use, copy, modify, merge, publish,
12distribute, sublicense, and/or sell copies of the Software, and to
13permit persons to whom the Software is furnished to do so, subject to
14the following conditions:
15
16The above copyright notice and this permission notice shall be
17included in all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
23LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25WITH 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.  */
39PROTECTED unw_addr_space_t unw_local_addr_space;
40
41#else /* !UNW_REMOTE_ONLY */
42
43static struct unw_addr_space local_addr_space;
44
45PROTECTED unw_addr_space_t unw_local_addr_space = &local_addr_space;
46
47# ifdef UNW_LOCAL_ONLY
48
49HIDDEN void *
50tdep_uc_addr (ucontext_t *uc, int reg)
51{
52  return x86_r_uc_addr (uc, reg);
53}
54
55# endif /* UNW_LOCAL_ONLY */
56
57HIDDEN 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
64static void
65put_unwind_info (unw_addr_space_t as, unw_proc_info_t *proc_info, void *arg)
66{
67  /* it's a no-op */
68}
69
70static int
71get_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
88static unw_word_t last_good_addr[NLGA];
89static int lga_victim;
90
91static int
92validate_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
140static int
141access_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))
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))
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
189static int
190access_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
219static int
220access_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
252static int
253get_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);
258}
259
260HIDDEN void
261x86_local_addr_space_init (void)
262{
263  memset (&local_addr_space, 0, sizeof (local_addr_space));
264  local_addr_space.caching_policy = UNW_CACHE_GLOBAL;
265  local_addr_space.acc.find_proc_info = dwarf_find_proc_info;
266  local_addr_space.acc.put_unwind_info = put_unwind_info;
267  local_addr_space.acc.get_dyn_info_list_addr = get_dyn_info_list_addr;
268  local_addr_space.acc.access_mem = access_mem;
269  local_addr_space.acc.access_reg = access_reg;
270  local_addr_space.acc.access_fpreg = access_fpreg;
271  local_addr_space.acc.resume = x86_local_resume;
272  local_addr_space.acc.get_proc_name = get_static_proc_name;
273  unw_flush_cache (&local_addr_space, 0, 0);
274
275  map_local_init ();
276}
277
278#endif /* !UNW_REMOTE_ONLY */
279