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

TOMOYO Linux Cross Reference
Linux/arch/hexagon/kernel/kgdb.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * arch/hexagon/kernel/kgdb.c - Hexagon KGDB Support
  3  *
  4  * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
  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 and
  8  * only version 2 as 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, write to the Free Software
 17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 18  * 02110-1301, USA.
 19  */
 20 
 21 #include <linux/irq.h>
 22 #include <linux/sched.h>
 23 #include <linux/kdebug.h>
 24 #include <linux/kgdb.h>
 25 
 26 /* All registers are 4 bytes, for now */
 27 #define GDB_SIZEOF_REG 4
 28 
 29 /* The register names are used during printing of the regs;
 30  * Keep these at three letters to pretty-print. */
 31 struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
 32         { " r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, r00)},
 33         { " r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, r01)},
 34         { " r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r02)},
 35         { " r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r03)},
 36         { " r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r04)},
 37         { " r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r05)},
 38         { " r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r06)},
 39         { " r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r07)},
 40         { " r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r08)},
 41         { " r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r09)},
 42         { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10)},
 43         { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11)},
 44         { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12)},
 45         { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13)},
 46         { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14)},
 47         { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15)},
 48         { "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, r16)},
 49         { "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, r17)},
 50         { "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, r18)},
 51         { "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, r19)},
 52         { "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, r20)},
 53         { "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, r21)},
 54         { "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, r22)},
 55         { "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, r23)},
 56         { "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, r24)},
 57         { "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, r25)},
 58         { "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, r26)},
 59         { "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, r27)},
 60         { "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, r28)},
 61         { "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, r29)},
 62         { "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, r30)},
 63         { "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, r31)},
 64 
 65         { "usr", GDB_SIZEOF_REG, offsetof(struct pt_regs, usr)},
 66         { "preds", GDB_SIZEOF_REG, offsetof(struct pt_regs, preds)},
 67         { " m0", GDB_SIZEOF_REG, offsetof(struct pt_regs, m0)},
 68         { " m1", GDB_SIZEOF_REG, offsetof(struct pt_regs, m1)},
 69         { "sa0", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa0)},
 70         { "sa1", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa1)},
 71         { "lc0", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc0)},
 72         { "lc1", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc1)},
 73         { " gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp)},
 74         { "ugp", GDB_SIZEOF_REG, offsetof(struct pt_regs, ugp)},
 75         { "cs0", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs0)},
 76         { "cs1", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs1)},
 77         { "psp", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmpsp)},
 78         { "elr", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmel)},
 79         { "est", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmest)},
 80         { "badva", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmbadva)},
 81         { "restart_r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, restart_r0)},
 82         { "syscall_nr", GDB_SIZEOF_REG, offsetof(struct pt_regs, syscall_nr)},
 83 };
 84 
 85 struct kgdb_arch arch_kgdb_ops = {
 86         /* trap0(#0xDB) 0x0cdb0054 */
 87         .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
 88 };
 89 
 90 char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
 91 {
 92         if (regno >= DBG_MAX_REG_NUM || regno < 0)
 93                 return NULL;
 94 
 95         *((unsigned long *) mem) = *((unsigned long *) ((void *)regs +
 96                 dbg_reg_def[regno].offset));
 97 
 98         return dbg_reg_def[regno].name;
 99 }
100 
101 int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
102 {
103         if (regno >= DBG_MAX_REG_NUM || regno < 0)
104                 return -EINVAL;
105 
106         *((unsigned long *) ((void *)regs + dbg_reg_def[regno].offset)) =
107                 *((unsigned long *) mem);
108 
109         return 0;
110 }
111 
112 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
113 {
114         instruction_pointer(regs) = pc;
115 }
116 
117 #ifdef CONFIG_SMP
118 
119 /**
120  * kgdb_roundup_cpus - Get other CPUs into a holding pattern
121  * @flags: Current IRQ state
122  *
123  * On SMP systems, we need to get the attention of the other CPUs
124  * and get them be in a known state.  This should do what is needed
125  * to get the other CPUs to call kgdb_wait(). Note that on some arches,
126  * the NMI approach is not used for rounding up all the CPUs. For example,
127  * in case of MIPS, smp_call_function() is used to roundup CPUs. In
128  * this case, we have to make sure that interrupts are enabled before
129  * calling smp_call_function(). The argument to this function is
130  * the flags that will be used when restoring the interrupts. There is
131  * local_irq_save() call before kgdb_roundup_cpus().
132  *
133  * On non-SMP systems, this is not called.
134  */
135 
136 static void hexagon_kgdb_nmi_hook(void *ignored)
137 {
138         kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
139 }
140 
141 void kgdb_roundup_cpus(unsigned long flags)
142 {
143         local_irq_enable();
144         smp_call_function(hexagon_kgdb_nmi_hook, NULL, 0);
145         local_irq_disable();
146 }
147 #endif
148 
149 
150 /*  Not yet working  */
151 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
152                                  struct task_struct *task)
153 {
154         struct pt_regs *thread_regs;
155 
156         if (task == NULL)
157                 return;
158 
159         /* Initialize to zero */
160         memset(gdb_regs, 0, NUMREGBYTES);
161 
162         /* Otherwise, we have only some registers from switch_to() */
163         thread_regs = task_pt_regs(task);
164         gdb_regs[0] = thread_regs->r00;
165 }
166 
167 /**
168  * kgdb_arch_handle_exception - Handle architecture specific GDB packets.
169  * @vector: The error vector of the exception that happened.
170  * @signo: The signal number of the exception that happened.
171  * @err_code: The error code of the exception that happened.
172  * @remcom_in_buffer: The buffer of the packet we have read.
173  * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
174  * @regs: The &struct pt_regs of the current process.
175  *
176  * This function MUST handle the 'c' and 's' command packets,
177  * as well packets to set / remove a hardware breakpoint, if used.
178  * If there are additional packets which the hardware needs to handle,
179  * they are handled here.  The code should return -1 if it wants to
180  * process more packets, and a %0 or %1 if it wants to exit from the
181  * kgdb callback.
182  *
183  * Not yet working.
184  */
185 int kgdb_arch_handle_exception(int vector, int signo, int err_code,
186                                char *remcom_in_buffer, char *remcom_out_buffer,
187                                struct pt_regs *linux_regs)
188 {
189         switch (remcom_in_buffer[0]) {
190         case 's':
191         case 'c':
192                 return 0;
193         }
194         /* Stay in the debugger. */
195         return -1;
196 }
197 
198 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
199 {
200         /* cpu roundup */
201         if (atomic_read(&kgdb_active) != -1) {
202                 kgdb_nmicallback(smp_processor_id(), args->regs);
203                 return NOTIFY_STOP;
204         }
205 
206         if (user_mode(args->regs))
207                 return NOTIFY_DONE;
208 
209         if (kgdb_handle_exception(args->trapnr & 0xff, args->signr, args->err,
210                                     args->regs))
211                 return NOTIFY_DONE;
212 
213         return NOTIFY_STOP;
214 }
215 
216 static int
217 kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
218 {
219         unsigned long flags;
220         int ret;
221 
222         local_irq_save(flags);
223         ret = __kgdb_notify(ptr, cmd);
224         local_irq_restore(flags);
225 
226         return ret;
227 }
228 
229 static struct notifier_block kgdb_notifier = {
230         .notifier_call = kgdb_notify,
231 
232         /*
233          * Lowest-prio notifier priority, we want to be notified last:
234          */
235         .priority = -INT_MAX,
236 };
237 
238 /**
239  * kgdb_arch_init - Perform any architecture specific initalization.
240  *
241  * This function will handle the initalization of any architecture
242  * specific callbacks.
243  */
244 int kgdb_arch_init(void)
245 {
246         return register_die_notifier(&kgdb_notifier);
247 }
248 
249 /**
250  * kgdb_arch_exit - Perform any architecture specific uninitalization.
251  *
252  * This function will handle the uninitalization of any architecture
253  * specific callbacks, for dynamic registration and unregistration.
254  */
255 void kgdb_arch_exit(void)
256 {
257         unregister_die_notifier(&kgdb_notifier);
258 }
259 

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