Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef LINUX_CRASH_DUMP_H
       3             : #define LINUX_CRASH_DUMP_H
       4             : 
       5             : #include <linux/kexec.h>
       6             : #include <linux/proc_fs.h>
       7             : #include <linux/elf.h>
       8             : #include <linux/pgtable.h>
       9             : #include <uapi/linux/vmcore.h>
      10             : 
      11             : #include <linux/pgtable.h> /* for pgprot_t */
      12             : 
      13             : #ifdef CONFIG_CRASH_DUMP
      14             : #define ELFCORE_ADDR_MAX        (-1ULL)
      15             : #define ELFCORE_ADDR_ERR        (-2ULL)
      16             : 
      17             : extern unsigned long long elfcorehdr_addr;
      18             : extern unsigned long long elfcorehdr_size;
      19             : 
      20             : extern int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size);
      21             : extern void elfcorehdr_free(unsigned long long addr);
      22             : extern ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos);
      23             : extern ssize_t elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos);
      24             : extern int remap_oldmem_pfn_range(struct vm_area_struct *vma,
      25             :                                   unsigned long from, unsigned long pfn,
      26             :                                   unsigned long size, pgprot_t prot);
      27             : 
      28             : extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
      29             :                                                 unsigned long, int);
      30             : extern ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf,
      31             :                                           size_t csize, unsigned long offset,
      32             :                                           int userbuf);
      33             : 
      34             : void vmcore_cleanup(void);
      35             : 
      36             : /* Architecture code defines this if there are other possible ELF
      37             :  * machine types, e.g. on bi-arch capable hardware. */
      38             : #ifndef vmcore_elf_check_arch_cross
      39             : #define vmcore_elf_check_arch_cross(x) 0
      40             : #endif
      41             : 
      42             : /*
      43             :  * Architecture code can redefine this if there are any special checks
      44             :  * needed for 32-bit ELF or 64-bit ELF vmcores.  In case of 32-bit
      45             :  * only architecture, vmcore_elf64_check_arch can be set to zero.
      46             :  */
      47             : #ifndef vmcore_elf32_check_arch
      48             : #define vmcore_elf32_check_arch(x) elf_check_arch(x)
      49             : #endif
      50             : 
      51             : #ifndef vmcore_elf64_check_arch
      52             : #define vmcore_elf64_check_arch(x) (elf_check_arch(x) || vmcore_elf_check_arch_cross(x))
      53             : #endif
      54             : 
      55             : /*
      56             :  * is_kdump_kernel() checks whether this kernel is booting after a panic of
      57             :  * previous kernel or not. This is determined by checking if previous kernel
      58             :  * has passed the elf core header address on command line.
      59             :  *
      60             :  * This is not just a test if CONFIG_CRASH_DUMP is enabled or not. It will
      61             :  * return true if CONFIG_CRASH_DUMP=y and if kernel is booting after a panic
      62             :  * of previous kernel.
      63             :  */
      64             : 
      65             : static inline bool is_kdump_kernel(void)
      66             : {
      67             :         return elfcorehdr_addr != ELFCORE_ADDR_MAX;
      68             : }
      69             : 
      70             : /* is_vmcore_usable() checks if the kernel is booting after a panic and
      71             :  * the vmcore region is usable.
      72             :  *
      73             :  * This makes use of the fact that due to alignment -2ULL is not
      74             :  * a valid pointer, much in the vain of IS_ERR(), except
      75             :  * dealing directly with an unsigned long long rather than a pointer.
      76             :  */
      77             : 
      78             : static inline int is_vmcore_usable(void)
      79             : {
      80             :         return is_kdump_kernel() && elfcorehdr_addr != ELFCORE_ADDR_ERR ? 1 : 0;
      81             : }
      82             : 
      83             : /* vmcore_unusable() marks the vmcore as unusable,
      84             :  * without disturbing the logic of is_kdump_kernel()
      85             :  */
      86             : 
      87             : static inline void vmcore_unusable(void)
      88             : {
      89             :         if (is_kdump_kernel())
      90             :                 elfcorehdr_addr = ELFCORE_ADDR_ERR;
      91             : }
      92             : 
      93             : #define HAVE_OLDMEM_PFN_IS_RAM 1
      94             : extern int register_oldmem_pfn_is_ram(int (*fn)(unsigned long pfn));
      95             : extern void unregister_oldmem_pfn_is_ram(void);
      96             : 
      97             : #else /* !CONFIG_CRASH_DUMP */
      98          18 : static inline bool is_kdump_kernel(void) { return 0; }
      99             : #endif /* CONFIG_CRASH_DUMP */
     100             : 
     101             : /* Device Dump information to be filled by drivers */
     102             : struct vmcoredd_data {
     103             :         char dump_name[VMCOREDD_MAX_NAME_BYTES]; /* Unique name of the dump */
     104             :         unsigned int size;                       /* Size of the dump */
     105             :         /* Driver's registered callback to be invoked to collect dump */
     106             :         int (*vmcoredd_callback)(struct vmcoredd_data *data, void *buf);
     107             : };
     108             : 
     109             : #ifdef CONFIG_PROC_VMCORE_DEVICE_DUMP
     110             : int vmcore_add_device_dump(struct vmcoredd_data *data);
     111             : #else
     112             : static inline int vmcore_add_device_dump(struct vmcoredd_data *data)
     113             : {
     114             :         return -EOPNOTSUPP;
     115             : }
     116             : #endif /* CONFIG_PROC_VMCORE_DEVICE_DUMP */
     117             : 
     118             : #ifdef CONFIG_PROC_VMCORE
     119             : ssize_t read_from_oldmem(char *buf, size_t count,
     120             :                          u64 *ppos, int userbuf,
     121             :                          bool encrypted);
     122             : #else
     123             : static inline ssize_t read_from_oldmem(char *buf, size_t count,
     124             :                                        u64 *ppos, int userbuf,
     125             :                                        bool encrypted)
     126             : {
     127             :         return -EOPNOTSUPP;
     128             : }
     129             : #endif /* CONFIG_PROC_VMCORE */
     130             : 
     131             : #endif /* LINUX_CRASHDUMP_H */