Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /* Rewritten and vastly simplified by Rusty Russell for in-kernel
       3                 :            :  * module loader:
       4                 :            :  *   Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
       5                 :            :  */
       6                 :            : #ifndef _LINUX_KALLSYMS_H
       7                 :            : #define _LINUX_KALLSYMS_H
       8                 :            : 
       9                 :            : #include <linux/errno.h>
      10                 :            : #include <linux/kernel.h>
      11                 :            : #include <linux/stddef.h>
      12                 :            : #include <linux/mm.h>
      13                 :            : #include <linux/module.h>
      14                 :            : 
      15                 :            : #include <asm/sections.h>
      16                 :            : 
      17                 :            : #define KSYM_NAME_LEN 128
      18                 :            : #define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + (KSYM_NAME_LEN - 1) + \
      19                 :            :                          2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + 1)
      20                 :            : 
      21                 :            : struct cred;
      22                 :            : struct module;
      23                 :            : 
      24                 :            : static inline int is_kernel_inittext(unsigned long addr)
      25                 :            : {
      26                 :          0 :         if (addr >= (unsigned long)_sinittext
      27                 :          0 :             && addr <= (unsigned long)_einittext)
      28                 :            :                 return 1;
      29                 :            :         return 0;
      30                 :            : }
      31                 :            : 
      32                 :            : static inline int is_kernel_text(unsigned long addr)
      33                 :            : {
      34                 :            :         if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
      35                 :            :             arch_is_kernel_text(addr))
      36                 :            :                 return 1;
      37                 :            :         return in_gate_area_no_mm(addr);
      38                 :            : }
      39                 :            : 
      40                 :            : static inline int is_kernel(unsigned long addr)
      41                 :            : {
      42                 :          3 :         if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end)
      43                 :            :                 return 1;
      44                 :          0 :         return in_gate_area_no_mm(addr);
      45                 :            : }
      46                 :            : 
      47                 :            : static inline int is_ksym_addr(unsigned long addr)
      48                 :            : {
      49                 :            :         if (IS_ENABLED(CONFIG_KALLSYMS_ALL))
      50                 :            :                 return is_kernel(addr);
      51                 :            : 
      52                 :            :         return is_kernel_text(addr) || is_kernel_inittext(addr);
      53                 :            : }
      54                 :            : 
      55                 :            : static inline void *dereference_symbol_descriptor(void *ptr)
      56                 :            : {
      57                 :            : #ifdef HAVE_DEREFERENCE_FUNCTION_DESCRIPTOR
      58                 :            :         struct module *mod;
      59                 :            : 
      60                 :            :         ptr = dereference_kernel_function_descriptor(ptr);
      61                 :            :         if (is_ksym_addr((unsigned long)ptr))
      62                 :            :                 return ptr;
      63                 :            : 
      64                 :            :         preempt_disable();
      65                 :            :         mod = __module_address((unsigned long)ptr);
      66                 :            :         preempt_enable();
      67                 :            : 
      68                 :            :         if (mod)
      69                 :            :                 ptr = dereference_module_function_descriptor(mod, ptr);
      70                 :            : #endif
      71                 :            :         return ptr;
      72                 :            : }
      73                 :            : 
      74                 :            : #ifdef CONFIG_KALLSYMS
      75                 :            : /* Lookup the address for a symbol. Returns 0 if not found. */
      76                 :            : unsigned long kallsyms_lookup_name(const char *name);
      77                 :            : 
      78                 :            : /* Call a function on each kallsyms symbol in the core kernel */
      79                 :            : int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
      80                 :            :                                       unsigned long),
      81                 :            :                             void *data);
      82                 :            : 
      83                 :            : extern int kallsyms_lookup_size_offset(unsigned long addr,
      84                 :            :                                   unsigned long *symbolsize,
      85                 :            :                                   unsigned long *offset);
      86                 :            : 
      87                 :            : /* Lookup an address.  modname is set to NULL if it's in the kernel. */
      88                 :            : const char *kallsyms_lookup(unsigned long addr,
      89                 :            :                             unsigned long *symbolsize,
      90                 :            :                             unsigned long *offset,
      91                 :            :                             char **modname, char *namebuf);
      92                 :            : 
      93                 :            : /* Look up a kernel symbol and return it in a text buffer. */
      94                 :            : extern int sprint_symbol(char *buffer, unsigned long address);
      95                 :            : extern int sprint_symbol_no_offset(char *buffer, unsigned long address);
      96                 :            : extern int sprint_backtrace(char *buffer, unsigned long address);
      97                 :            : 
      98                 :            : int lookup_symbol_name(unsigned long addr, char *symname);
      99                 :            : int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
     100                 :            : 
     101                 :            : /* How and when do we show kallsyms values? */
     102                 :            : extern bool kallsyms_show_value(const struct cred *cred);
     103                 :            : 
     104                 :            : #else /* !CONFIG_KALLSYMS */
     105                 :            : 
     106                 :            : static inline unsigned long kallsyms_lookup_name(const char *name)
     107                 :            : {
     108                 :            :         return 0;
     109                 :            : }
     110                 :            : 
     111                 :            : static inline int kallsyms_on_each_symbol(int (*fn)(void *, const char *,
     112                 :            :                                                     struct module *,
     113                 :            :                                                     unsigned long),
     114                 :            :                                           void *data)
     115                 :            : {
     116                 :            :         return 0;
     117                 :            : }
     118                 :            : 
     119                 :            : static inline int kallsyms_lookup_size_offset(unsigned long addr,
     120                 :            :                                               unsigned long *symbolsize,
     121                 :            :                                               unsigned long *offset)
     122                 :            : {
     123                 :            :         return 0;
     124                 :            : }
     125                 :            : 
     126                 :            : static inline const char *kallsyms_lookup(unsigned long addr,
     127                 :            :                                           unsigned long *symbolsize,
     128                 :            :                                           unsigned long *offset,
     129                 :            :                                           char **modname, char *namebuf)
     130                 :            : {
     131                 :            :         return NULL;
     132                 :            : }
     133                 :            : 
     134                 :            : static inline int sprint_symbol(char *buffer, unsigned long addr)
     135                 :            : {
     136                 :            :         *buffer = '\0';
     137                 :            :         return 0;
     138                 :            : }
     139                 :            : 
     140                 :            : static inline int sprint_symbol_no_offset(char *buffer, unsigned long addr)
     141                 :            : {
     142                 :            :         *buffer = '\0';
     143                 :            :         return 0;
     144                 :            : }
     145                 :            : 
     146                 :            : static inline int sprint_backtrace(char *buffer, unsigned long addr)
     147                 :            : {
     148                 :            :         *buffer = '\0';
     149                 :            :         return 0;
     150                 :            : }
     151                 :            : 
     152                 :            : static inline int lookup_symbol_name(unsigned long addr, char *symname)
     153                 :            : {
     154                 :            :         return -ERANGE;
     155                 :            : }
     156                 :            : 
     157                 :            : static inline int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
     158                 :            : {
     159                 :            :         return -ERANGE;
     160                 :            : }
     161                 :            : 
     162                 :            : static inline bool kallsyms_show_value(const struct cred *cred)
     163                 :            : {
     164                 :            :         return false;
     165                 :            : }
     166                 :            : 
     167                 :            : #endif /*CONFIG_KALLSYMS*/
     168                 :            : 
     169                 :            : static inline void print_ip_sym(unsigned long ip)
     170                 :            : {
     171                 :          0 :         printk("[<%px>] %pS\n", (void *) ip, (void *) ip);
     172                 :            : }
     173                 :            : 
     174                 :            : #endif /*_LINUX_KALLSYMS_H*/