Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_ELFCORE_H
       3             : #define _LINUX_ELFCORE_H
       4             : 
       5             : #include <linux/user.h>
       6             : #include <linux/bug.h>
       7             : #include <linux/sched/task_stack.h>
       8             : #include <linux/types.h>
       9             : #include <linux/signal.h>
      10             : #include <linux/time.h>
      11             : #include <linux/ptrace.h>
      12             : #include <linux/fs.h>
      13             : #include <linux/elf.h>
      14             : 
      15             : struct coredump_params;
      16             : 
      17             : struct elf_siginfo
      18             : {
      19             :         int     si_signo;                       /* signal number */
      20             :         int     si_code;                        /* extra code */
      21             :         int     si_errno;                       /* errno */
      22             : };
      23             : 
      24             : /*
      25             :  * Definitions to generate Intel SVR4-like core files.
      26             :  * These mostly have the same names as the SVR4 types with "elf_"
      27             :  * tacked on the front to prevent clashes with linux definitions,
      28             :  * and the typedef forms have been avoided.  This is mostly like
      29             :  * the SVR4 structure, but more Linuxy, with things that Linux does
      30             :  * not support and which gdb doesn't really use excluded.
      31             :  */
      32             : struct elf_prstatus_common
      33             : {
      34             :         struct elf_siginfo pr_info;     /* Info associated with signal */
      35             :         short   pr_cursig;              /* Current signal */
      36             :         unsigned long pr_sigpend;       /* Set of pending signals */
      37             :         unsigned long pr_sighold;       /* Set of held signals */
      38             :         pid_t   pr_pid;
      39             :         pid_t   pr_ppid;
      40             :         pid_t   pr_pgrp;
      41             :         pid_t   pr_sid;
      42             :         struct __kernel_old_timeval pr_utime;   /* User time */
      43             :         struct __kernel_old_timeval pr_stime;   /* System time */
      44             :         struct __kernel_old_timeval pr_cutime;  /* Cumulative user time */
      45             :         struct __kernel_old_timeval pr_cstime;  /* Cumulative system time */
      46             : };
      47             : 
      48             : struct elf_prstatus
      49             : {
      50             :         struct elf_prstatus_common common;
      51             :         elf_gregset_t pr_reg;   /* GP registers */
      52             :         int pr_fpvalid;         /* True if math co-processor being used.  */
      53             : };
      54             : 
      55             : #define ELF_PRARGSZ     (80)    /* Number of chars for args */
      56             : 
      57             : struct elf_prpsinfo
      58             : {
      59             :         char    pr_state;       /* numeric process state */
      60             :         char    pr_sname;       /* char for pr_state */
      61             :         char    pr_zomb;        /* zombie */
      62             :         char    pr_nice;        /* nice val */
      63             :         unsigned long pr_flag;  /* flags */
      64             :         __kernel_uid_t  pr_uid;
      65             :         __kernel_gid_t  pr_gid;
      66             :         pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
      67             :         /* Lots missing */
      68             :         /*
      69             :          * The hard-coded 16 is derived from TASK_COMM_LEN, but it can't be
      70             :          * changed as it is exposed to userspace. We'd better make it hard-coded
      71             :          * here.
      72             :          */
      73             :         char    pr_fname[16];   /* filename of executable */
      74             :         char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
      75             : };
      76             : 
      77           0 : static inline void elf_core_copy_regs(elf_gregset_t *elfregs, struct pt_regs *regs)
      78             : {
      79             : #ifdef ELF_CORE_COPY_REGS
      80           0 :         ELF_CORE_COPY_REGS((*elfregs), regs)
      81             : #else
      82             :         BUG_ON(sizeof(*elfregs) != sizeof(*regs));
      83             :         *(struct pt_regs *)elfregs = *regs;
      84             : #endif
      85           0 : }
      86             : 
      87             : static inline void elf_core_copy_kernel_regs(elf_gregset_t *elfregs, struct pt_regs *regs)
      88             : {
      89             : #ifdef ELF_CORE_COPY_KERNEL_REGS
      90             :         ELF_CORE_COPY_KERNEL_REGS((*elfregs), regs);
      91             : #else
      92             :         elf_core_copy_regs(elfregs, regs);
      93             : #endif
      94             : }
      95             : 
      96             : static inline int elf_core_copy_task_regs(struct task_struct *t, elf_gregset_t* elfregs)
      97             : {
      98             : #if defined (ELF_CORE_COPY_TASK_REGS)
      99             :         return ELF_CORE_COPY_TASK_REGS(t, elfregs);
     100             : #elif defined (task_pt_regs)
     101           0 :         elf_core_copy_regs(elfregs, task_pt_regs(t));
     102             : #endif
     103             :         return 0;
     104             : }
     105             : 
     106             : extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
     107             : 
     108             : static inline int elf_core_copy_task_fpregs(struct task_struct *t, struct pt_regs *regs, elf_fpregset_t *fpu)
     109             : {
     110             : #ifdef ELF_CORE_COPY_FPREGS
     111           0 :         return ELF_CORE_COPY_FPREGS(t, fpu);
     112             : #else
     113             :         return dump_fpu(regs, fpu);
     114             : #endif
     115             : }
     116             : 
     117             : #ifdef CONFIG_ARCH_BINFMT_ELF_EXTRA_PHDRS
     118             : /*
     119             :  * These functions parameterize elf_core_dump in fs/binfmt_elf.c to write out
     120             :  * extra segments containing the gate DSO contents.  Dumping its
     121             :  * contents makes post-mortem fully interpretable later without matching up
     122             :  * the same kernel and hardware config to see what PC values meant.
     123             :  * Dumping its extra ELF program headers includes all the other information
     124             :  * a debugger needs to easily find how the gate DSO was being used.
     125             :  */
     126             : extern Elf_Half elf_core_extra_phdrs(void);
     127             : extern int
     128             : elf_core_write_extra_phdrs(struct coredump_params *cprm, loff_t offset);
     129             : extern int
     130             : elf_core_write_extra_data(struct coredump_params *cprm);
     131             : extern size_t elf_core_extra_data_size(void);
     132             : #else
     133             : static inline Elf_Half elf_core_extra_phdrs(void)
     134             : {
     135             :         return 0;
     136             : }
     137             : 
     138             : static inline int elf_core_write_extra_phdrs(struct coredump_params *cprm, loff_t offset)
     139             : {
     140             :         return 1;
     141             : }
     142             : 
     143             : static inline int elf_core_write_extra_data(struct coredump_params *cprm)
     144             : {
     145             :         return 1;
     146             : }
     147             : 
     148             : static inline size_t elf_core_extra_data_size(void)
     149             : {
     150             :         return 0;
     151             : }
     152             : #endif /* CONFIG_ARCH_BINFMT_ELF_EXTRA_PHDRS */
     153             : 
     154             : #endif /* _LINUX_ELFCORE_H */