arch/s390/kernel/binfmt_elf32.c

   1 /*
   2  * Support for 32-bit Linux for S390 ELF binaries.
   3  *
   4  * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   5  * Author(s): Gerhard Tonn (ton@de.ibm.com)
   6  *
   7  * Heavily inspired by the 32-bit Sparc compat code which is
   8  * Copyright (C) 1995, 1996, 1997, 1998 David S. Miller (davem@redhat.com)
   9  * Copyright (C) 1995, 1996, 1997, 1998 Jakub Jelinek   (jj@ultra.linux.cz)
  10  */
  11
  12 #define __ASMS390_ELF_H
  13
  14 #include <linux/time.h>
  15
  16 /*
  17  * These are used to set parameters in the core dumps.
  18  */
  19 #define ELF_CLASS       ELFCLASS32
  20 #define ELF_DATA        ELFDATA2MSB
  21 #define ELF_ARCH        EM_S390
  22
  23 /*
  24  * This is used to ensure we don't load something for the wrong architecture.
  25  */
  26 #define elf_check_arch(x) \
  27         (((x)->e_machine == EM_S390 || (x)->e_machine == EM_S390_OLD) \
  28          && (x)->e_ident[EI_CLASS] == ELF_CLASS)
  29
  30 /* ELF register definitions */
  31 #define NUM_GPRS      16
  32 #define NUM_FPRS      16
  33 #define NUM_ACRS      16
  34
  35 /* For SVR4/S390 the function pointer to be registered with `atexit` is
  36    passed in R14. */
  37 #define ELF_PLAT_INIT(_r, load_addr) \
  38         do { \
  39                 _r->gprs[14] = 0; \
  40         } while(0)
  41
  42 #define USE_ELF_CORE_DUMP
  43 #define ELF_EXEC_PAGESIZE       4096
  44
  45 /* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
  46    use of this is to invoke "./ld.so someprog" to test out a new version of
  47    the loader.  We need to make sure that it is out of the way of the program
  48    that it will "exec", and that there is sufficient room for the brk.  */
  49
  50 #define ELF_ET_DYN_BASE         (TASK_SIZE / 3 * 2)
  51
  52 /* Wow, the "main" arch needs arch dependent functions too.. :) */
  53
  54 /* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
  55    now struct_user_regs, they are different) */
  56
  57 #define ELF_CORE_COPY_REGS(pr_reg, regs) dump_regs32(regs, &pr_reg);
  58
  59 #define ELF_CORE_COPY_TASK_REGS(tsk, regs) dump_task_regs32(tsk, regs)
  60
  61 #define ELF_CORE_COPY_FPREGS(tsk, fpregs) dump_task_fpu(tsk, fpregs)
  62
  63 /* This yields a mask that user programs can use to figure out what
  64    instruction set this CPU supports. */
  65
  66 #define ELF_HWCAP (0)
  67
  68 /* This yields a string that ld.so will use to load implementation
  69    specific libraries for optimization.  This is more specific in
  70    intent than poking at uname or /proc/cpuinfo.
  71
  72    For the moment, we have only optimizations for the Intel generations,
  73    but that could change... */
  74
  75 #define ELF_PLATFORM (NULL)
  76
  77 #define SET_PERSONALITY(ex, ibcs2)                      \
  78 do {                                                    \
  79         if (ibcs2)                                      \
  80                 set_personality(PER_SVR4);              \
  81         else if (current->personality != PER_LINUX32)   \
  82                 set_personality(PER_LINUX);             \
  83         set_thread_flag(TIF_31BIT);                     \
  84 } while (0)
  85
  86 #include "compat_linux.h"
  87
  88 typedef _s390_fp_regs32 elf_fpregset_t;
  89
  90 typedef struct
  91 {
  92
  93         _psw_t32        psw;
  94         __u32           gprs[__NUM_GPRS];
  95         __u32           acrs[__NUM_ACRS];
  96         __u32           orig_gpr2;
  97 } s390_regs32;
  98 typedef s390_regs32 elf_gregset_t;
  99
 100 static inline int dump_regs32(struct pt_regs *ptregs, elf_gregset_t *regs)
 101 {
 102         int i;
 103
 104         memcpy(&regs->psw.mask, &ptregs->psw.mask, 4);
 105         memcpy(&regs->psw.addr, (char *)&ptregs->psw.addr + 4, 4);
 106         for (i = 0; i < NUM_GPRS; i++)
 107                 regs->gprs[i] = ptregs->gprs[i];
 108         save_access_regs(regs->acrs);
 109         regs->orig_gpr2 = ptregs->orig_gpr2;
 110         return 1;
 111 }
 112
 113 static inline int dump_task_regs32(struct task_struct *tsk, elf_gregset_t *regs)
 114 {
 115         struct pt_regs *ptregs = task_pt_regs(tsk);
 116         int i;
 117
 118         memcpy(&regs->psw.mask, &ptregs->psw.mask, 4);
 119         memcpy(&regs->psw.addr, (char *)&ptregs->psw.addr + 4, 4);
 120         for (i = 0; i < NUM_GPRS; i++)
 121                 regs->gprs[i] = ptregs->gprs[i];
 122         memcpy(regs->acrs, tsk->thread.acrs, sizeof(regs->acrs));
 123         regs->orig_gpr2 = ptregs->orig_gpr2;
 124         return 1;
 125 }
 126
 127 static inline int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
 128 {
 129         if (tsk == current)
 130                 save_fp_regs((s390_fp_regs *) fpregs);
 131         else
 132                 memcpy(fpregs, &tsk->thread.fp_regs, sizeof(elf_fpregset_t));
 133         return 1;
 134 }
 135
 136 #include <asm/processor.h>
 137 #include <linux/module.h>
 138 #include <linux/elfcore.h>
 139 #include <linux/binfmts.h>
 140 #include <linux/compat.h>
 141
 142 #define elf_prstatus elf_prstatus32
 143 struct elf_prstatus32
 144 {
 145         struct elf_siginfo pr_info;     /* Info associated with signal */
 146         short   pr_cursig;              /* Current signal */
 147         u32     pr_sigpend;     /* Set of pending signals */
 148         u32     pr_sighold;     /* Set of held signals */
 149         pid_t   pr_pid;
 150         pid_t   pr_ppid;
 151         pid_t   pr_pgrp;
 152         pid_t   pr_sid;
 153         struct compat_timeval pr_utime; /* User time */
 154         struct compat_timeval pr_stime; /* System time */
 155         struct compat_timeval pr_cutime;        /* Cumulative user time */
 156         struct compat_timeval pr_cstime;        /* Cumulative system time */
 157         elf_gregset_t pr_reg;   /* GP registers */
 158         int pr_fpvalid;         /* True if math co-processor being used.  */
 159 };
 160
 161 #define elf_prpsinfo elf_prpsinfo32
 162 struct elf_prpsinfo32
 163 {
 164         char    pr_state;       /* numeric process state */
 165         char    pr_sname;       /* char for pr_state */
 166         char    pr_zomb;        /* zombie */
 167         char    pr_nice;        /* nice val */
 168         u32     pr_flag;        /* flags */
 169         u16     pr_uid;
 170         u16     pr_gid;
 171         pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
 172         /* Lots missing */
 173         char    pr_fname[16];   /* filename of executable */
 174         char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
 175 };
 176
 177 #include <linux/highuid.h>
 178
 179 /*
 180 #define init_elf_binfmt init_elf32_binfmt
 181 */
 182
 183 #undef start_thread
 184 #define start_thread                    start_thread31
 185
 186 MODULE_DESCRIPTION("Binary format loader for compatibility with 32bit Linux for S390 binaries,"
 187                    " Copyright 2000 IBM Corporation");
 188 MODULE_AUTHOR("Gerhard Tonn <ton@de.ibm.com>");
 189
 190 #undef MODULE_DESCRIPTION
 191 #undef MODULE_AUTHOR
 192
 193 #undef cputime_to_timeval
 194 #define cputime_to_timeval cputime_to_compat_timeval
 195 static inline void
 196 cputime_to_compat_timeval(const cputime_t cputime, struct compat_timeval *value)
 197 {
 198         value->tv_usec = cputime % 1000000;
 199         value->tv_sec = cputime / 1000000;
 200 }
 201
 202 #include "../../../fs/binfmt_elf.c"
 203