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 <asm/pgalloc.h>
 138 #include <linux/module.h>
 139 #include <linux/elfcore.h>
 140 #include <linux/binfmts.h>
 141 #include <linux/compat.h>
 142
 143 #define elf_prstatus elf_prstatus32
 144 struct elf_prstatus32
 145 {
 146         struct elf_siginfo pr_info;     /* Info associated with signal */
 147         short   pr_cursig;              /* Current signal */
 148         u32     pr_sigpend;     /* Set of pending signals */
 149         u32     pr_sighold;     /* Set of held signals */
 150         pid_t   pr_pid;
 151         pid_t   pr_ppid;
 152         pid_t   pr_pgrp;
 153         pid_t   pr_sid;
 154         struct compat_timeval pr_utime; /* User time */
 155         struct compat_timeval pr_stime; /* System time */
 156         struct compat_timeval pr_cutime;        /* Cumulative user time */
 157         struct compat_timeval pr_cstime;        /* Cumulative system time */
 158         elf_gregset_t pr_reg;   /* GP registers */
 159         int pr_fpvalid;         /* True if math co-processor being used.  */
 160 };
 161
 162 #define elf_prpsinfo elf_prpsinfo32
 163 struct elf_prpsinfo32
 164 {
 165         char    pr_state;       /* numeric process state */
 166         char    pr_sname;       /* char for pr_state */
 167         char    pr_zomb;        /* zombie */
 168         char    pr_nice;        /* nice val */
 169         u32     pr_flag;        /* flags */
 170         u16     pr_uid;
 171         u16     pr_gid;
 172         pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
 173         /* Lots missing */
 174         char    pr_fname[16];   /* filename of executable */
 175         char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
 176 };
 177
 178 #include <linux/highuid.h>
 179
 180 /*
 181 #define init_elf_binfmt init_elf32_binfmt
 182 */
 183
 184 #undef start_thread
 185 #define start_thread                    start_thread31
 186
 187 static inline void start_thread31(struct pt_regs *regs, unsigned long new_psw,
 188                                   unsigned long new_stackp)
 189 {
 190         set_fs(USER_DS);
 191         regs->psw.mask  = psw_user32_bits;
 192         regs->psw.addr  = new_psw;
 193         regs->gprs[15]  = new_stackp;
 194         crst_table_downgrade(current->mm, 1UL << 31);
 195 }
 196
 197 MODULE_DESCRIPTION("Binary format loader for compatibility with 32bit Linux for S390 binaries,"
 198                    " Copyright 2000 IBM Corporation");
 199 MODULE_AUTHOR("Gerhard Tonn <ton@de.ibm.com>");
 200
 201 #undef MODULE_DESCRIPTION
 202 #undef MODULE_AUTHOR
 203
 204 #undef cputime_to_timeval
 205 #define cputime_to_timeval cputime_to_compat_timeval
 206 static inline void
 207 cputime_to_compat_timeval(const cputime_t cputime, struct compat_timeval *value)
 208 {
 209         value->tv_usec = cputime % 1000000;
 210         value->tv_sec = cputime / 1000000;
 211 }
 212
 213 #include "../../../fs/binfmt_elf.c"
 214