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

TOMOYO Linux Cross Reference
Linux/arch/arm64/kernel/debug-monitors.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ 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.72 ] ~ [ 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  * ARMv8 single-step debug support and mdscr context switching.
  3  *
  4  * Copyright (C) 2012 ARM Limited
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but 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  * Author: Will Deacon <will.deacon@arm.com>
 19  */
 20 
 21 #include <linux/cpu.h>
 22 #include <linux/debugfs.h>
 23 #include <linux/hardirq.h>
 24 #include <linux/init.h>
 25 #include <linux/ptrace.h>
 26 #include <linux/stat.h>
 27 
 28 #include <asm/debug-monitors.h>
 29 #include <asm/local.h>
 30 #include <asm/cputype.h>
 31 #include <asm/system_misc.h>
 32 
 33 /* Low-level stepping controls. */
 34 #define DBG_MDSCR_SS            (1 << 0)
 35 #define DBG_SPSR_SS             (1 << 21)
 36 
 37 /* MDSCR_EL1 enabling bits */
 38 #define DBG_MDSCR_KDE           (1 << 13)
 39 #define DBG_MDSCR_MDE           (1 << 15)
 40 #define DBG_MDSCR_MASK          ~(DBG_MDSCR_KDE | DBG_MDSCR_MDE)
 41 
 42 /* Determine debug architecture. */
 43 u8 debug_monitors_arch(void)
 44 {
 45         return read_cpuid(ID_AA64DFR0_EL1) & 0xf;
 46 }
 47 
 48 /*
 49  * MDSCR access routines.
 50  */
 51 static void mdscr_write(u32 mdscr)
 52 {
 53         unsigned long flags;
 54         local_dbg_save(flags);
 55         asm volatile("msr mdscr_el1, %0" :: "r" (mdscr));
 56         local_dbg_restore(flags);
 57 }
 58 
 59 static u32 mdscr_read(void)
 60 {
 61         u32 mdscr;
 62         asm volatile("mrs %0, mdscr_el1" : "=r" (mdscr));
 63         return mdscr;
 64 }
 65 
 66 /*
 67  * Allow root to disable self-hosted debug from userspace.
 68  * This is useful if you want to connect an external JTAG debugger.
 69  */
 70 static u32 debug_enabled = 1;
 71 
 72 static int create_debug_debugfs_entry(void)
 73 {
 74         debugfs_create_bool("debug_enabled", 0644, NULL, &debug_enabled);
 75         return 0;
 76 }
 77 fs_initcall(create_debug_debugfs_entry);
 78 
 79 static int __init early_debug_disable(char *buf)
 80 {
 81         debug_enabled = 0;
 82         return 0;
 83 }
 84 
 85 early_param("nodebugmon", early_debug_disable);
 86 
 87 /*
 88  * Keep track of debug users on each core.
 89  * The ref counts are per-cpu so we use a local_t type.
 90  */
 91 static DEFINE_PER_CPU(local_t, mde_ref_count);
 92 static DEFINE_PER_CPU(local_t, kde_ref_count);
 93 
 94 void enable_debug_monitors(enum debug_el el)
 95 {
 96         u32 mdscr, enable = 0;
 97 
 98         WARN_ON(preemptible());
 99 
100         if (local_inc_return(&__get_cpu_var(mde_ref_count)) == 1)
101                 enable = DBG_MDSCR_MDE;
102 
103         if (el == DBG_ACTIVE_EL1 &&
104             local_inc_return(&__get_cpu_var(kde_ref_count)) == 1)
105                 enable |= DBG_MDSCR_KDE;
106 
107         if (enable && debug_enabled) {
108                 mdscr = mdscr_read();
109                 mdscr |= enable;
110                 mdscr_write(mdscr);
111         }
112 }
113 
114 void disable_debug_monitors(enum debug_el el)
115 {
116         u32 mdscr, disable = 0;
117 
118         WARN_ON(preemptible());
119 
120         if (local_dec_and_test(&__get_cpu_var(mde_ref_count)))
121                 disable = ~DBG_MDSCR_MDE;
122 
123         if (el == DBG_ACTIVE_EL1 &&
124             local_dec_and_test(&__get_cpu_var(kde_ref_count)))
125                 disable &= ~DBG_MDSCR_KDE;
126 
127         if (disable) {
128                 mdscr = mdscr_read();
129                 mdscr &= disable;
130                 mdscr_write(mdscr);
131         }
132 }
133 
134 /*
135  * OS lock clearing.
136  */
137 static void clear_os_lock(void *unused)
138 {
139         asm volatile("msr mdscr_el1, %0" : : "r" (0));
140         isb();
141         asm volatile("msr oslar_el1, %0" : : "r" (0));
142         isb();
143 }
144 
145 static int __cpuinit os_lock_notify(struct notifier_block *self,
146                                     unsigned long action, void *data)
147 {
148         int cpu = (unsigned long)data;
149         if (action == CPU_ONLINE)
150                 smp_call_function_single(cpu, clear_os_lock, NULL, 1);
151         return NOTIFY_OK;
152 }
153 
154 static struct notifier_block __cpuinitdata os_lock_nb = {
155         .notifier_call = os_lock_notify,
156 };
157 
158 static int __cpuinit debug_monitors_init(void)
159 {
160         /* Clear the OS lock. */
161         smp_call_function(clear_os_lock, NULL, 1);
162         clear_os_lock(NULL);
163 
164         /* Register hotplug handler. */
165         register_cpu_notifier(&os_lock_nb);
166         return 0;
167 }
168 postcore_initcall(debug_monitors_init);
169 
170 /*
171  * Single step API and exception handling.
172  */
173 static void set_regs_spsr_ss(struct pt_regs *regs)
174 {
175         unsigned long spsr;
176 
177         spsr = regs->pstate;
178         spsr &= ~DBG_SPSR_SS;
179         spsr |= DBG_SPSR_SS;
180         regs->pstate = spsr;
181 }
182 
183 static void clear_regs_spsr_ss(struct pt_regs *regs)
184 {
185         unsigned long spsr;
186 
187         spsr = regs->pstate;
188         spsr &= ~DBG_SPSR_SS;
189         regs->pstate = spsr;
190 }
191 
192 static int single_step_handler(unsigned long addr, unsigned int esr,
193                                struct pt_regs *regs)
194 {
195         siginfo_t info;
196 
197         /*
198          * If we are stepping a pending breakpoint, call the hw_breakpoint
199          * handler first.
200          */
201         if (!reinstall_suspended_bps(regs))
202                 return 0;
203 
204         if (user_mode(regs)) {
205                 info.si_signo = SIGTRAP;
206                 info.si_errno = 0;
207                 info.si_code  = TRAP_HWBKPT;
208                 info.si_addr  = (void __user *)instruction_pointer(regs);
209                 force_sig_info(SIGTRAP, &info, current);
210 
211                 /*
212                  * ptrace will disable single step unless explicitly
213                  * asked to re-enable it. For other clients, it makes
214                  * sense to leave it enabled (i.e. rewind the controls
215                  * to the active-not-pending state).
216                  */
217                 user_rewind_single_step(current);
218         } else {
219                 /* TODO: route to KGDB */
220                 pr_warning("Unexpected kernel single-step exception at EL1\n");
221                 /*
222                  * Re-enable stepping since we know that we will be
223                  * returning to regs.
224                  */
225                 set_regs_spsr_ss(regs);
226         }
227 
228         return 0;
229 }
230 
231 static int __init single_step_init(void)
232 {
233         hook_debug_fault_code(DBG_ESR_EVT_HWSS, single_step_handler, SIGTRAP,
234                               TRAP_HWBKPT, "single-step handler");
235         return 0;
236 }
237 arch_initcall(single_step_init);
238 
239 /* Re-enable single step for syscall restarting. */
240 void user_rewind_single_step(struct task_struct *task)
241 {
242         /*
243          * If single step is active for this thread, then set SPSR.SS
244          * to 1 to avoid returning to the active-pending state.
245          */
246         if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP))
247                 set_regs_spsr_ss(task_pt_regs(task));
248 }
249 
250 void user_fastforward_single_step(struct task_struct *task)
251 {
252         if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP))
253                 clear_regs_spsr_ss(task_pt_regs(task));
254 }
255 
256 /* Kernel API */
257 void kernel_enable_single_step(struct pt_regs *regs)
258 {
259         WARN_ON(!irqs_disabled());
260         set_regs_spsr_ss(regs);
261         mdscr_write(mdscr_read() | DBG_MDSCR_SS);
262         enable_debug_monitors(DBG_ACTIVE_EL1);
263 }
264 
265 void kernel_disable_single_step(void)
266 {
267         WARN_ON(!irqs_disabled());
268         mdscr_write(mdscr_read() & ~DBG_MDSCR_SS);
269         disable_debug_monitors(DBG_ACTIVE_EL1);
270 }
271 
272 int kernel_active_single_step(void)
273 {
274         WARN_ON(!irqs_disabled());
275         return mdscr_read() & DBG_MDSCR_SS;
276 }
277 
278 /* ptrace API */
279 void user_enable_single_step(struct task_struct *task)
280 {
281         set_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP);
282         set_regs_spsr_ss(task_pt_regs(task));
283 }
284 
285 void user_disable_single_step(struct task_struct *task)
286 {
287         clear_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP);
288 }
289 

~ [ 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