Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _ASM_GENERIC_SECTIONS_H_
       3                 :            : #define _ASM_GENERIC_SECTIONS_H_
       4                 :            : 
       5                 :            : /* References to section boundaries */
       6                 :            : 
       7                 :            : #include <linux/compiler.h>
       8                 :            : #include <linux/types.h>
       9                 :            : 
      10                 :            : /*
      11                 :            :  * Usage guidelines:
      12                 :            :  * _text, _data: architecture specific, don't use them in arch-independent code
      13                 :            :  * [_stext, _etext]: contains .text.* sections, may also contain .rodata.*
      14                 :            :  *                   and/or .init.* sections
      15                 :            :  * [_sdata, _edata]: contains .data.* sections, may also contain .rodata.*
      16                 :            :  *                   and/or .init.* sections.
      17                 :            :  * [__start_rodata, __end_rodata]: contains .rodata.* sections
      18                 :            :  * [__start_ro_after_init, __end_ro_after_init]:
      19                 :            :  *                   contains .data..ro_after_init section
      20                 :            :  * [__init_begin, __init_end]: contains .init.* sections, but .init.text.*
      21                 :            :  *                   may be out of this range on some architectures.
      22                 :            :  * [_sinittext, _einittext]: contains .init.text.* sections
      23                 :            :  * [__bss_start, __bss_stop]: contains BSS sections
      24                 :            :  *
      25                 :            :  * Following global variables are optional and may be unavailable on some
      26                 :            :  * architectures and/or kernel configurations.
      27                 :            :  *      _text, _data
      28                 :            :  *      __kprobes_text_start, __kprobes_text_end
      29                 :            :  *      __entry_text_start, __entry_text_end
      30                 :            :  *      __ctors_start, __ctors_end
      31                 :            :  *      __irqentry_text_start, __irqentry_text_end
      32                 :            :  *      __softirqentry_text_start, __softirqentry_text_end
      33                 :            :  *      __start_opd, __end_opd
      34                 :            :  */
      35                 :            : extern char _text[], _stext[], _etext[];
      36                 :            : extern char _data[], _sdata[], _edata[];
      37                 :            : extern char __bss_start[], __bss_stop[];
      38                 :            : extern char __init_begin[], __init_end[];
      39                 :            : extern char _sinittext[], _einittext[];
      40                 :            : extern char __start_ro_after_init[], __end_ro_after_init[];
      41                 :            : extern char _end[];
      42                 :            : extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[];
      43                 :            : extern char __kprobes_text_start[], __kprobes_text_end[];
      44                 :            : extern char __entry_text_start[], __entry_text_end[];
      45                 :            : extern char __start_rodata[], __end_rodata[];
      46                 :            : extern char __irqentry_text_start[], __irqentry_text_end[];
      47                 :            : extern char __softirqentry_text_start[], __softirqentry_text_end[];
      48                 :            : extern char __start_once[], __end_once[];
      49                 :            : 
      50                 :            : /* Start and end of .ctors section - used for constructor calls. */
      51                 :            : extern char __ctors_start[], __ctors_end[];
      52                 :            : 
      53                 :            : /* Start and end of .opd section - used for function descriptors. */
      54                 :            : extern char __start_opd[], __end_opd[];
      55                 :            : 
      56                 :            : extern __visible const void __nosave_begin, __nosave_end;
      57                 :            : 
      58                 :            : /* Function descriptor handling (if any).  Override in asm/sections.h */
      59                 :            : #ifndef dereference_function_descriptor
      60                 :            : #define dereference_function_descriptor(p) (p)
      61                 :            : #define dereference_kernel_function_descriptor(p) (p)
      62                 :            : #endif
      63                 :            : 
      64                 :            : /* random extra sections (if any).  Override
      65                 :            :  * in asm/sections.h */
      66                 :            : #ifndef arch_is_kernel_text
      67                 :            : static inline int arch_is_kernel_text(unsigned long addr)
      68                 :            : {
      69                 :            :         return 0;
      70                 :            : }
      71                 :            : #endif
      72                 :            : 
      73                 :            : #ifndef arch_is_kernel_data
      74                 :            : static inline int arch_is_kernel_data(unsigned long addr)
      75                 :            : {
      76                 :            :         return 0;
      77                 :            : }
      78                 :            : #endif
      79                 :            : 
      80                 :            : /*
      81                 :            :  * Check if an address is part of freed initmem. This is needed on architectures
      82                 :            :  * with virt == phys kernel mapping, for code that wants to check if an address
      83                 :            :  * is part of a static object within [_stext, _end]. After initmem is freed,
      84                 :            :  * memory can be allocated from it, and such allocations would then have
      85                 :            :  * addresses within the range [_stext, _end].
      86                 :            :  */
      87                 :            : #ifndef arch_is_kernel_initmem_freed
      88                 :            : static inline int arch_is_kernel_initmem_freed(unsigned long addr)
      89                 :            : {
      90                 :            :         return 0;
      91                 :            : }
      92                 :            : #endif
      93                 :            : 
      94                 :            : /**
      95                 :            :  * memory_contains - checks if an object is contained within a memory region
      96                 :            :  * @begin: virtual address of the beginning of the memory region
      97                 :            :  * @end: virtual address of the end of the memory region
      98                 :            :  * @virt: virtual address of the memory object
      99                 :            :  * @size: size of the memory object
     100                 :            :  *
     101                 :            :  * Returns: true if the object specified by @virt and @size is entirely
     102                 :            :  * contained within the memory region defined by @begin and @end, false
     103                 :            :  * otherwise.
     104                 :            :  */
     105                 :            : static inline bool memory_contains(void *begin, void *end, void *virt,
     106                 :            :                                    size_t size)
     107                 :            : {
     108                 :          3 :         return virt >= begin && virt + size <= end;
     109                 :            : }
     110                 :            : 
     111                 :            : /**
     112                 :            :  * memory_intersects - checks if the region occupied by an object intersects
     113                 :            :  *                     with another memory region
     114                 :            :  * @begin: virtual address of the beginning of the memory regien
     115                 :            :  * @end: virtual address of the end of the memory region
     116                 :            :  * @virt: virtual address of the memory object
     117                 :            :  * @size: size of the memory object
     118                 :            :  *
     119                 :            :  * Returns: true if an object's memory region, specified by @virt and @size,
     120                 :            :  * intersects with the region specified by @begin and @end, false otherwise.
     121                 :            :  */
     122                 :            : static inline bool memory_intersects(void *begin, void *end, void *virt,
     123                 :            :                                      size_t size)
     124                 :            : {
     125                 :          0 :         void *vend = virt + size;
     126                 :            : 
     127                 :          0 :         return (virt >= begin && virt < end) || (vend >= begin && vend < end);
     128                 :            : }
     129                 :            : 
     130                 :            : /**
     131                 :            :  * init_section_contains - checks if an object is contained within the init
     132                 :            :  *                         section
     133                 :            :  * @virt: virtual address of the memory object
     134                 :            :  * @size: size of the memory object
     135                 :            :  *
     136                 :            :  * Returns: true if the object specified by @virt and @size is entirely
     137                 :            :  * contained within the init section, false otherwise.
     138                 :            :  */
     139                 :            : static inline bool init_section_contains(void *virt, size_t size)
     140                 :            : {
     141                 :            :         return memory_contains(__init_begin, __init_end, virt, size);
     142                 :            : }
     143                 :            : 
     144                 :            : /**
     145                 :            :  * init_section_intersects - checks if the region occupied by an object
     146                 :            :  *                           intersects with the init section
     147                 :            :  * @virt: virtual address of the memory object
     148                 :            :  * @size: size of the memory object
     149                 :            :  *
     150                 :            :  * Returns: true if an object's memory region, specified by @virt and @size,
     151                 :            :  * intersects with the init section, false otherwise.
     152                 :            :  */
     153                 :            : static inline bool init_section_intersects(void *virt, size_t size)
     154                 :            : {
     155                 :            :         return memory_intersects(__init_begin, __init_end, virt, size);
     156                 :            : }
     157                 :            : 
     158                 :            : /**
     159                 :            :  * is_kernel_rodata - checks if the pointer address is located in the
     160                 :            :  *                    .rodata section
     161                 :            :  *
     162                 :            :  * @addr: address to check
     163                 :            :  *
     164                 :            :  * Returns: true if the address is located in .rodata, false otherwise.
     165                 :            :  */
     166                 :            : static inline bool is_kernel_rodata(unsigned long addr)
     167                 :            : {
     168                 :          3 :         return addr >= (unsigned long)__start_rodata &&
     169                 :          3 :                addr < (unsigned long)__end_rodata;
     170                 :            : }
     171                 :            : 
     172                 :            : #endif /* _ASM_GENERIC_SECTIONS_H_ */