include/linux/kdbprivate.h

   1 #ifndef _KDBPRIVATE_H
   2 #define _KDBPRIVATE_H
   3
   4 /*
   5  * Kernel Debugger Architecture Independent Private Headers
   6  *
   7  * This file is subject to the terms and conditions of the GNU General Public
   8  * License.  See the file "COPYING" in the main directory of this archive
   9  * for more details.
  10  *
  11  * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
  12  */
  13
  14
  15 #include <linux/dis-asm.h>
  16 #include <asm/kdbprivate.h>
  17 #include <asm/bfd.h>
  18
  19         /*
  20          * Kernel Debugger Error codes.  Must not overlap with command codes.
  21          */
  22
  23 #define KDB_NOTFOUND    (-1)
  24 #define KDB_ARGCOUNT    (-2)
  25 #define KDB_BADWIDTH    (-3)
  26 #define KDB_BADRADIX    (-4)
  27 #define KDB_NOTENV      (-5)
  28 #define KDB_NOENVVALUE  (-6)
  29 #define KDB_NOTIMP      (-7)
  30 #define KDB_ENVFULL     (-8)
  31 #define KDB_ENVBUFFULL  (-9 )
  32 #define KDB_TOOMANYBPT  (-10)
  33 #define KDB_TOOMANYDBREGS (-11)
  34 #define KDB_DUPBPT      (-12)
  35 #define KDB_BPTNOTFOUND (-13)
  36 #define KDB_BADMODE     (-14)
  37 #define KDB_BADINT      (-15)
  38 #define KDB_INVADDRFMT  (-16)
  39 #define KDB_BADREG      (-17)
  40 #define KDB_BADCPUNUM   (-18)
  41 #define KDB_BADLENGTH   (-19)
  42 #define KDB_NOBP        (-20)
  43 #define KDB_BADADDR     (-21)
  44
  45         /*
  46          * Kernel Debugger Command codes.  Must not overlap with error codes.
  47          */
  48 #define KDB_CMD_GO      (-1001)
  49 #define KDB_CMD_CPU     (-1002)
  50 #define KDB_CMD_SS      (-1003)
  51 #define KDB_CMD_SSB     (-1004)
  52
  53         /*
  54          * Internal debug flags
  55          */
  56 /*      KDB_DEBUG_FLAG_BT       0x0001          Was Stack traceback debug */
  57 #define KDB_DEBUG_FLAG_BP       0x0002          /* Breakpoint subsystem debug */
  58 #define KDB_DEBUG_FLAG_BB_SUMM  0x0004          /* Basic block analysis, summary only */
  59 #define KDB_DEBUG_FLAG_AR       0x0008          /* Activation record, generic */
  60 #define KDB_DEBUG_FLAG_ARA      0x0010          /* Activation record, arch specific */
  61 #define KDB_DEBUG_FLAG_BB       0x0020          /* All basic block analysis */
  62 #define KDB_DEBUG_FLAG_STATE    0x0040          /* State flags */
  63 #define KDB_DEBUG_FLAG_MASK     0xffff          /* All debug flags */
  64 #define KDB_DEBUG_FLAG_SHIFT    16              /* Shift factor for dbflags */
  65
  66 #define KDB_DEBUG(flag)         (kdb_flags & (KDB_DEBUG_FLAG_##flag << KDB_DEBUG_FLAG_SHIFT))
  67 #define KDB_DEBUG_STATE(text,value)     if (KDB_DEBUG(STATE)) kdb_print_state(text, value)
  68
  69 typedef enum {
  70         KDB_REPEAT_NONE = 0,            /* Do not repeat this command */
  71         KDB_REPEAT_NO_ARGS,             /* Repeat the command without arguments */
  72         KDB_REPEAT_WITH_ARGS,           /* Repeat the command including its arguments */
  73 } kdb_repeat_t;
  74
  75 typedef int (*kdb_func_t)(int, const char **);
  76
  77         /*
  78          * Symbol table format returned by kallsyms.
  79          */
  80
  81 typedef struct __ksymtab {
  82                 unsigned long value;            /* Address of symbol */
  83                 const char *mod_name;           /* Module containing symbol or "kernel" */
  84                 unsigned long mod_start;
  85                 unsigned long mod_end;
  86                 const char *sec_name;           /* Section containing symbol */
  87                 unsigned long sec_start;
  88                 unsigned long sec_end;
  89                 const char *sym_name;           /* Full symbol name, including any version */
  90                 unsigned long sym_start;
  91                 unsigned long sym_end;
  92                 } kdb_symtab_t;
  93 extern int kallsyms_symbol_next(char *prefix_name, int flag);
  94 extern int kallsyms_symbol_complete(char *prefix_name, int max_len);
  95
  96         /*
  97          * Exported Symbols for kernel loadable modules to use.
  98          */
  99 extern int kdb_register(char *, kdb_func_t, char *, char *, short);
 100 extern int kdb_register_repeat(char *, kdb_func_t, char *, char *, short, kdb_repeat_t);
 101 extern int kdb_unregister(char *);
 102
 103 extern int kdb_getarea_size(void *, unsigned long, size_t);
 104 extern int kdb_putarea_size(unsigned long, void *, size_t);
 105
 106 /* Like get_user and put_user, kdb_getarea and kdb_putarea take variable
 107  * names, not pointers.  The underlying *_size functions take pointers.
 108  */
 109 #define kdb_getarea(x,addr) kdb_getarea_size(&(x), addr, sizeof((x)))
 110 #define kdb_putarea(addr,x) kdb_putarea_size(addr, &(x), sizeof((x)))
 111
 112 extern int kdb_getphysword(unsigned long *word,
 113                         unsigned long addr, size_t size);
 114 extern int kdb_getword(unsigned long *, unsigned long, size_t);
 115 extern int kdb_putword(unsigned long, unsigned long, size_t);
 116
 117 extern int kdbgetularg(const char *, unsigned long *);
 118 extern char *kdbgetenv(const char *);
 119 extern int kdbgetintenv(const char *, int *);
 120 extern int kdbgetaddrarg(int, const char**, int*, unsigned long *,
 121                          long *, char **);
 122 extern int kdbgetsymval(const char *, kdb_symtab_t *);
 123 extern int kdbnearsym(unsigned long, kdb_symtab_t *);
 124 extern void kdbnearsym_cleanup(void);
 125 extern char *kdb_read(char *buffer, size_t bufsize);
 126 extern char *kdb_strdup(const char *str, gfp_t type);
 127 extern void kdb_symbol_print(kdb_machreg_t, const kdb_symtab_t *, unsigned int);
 128
 129          /*
 130           * Do we have a set of registers?
 131           */
 132
 133 #define KDB_NULL_REGS(regs) \
 134         (regs == (struct pt_regs *)NULL ? kdb_printf("%s: null regs - should never happen\n", __FUNCTION__), 1 : 0)
 135
 136          /*
 137           * Routine for debugging the debugger state.
 138           */
 139
 140 extern void kdb_print_state(const char *, int);
 141
 142         /*
 143          * Per cpu kdb state.  A cpu can be under kdb control but outside kdb,
 144          * for example when doing single step.
 145          */
 146 volatile extern int kdb_state[ /*NR_CPUS*/ ];
 147 #define KDB_STATE_KDB           0x00000001      /* Cpu is inside kdb */
 148 #define KDB_STATE_LEAVING       0x00000002      /* Cpu is leaving kdb */
 149 #define KDB_STATE_CMD           0x00000004      /* Running a kdb command */
 150 #define KDB_STATE_KDB_CONTROL   0x00000008      /* This cpu is under kdb control */
 151 #define KDB_STATE_HOLD_CPU      0x00000010      /* Hold this cpu inside kdb */
 152 #define KDB_STATE_DOING_SS      0x00000020      /* Doing ss command */
 153 #define KDB_STATE_DOING_SSB     0x00000040      /* Doing ssb command, DOING_SS is also set */
 154 #define KDB_STATE_SSBPT         0x00000080      /* Install breakpoint after one ss, independent of DOING_SS */
 155 #define KDB_STATE_REENTRY       0x00000100      /* Valid re-entry into kdb */
 156 #define KDB_STATE_SUPPRESS      0x00000200      /* Suppress error messages */
 157 #define KDB_STATE_LONGJMP       0x00000400      /* longjmp() data is available */
 158 #define KDB_STATE_GO_SWITCH     0x00000800      /* go is switching back to initial cpu */
 159 #define KDB_STATE_PRINTF_LOCK   0x00001000      /* Holds kdb_printf lock */
 160 #define KDB_STATE_WAIT_IPI      0x00002000      /* Waiting for kdb_ipi() NMI */
 161 #define KDB_STATE_RECURSE       0x00004000      /* Recursive entry to kdb */
 162 #define KDB_STATE_IP_ADJUSTED   0x00008000      /* Restart IP has been adjusted */
 163 #define KDB_STATE_GO1           0x00010000      /* go only releases one cpu */
 164 #define KDB_STATE_KEYBOARD      0x00020000      /* kdb entered via keyboard on this cpu */
 165 #define KDB_STATE_KEXEC         0x00040000      /* kexec issued */
 166 #define KDB_STATE_ARCH          0xff000000      /* Reserved for arch specific use */
 167
 168 #define KDB_STATE_CPU(flag,cpu)         (kdb_state[cpu] & KDB_STATE_##flag)
 169 #define KDB_STATE_SET_CPU(flag,cpu)     ((void)(kdb_state[cpu] |= KDB_STATE_##flag))
 170 #define KDB_STATE_CLEAR_CPU(flag,cpu)   ((void)(kdb_state[cpu] &= ~KDB_STATE_##flag))
 171
 172 #define KDB_STATE(flag)         KDB_STATE_CPU(flag,smp_processor_id())
 173 #define KDB_STATE_SET(flag)     KDB_STATE_SET_CPU(flag,smp_processor_id())
 174 #define KDB_STATE_CLEAR(flag)   KDB_STATE_CLEAR_CPU(flag,smp_processor_id())
 175
 176         /*
 177          * kdb_nextline
 178          *
 179          *      Contains the current line number on the screen.  Used
 180          *      to handle the built-in pager (LINES env variable)
 181          */
 182 extern volatile int kdb_nextline;
 183
 184         /*
 185          * Breakpoint state
 186          *
 187          *      Each active and inactive breakpoint is represented by
 188          *      an instance of the following data structure.
 189          */
 190
 191 typedef struct _kdb_bp {
 192         bfd_vma         bp_addr;        /* Address breakpoint is present at */
 193         kdb_machinst_t  bp_inst;        /* Replaced instruction */
 194
 195         unsigned int    bp_free:1;      /* This entry is available */
 196
 197         unsigned int    bp_enabled:1;   /* Breakpoint is active in register */
 198         unsigned int    bp_global:1;    /* Global to all processors */
 199
 200         unsigned int    bp_hardtype:1;  /* Uses hardware register */
 201         unsigned int    bp_forcehw:1;   /* Force hardware register */
 202         unsigned int    bp_installed:1; /* Breakpoint is installed */
 203         unsigned int    bp_delay:1;     /* Do delayed bp handling */
 204         unsigned int    bp_delayed:1;   /* Delayed breakpoint */
 205
 206         int             bp_cpu;         /* Cpu #  (if bp_global == 0) */
 207         kdbhard_bp_t    bp_template;    /* Hardware breakpoint template */
 208         kdbhard_bp_t   *bp_hard[NR_CPUS]; /* Hardware breakpoint structure */
 209         int             bp_adjust;      /* Adjustment to PC for real instruction */
 210 } kdb_bp_t;
 211
 212         /*
 213          * Breakpoint handling subsystem global variables
 214          */
 215 extern kdb_bp_t kdb_breakpoints[/* KDB_MAXBPT */];
 216
 217         /*
 218          * Breakpoint architecture dependent functions.  Must be provided
 219          * in some form for all architectures.
 220          */
 221 extern void kdba_initbp(void);
 222 extern void kdba_printbp(kdb_bp_t *);
 223 extern void kdba_alloc_hwbp(kdb_bp_t *bp, int *diagp);
 224 extern void kdba_free_hwbp(kdb_bp_t *bp);
 225 extern int kdba_parsebp(int, const char**, int *, kdb_bp_t*);
 226 extern char *kdba_bptype(kdbhard_bp_t *);
 227 extern void kdba_setsinglestep(struct pt_regs *);
 228 extern void kdba_clearsinglestep(struct pt_regs *);
 229
 230         /*
 231          * Adjust instruction pointer architecture dependent function.  Must be
 232          * provided in some form for all architectures.
 233          */
 234 extern void kdba_adjust_ip(kdb_reason_t, int, struct pt_regs *);
 235
 236         /*
 237          * KDB-only global function prototypes.
 238          */
 239 extern void kdb_id1(unsigned long);
 240 extern void kdb_id_init(void);
 241
 242         /*
 243          * Initialization functions.
 244          */
 245 extern void kdba_init(void);
 246 extern void kdb_io_init(void);
 247
 248         /*
 249          * Architecture specific function to read a string.
 250          */
 251 typedef int (*get_char_func)(void);
 252 extern get_char_func poll_funcs[];
 253
 254 #ifndef CONFIG_IA64
 255         /*
 256          * Data for a single activation record on stack.
 257          */
 258
 259 struct kdb_stack_info {
 260         kdb_machreg_t physical_start;
 261         kdb_machreg_t physical_end;
 262         kdb_machreg_t logical_start;
 263         kdb_machreg_t logical_end;
 264         kdb_machreg_t next;
 265         const char *  id;
 266 };
 267
 268 typedef struct { DECLARE_BITMAP(bits, KDBA_MAXARGS); } valid_t;
 269
 270 struct kdb_activation_record {
 271         struct kdb_stack_info   stack;          /* information about current stack */
 272         int             args;                   /* number of arguments detected */
 273         kdb_machreg_t   arg[KDBA_MAXARGS];      /* -> arguments */
 274         valid_t         valid;                  /* is argument n valid? */
 275 };
 276 #endif
 277
 278         /*
 279          * Architecture specific Stack Traceback functions.
 280          */
 281
 282 struct task_struct;
 283
 284 extern int kdba_bt_address(kdb_machreg_t, int);
 285 extern int kdba_bt_process(const struct task_struct *, int);
 286
 287         /*
 288          * KDB Command Table
 289          */
 290
 291 typedef struct _kdbtab {
 292         char    *cmd_name;              /* Command name */
 293         kdb_func_t cmd_func;            /* Function to execute command */
 294         char    *cmd_usage;             /* Usage String for this command */
 295         char    *cmd_help;              /* Help message for this command */
 296         short    cmd_flags;             /* Parsing flags */
 297         short    cmd_minlen;            /* Minimum legal # command chars required */
 298         kdb_repeat_t cmd_repeat;        /* Does command auto repeat on enter? */
 299 } kdbtab_t;
 300
 301         /*
 302          * External command function declarations
 303          */
 304
 305 extern int kdb_id(int, const char **);
 306 extern int kdb_bt(int, const char **);
 307
 308         /*
 309          * External utility function declarations
 310          */
 311 extern char* kdb_getstr(char *, size_t, char *);
 312
 313         /*
 314          * Register contents manipulation
 315          */
 316 extern int kdba_getregcontents(const char *, struct pt_regs *, kdb_machreg_t *);
 317 extern int kdba_setregcontents(const char *, struct pt_regs *, kdb_machreg_t);
 318 extern int kdba_dumpregs(struct pt_regs *, const char *, const char *);
 319 extern int kdba_setpc(struct pt_regs *, kdb_machreg_t);
 320 extern kdb_machreg_t kdba_getpc(struct pt_regs *);
 321
 322         /*
 323          * Debug register handling.
 324          */
 325 extern void kdba_installdbreg(kdb_bp_t*);
 326 extern void kdba_removedbreg(kdb_bp_t*);
 327
 328         /*
 329          * Breakpoint handling - External interfaces
 330          */
 331 extern void kdb_initbptab(void);
 332 extern void kdb_bp_install_global(struct pt_regs *);
 333 extern void kdb_bp_install_local(struct pt_regs *);
 334 extern void kdb_bp_remove_global(void);
 335 extern void kdb_bp_remove_local(void);
 336
 337         /*
 338          * Breakpoint handling - Internal to kdb_bp.c/kdba_bp.c
 339          */
 340 extern int kdba_installbp(struct pt_regs *regs, kdb_bp_t *);
 341 extern int kdba_removebp(kdb_bp_t *);
 342
 343
 344 typedef enum {
 345         KDB_DB_BPT,     /* Breakpoint */
 346         KDB_DB_SS,      /* Single-step trap */
 347         KDB_DB_SSB,     /* Single step to branch */
 348         KDB_DB_SSBPT,   /* Single step over breakpoint */
 349         KDB_DB_NOBPT    /* Spurious breakpoint */
 350 } kdb_dbtrap_t;
 351
 352 extern kdb_dbtrap_t kdba_db_trap(struct pt_regs *, int);        /* DEBUG trap/fault handler */
 353 extern kdb_dbtrap_t kdba_bp_trap(struct pt_regs *, int);        /* Breakpoint trap/fault hdlr */
 354
 355         /*
 356          * Interrupt Handling
 357          */
 358 typedef unsigned long kdb_intstate_t;
 359
 360 extern void kdba_disableint(kdb_intstate_t *);
 361 extern void kdba_restoreint(kdb_intstate_t *);
 362
 363         /*
 364          * SMP and process stack manipulation routines.
 365          */
 366 extern int kdba_ipi(struct pt_regs *, void (*)(void));
 367 extern int kdba_main_loop(kdb_reason_t, kdb_reason_t, int, kdb_dbtrap_t, struct pt_regs *);
 368 extern int kdb_main_loop(kdb_reason_t, kdb_reason_t, int, kdb_dbtrap_t, struct pt_regs *);
 369
 370         /*
 371          * General Disassembler interfaces
 372          */
 373 extern int kdb_dis_fprintf(PTR, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 374 extern int kdb_dis_fprintf_dummy(PTR, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 375 extern disassemble_info kdb_di;
 376
 377         /*
 378          * Architecture Dependent Disassembler interfaces
 379          */
 380 extern int  kdba_id_printinsn(kdb_machreg_t, disassemble_info *);
 381 extern int  kdba_id_parsemode(const char *, disassemble_info*);
 382 extern void kdba_id_init(disassemble_info *);
 383 extern void kdba_check_pc(kdb_machreg_t *);
 384
 385         /*
 386          * Miscellaneous functions and data areas
 387          */
 388 extern char *kdb_cmds[];
 389 extern void debugger_syslog_data(char *syslog_data[]);
 390 extern unsigned long kdb_task_state_string(const char *);
 391 extern char kdb_task_state_char (const struct task_struct *);
 392 extern unsigned long kdb_task_state(const struct task_struct *p, unsigned long mask);
 393 extern void kdb_ps_suppressed(void);
 394 extern void kdb_ps1(const struct task_struct *p);
 395 extern int kdb_parse(const char *cmdstr);
 396 extern void kdb_print_nameval(const char *name, unsigned long val);
 397 extern void kdb_send_sig_info(struct task_struct *p, struct siginfo *info, int seqno);
 398 #ifdef CONFIG_SWAP
 399 extern void kdb_si_swapinfo(struct sysinfo *);
 400 #else
 401 #include <linux/swap.h>
 402 #define kdb_si_swapinfo(x) si_swapinfo(x)
 403 #endif
 404 extern void kdb_meminfo_proc_show(void);
 405 #ifdef  CONFIG_HUGETLB_PAGE
 406 extern void kdb_hugetlb_report_meminfo(void);
 407 #endif  /* CONFIG_HUGETLB_PAGE */
 408 extern const char *kdb_walk_kallsyms(loff_t *pos);
 409
 410         /*
 411          * Architecture Dependant Local Processor setup & cleanup interfaces
 412          */
 413 extern void kdba_local_arch_setup(void);
 414 extern void kdba_local_arch_cleanup(void);
 415
 416         /*
 417          * Defines for kdb_symbol_print.
 418          */
 419 #define KDB_SP_SPACEB   0x0001          /* Space before string */
 420 #define KDB_SP_SPACEA   0x0002          /* Space after string */
 421 #define KDB_SP_PAREN    0x0004          /* Parenthesis around string */
 422 #define KDB_SP_VALUE    0x0008          /* Print the value of the address */
 423 #define KDB_SP_SYMSIZE  0x0010          /* Print the size of the symbol */
 424 #define KDB_SP_NEWLINE  0x0020          /* Newline after string */
 425 #define KDB_SP_DEFAULT (KDB_SP_VALUE|KDB_SP_PAREN)
 426
 427 /* Save data about running processes */
 428
 429 struct kdb_running_process {
 430         struct task_struct *p;
 431         struct pt_regs *regs;
 432         int seqno;                              /* kdb sequence number */
 433         int irq_depth;                          /* irq count */
 434         struct kdba_running_process arch;       /* arch dependent save data */
 435 };
 436
 437 extern struct kdb_running_process kdb_running_process[/* NR_CPUS */];
 438
 439 extern int kdb_save_running(struct pt_regs *, kdb_reason_t, kdb_reason_t, int, kdb_dbtrap_t);
 440 extern void kdb_unsave_running(struct pt_regs *);
 441 extern struct task_struct *kdb_curr_task(int);
 442
 443 /*      Incremented each time the main kdb loop is entered on the initial cpu,
 444  *      it gives some indication of how old the saved data is.
 445  */
 446 extern int kdb_seqno;
 447
 448 #define kdb_task_has_cpu(p) (task_curr(p))
 449 extern void kdb_runqueue(unsigned long cpu, kdb_printf_t xxx_printf);
 450
 451 /* Simplify coexistence with NPTL */
 452 #define kdb_do_each_thread(g, p) do_each_thread(g, p)
 453 #define kdb_while_each_thread(g, p) while_each_thread(g, p)
 454
 455 #define GFP_KDB (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL)
 456
 457 extern void *debug_kmalloc(size_t size, gfp_t flags);
 458 extern void debug_kfree(void *);
 459 extern void debug_kusage(void);
 460
 461 extern void kdba_set_current_task(const struct task_struct *);
 462 extern const struct task_struct *kdb_current_task;
 463 extern struct pt_regs *kdb_current_regs;
 464
 465 /* Functions to safely read and write kernel areas.  The {to,from}_xxx
 466  * addresses are not necessarily valid, these functions must check for
 467  * validity.  If the arch already supports get and put routines with suitable
 468  * validation and/or recovery on invalid addresses then use those routines,
 469  * otherwise check it yourself.
 470  */
 471
 472 extern int kdba_putarea_size(unsigned long to_xxx, void *from, size_t size);
 473 extern int kdba_getarea_size(void *to, unsigned long from_xxx, size_t size);
 474 extern int kdba_verify_rw(unsigned long addr, size_t size);
 475
 476 #ifndef KDB_RUNNING_PROCESS_ORIGINAL
 477 #define KDB_RUNNING_PROCESS_ORIGINAL kdb_running_process
 478 #endif
 479
 480 extern int kdb_wait_for_cpus_secs;
 481 extern void kdba_cpu_up(void);
 482 extern char kdb_prompt_str[];
 483
 484 #define KDB_WORD_SIZE   ((int)sizeof(kdb_machreg_t))
 485
 486 #ifdef CONFIG_KDB_USB
 487 #include <linux/usb.h>
 488
 489 /* support up to 8 USB keyboards (probably excessive, but...) */
 490 #define KDB_USB_NUM_KEYBOARDS   8
 491
 492 struct kdb_usb_kbd_info {
 493         struct urb *urb;                /* pointer to the URB */
 494         unsigned char *buffer;          /* pointer to the kbd char buffer */
 495         int (*poll_func)(struct urb *urb); /* poll function to retrieve chars */
 496         int     poll_ret;       /* return val from poll_func */
 497         int     caps_lock;      /* state of the caps lock for this keyboard */
 498         struct uhci_qh *qh;
 499         int kdb_hid_event;
 500         struct urb *hid_urb;    /* pointer to the HID URB */
 501         /* USB Host Controller specific callbacks */
 502         kdb_hc_keyboard_attach_t kdb_hc_keyboard_attach;
 503         kdb_hc_keyboard_detach_t kdb_hc_keyboard_detach;
 504         int (*kdb_hc_urb_complete)(struct urb *urb); /* called when URB int is
 505                                                         processed */
 506
 507 };
 508
 509 extern struct kdb_usb_kbd_info kdb_usb_kbds[KDB_USB_NUM_KEYBOARDS];
 510
 511 #endif /* CONFIG_KDB_USB */
 512
 513 #ifdef CONFIG_KDB_KDUMP
 514 #define KDUMP_REASON_RESET      0
 515 extern void kdba_kdump_shutdown_slave(struct pt_regs *);
 516 #endif /* CONFIG_KDB_KDUMP */
 517
 518 #endif  /* !_KDBPRIVATE_H */