~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/xtensa/kernel/stacktrace.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Kernel and userspace stack tracing.
  3  *
  4  * This file is subject to the terms and conditions of the GNU General Public
  5  * License.  See the file "COPYING" in the main directory of this archive
  6  * for more details.
  7  *
  8  * Copyright (C) 2001 - 2013 Tensilica Inc.
  9  * Copyright (C) 2015 Cadence Design Systems Inc.
 10  */
 11 #include <linux/export.h>
 12 #include <linux/sched.h>
 13 #include <linux/stacktrace.h>
 14 
 15 #include <asm/stacktrace.h>
 16 #include <asm/traps.h>
 17 #include <asm/uaccess.h>
 18 
 19 #if IS_ENABLED(CONFIG_OPROFILE) || IS_ENABLED(CONFIG_PERF_EVENTS)
 20 
 21 /* Address of common_exception_return, used to check the
 22  * transition from kernel to user space.
 23  */
 24 extern int common_exception_return;
 25 
 26 /* A struct that maps to the part of the frame containing the a0 and
 27  * a1 registers.
 28  */
 29 struct frame_start {
 30         unsigned long a0;
 31         unsigned long a1;
 32 };
 33 
 34 void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
 35                            int (*ufn)(struct stackframe *frame, void *data),
 36                            void *data)
 37 {
 38         unsigned long windowstart = regs->windowstart;
 39         unsigned long windowbase = regs->windowbase;
 40         unsigned long a0 = regs->areg[0];
 41         unsigned long a1 = regs->areg[1];
 42         unsigned long pc = regs->pc;
 43         struct stackframe frame;
 44         int index;
 45 
 46         if (!depth--)
 47                 return;
 48 
 49         frame.pc = pc;
 50         frame.sp = a1;
 51 
 52         if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
 53                 return;
 54 
 55         /* Two steps:
 56          *
 57          * 1. Look through the register window for the
 58          * previous PCs in the call trace.
 59          *
 60          * 2. Look on the stack.
 61          */
 62 
 63         /* Step 1.  */
 64         /* Rotate WINDOWSTART to move the bit corresponding to
 65          * the current window to the bit #0.
 66          */
 67         windowstart = (windowstart << WSBITS | windowstart) >> windowbase;
 68 
 69         /* Look for bits that are set, they correspond to
 70          * valid windows.
 71          */
 72         for (index = WSBITS - 1; (index > 0) && depth; depth--, index--)
 73                 if (windowstart & (1 << index)) {
 74                         /* Get the PC from a0 and a1. */
 75                         pc = MAKE_PC_FROM_RA(a0, pc);
 76                         /* Read a0 and a1 from the
 77                          * corresponding position in AREGs.
 78                          */
 79                         a0 = regs->areg[index * 4];
 80                         a1 = regs->areg[index * 4 + 1];
 81 
 82                         frame.pc = pc;
 83                         frame.sp = a1;
 84 
 85                         if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
 86                                 return;
 87                 }
 88 
 89         /* Step 2. */
 90         /* We are done with the register window, we need to
 91          * look through the stack.
 92          */
 93         if (!depth)
 94                 return;
 95 
 96         /* Start from the a1 register. */
 97         /* a1 = regs->areg[1]; */
 98         while (a0 != 0 && depth--) {
 99                 struct frame_start frame_start;
100                 /* Get the location for a1, a0 for the
101                  * previous frame from the current a1.
102                  */
103                 unsigned long *psp = (unsigned long *)a1;
104 
105                 psp -= 4;
106 
107                 /* Check if the region is OK to access. */
108                 if (!access_ok(VERIFY_READ, psp, sizeof(frame_start)))
109                         return;
110                 /* Copy a1, a0 from user space stack frame. */
111                 if (__copy_from_user_inatomic(&frame_start, psp,
112                                               sizeof(frame_start)))
113                         return;
114 
115                 pc = MAKE_PC_FROM_RA(a0, pc);
116                 a0 = frame_start.a0;
117                 a1 = frame_start.a1;
118 
119                 frame.pc = pc;
120                 frame.sp = a1;
121 
122                 if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
123                         return;
124         }
125 }
126 EXPORT_SYMBOL(xtensa_backtrace_user);
127 
128 void xtensa_backtrace_kernel(struct pt_regs *regs, unsigned int depth,
129                              int (*kfn)(struct stackframe *frame, void *data),
130                              int (*ufn)(struct stackframe *frame, void *data),
131                              void *data)
132 {
133         unsigned long pc = regs->depc > VALID_DOUBLE_EXCEPTION_ADDRESS ?
134                 regs->depc : regs->pc;
135         unsigned long sp_start, sp_end;
136         unsigned long a0 = regs->areg[0];
137         unsigned long a1 = regs->areg[1];
138 
139         sp_start = a1 & ~(THREAD_SIZE - 1);
140         sp_end = sp_start + THREAD_SIZE;
141 
142         /* Spill the register window to the stack first. */
143         spill_registers();
144 
145         /* Read the stack frames one by one and create the PC
146          * from the a0 and a1 registers saved there.
147          */
148         while (a1 > sp_start && a1 < sp_end && depth--) {
149                 struct stackframe frame;
150                 unsigned long *psp = (unsigned long *)a1;
151 
152                 frame.pc = pc;
153                 frame.sp = a1;
154 
155                 if (kernel_text_address(pc) && kfn(&frame, data))
156                         return;
157 
158                 if (pc == (unsigned long)&common_exception_return) {
159                         regs = (struct pt_regs *)a1;
160                         if (user_mode(regs)) {
161                                 if (ufn == NULL)
162                                         return;
163                                 xtensa_backtrace_user(regs, depth, ufn, data);
164                                 return;
165                         }
166                         a0 = regs->areg[0];
167                         a1 = regs->areg[1];
168                         continue;
169                 }
170 
171                 sp_start = a1;
172 
173                 pc = MAKE_PC_FROM_RA(a0, pc);
174                 a0 = *(psp - 4);
175                 a1 = *(psp - 3);
176         }
177 }
178 EXPORT_SYMBOL(xtensa_backtrace_kernel);
179 
180 #endif
181 
182 void walk_stackframe(unsigned long *sp,
183                 int (*fn)(struct stackframe *frame, void *data),
184                 void *data)
185 {
186         unsigned long a0, a1;
187         unsigned long sp_end;
188 
189         a1 = (unsigned long)sp;
190         sp_end = ALIGN(a1, THREAD_SIZE);
191 
192         spill_registers();
193 
194         while (a1 < sp_end) {
195                 struct stackframe frame;
196 
197                 sp = (unsigned long *)a1;
198 
199                 a0 = *(sp - 4);
200                 a1 = *(sp - 3);
201 
202                 if (a1 <= (unsigned long)sp)
203                         break;
204 
205                 frame.pc = MAKE_PC_FROM_RA(a0, a1);
206                 frame.sp = a1;
207 
208                 if (fn(&frame, data))
209                         return;
210         }
211 }
212 
213 #ifdef CONFIG_STACKTRACE
214 
215 struct stack_trace_data {
216         struct stack_trace *trace;
217         unsigned skip;
218 };
219 
220 static int stack_trace_cb(struct stackframe *frame, void *data)
221 {
222         struct stack_trace_data *trace_data = data;
223         struct stack_trace *trace = trace_data->trace;
224 
225         if (trace_data->skip) {
226                 --trace_data->skip;
227                 return 0;
228         }
229         if (!kernel_text_address(frame->pc))
230                 return 0;
231 
232         trace->entries[trace->nr_entries++] = frame->pc;
233         return trace->nr_entries >= trace->max_entries;
234 }
235 
236 void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
237 {
238         struct stack_trace_data trace_data = {
239                 .trace = trace,
240                 .skip = trace->skip,
241         };
242         walk_stackframe(stack_pointer(task), stack_trace_cb, &trace_data);
243 }
244 EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
245 
246 void save_stack_trace(struct stack_trace *trace)
247 {
248         save_stack_trace_tsk(current, trace);
249 }
250 EXPORT_SYMBOL_GPL(save_stack_trace);
251 
252 #endif
253 
254 #ifdef CONFIG_FRAME_POINTER
255 
256 struct return_addr_data {
257         unsigned long addr;
258         unsigned skip;
259 };
260 
261 static int return_address_cb(struct stackframe *frame, void *data)
262 {
263         struct return_addr_data *r = data;
264 
265         if (r->skip) {
266                 --r->skip;
267                 return 0;
268         }
269         if (!kernel_text_address(frame->pc))
270                 return 0;
271         r->addr = frame->pc;
272         return 1;
273 }
274 
275 unsigned long return_address(unsigned level)
276 {
277         struct return_addr_data r = {
278                 .skip = level + 1,
279         };
280         walk_stackframe(stack_pointer(NULL), return_address_cb, &r);
281         return r.addr;
282 }
283 EXPORT_SYMBOL(return_address);
284 
285 #endif
286 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp