Branch data     Line data    Source code

       1                 :            : /* Rewritten and vastly simplified by Rusty Russell for in-kernel
       2                 :            :  * module loader:
       3                 :            :  *   Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
       4                 :            :  */
       5                 :            : #ifndef _LINUX_KALLSYMS_H
       6                 :            : #define _LINUX_KALLSYMS_H
       7                 :            : 
       8                 :            : #include <linux/errno.h>
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/stddef.h>
      11                 :            : 
      12                 :            : #define KSYM_NAME_LEN 128
      13                 :            : #define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + (KSYM_NAME_LEN - 1) + \
      14                 :            :                          2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + 1)
      15                 :            : 
      16                 :            : struct module;
      17                 :            : 
      18                 :            : #ifdef CONFIG_KALLSYMS
      19                 :            : /* Lookup the address for a symbol. Returns 0 if not found. */
      20                 :            : unsigned long kallsyms_lookup_name(const char *name);
      21                 :            : 
      22                 :            : /* Call a function on each kallsyms symbol in the core kernel */
      23                 :            : int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
      24                 :            :                                       unsigned long),
      25                 :            :                             void *data);
      26                 :            : 
      27                 :            : extern int kallsyms_lookup_size_offset(unsigned long addr,
      28                 :            :                                   unsigned long *symbolsize,
      29                 :            :                                   unsigned long *offset);
      30                 :            : 
      31                 :            : /* Lookup an address.  modname is set to NULL if it's in the kernel. */
      32                 :            : const char *kallsyms_lookup(unsigned long addr,
      33                 :            :                             unsigned long *symbolsize,
      34                 :            :                             unsigned long *offset,
      35                 :            :                             char **modname, char *namebuf);
      36                 :            : 
      37                 :            : /* Look up a kernel symbol and return it in a text buffer. */
      38                 :            : extern int sprint_symbol(char *buffer, unsigned long address);
      39                 :            : extern int sprint_symbol_no_offset(char *buffer, unsigned long address);
      40                 :            : extern int sprint_backtrace(char *buffer, unsigned long address);
      41                 :            : 
      42                 :            : /* Look up a kernel symbol and print it to the kernel messages. */
      43                 :            : extern void __print_symbol(const char *fmt, unsigned long address);
      44                 :            : 
      45                 :            : int lookup_symbol_name(unsigned long addr, char *symname);
      46                 :            : int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
      47                 :            : 
      48                 :            : #else /* !CONFIG_KALLSYMS */
      49                 :            : 
      50                 :            : static inline unsigned long kallsyms_lookup_name(const char *name)
      51                 :            : {
      52                 :            :         return 0;
      53                 :            : }
      54                 :            : 
      55                 :            : static inline int kallsyms_on_each_symbol(int (*fn)(void *, const char *,
      56                 :            :                                                     struct module *,
      57                 :            :                                                     unsigned long),
      58                 :            :                                           void *data)
      59                 :            : {
      60                 :            :         return 0;
      61                 :            : }
      62                 :            : 
      63                 :            : static inline int kallsyms_lookup_size_offset(unsigned long addr,
      64                 :            :                                               unsigned long *symbolsize,
      65                 :            :                                               unsigned long *offset)
      66                 :            : {
      67                 :            :         return 0;
      68                 :            : }
      69                 :            : 
      70                 :            : static inline const char *kallsyms_lookup(unsigned long addr,
      71                 :            :                                           unsigned long *symbolsize,
      72                 :            :                                           unsigned long *offset,
      73                 :            :                                           char **modname, char *namebuf)
      74                 :            : {
      75                 :            :         return NULL;
      76                 :            : }
      77                 :            : 
      78                 :            : static inline int sprint_symbol(char *buffer, unsigned long addr)
      79                 :            : {
      80                 :            :         *buffer = '\0';
      81                 :            :         return 0;
      82                 :            : }
      83                 :            : 
      84                 :            : static inline int sprint_symbol_no_offset(char *buffer, unsigned long addr)
      85                 :            : {
      86                 :            :         *buffer = '\0';
      87                 :            :         return 0;
      88                 :            : }
      89                 :            : 
      90                 :            : static inline int sprint_backtrace(char *buffer, unsigned long addr)
      91                 :            : {
      92                 :            :         *buffer = '\0';
      93                 :            :         return 0;
      94                 :            : }
      95                 :            : 
      96                 :            : static inline int lookup_symbol_name(unsigned long addr, char *symname)
      97                 :            : {
      98                 :            :         return -ERANGE;
      99                 :            : }
     100                 :            : 
     101                 :            : static inline int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
     102                 :            : {
     103                 :            :         return -ERANGE;
     104                 :            : }
     105                 :            : 
     106                 :            : /* Stupid that this does nothing, but I didn't create this mess. */
     107                 :            : #define __print_symbol(fmt, addr)
     108                 :            : #endif /*CONFIG_KALLSYMS*/
     109                 :            : 
     110                 :            : /* This macro allows us to keep printk typechecking */
     111                 :            : static __printf(1, 2)
     112                 :            : void __check_printsym_format(const char *fmt, ...)
     113                 :            : {
     114                 :            : }
     115                 :            : 
     116                 :            : static inline void print_symbol(const char *fmt, unsigned long addr)
     117                 :            : {
     118                 :            :         __check_printsym_format(fmt, "");
     119                 :          0 :         __print_symbol(fmt, (unsigned long)
     120                 :          0 :                        __builtin_extract_return_addr((void *)addr));
     121                 :            : }
     122                 :            : 
     123                 :            : static inline void print_ip_sym(unsigned long ip)
     124                 :            : {
     125                 :          0 :         printk("[<%p>] %pS\n", (void *) ip, (void *) ip);
     126                 :            : }
     127                 :            : 
     128                 :            : #endif /*_LINUX_KALLSYMS_H*/